bench.yml

# Runs tempo benchmarks.
#
# E2E benchmarks run `nu bench-e2e.nu e2e` against the dual-schelk runner.
# Replay benchmarks use `nu tempo.nu bench-replay`.
#
# Trigger via PR comment (`@decofe bench`, `derek bench`, or `derek clear`).

on:
  issue_comment:
    types: [created]
env:
  CARGO_TERM_COLOR: always
  RUSTC_WRAPPER: "sccache"
  BENCH_RUNNERS: 1

name: bench

permissions:
  contents: read
  issues: write # zizmor: ignore[excessive-permissions] -- required by reusable workflows
  pull-requests: write # zizmor: ignore[excessive-permissions] -- required by reusable workflows

jobs:
  tempo-bench-ack:
    if: github.event_name == 'issue_comment' && github.event.issue.pull_request
    name: tempo-bench-ack
    runs-on: ubuntu-latest
    permissions:
      contents: read
      issues: write
      pull-requests: write
    outputs:
      pr: ${{ steps.args.outputs.pr }}
      actor: ${{ steps.args.outputs.actor }}
      mode: ${{ steps.args.outputs.mode }}
      preset: ${{ steps.args.outputs.preset }}
      duration: ${{ steps.args.outputs.duration }}
      bloat: ${{ steps.args.outputs.bloat }}
      tps: ${{ steps.args.outputs.tps }}
      accounts: ${{ steps.args.outputs.accounts }}
      max-concurrent-requests: ${{ steps.args.outputs.max-concurrent-requests }}
      baseline: ${{ steps.args.outputs.baseline }}
      feature: ${{ steps.args.outputs.feature }}
      baseline-hardfork: ${{ steps.args.outputs.baseline-hardfork }}
      feature-hardfork: ${{ steps.args.outputs.feature-hardfork }}
      baseline-features: ${{ steps.args.outputs.baseline-features }}
      feature-features: ${{ steps.args.outputs.feature-features }}
      txgen-ref: ${{ steps.args.outputs.txgen-ref }}
      token-count: ${{ steps.args.outputs.token-count }}
      baseline-name: ${{ steps.args.outputs.baseline-name }}
      feature-name: ${{ steps.args.outputs.feature-name }}
      samply: ${{ steps.args.outputs.samply }}
      tracy: ${{ steps.args.outputs.tracy }}
      tracy-seconds: ${{ steps.args.outputs.tracy-seconds }}
      tracy-offset: ${{ steps.args.outputs.tracy-offset }}
      otlp: ${{ steps.args.outputs.otlp }}
      valscope: ${{ steps.args.outputs.valscope }}
      skip-state-root: ${{ steps.args.outputs.skip-state-root }}
      baseline-args: ${{ steps.args.outputs.baseline-args }}
      feature-args: ${{ steps.args.outputs.feature-args }}
      gas-limit: ${{ steps.args.outputs.gas-limit }}
      general-gas-limit: ${{ steps.args.outputs.general-gas-limit }}
      run-type: ${{ steps.args.outputs.run-type }}
      force-bloat: ${{ steps.args.outputs.force-bloat }}
      no-cache: ${{ steps.args.outputs.no-cache }}
      no-slack: ${{ steps.args.outputs.no-slack }}
      metrics: ${{ steps.args.outputs.metrics }}
      bench-args: ${{ steps.args.outputs.bench-args }}
      bench-env: ${{ steps.args.outputs.bench-env }}
      baseline-env: ${{ steps.args.outputs.baseline-env }}
      feature-env: ${{ steps.args.outputs.feature-env }}
      blocks: ${{ steps.args.outputs.blocks }}
      warmup: ${{ steps.args.outputs.warmup }}
      chain: ${{ steps.args.outputs.chain }}
      run-pairs: ${{ steps.args.outputs.run-pairs }}
      run-side: ${{ steps.args.outputs.run-side }}
      comment-id: ${{ steps.ack.outputs.comment-id }}
      pr-head-sha: ${{ steps.args.outputs.pr-head-sha }}
      pr-head-ref: ${{ steps.args.outputs.pr-head-ref }}
    steps:
      - name: Detect bench command
        id: command
        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
        with:
          script: |
            const body = context.payload.comment.body.trim();
            const isBenchCommand = body.startsWith('@decofe bench') || body.startsWith('derek bench');
            const isClearCommand = body === 'derek clear' || body === '@decofe clear';
            core.setOutput('is-bench-command', String(isBenchCommand));
            core.setOutput('is-clear-command', String(isClearCommand));

      - name: Check org membership
        if: steps.command.outputs.is-bench-command == 'true' || steps.command.outputs.is-clear-command == 'true'
        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
        with:
          github-token: ${{ secrets.DEREK_BENCH_ACK_TOKEN }}
          script: |
            const org = 'tempoxyz';
            const checkMembership = async (username) => {
              try {
                const { status } = await github.rest.orgs.checkMembershipForUser({ org, username });
                return status === 204 || status === 302;
              } catch {
                return false;
              }
            };

            const commenter = context.payload.comment.user.login;
            if (!await checkMembership(commenter)) {
              core.setFailed(`@${commenter} is not a member of ${org}`);
              return;
            }

            const { data: pr } = await github.rest.pulls.get({
              owner: context.repo.owner,
              repo: context.repo.repo,
              pull_number: context.issue.number,
            });
            const prAuthor = pr.user.login;
            if (!await checkMembership(prAuthor)) {
              core.setFailed(`PR author @${prAuthor} is not a member of ${org}`);
            }

      - name: Clear benchmark comments
        if: steps.command.outputs.is-clear-command == 'true'
        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
        with:
          github-token: ${{ secrets.DEREK_BENCH_TOKEN }}
          script: |
            await github.rest.reactions.createForIssueComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              comment_id: context.payload.comment.id,
              content: 'eyes',
            });

            const shouldHideComment = (comment) => {
              const body = comment.body.trim();
              return comment.user.login === 'decofe' || body.startsWith('derek') || body.startsWith('@decofe');
            };
            const comments = await github.paginate(github.rest.issues.listComments, {
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.issue.number,
              per_page: 100,
            });
            let hidden = 0;
            for (const comment of comments) {
              if (!shouldHideComment(comment)) continue;

              await github.graphql(`
                mutation($subjectId: ID!) {
                  minimizeComment(input: {subjectId: $subjectId, classifier: OUTDATED}) {
                    minimizedComment {
                      isMinimized
                    }
                  }
                }
              `, {
                subjectId: comment.node_id,
              });
              hidden += 1;
            }

            core.notice(`Hid ${hidden} Derek comment(s).`);

      - name: Parse arguments
        id: args
        if: steps.command.outputs.is-bench-command == 'true'
        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
        env:
          INPUT_REF_NAME: ${{ github.ref_name }}
        with:
          github-token: ${{ secrets.DEREK_BENCH_TOKEN }}
          script: |
            let pr, actor, mode, preset, duration, bloat, tokenCount, tps, accounts, maxConcurrentRequests, baseline, feature, baselineHardfork, featureHardfork, baselineFeatures, featureFeatures, txgenRef, samply, tracy, tracySeconds, tracyOffset, otlp, valscope, skipStateRoot, baselineArgs, featureArgs, gasLimit, generalGasLimit, runType, forceBloat, noCache, noSlack, metrics, benchArgs, benchEnv, baselineEnv, featureEnv, blocks, warmup, runPairs, runSide;
            let explicitWarmup = false;
            let explicitDuration = false;
            let explicitRunPairs = false;
            let explicitTracyOffset = false;

            pr = String(context.issue.number);
            actor = context.payload.comment.user.login;

            const body = context.payload.comment.body.trim();
            const intArgs = new Set(['duration', 'bloat', 'token-count', 'tps', 'accounts', 'max-concurrent-requests', 'gas-limit', 'general-gas-limit', 'tracy-seconds', 'tracy-offset', 'blocks', 'warmup', 'run-pairs']);
            const refArgs = new Set(['baseline', 'feature', 'txgen-ref']);
            const stringArgs = new Set(['mode', 'preset', 'baseline-args', 'feature-args', 'baseline-features', 'feature-features', 'bench-args', 'bench-env', 'baseline-env', 'feature-env', 'chain', 'baseline-hardfork', 'feature-hardfork', 'run-side']);
            const boolArgs = new Set(['samply', 'tracy', 'force-bloat', 'no-cache', 'no-slack', 'otlp', 'valscope', 'metrics', 'skip-state-root']);
            const bloatValues = new Set(['1', '10', '100']);
            const hardforkValues = new Set(['T0', 'T1', 'T1A', 'T1B', 'T1C', 'T2', 'T3', 'T4', 'T5', 'T6', 'T7', 'T8', 'T9']);
            const defaults = { mode: 'e2e', preset: 'default', duration: '300', bloat: '100', 'token-count': '4', tps: '50000', accounts: '1000', 'max-concurrent-requests': '500', baseline: '', feature: '', 'baseline-hardfork': '', 'feature-hardfork': '', 'baseline-features': '', 'feature-features': '', 'txgen-ref': '', samply: 'false', tracy: 'off', 'tracy-seconds': '10', 'tracy-offset': '', otlp: 'true', valscope: 'false', metrics: 'false', 'skip-state-root': 'false', 'baseline-args': '', 'feature-args': '', 'gas-limit': '1000000000000', 'general-gas-limit': '1000000000000', 'force-bloat': 'false', 'no-cache': 'false', 'no-slack': 'false', 'bench-args': '', 'bench-env': '', 'baseline-env': '', 'feature-env': '', blocks: '5000', warmup: '', chain: 'mainnet', 'run-pairs': '2', 'run-side': 'comparison' };
            const unknown = [];
            const invalid = [];
            const defaultWarmup = (blockCount) => String(Math.floor(Number(blockCount) / 4));
            const parseGasLimit = (value) => {
              const match = value.match(/^(\d+)([MGT])?$/i);
              if (!match) return null;
              const multipliers = { M: 1_000_000n, G: 1_000_000_000n, T: 1_000_000_000_000n };
              const suffix = match[2]?.toUpperCase();
              const gasLimit = BigInt(match[1]) * (suffix ? multipliers[suffix] : 1n);
              return gasLimit.toString();
            };
            const args = body.replace(/^(?:@decofe|derek) bench\s*/, '');
            // Parse args, handling quoted values like key="value with spaces"
            const parts = [];
            const argRegex = /(\S+?="[^"]*"|\S+?='[^']*'|\S+)/g;
            let m;
            while ((m = argRegex.exec(args)) !== null) parts.push(m[1]);
            for (const part of parts) {
              const eq = part.indexOf('=');
              if (eq === -1) {
                if (boolArgs.has(part)) {
                  defaults[part] = 'true';
                } else {
                  unknown.push(part);
                }
                continue;
              }
              const key = part.slice(0, eq);
              let value = part.slice(eq + 1);
              // Strip surrounding quotes
              if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
                value = value.slice(1, -1);
              }
              if (key === 'bloat') {
                if (!bloatValues.has(value)) {
                  invalid.push(`\`${key}=${value}\` (must be one of: 1, 10, 100)`);
                } else {
                  defaults[key] = value;
                }
              } else if (key === 'gas-limit' || key === 'general-gas-limit') {
                const parsedGasLimit = parseGasLimit(value);
                if (parsedGasLimit === null) {
                  invalid.push(`\`${key}=${value}\` (must be a positive integer, optionally using M/G/T suffix)`);
                } else {
                  defaults[key] = parsedGasLimit;
                }
              } else if (intArgs.has(key)) {
                if (!/^\d+$/.test(value)) {
                  invalid.push(`\`${key}=${value}\` (must be a positive integer)`);
                } else {
                  defaults[key] = value;
                  if (key === 'warmup') explicitWarmup = true;
                  if (key === 'duration') explicitDuration = true;
                  if (key === 'run-pairs') explicitRunPairs = true;
                  if (key === 'tracy-offset') explicitTracyOffset = true;
                }
              } else if (refArgs.has(key)) {
                if (!value) {
                  invalid.push(`\`${key}=\` (must be a git ref)`);
                } else {
                  defaults[key] = value;
                }
              } else if (boolArgs.has(key)) {
                if (value === 'true' || value === 'false') {
                  defaults[key] = value;
                } else {
                  invalid.push(`\`${key}=${value}\` (must be true or false)`);
                }
              } else if (stringArgs.has(key)) {
                if (!value) {
                  invalid.push(`\`${key}=\` (must not be empty)`);
                } else {
                  defaults[key] = value;
                }
              } else {
                unknown.push(key);
              }
            }
            const errors = [];
            if (unknown.length) errors.push(`Unknown argument(s): \`${unknown.join('`, `')}\``);
            if (invalid.length) errors.push(`Invalid value(s): ${invalid.join(', ')}`);
            if (errors.length) {
              const msg = `❌ **Invalid bench command**\n\n${errors.join('\n')}\n\n**Usage:** \`@decofe bench [mode=MODE] [chain=mainnet|testnet] [blocks=N] [warmup=N] [run-pairs=N] [run-side=comparison|feature] [preset=NAME] [duration=N] [bloat=1|10|100] [token-count=N] [tps=N] [accounts=N] [max-concurrent-requests=N] [gas-limit=N|NM|NG|NT] [general-gas-limit=N|NM|NG|NT] [baseline=REF] [feature=REF] [baseline-hardfork=T0|T1|T1A|T1B|T1C|T2|T3|T4|T5|T6|T7|T8] [feature-hardfork=T0|T1|T1A|T1B|T1C|T2|T3|T4|T5|T6|T7|T8] [baseline-features="FEATURES"] [feature-features="FEATURES"] [txgen-ref=REF] [samply] [tracy] [otlp] [metrics[=true|false]] [valscope] [skip-state-root] [force-bloat] [no-cache] [no-slack] [tracy-seconds=N] [tracy-offset=N] [baseline-args="ARGS"] [feature-args="ARGS"] [bench-args="ARGS"] [bench-env="VARS"] [baseline-env="VARS"] [feature-env="VARS"]\``;
              await github.rest.issues.createComment({
                owner: context.repo.owner,
                repo: context.repo.repo,
                issue_number: context.issue.number,
                body: msg,
              });
              core.setFailed(msg);
              return;
            }
            mode = defaults.mode;
            preset = defaults.preset;
            duration = defaults.duration;
            bloat = defaults.bloat;
            tokenCount = defaults['token-count'];
            tps = defaults.tps;
            accounts = defaults.accounts;
            maxConcurrentRequests = defaults['max-concurrent-requests'];
            baseline = defaults.baseline;
            feature = defaults.feature;
            baselineHardfork = defaults['baseline-hardfork'];
            featureHardfork = defaults['feature-hardfork'];
            baselineFeatures = defaults['baseline-features'];
            featureFeatures = defaults['feature-features'];
            txgenRef = defaults['txgen-ref'];
            samply = defaults.samply;
            tracy = defaults.tracy === 'true' ? 'tracy' : 'off';
            tracySeconds = defaults['tracy-seconds'];
            tracyOffset = defaults['tracy-offset'];
            otlp = defaults.otlp;
            valscope = defaults.valscope;
            metrics = defaults.metrics;
            skipStateRoot = defaults['skip-state-root'];
            baselineArgs = defaults['baseline-args'];
            featureArgs = defaults['feature-args'];
            gasLimit = defaults['gas-limit'];
            generalGasLimit = defaults['general-gas-limit'];
            runType = 'manual';
            forceBloat = defaults['force-bloat'];
            noCache = defaults['no-cache'];
            noSlack = defaults['no-slack'];
            benchArgs = defaults['bench-args'];
            benchEnv = defaults['bench-env'];
            baselineEnv = defaults['baseline-env'];
            featureEnv = defaults['feature-env'];
            blocks = defaults.blocks;
            warmup = defaults.warmup;
            runPairs = defaults['run-pairs'];
            runSide = defaults['run-side'];
            var chain = defaults.chain;
            if (mode === 'e2e') {
              if (!explicitDuration) duration = '90';
              if (!explicitRunPairs) runPairs = '3';
            }
            if (!explicitWarmup) {
              warmup = defaultWarmup(blocks);
            }
            if (!explicitTracyOffset) {
              tracyOffset = String(Math.floor(Number(duration) / 2));
            }

            const usageStr = '**Usage:** `@decofe bench [mode=MODE] [chain=mainnet|testnet] [blocks=N] [warmup=N] [run-pairs=N] [run-side=comparison|feature] [preset=NAME] [duration=N] [bloat=1|10|100] [token-count=N] [tps=N] [accounts=N] [max-concurrent-requests=N] [gas-limit=N|NM|NG|NT] [general-gas-limit=N|NM|NG|NT] [baseline=REF] [feature=REF] [baseline-hardfork=T0|T1|T1A|T1B|T1C|T2|T3|T4|T5|T6|T7|T8] [feature-hardfork=T0|T1|T1A|T1B|T1C|T2|T3|T4|T5|T6|T7|T8] [baseline-features="FEATURES"] [feature-features="FEATURES"] [txgen-ref=REF] [samply] [tracy] [otlp] [metrics[=true|false]] [valscope] [skip-state-root] [force-bloat] [no-cache] [no-slack] [tracy-seconds=N] [tracy-offset=N] [baseline-args="ARGS"] [feature-args="ARGS"] [bench-args="ARGS"] [bench-env="VARS"] [baseline-env="VARS"] [feature-env="VARS"]`';

            // Validate chain value
            if (!['mainnet', 'testnet'].includes(chain)) {
              const msg = `❌ **Invalid bench command**\n\n\`chain=${chain}\` is not valid. Must be \`mainnet\` or \`testnet\`.\n\n${usageStr}`;
              await github.rest.issues.createComment({
                owner: context.repo.owner,
                repo: context.repo.repo,
                issue_number: context.issue.number,
                body: msg,
              });
              core.setFailed(msg);
              return;
            }

            // Validate mode value
            if (!['e2e', 'replay'].includes(mode)) {
              const msg = `❌ **Invalid bench command**\n\n\`mode=${mode}\` is not valid. Must be \`e2e\` or \`replay\`.\n\n${usageStr}`;
              await github.rest.issues.createComment({
                owner: context.repo.owner,
                repo: context.repo.repo,
                issue_number: context.issue.number,
                body: msg,
              });
              core.setFailed(msg);
              return;
            }
            if (!['comparison', 'feature'].includes(runSide)) {
              const msg = `❌ **Invalid bench command**\n\n\`run-side=${runSide}\` is not valid. Must be \`comparison\` or \`feature\`.\n\n${usageStr}`;
              await github.rest.issues.createComment({
                owner: context.repo.owner,
                repo: context.repo.repo,
                issue_number: context.issue.number,
                body: msg,
              });
              core.setFailed(msg);
              return;
            }
            if (runSide !== 'comparison' && mode !== 'e2e') {
              const msg = `❌ **Invalid bench command**\n\n\`run-side=${runSide}\` is only supported with \`mode=e2e\`.\n\n${usageStr}`;
              await github.rest.issues.createComment({
                owner: context.repo.owner,
                repo: context.repo.repo,
                issue_number: context.issue.number,
                body: msg,
              });
              core.setFailed(msg);
              return;
            }

            if ((baselineHardfork || featureHardfork) && mode !== 'e2e') {
              const msg = `❌ **Invalid bench command**\n\n\`baseline-hardfork\` and \`feature-hardfork\` are only supported with \`mode=e2e\`.\n\n${usageStr}`;
              await github.rest.issues.createComment({
                owner: context.repo.owner,
                repo: context.repo.repo,
                issue_number: context.issue.number,
                body: msg,
              });
              core.setFailed(msg);
              return;
            }
            if ((baselineHardfork || featureHardfork) && !(baselineHardfork && featureHardfork)) {
              const msg = `❌ **Invalid bench command**\n\n\`baseline-hardfork\` and \`feature-hardfork\` must be provided together.\n\n${usageStr}`;
              await github.rest.issues.createComment({
                owner: context.repo.owner,
                repo: context.repo.repo,
                issue_number: context.issue.number,
                body: msg,
              });
              core.setFailed(msg);
              return;
            }
            if (baselineHardfork || featureHardfork) {
              baselineHardfork = baselineHardfork.toUpperCase();
              featureHardfork = featureHardfork.toUpperCase();
              const badHardforks = [baselineHardfork, featureHardfork].filter(value => !hardforkValues.has(value));
              if (badHardforks.length) {
                const msg = `❌ **Invalid bench command**\n\nUnknown hardfork(s): \`${badHardforks.join('`, `')}\`. Must be one of: \`${Array.from(hardforkValues).join('`, `')}\`.\n\n${usageStr}`;
                await github.rest.issues.createComment({
                  owner: context.repo.owner,
                  repo: context.repo.repo,
                  issue_number: context.issue.number,
                  body: msg,
                });
                core.setFailed(msg);
                return;
              }
            }

            // Validate tracy value
            if (!['off', 'tracy'].includes(tracy)) {
              const msg = `❌ **Invalid bench command**\n\n\`tracy=${tracy}\` is not valid. Must be \`off\` or \`tracy\`.\n\n${usageStr}`;
              await github.rest.issues.createComment({
                owner: context.repo.owner,
                repo: context.repo.repo,
                issue_number: context.issue.number,
                body: msg,
              });
              core.setFailed(msg);
              return;
            }

            if (!['manual', 'nightly'].includes(runType)) {
              const msg = `❌ **Invalid benchmark type**\n\n\`run-type=${runType}\` is not valid. Must be \`manual\` or \`nightly\`.`;
              core.setFailed(msg);
              return;
            }
            if (Number(runPairs) < 1) {
              const msg = `❌ **Invalid bench command**\n\n\`run-pairs=${runPairs}\` is not valid. Must be a positive integer.\n\n${usageStr}`;
              await github.rest.issues.createComment({
                owner: context.repo.owner,
                repo: context.repo.repo,
                issue_number: context.issue.number,
                body: msg,
              });
              core.setFailed(msg);
              return;
            }
            if (Number(tokenCount) < 1 || Number(tokenCount) > 4) {
              const msg = `❌ **Invalid bench command**\n\n\`token-count=${tokenCount}\` is not valid. Must be between 1 and 4, matching the TIP20 tokens available in state bloat.\n\n${usageStr}`;
              await github.rest.issues.createComment({
                owner: context.repo.owner,
                repo: context.repo.repo,
                issue_number: context.issue.number,
                body: msg,
              });
              core.setFailed(msg);
              return;
            }

            // Resolve display names for baseline/feature
            let baselineName = baseline || 'merge-base';
            let featureName = feature;
            if (pr) {
              const { data: prData } = await github.rest.pulls.get({
                owner: context.repo.owner,
                repo: context.repo.repo,
                pull_number: parseInt(pr),
              });
              core.setOutput('pr-head-sha', prData.head.sha);
              core.setOutput('pr-head-ref', prData.head.ref);
              if (!featureName) featureName = prData.head.ref;
            } else {
              if (!featureName) featureName = process.env.INPUT_REF_NAME;
            }

            core.setOutput('pr', pr || '');
            core.setOutput('actor', actor);
            core.setOutput('mode', mode);
            core.setOutput('preset', preset);
            core.setOutput('duration', duration);
            core.setOutput('bloat', bloat);
            core.setOutput('token-count', tokenCount);
            core.setOutput('tps', tps);
            core.setOutput('accounts', accounts);
            core.setOutput('max-concurrent-requests', maxConcurrentRequests);
            core.setOutput('baseline', baseline);
            core.setOutput('feature', feature);
            core.setOutput('baseline-hardfork', baselineHardfork || '');
            core.setOutput('feature-hardfork', featureHardfork || '');
            core.setOutput('baseline-features', baselineFeatures || '');
            core.setOutput('feature-features', featureFeatures || '');
            core.setOutput('txgen-ref', txgenRef || '');
            core.setOutput('baseline-name', baselineName);
            core.setOutput('feature-name', featureName);
            core.setOutput('samply', samply);
            core.setOutput('tracy', tracy);
            core.setOutput('tracy-seconds', tracySeconds);
            core.setOutput('tracy-offset', tracyOffset);
            core.setOutput('otlp', otlp);
            core.setOutput('valscope', valscope);
            core.setOutput('skip-state-root', skipStateRoot);
            core.setOutput('baseline-args', baselineArgs || '');
            core.setOutput('feature-args', featureArgs || '');
            core.setOutput('gas-limit', gasLimit);
            core.setOutput('general-gas-limit', generalGasLimit || '');
            core.setOutput('run-type', runType);
            core.setOutput('force-bloat', forceBloat);
            core.setOutput('no-cache', noCache);
            core.setOutput('no-slack', noSlack);
            core.setOutput('metrics', metrics);
            core.setOutput('bench-args', benchArgs || '');
            core.setOutput('bench-env', benchEnv || '');
            core.setOutput('baseline-env', baselineEnv || '');
            core.setOutput('feature-env', featureEnv || '');
            core.setOutput('blocks', blocks);
            core.setOutput('warmup', warmup);
            core.setOutput('chain', chain);
            core.setOutput('run-pairs', runPairs);
            core.setOutput('run-side', runSide);

      - name: Acknowledge request
        id: ack
        if: steps.command.outputs.is-bench-command == 'true'
        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
        env:
          ACK_PR: ${{ steps.args.outputs.pr }}
          ACK_ACTOR: ${{ steps.args.outputs.actor }}
          ACK_MODE: ${{ steps.args.outputs.mode }}
          ACK_PRESET: ${{ steps.args.outputs.preset }}
          ACK_DURATION: ${{ steps.args.outputs.duration }}
          ACK_BLOAT: ${{ steps.args.outputs.bloat }}
          ACK_TOKEN_COUNT: ${{ steps.args.outputs.token-count }}
          ACK_TPS: ${{ steps.args.outputs.tps }}
          ACK_ACCOUNTS: ${{ steps.args.outputs.accounts }}
          ACK_MAX_CONCURRENT_REQUESTS: ${{ steps.args.outputs.max-concurrent-requests }}
          ACK_BASELINE_NAME: ${{ steps.args.outputs.baseline-name }}
          ACK_FEATURE_NAME: ${{ steps.args.outputs.feature-name }}
          ACK_BASELINE_HARDFORK: ${{ steps.args.outputs.baseline-hardfork }}
          ACK_FEATURE_HARDFORK: ${{ steps.args.outputs.feature-hardfork }}
          ACK_BASELINE_FEATURES: ${{ steps.args.outputs.baseline-features }}
          ACK_FEATURE_FEATURES: ${{ steps.args.outputs.feature-features }}
          ACK_TXGEN_REF: ${{ steps.args.outputs.txgen-ref }}
          ACK_SAMPLY: ${{ steps.args.outputs.samply }}
          ACK_TRACY: ${{ steps.args.outputs.tracy }}
          ACK_OTLP: ${{ steps.args.outputs.otlp }}
          ACK_VALSCOPE: ${{ steps.args.outputs.valscope }}
          ACK_BASELINE_ARGS: ${{ steps.args.outputs.baseline-args }}
          ACK_FEATURE_ARGS: ${{ steps.args.outputs.feature-args }}
          ACK_GAS_LIMIT: ${{ steps.args.outputs.gas-limit }}
          ACK_GENERAL_GAS_LIMIT: ${{ steps.args.outputs.general-gas-limit }}
          ACK_RUN_PAIRS: ${{ steps.args.outputs.run-pairs }}
          ACK_RUN_SIDE: ${{ steps.args.outputs.run-side }}
          ACK_NO_CACHE: ${{ steps.args.outputs.no-cache }}
        with:
          github-token: ${{ secrets.DEREK_BENCH_TOKEN }}
          script: |
            if (context.eventName === 'issue_comment') {
              await github.rest.reactions.createForIssueComment({
                owner: context.repo.owner,
                repo: context.repo.repo,
                comment_id: context.payload.comment.id,
                content: 'eyes',
              });
            }

            const pr = process.env.ACK_PR;
            if (!pr) return;

            const runUrl = `${context.serverUrl}/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}`;

            const actor = process.env.ACK_ACTOR;
            const mode = process.env.ACK_MODE;
            const preset = process.env.ACK_PRESET;
            const duration = process.env.ACK_DURATION;
            const bloat = process.env.ACK_BLOAT;
            const tokenCount = process.env.ACK_TOKEN_COUNT;
            const tps = process.env.ACK_TPS;
            const accounts = process.env.ACK_ACCOUNTS;
            const maxConcurrentRequests = process.env.ACK_MAX_CONCURRENT_REQUESTS;
            const baseline = process.env.ACK_BASELINE_NAME;
            const feature = process.env.ACK_FEATURE_NAME;
            const baselineHardfork = process.env.ACK_BASELINE_HARDFORK || '';
            const featureHardfork = process.env.ACK_FEATURE_HARDFORK || '';
            const baselineFeatureFlags = process.env.ACK_BASELINE_FEATURES || '';
            const featureFeatureFlags = process.env.ACK_FEATURE_FEATURES || '';
            const txgenRef = process.env.ACK_TXGEN_REF || 'default';
            const samply = process.env.ACK_SAMPLY === 'true';
            const samplyNote = samply ? ', samply: `enabled`' : '';
            const tracy = process.env.ACK_TRACY;
            const tracyNote = tracy !== 'off' ? ', tracy: `enabled`' : '';
            const otlp = process.env.ACK_OTLP === 'true';
            const otlpNote = otlp ? ', otlp: `enabled`' : ', otlp: `disabled`';
            const valscope = process.env.ACK_VALSCOPE === 'true';
            const valscopeNote = valscope ? ', valscope: `enabled`' : ', valscope: `disabled`';
            const bNa = process.env.ACK_BASELINE_ARGS || '';
            const fNa = process.env.ACK_FEATURE_ARGS || '';
            const naNote = (bNa || fNa) ? `${bNa ? `, baseline-args: \`${bNa}\`` : ''}${fNa ? `, feature-args: \`${fNa}\`` : ''}` : '';
            const gasLimit = process.env.ACK_GAS_LIMIT;
            const generalGasLimit = process.env.ACK_GENERAL_GAS_LIMIT || '';
            const generalGasLimitNote = generalGasLimit ? `, general-gas-limit: \`${generalGasLimit}\`` : '';
            const runPairs = process.env.ACK_RUN_PAIRS || '2';
            const runSide = process.env.ACK_RUN_SIDE || 'comparison';
            const noCache = process.env.ACK_NO_CACHE === 'true';
            const noCacheNote = noCache ? ', no-cache: `true`' : '';
            const hardforkNote = (baselineHardfork || featureHardfork) ? `, baseline-hardfork: \`${baselineHardfork}\`, feature-hardfork: \`${featureHardfork}\`` : '';
            const featureFlagsNote = `${baselineFeatureFlags ? `, baseline-features: \`${baselineFeatureFlags}\`` : ''}${featureFeatureFlags ? `, feature-features: \`${featureFeatureFlags}\`` : ''}`;
            const runSideNote = runSide !== 'comparison' ? `, run-side: \`${runSide}\`` : '';
            const config = `**Config:** mode: \`${mode}\`, preset: \`${preset}\`, duration: \`${duration}s\`, bloat: \`${bloat} GiB\`, token-count: \`${tokenCount}\`, tps: \`${tps}\`, accounts: \`${accounts}\`, max-concurrent-requests: \`${maxConcurrentRequests}\`, gas-limit: \`${gasLimit}\`${generalGasLimitNote}, run-pairs: \`${runPairs}\`${runSideNote}, baseline: \`${baseline}\`, feature: \`${feature}\`, txgen-ref: \`${txgenRef}\`${hardforkNote}${featureFlagsNote}${samplyNote}${tracyNote}${otlpNote}${valscopeNote}${naNote}${noCacheNote}`;

            const { data: comment } = await github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: parseInt(pr),
              body: `cc @${actor}\n\n🚀 Benchmark queued! [View run](${runUrl})\n\n⏳ **Status:** Waiting for runner...\n\n${config}`,
            });
            core.setOutput('comment-id', String(comment.id));

  bench-e2e:
    needs: tempo-bench-ack
    if: needs.tempo-bench-ack.outputs.mode == 'e2e'
    uses: ./.github/workflows/bench-e2e.yml
    with:
      pr: ${{ needs.tempo-bench-ack.outputs.pr }}
      actor: ${{ needs.tempo-bench-ack.outputs.actor }}
      mode: ${{ needs.tempo-bench-ack.outputs.mode }}
      preset: ${{ needs.tempo-bench-ack.outputs.preset }}
      duration: ${{ needs.tempo-bench-ack.outputs.duration }}
      bloat: ${{ needs.tempo-bench-ack.outputs.bloat }}
      token-count: ${{ needs.tempo-bench-ack.outputs.token-count }}
      tps: ${{ needs.tempo-bench-ack.outputs.tps }}
      accounts: ${{ needs.tempo-bench-ack.outputs.accounts }}
      max-concurrent-requests: ${{ needs.tempo-bench-ack.outputs.max-concurrent-requests }}
      baseline: ${{ needs.tempo-bench-ack.outputs.baseline }}
      feature: ${{ needs.tempo-bench-ack.outputs.feature }}
      baseline-hardfork: ${{ needs.tempo-bench-ack.outputs.baseline-hardfork }}
      feature-hardfork: ${{ needs.tempo-bench-ack.outputs.feature-hardfork }}
      baseline-features: ${{ needs.tempo-bench-ack.outputs.baseline-features }}
      feature-features: ${{ needs.tempo-bench-ack.outputs.feature-features }}
      txgen-ref: ${{ needs.tempo-bench-ack.outputs.txgen-ref }}
      baseline-name: ${{ needs.tempo-bench-ack.outputs.baseline-name }}
      feature-name: ${{ needs.tempo-bench-ack.outputs.feature-name }}
      samply: ${{ needs.tempo-bench-ack.outputs.samply }}
      tracy: ${{ needs.tempo-bench-ack.outputs.tracy }}
      tracy-seconds: ${{ needs.tempo-bench-ack.outputs.tracy-seconds }}
      tracy-offset: ${{ needs.tempo-bench-ack.outputs.tracy-offset }}
      otlp: ${{ needs.tempo-bench-ack.outputs.otlp }}
      valscope: ${{ needs.tempo-bench-ack.outputs.valscope }}
      skip-state-root: ${{ needs.tempo-bench-ack.outputs.skip-state-root }}
      baseline-args: ${{ needs.tempo-bench-ack.outputs.baseline-args }}
      feature-args: ${{ needs.tempo-bench-ack.outputs.feature-args }}
      gas-limit: ${{ needs.tempo-bench-ack.outputs.gas-limit }}
      general-gas-limit: ${{ needs.tempo-bench-ack.outputs.general-gas-limit }}
      run-pairs: ${{ needs.tempo-bench-ack.outputs.run-pairs }}
      run-side: ${{ needs.tempo-bench-ack.outputs.run-side }}
      run-type: ${{ needs.tempo-bench-ack.outputs.run-type }}
      force-bloat: ${{ needs.tempo-bench-ack.outputs.force-bloat }}
      no-cache: ${{ needs.tempo-bench-ack.outputs.no-cache }}
      no-slack: ${{ needs.tempo-bench-ack.outputs.no-slack }}
      metrics: ${{ needs.tempo-bench-ack.outputs.metrics }}
      bench-args: ${{ needs.tempo-bench-ack.outputs.bench-args }}
      bench-env: ${{ needs.tempo-bench-ack.outputs.bench-env }}
      baseline-env: ${{ needs.tempo-bench-ack.outputs.baseline-env }}
      feature-env: ${{ needs.tempo-bench-ack.outputs.feature-env }}
      comment-id: ${{ needs.tempo-bench-ack.outputs.comment-id }}
      pr-head-sha: ${{ needs.tempo-bench-ack.outputs.pr-head-sha }}
      pr-head-ref: ${{ needs.tempo-bench-ack.outputs.pr-head-ref }}
    secrets:
      DEREK_BENCH_TOKEN: ${{ secrets.DEREK_BENCH_TOKEN }}
      TEMPO_TELEMETRY_URL: ${{ secrets.TEMPO_TELEMETRY_URL }}
      GRAFANA_TEMPO: ${{ secrets.GRAFANA_TEMPO }}
      CLICKHOUSE_URL: ${{ secrets.CLICKHOUSE_URL }}
      CLICKHOUSE_USER: ${{ secrets.CLICKHOUSE_USER }}
      CLICKHOUSE_PASSWORD: ${{ secrets.CLICKHOUSE_PASSWORD }}
      BENCH_VICTORIAMETRICS_URL: ${{ secrets.BENCH_VICTORIAMETRICS_URL }}
      VICTORIAMETRICS_URL: ${{ secrets.VICTORIAMETRICS_URL }}
      VICTORIALOGS_URL: ${{ secrets.VICTORIALOGS_URL }}
      SLACK_BENCH_BOT_TOKEN: ${{ secrets.SLACK_BENCH_BOT_TOKEN }}
      SLACK_BENCH_CHANNEL: ${{ secrets.SLACK_BENCH_CHANNEL }}

  bench-replay:
    needs: tempo-bench-ack
    if: needs.tempo-bench-ack.outputs.mode == 'replay'
    uses: ./.github/workflows/bench-replay.yml
    with:
      chain: ${{ needs.tempo-bench-ack.outputs.chain }}
      pr: ${{ needs.tempo-bench-ack.outputs.pr }}
      actor: ${{ needs.tempo-bench-ack.outputs.actor }}
      baseline: ${{ needs.tempo-bench-ack.outputs.baseline }}
      feature: ${{ needs.tempo-bench-ack.outputs.feature }}
      baseline-name: ${{ needs.tempo-bench-ack.outputs.baseline-name }}
      feature-name: ${{ needs.tempo-bench-ack.outputs.feature-name }}
      samply: ${{ needs.tempo-bench-ack.outputs.samply }}
      otlp: ${{ needs.tempo-bench-ack.outputs.otlp }}
      baseline-features: ${{ needs.tempo-bench-ack.outputs.baseline-features }}
      feature-features: ${{ needs.tempo-bench-ack.outputs.feature-features }}
      baseline-args: ${{ needs.tempo-bench-ack.outputs.baseline-args }}
      feature-args: ${{ needs.tempo-bench-ack.outputs.feature-args }}
      blocks: ${{ needs.tempo-bench-ack.outputs.blocks }}
      warmup: ${{ needs.tempo-bench-ack.outputs.warmup }}
      run-pairs: ${{ needs.tempo-bench-ack.outputs.run-pairs }}
      metrics: ${{ needs.tempo-bench-ack.outputs.metrics }}
      comment-id: ${{ needs.tempo-bench-ack.outputs.comment-id }}
      pr-head-sha: ${{ needs.tempo-bench-ack.outputs.pr-head-sha }}
      pr-head-ref: ${{ needs.tempo-bench-ack.outputs.pr-head-ref }}
    secrets:
      DEREK_BENCH_TOKEN: ${{ secrets.DEREK_BENCH_TOKEN }}
      DEREK_TOKEN: ${{ secrets.DEREK_TOKEN }}
      TEMPO_TELEMETRY_URL: ${{ secrets.TEMPO_TELEMETRY_URL }}
      GRAFANA_TEMPO: ${{ secrets.GRAFANA_TEMPO }}
      BENCH_VICTORIAMETRICS_URL: ${{ secrets.BENCH_VICTORIAMETRICS_URL }}