BatchPayer

[
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "tracker",
        "type": "address"
      },
      {
        "internalType": "address[]",
        "name": "holders",
        "type": "address[]"
      }
    ],
    "name": "payMany",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  }
]

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

interface IDividendTracker {
    function withdraw(address holder) external;
}

/// @title  BatchPayer — a gas-saving payout *trigger* for the MEMEDEX DividendTracker.
/// @notice STATELESS, PERMISSIONLESS, and NON-CUSTODIAL. This contract holds no funds and has no privileges.
///         The only thing it can do is call the DividendTracker's already-public `withdraw(holder)`, which pays
///         that holder everything they are owed straight to THEIR OWN wallet — the destination is fixed inside
///         the (immutable) tracker and cannot be influenced from here. Therefore this contract can NEVER
///         withhold, redirect, pause, or drain anything. It exists only to speed up honest payouts by triggering
///         many `withdraw` calls in one transaction instead of rolling the tracker's append-only holder array
///         (which never removes sold-out wallets, so it bloats forever and wastes gas).
///
///         The tracker's security guarantees are untouched: any holder can still call `withdraw` on the tracker
///         themselves at any time, exactly as before. Nothing about "can't be paused/upgraded/drained" or
///         "no one can withhold, redirect, or withdraw what you're owed" changes — this only automates the
///         permissionless path that already exists.
contract BatchPayer {
    /// @notice Trigger `tracker.withdraw(holder)` for each address in `holders`. A per-holder try/catch means a
    ///         single holder whose reward token misbehaves (honeypot / paused / blacklist) is skipped rather than
    ///         reverting the whole batch — matching the fault-tolerance of the tracker's own `process()`.
    /// @param tracker The DividendTracker address.
    /// @param holders The wallets to pay (the keeper feeds in the CURRENT set of real holders each cycle).
    function payMany(address tracker, address[] calldata holders) external {
        IDividendTracker t = IDividendTracker(tracker);
        uint256 n = holders.length;
        for (uint256 i = 0; i < n; i++) {
            try t.withdraw(holders[i]) {} catch {
                // a misbehaving reward token for this holder is skipped; they can be retried next cycle or
                // self-withdraw. Never reverts the batch.
            }
        }
    }
}