I need a contract that can send funds at 1 time to multiple addresses by percentage. Ex: n disbursements 1@ 20% Another - 14% Another - x% Another - x% and so on.

Ethereum does NOT have this capability. Does EOS?

2 Answers 2


If you want to send tokens to multiple accounts. You should send the names and the corresponding percentage inside a vector. I have written the code and tested the same with my contract It goes like this:

void samplecontract::percentage(account_name sender,
                                  vector<account_name> &receivers,
                                  vector<double> &percentages,
                                  vector<string> &memos,
                                  string memo)
    eosio::token t(N(eosio.token));
    const auto sym_name = eosio::symbol_type(S(4, EOS)).name();
    //get balance of sender first
    const auto my_balance = t.get_balance(sender, sym_name);

    print("\n initiate transacitons  _________________\n");
    for (int i = 0; i < receivers.size(); i++)
        //calculating asset to be send 
        eosio::asset tosend = (my_balance * (percentages[i] * 100)) / 10000;
        print("value is _____________", tosend);
        samplecontract::senderaction(sender, receivers[i], tosend, memos[i], 0);


void samplecontract::senderaction(account_name sender,
                                      account_name to,
                                      asset quantity,
                                      string memo,
                                      uint64_t delay)
    eosio::transaction txn{};

        eosio::permission_level(sender, N(active)),
        std::make_tuple(sender, to, quantity, memo));
    txn.delay_sec = delay;
    txn.send(eosio::string_to_name(memo.c_str()), sender);


I added this as a deferred transaction you can use inline transaction as well. Remember both action should be @abi action. You can also customize the logic of memos , it's up to you. This code working fine in my case.


You can easily execute a transfer action in smart contract. For my current project, I have created an executeTransfer method that I can call from my other code whenever I need to move tokens around.

void executeTransfer(name from, name to, asset quantity) {
        permission_level{ from, "active"_n},
        std::make_tuple(from, to, quantity, string("Token Transfer"))
    ).send() ;

If you want to disperse tokens to multiple accounts, simply calculate the number of tokens for each account, and call the method multiple times (once for each account you need to send to). Because all smart contract invocations are transactional, if any of the transfers fail, then the entire operation will roll back and no tokens will be sent to anyone.

  • The number of tokens must be expressed as a percentage because the quantity changes based token price. Is this possible?
    – Fred Jones
    Commented Nov 8, 2018 at 3:47
  • Also it must be done automatically: the contract receives x number of tokens and automatically disperses every time based %.
    – Fred Jones
    Commented Nov 8, 2018 at 3:50
  • You can pass floats into a method. Once you have the appropriate percentages, you can then calculate the amount to be paid to each account and then call the executeTransfer method with the appropriate values. You cannot send tokens when calling a smart contract method, so you'd either have to send the tokens to the contract, then invoke the dispersal method, or implement the logic inside your contracts transfer method and disperse the tokens from there. Commented Nov 8, 2018 at 22:50

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.