Solidity ERC-20 – Handling Multiple Transfers

I tried calling MyToken.transferAnyERC20Token() which also uses ERC20(token).transfer(). That works fine over there, but the seemingly same call in the airdrop contract errors out.

I'm not 100% sure this is the solution, but the way you described your process hints at some confusion about where the tokens should be.

When you test manually, your externally owned account that signs the transaction needs to have tokens in order to send them. The same goes for the Airdrop. It can't send what it doesn't have.

Did you remember to transfer from the deployer/minter account to the Airdrop contract before instructing the Airdrop contract to send tokens it doesn't have?

In case it isn't clear.

1. Alice deploys the contracts and Alice (usually) has 100% of the initial supply.
2. Alice wants the Airdrop contract to distribute tokens, so Alice transfers sufficient tokens to the Airdrop contract.
3. Alice signs a transaction to the Airdrop contract, instructing it to forward tokens in the Airdrop contract's custody to recipients.

The OpenZeppelin implementation of ERC20 which you appear to be using will throw an exception in the case that the sender (which is the Airdrop contract) has insufficient tokens to draw from for the transfer method.

Hope it helps.

I believe @shane's answer is a bit misleading. Yes, you can add freezing functionality in your token contract, as mentioned in the comments.

If you are worried whether this gives "too much power" to the token contract owner, it's just an issue about how the freezing functionality is coded. If you add a generic possibility to freeze whatever transfers whenever the owner wants then I agree that it might not be a good idea business-wise.

However, nothing stops you from implementing the freezing functionality so that (certain) transfers can be frozen only during some time (or other criteria) and after that the freezing functionality would not work anymore and it would be useless.

So your transfer function could have something like this:

pragma solidity ^0.4.25;
contract TokenContract { 
    uint256 freezingPossible = 1539060104; // decides by you
    address oneFrozen = 0x123;


    function transfer(address to, uint tokens) public returns (bool success) {
        if (now < freezingPossible) {
            require(to != oneFrozen, "The account should not be frozen");
        }
        // normal transfer logic
    }
}

The above code actually prevents transferring tokens to the frozen account, not from it as is required, but hopefully you get the idea.

Remember to implement similar functionality also for transferFrom.