[on hold till next version] Port getOwnersByPage to an extension

smart-contract-extensions/contracts/LockInspector.sol

@@ -0,0 +1,51 @@
+pragma solidity ^0.5.0;
+
+import 'unlock-abi-1-3/IPublicLockV6.sol';
+
+/**
+ * @notice Read-only calls to ease reviewing a lock's details.
+ */
+contract LockInspector
+{
+ /**
+  * @notice A function which returns a subset of the keys for this Lock as an array
+  * @param _lock the address of the lock to check
+  * @param _page the page of key owners requested when faceted by page size
+  * @param _pageSize the number of Key Owners requested per page
+  */
+  function getOwnersByPage(
+    IPublicLock _lock,
+    uint _page,
+    uint _pageSize
+  ) external view
+    returns (address[] memory)
+  {
+    uint pageSize = _pageSize;
+    uint startIndex = _page * pageSize;
+    uint endOfPageIndex;
+    uint ownerCount = _lock.numberOfOwners();
+
+    if(startIndex + pageSize > ownerCount)
+    {
+      endOfPageIndex = ownerCount;
+      pageSize = ownerCount - startIndex;
+    }
+    else
+    {
+      endOfPageIndex = (startIndex + pageSize);
+    }
+
+    // new temp in-memory array to hold pageSize number of requested owners:
+    address[] memory ownersByPage = new address[](pageSize);
+    uint pageIndex = 0;
+
+    // Build the requested set of owners into a new temporary array:
+    for (uint i = startIndex; i < endOfPageIndex; i++)
+    {
+      ownersByPage[pageIndex] = _lock.owners(i);
+      pageIndex++;
+    }
+
+    return ownersByPage;
+  }
+}

smart-contract-extensions/test/lockInspector/getOwnersByPage.js

@@ -0,0 +1,91 @@
+const { protocols } = require('hardlydifficult-ethereum-contracts')
+
+const LockInspector = artifacts.require('LockInspector.sol')
+
+const keyPrice = web3.utils.toWei('0.01', 'ether')
+let lock
+let lockInspector
+
+contract('getOwnersByPage', accounts => {
+  before(async () => {
+    lock = await protocols.unlock.createTestLock(web3, {
+      keyPrice,
+      from: accounts[1], // Lock owner
+    })
+    lockInspector = await LockInspector.new()
+  })
+
+  describe('when there are 0 key owners', () => {
+    it('returns empty results', async () => {
+      const results = await lockInspector.getOwnersByPage(lock.address, 0, 2, {
+        from: accounts[5],
+      })
+      assert.equal(results.length, 0)
+    })
+  })
+
+  describe('when there are less owners than the page size', () => {
+    it('should return all of the key owners', async () => {
+      await lock.purchase(0, accounts[1], web3.utils.padLeft(0, 40), [], {
+        value: keyPrice,
+        from: accounts[1],
+      })
+      let result = await lockInspector.getOwnersByPage(lock.address, 0, 2, {
+        from: accounts[0],
+      })
+      assert.equal(result.length, 1)
+      assert.include(result, accounts[1])
+    })
+  })
+
+  describe('when there are more owners than the page size', () => {
+    it('return page size number of key owners', async () => {
+      await lock.purchase(0, accounts[1], web3.utils.padLeft(0, 40), [], {
+        value: keyPrice,
+        from: accounts[1],
+      })
+
+      await lock.purchase(0, accounts[2], web3.utils.padLeft(0, 40), [], {
+        value: keyPrice,
+        from: accounts[2],
+      })
+
+      await lock.purchase(0, accounts[3], web3.utils.padLeft(0, 40), [], {
+        value: keyPrice,
+        from: accounts[3],
+      })
+
+      let result = await lockInspector.getOwnersByPage(lock.address, 0, 2, {
+        from: accounts[0],
+      })
+      assert.equal(result.length, 2)
+      assert.include(result, accounts[1])
+      assert.include(result, accounts[2])
+    })
+  })
+
+  describe('when requesting a secondary page', () => {
+    it('return page size number of key owners', async () => {
+      await lock.purchase(0, accounts[1], web3.utils.padLeft(0, 40), [], {
+        value: keyPrice,
+        from: accounts[1],
+      })
+
+      await lock.purchase(0, accounts[2], web3.utils.padLeft(0, 40), [], {
+        value: keyPrice,
+        from: accounts[2],
+      })
+
+      await lock.purchase(0, accounts[3], web3.utils.padLeft(0, 40), [], {
+        value: keyPrice,
+        from: accounts[3],
+      })
+
+      let result = await lockInspector.getOwnersByPage(lock.address, 1, 2, {
+        from: accounts[0],
+      })
+      assert.equal(result.length, 1)
+      assert.equal(accounts[3], result[0])
+    })
+  })
+})

smart-contracts/contracts/interfaces/IPublicLock.sol

@@ -102,17 +102,6 @@ contract IPublicLock is IERC721Enumerable {
     address _account
   ) external view returns (uint);
 
-  /**
-  * A function which returns a subset of the keys for this Lock as an array
-  * @param _page the page of key owners requested when faceted by page size
-  * @param _pageSize the number of Key Owners requested per page
-  * @dev Throws if there are no key owners yet
-  */
-  function getOwnersByPage(
-    uint _page,
-    uint _pageSize
-  ) external view returns (address[] memory);
-
   /**
    * Checks if the given address owns the given tokenId.
    * @param _tokenId The tokenId of the key to check

smart-contracts/contracts/mixins/MixinKeys.sol

@@ -131,41 +131,6 @@ contract MixinKeys is
     return keyByOwner[_account].tokenId;
   }
 
- /**
-  * A function which returns a subset of the keys for this Lock as an array
-  * @param _page the page of key owners requested when faceted by page size
-  * @param _pageSize the number of Key Owners requested per page
-  */
-  function getOwnersByPage(uint _page, uint _pageSize)
-    public
-    view
-    returns (address[] memory)
-  {
-    require(owners.length > 0, 'NO_OUTSTANDING_KEYS');
-    uint pageSize = _pageSize;
-    uint _startIndex = _page * pageSize;
-    uint endOfPageIndex;
-
-    if (_startIndex + pageSize > owners.length) {
-      endOfPageIndex = owners.length;
-      pageSize = owners.length - _startIndex;
-    } else {
-      endOfPageIndex = (_startIndex + pageSize);
-    }
-
-    // new temp in-memory array to hold pageSize number of requested owners:
-    address[] memory ownersByPage = new address[](pageSize);
-    uint pageIndex = 0;
-
-    // Build the requested set of owners into a new temporary array:
-    for (uint i = _startIndex; i < endOfPageIndex; i++) {
-      ownersByPage[pageIndex] = owners[i];
-      pageIndex++;
-    }
-
-    return ownersByPage;
-  }
-
   /**
    * Checks if the given address owns the given tokenId.
    */