[Ethereum] How to create an array of unique addresses

contract-designcontract-developmentsolidity

I have a contract that contains a simple mapping; let's say mapping(address => uint256) balances;

I want to be able to somehow get all the participants of this smart contract. The simplest way seems to have an additional dynamic array of addresses and iterate over them. But searching for an address on each token transfer or payable function call looks overcomplicated.

Is there a way to have something like a set() in Python, i.e. an array of unique addresses?

Best Answer

There's no native set in solidity but you can work something simpler with an array and a mapping.

It is very simple, but have the disadvantage it is append only set, you cannot easily delete an element from it.

contract SimpleSet {
    // Mapping from address to position in the array
    // 0 means the address is not in the array
    mapping (address => uint) index;

    // Array with address 
    address[] store;

    function SimpleSet() public {
        // We will use position 0 to flag invalid address
        store.push(0x0);
    }

    function addToArray(address who) public {
        if (!inArray(who)) {
            // Append
            index[who] = store.length;
            store.push(who);
        }
    }

    function inArray(address who) public view returns (bool) {
        // address 0x0 is not valid if pos is 0 is not in the array
        if (who != 0x0 && index[who] > 0) {
            return true;
        }
        return false;
    }

    function getPosition(uint pos) public view returns (address) {
        // Position 0 is not valid
        require(pos > 0); 
        return store[pos];
    }
}

Related Solutions

ERC-20 – Effective Ways to Store Dividends in Tokens

The token standard doesn't require you to store balances in any particular structure - a public mapping is not part of the standard - so you can simply do this:

struct Account {
    uint balance;
    uint dividends;
}

mapping(address=>Account) accounts;

Assuming you give out dividends proportional to a user's token balances, though, updating the dividends is still going to be a lot of work. Fortunately, there's a better way:

uint totalSupply;
uint totalDividends;

struct Account {
    uint balance;
    uint lastTotalDividends;
}
mapping(address=>Account) accounts;

Now, when you want to give out dividends, increase totalDividends by the amount of the dividend. When a user wants to withdraw their portion of any dividends, they calculate (accounts[user].balance * (totalDividends - accounts[user].lastTotalDividends)) / totalSupply - that is, take the amount of dividend disbursed since they last checked, and calculate the fraction of it they should receive based on the percentage of the tokens they own. Then, update lastTotalDividends to the current value of totalDividends.

Note that if you're doing this, you need to prevent users from sending or receiving tokens until they've withdrawn their dividends, or else users could 'double dip' by transferring tokens between accounts. You could avoid this by adding another field to Account that tracks the dividends they're entitled to but haven't yet withdrawn, and updating that before a transfer out of or into an account.

Solidity Best Practices – Array vs Mapping: When to Use One Over the Other

It always depends on your needs.

The biggest difference is that you can't iterate over a mapping. So if you store two entries (key => value) in a mapping, there is no way to get the values without knowing the keys.

In your example, it also depends on your needs. If you only want to access the answers based on known key (so for example a function which takes an address as input and returns its answer), then you should use a mapping. But if you need to be able to find out how many answers have been given and/or from which addresses, you can't use mapping (at least alone).

Sometimes the optimal solution is to use both: store the actual data in mapping and then store the keys in a separate array, over which you can iterate. The reason is that accessing the actual values is much easier & cheaper from a mapping, given the key. If the values are only in an array, you have to iterate over the whole array to find the right entry.

Arrays also have the downside that if it grows too big, your contract may become unusable. If, for example, you need to search for a value from the array and iterating the whole array costs more than the block gas limit, the contract is basically bricked and useless.

Best Answer

Related Solutions

ERC-20 – Effective Ways to Store Dividends in Tokens

Solidity Best Practices – Array vs Mapping: When to Use One Over the Other

Related Topic