How to divide and allocate the amount to token holders without loops?

Question

I have a smart contract that keeps record of the people holding the tokens in form of array of addresses. An owner of the smart contract, whenever, sends some ethers to the contract these ethers shall be divided among all token holders depending on how much they hold the tokens and accordingly these fund will be divided. We will allocate the funds to each holder in a form of mapping and once they want to redeem the pending reward will be sent to them.

My code is currently using a for loop to divide the received deposit among all token holders by iterating over the complete array of holders.Since using loop will eventually goes out of gas limit, so what should be the suggested approach here? How can we divide an amount among all token holders without looping/much gas?

Answer 1

You can use the amortisation of work pattern in order to do so. There is a detailed article that describe the similar case.

const uint pointMultiplier = 10e18;
struct Account {
  uint balance;
  uint lastDividendPoints;
}
mapping(address=>Account) accounts;
uint totalSupply;
uint totalDividendPoints;
uint unclaimedDividends;
function dividendsOwing(address account) internal returns(uint) {
  var newDividendPoints = totalDividendPoints - accounts[account].lastDividendPoints;
  return (accounts[account].balance * newDividendPoints) / pointMultiplier;
}
modifier updateAccount(address account) {
  var owing = dividendsOwing(account);
  if(owing > 0) {
    unclaimedDividends -= owing;
    accounts[account].balance += owing;
    accounts[account].lastDividendPoints = totalDividendPoints;
  }
  _;
}
function disburse(uint amount) {
  totalDividendPoints += (amount * pointsMultiplier / totalSupply);
  totalSupply += amount;
  unclaimedDividends += amount;
}

Basically you make users to claim their own dividends with updateAccount modifier and only store totalDividendPoints and unclaimedDividends