Implementation of an address Enumerable Set

contracts/mocks/EnumerableSetMock.sol

@@ -0,0 +1,59 @@
+pragma solidity ^0.5.10;
+import "../utils/EnumerableSet.sol";
+
+
+/**
+ * @title EnumerableSetMock
+ * @dev Data structure - https://en.wikipedia.org/wiki/Set_(abstract_data_type)
+ * @author Alberto Cuesta Cañada
+ */
+contract EnumerableSetMock{
+
+    using EnumerableSet for EnumerableSet.AddressSet;
+
+    EnumerableSet.AddressSet private set;
+
+    constructor() public {
+        set = EnumerableSet.AddressSet({values: new address[](0)});
+    }
+
+    /**
+     * @dev Returns true if the value is in the set.
+     */
+    function testContains(address value)
+        public
+        view
+        returns (bool)
+    {
+        return EnumerableSet.contains(set, value);
+    }
+
+    /**
+     * @dev Insert an value as the new tail.
+     */
+    function testAdd(address value)
+        public
+    {
+        EnumerableSet.add(set, value);
+    }
+
+    /**
+     * @dev Remove an value.
+     */
+    function testRemove(address remove)
+        public
+    {
+        EnumerableSet.remove(set, remove);
+    }
+
+    /**
+     * @dev Return an array with all values in the set, from Head to Tail.
+     */
+    function testEnumerate()
+        public
+        view
+        returns (address[] memory)
+    {
+        return EnumerableSet.enumerate(set);
+    }
+}

contracts/utils/EnumerableSet.sol

@@ -0,0 +1,84 @@
+pragma solidity ^0.5.10;
+
+
+/**
+ * @title EnumerableSet
+ * @dev Data structure - https://en.wikipedia.org/wiki/Set_(abstract_data_type)
+ *
+ * An EnumerableSet.AddressSet is a data structure containing a number of unique addresses.
+ *
+ *  - It is possible to add and remove addresses in O(1).
+ *  - It is also possible to query if the AddressSet contains an address in O(1).
+ *  - It is possible to retrieve an array with all the addresses in the AddressSet using enumerate.
+ *    This operation is O(N) where N is the number of addresses in the AddressSet. The order in
+ *    which the addresses are retrieved is not guaranteed.
+ *
+ * Initialization of a set must include an empty array:
+ * `EnumerableSet.AddressSet set = EnumerableSet.AddressSet({values: new address[](0)});`
+ *
+ * @author Alberto Cuesta Cañada
+ */
+library EnumerableSet {
+
+    event ValueAdded(address value);
+    event ValueRemoved(address value);
+
+    struct AddressSet {
+        // Position of the value in the `values` array, plus 1 because index 0
+        // means a value is not in the set.
+        mapping (address => uint256) index;
+        address[] values;
+    }
+
+    /**
+     * @dev Add a value. O(1).
+     */
+    function add(AddressSet storage set, address value)
+        internal
+    {
+        if (!contains(set, value)){
+            set.index[value] = set.values.push(value);
+            emit ValueAdded(value);
+        }
+    }
+
+    /**
+     * @dev Remove a value. O(1).
+     */
+    function remove(AddressSet storage set, address value)
+        internal
+    {
+        if (contains(set, value)) {
+            set.values[set.index[value] - 1] = set.values[set.values.length - 1];
+            set.values.pop();
+            delete set.index[value];
+            emit ValueRemoved(value);
+        }
+    }
+
+    /**
+     * @dev Returns true if the value is in the set. O(1).
+     */
+    function contains(AddressSet storage set, address value)
+        internal
+        view
+        returns (bool)
+    {
+        return set.index[value] != 0;
+    }
+
+    /**
+     * @dev Return an array with all values in the set. O(N).
+     */
+    function enumerate(AddressSet storage set)
+        internal
+        view
+        returns (address[] memory)
+    {
+        address[] memory output = new address[](set.values.length);
+        for (uint256 i; i < set.values.length; i++){
+            output[i] = set.values[i];
+        }
+        return output;
+    }
+}

test/utils/EnumerableSet.test.js

@@ -0,0 +1,54 @@
+const { contract } = require('@openzeppelin/test-environment');
+
+const { expect } = require('chai');
+
+const EnumerableSetMock = contract.fromArtifact('EnumerableSetMock');
+
+const a = '0x0000000000000000000000000000000000000001';
+const b = '0x0000000000000000000000000000000000000002';
+const c = '0x0000000000000000000000000000000000000003';
+
+/** @test {EnumerableSet} contract */
+describe('EnumerableSet', function () {
+  beforeEach(async function () {
+    this.set = await EnumerableSetMock.new();
+  });
+
+  it('contains can return false.', async function () {
+    expect(await this.set.testContains(a)).to.equal(false);
+  });
+
+  it('adds a value.', async function () {
+    await this.set.testAdd(a);
+    expect(await this.set.testContains(a)).to.equal(true);
+  });
+
+  it('adds several values.', async function () {
+    await this.set.testAdd(a);
+    await this.set.testAdd(b);
+    expect(await this.set.testContains(a)).to.equal(true);
+    expect(await this.set.testContains(b)).to.equal(true);
+    expect(await this.set.testContains(c)).to.equal(false);
+  });
+
+  it('removes values.', async function () {
+    await this.set.testAdd(a);
+    await this.set.testRemove(a);
+    expect(await this.set.testContains(a)).to.equal(false);
+  });
+
+  it('enumerates values as an empty array', async function () {
+    expect(await this.set.testEnumerate()).to.eql([]);
+  });
+
+  it('enumerates an array of values', async function () {
+    await this.set.testAdd(a);
+    await this.set.testAdd(b);
+    await this.set.testAdd(c);
+    const result = (await this.set.testEnumerate());
+    expect(result.length).to.be.equal(3);
+    expect(result[0]).to.be.equal(a);
+    expect(result[1]).to.be.equal(b);
+    expect(result[2]).to.be.equal(c);
+  });
+});