Messages with tokens

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

import { AxelarExecutableWithToken } from '@axelar-network/axelar-gmp-sdk-solidity/contracts/executable/AxelarExecutableWithToken.sol';
import { IAxelarGasService } from '@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IAxelarGasService.sol';
import { IERC20 } from '@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IERC20.sol';
import { SafeTokenTransfer, SafeTokenTransferFrom } from '@axelar-network/axelar-gmp-sdk-solidity/contracts/libs/SafeTransfer.sol';

contract Distributor is AxelarExecutableWithToken {
    using SafeTokenTransfer for IERC20;
    using SafeTokenTransferFrom for IERC20;

    IAxelarGasService public immutable gasService;

    constructor(address gateway_, address gasService_) AxelarExecutableWithToken(gateway_) {
        gasService = IAxelarGasService(gasService_);
    }

    function sendToMany(
        string calldata destinationChain,
        string calldata destinationAddress,
        address[] calldata recipients,
        string calldata symbol,
        uint256 amount
    ) external payable {
        IERC20 token = IERC20(gatewayWithToken().tokenAddresses(symbol));

        // Take the tokens from the caller, who approved this contract first
        token.safeTransferFrom(msg.sender, address(this), amount);
        // Let the gateway take them from this contract
        token.approve(address(gateway()), amount);

        bytes memory payload = abi.encode(recipients);

        gasService.payNativeGasForContractCallWithToken{ value: msg.value }(
            address(this),
            destinationChain,
            destinationAddress,
            payload,
            symbol,
            amount,
            msg.sender // refund address
        );

        gatewayWithToken().callContractWithToken(destinationChain, destinationAddress, payload, symbol, amount);
    }

    function _execute(bytes32, string calldata, string calldata, bytes calldata) internal pure override {
        revert('Tokens required');
    }

    function _executeWithToken(
        bytes32 /* commandId */,
        string calldata /* sourceChain */,
        string calldata /* sourceAddress */,
        bytes calldata payload,
        string calldata tokenSymbol,
        uint256 amount
    ) internal override {
        // The gateway has already sent `amount` of the token to this contract
        address[] memory recipients = abi.decode(payload, (address[]));
        IERC20 token = IERC20(gatewayWithToken().tokenAddresses(tokenSymbol));

        uint256 share = amount / recipients.length;
        for (uint256 i = 0; i < recipients.length; i++) {
            token.safeTransfer(recipients[i], share);
        }
    }
}