Implement sortHash and sort on AddressArrayUtils

.gitignore

@@ -3,6 +3,7 @@
 /artifacts/ts
 /build
 /dist
+/node_modules
 /transpiled
 /types/generated/*
 coverage.json
@@ -31,4 +32,4 @@ yarn-error.log*
 blockchain/
 
 # Outputs
-deployments/outputs.ts
+deployments/outputs.ts

contracts/lib/AddressArrayUtils.sol

@@ -211,4 +211,23 @@ library AddressArrayUtils {
         }
         return true;
     }
+
+    /**
+     * Naive implementation of sort
+     * @return Returns a sorted array
+     */
+    function sort(address[] memory A) internal pure returns (address[] memory) {
+        uint256 length = A.length;
+        address[] memory newAddresses = A;
+        for (uint256 i = 0; i < length; i++) {
+            for (uint256 j = i + 1; j < length; j++) {
+                if (newAddresses[i] > newAddresses[j]) {
+                    address temp = newAddresses[i];
+                    newAddresses[i] = newAddresses[j];
+                    newAddresses[j] = temp;
+                }
+            }
+        }
+        return newAddresses;
+    }
 }

contracts/lib/HashUtils.sol

@@ -0,0 +1,17 @@
+pragma solidity 0.5.7;
+
+import { AddressArrayUtils } from "./AddressArrayUtils.sol";
+
+
+library HashUtils {
+    using AddressArrayUtils for address[];
+
+    /**
+     * Sorts the address array and hashes it using the keccak256 hashing algorithm.
+     * @param a The input array
+     * @return Returns bytes32 hash
+     */
+    function sortHash(address[] memory a) internal pure returns (bytes32) {
+        return keccak256(abi.encodePacked(a.sort()));
+    }
+}

contracts/mocks/ArrayAddressUtilsMock.sol

@@ -0,0 +1,12 @@
+pragma solidity 0.5.7;
+
+import { AddressArrayUtils } from "../lib/AddressArrayUtils.sol";
+
+
+contract AddressArrayUtilsMock {
+    using AddressArrayUtils for address[];
+
+    function testSort(address[] calldata _addressArray) external pure returns(address[] memory) {
+        return _addressArray.sort();
+    }
+}

contracts/mocks/HashUtilsMock.sol

@@ -0,0 +1,10 @@
+pragma solidity 0.5.7;
+
+import { HashUtils } from "../lib/HashUtils.sol";
+
+
+contract HashUtilsMock {
+    function testSortHash(address[] calldata _addressArray) external pure returns(bytes32) {
+        return HashUtils.sortHash(_addressArray);
+    }
+}

package.json

@@ -1,6 +1,6 @@
   {
   "name": "set-protocol-contract-utils",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "main": "dist/artifacts/index.js",
   "typings": "dist/typings/artifacts/index.d.ts",
   "files": [

test/contracts/lib/addressArrayUtils.spec.ts

@@ -0,0 +1,63 @@
+require('module-alias/register');
+
+import * as _ from 'lodash';
+import * as chai from 'chai';
+import { Address } from 'set-protocol-utils';
+
+
+import ChaiSetup from '@utils/chaiSetup';
+import { BigNumberSetup } from '@utils/bigNumberSetup';
+import { AddressArrayUtilsMockContract } from '@utils/contracts';
+
+import { LibraryMockHelper } from '@utils/helpers/libraryMockHelper';
+
+BigNumberSetup.configure();
+ChaiSetup.configure();
+const { expect } = chai;
+
+
+contract('AddressArrayUtils', accounts => {
+  const [ownerAccount] = accounts;
+  const libraryMockHelper = new LibraryMockHelper(ownerAccount);
+
+  let addressArrayUtils: AddressArrayUtilsMockContract;
+
+  beforeEach(async () => {
+    addressArrayUtils = await libraryMockHelper.deployAddressArrayUtilsMockAsync();
+  });
+
+  describe('#testSort', async () => {
+    let subjectToSort: Address[];
+
+    beforeEach(async () => {
+      subjectToSort = [
+        '0x6Ecbe1DB9EF729CBe972C83Fb886247691Fb6beb',
+        '0xE36Ea790bc9d7AB70C55260C66D52b1eca985f84',
+        '0x5409ED021D9299bf6814279A6A1411A7e866A631',
+      ];
+    });
+
+    async function subject(): Promise<string[]> {
+      return addressArrayUtils.testSort.callAsync(subjectToSort);
+    }
+
+    it('returns the sorted items', async () => {
+      const sortedResult = await subject();
+
+      const expectedResult = _.sortBy(subjectToSort);
+
+      expect(JSON.stringify(sortedResult)).to.equal(JSON.stringify(expectedResult));
+    });
+
+    describe('when the input is empty', async () => {
+      beforeEach(async () => {
+        subjectToSort = [];
+      });
+
+      it('returns an empty array', async () => {
+        const sortedResult = await subject();
+        expect(JSON.stringify(sortedResult)).to.equal(JSON.stringify([]));
+      });
+    });
+  });
+});

test/contracts/lib/hashUtils.spec.ts

@@ -0,0 +1,52 @@
+require('module-alias/register');
+
+import * as _ from 'lodash';
+import * as chai from 'chai';
+import { Address } from 'set-protocol-utils';
+
+
+import ChaiSetup from '@utils/chaiSetup';
+import { BigNumberSetup } from '@utils/bigNumberSetup';
+import { HashUtilsMockContract } from '@utils/contracts';
+import { getWeb3 } from '@utils/web3Helper';
+
+import { LibraryMockHelper } from '@utils/helpers/libraryMockHelper';
+
+BigNumberSetup.configure();
+ChaiSetup.configure();
+const { expect } = chai;
+const web3 = getWeb3();
+
+contract('HashUtils', accounts => {
+  const [ownerAccount] = accounts;
+  const libraryMockHelper = new LibraryMockHelper(ownerAccount);
+
+  let hashUtils: HashUtilsMockContract;
+
+  beforeEach(async () => {
+    hashUtils = await libraryMockHelper.deployHashUtilsMockAsync();
+  });
+
+  describe('#testSortHash', async () => {
+    let subjectAddressArray: Address[];
+
+    beforeEach(async () => {
+      subjectAddressArray = [
+        '0xE36Ea790bc9d7AB70C55260C66D52b1eca985f84',
+        '0x5409ED021D9299bf6814279A6A1411A7e866A631',
+      ];
+    });
+
+    async function subject(): Promise<string> {
+      return hashUtils.testSortHash.callAsync(subjectAddressArray);
+    }
+
+    it('returns the correct hash', async () => {
+      const result = await subject();
+
+      const sorted = _.sortBy(subjectAddressArray);
+      const expected = web3.utils.soliditySha3({ t: 'address', v: sorted });
+      expect(JSON.stringify(result)).to.equal(JSON.stringify(expected));
+    });
+  });
+});

utils/contracts.ts

@@ -1,3 +1,4 @@
+export { AddressArrayUtilsMockContract } from '../types/generated/address_array_utils_mock';
 export { BaseContract } from '../types/base_contract';
 export { BoundsLibraryMockContract } from '../types/generated/bounds_library_mock';
 export { AddressToAddressWhiteListContract } from '../types/generated/address_to_address_white_list';
@@ -7,6 +8,7 @@ export { Bytes32LibraryMockContract } from '../types/generated/bytes32_library_m
 export { CommonMathMockContract } from '../types/generated/common_math_mock';
 export { CommonValidationsLibraryMockContract } from '../types/generated/common_validations_library_mock';
 export { CompoundUtilsMockContract } from '../types/generated/compound_utils_mock';
+export { HashUtilsMockContract } from '../types/generated/hash_utils_mock';
 export { LimitOneUpgradeMockContract } from '../types/generated/limit_one_upgrade_mock';
 export { OracleWhiteListContract } from '../types/generated/oracle_white_list';
 export { ScaleValidationsMockContract } from '../types/generated/scale_validations_mock';

utils/helpers/libraryMockHelper.ts

@@ -1,11 +1,13 @@
 import { Address } from 'set-protocol-utils';
 import * as _ from 'lodash';
 import {
+  AddressArrayUtilsMockContract,
   BoundsLibraryMockContract,
   Bytes32LibraryMockContract,
   CommonValidationsLibraryMockContract,
   CommonMathMockContract,
   CompoundUtilsMockContract,
+  HashUtilsMockContract,
   ScaleValidationsMockContract
 } from '../contracts';
 import { BigNumber } from 'bignumber.js';
@@ -17,13 +19,15 @@ import {
 } from '../web3Helper';
 import { ZERO } from '../constants';
 
+const AddressArrayUtilsMock = importArtifactsFromSource('AddressArrayUtilsMock');
 const BoundsLibraryMock = importArtifactsFromSource('BoundsLibraryMock');
 const Bytes32Library = importArtifactsFromSource('Bytes32Library');
 const Bytes32LibraryMock = importArtifactsFromSource('Bytes32LibraryMock');
 const CommonMathMock = importArtifactsFromSource('CommonMathMock');
 const CommonValidationsLibrary = importArtifactsFromSource('CommonValidationsLibrary');
 const CommonValidationsLibraryMock = importArtifactsFromSource('CommonValidationsLibraryMock');
 const CompoundUtilsMock = importArtifactsFromSource('CompoundUtilsMock');
+const HashUtilsMock = importArtifactsFromSource('HashUtilsMock');
 const ScaleValidationsMock = importArtifactsFromSource('ScaleValidationsMock');
 
 
@@ -36,6 +40,17 @@ export class LibraryMockHelper {
 
   /* ============ Deployment ============ */
 
+  public async deployAddressArrayUtilsMockAsync(
+    from: Address = this._contractOwnerAddress
+  ): Promise<AddressArrayUtilsMockContract> {
+    const addressArrayUtils = await AddressArrayUtilsMock.new(txnFrom(from));
+
+    return new AddressArrayUtilsMockContract(
+      getContractInstance(addressArrayUtils),
+      txnFrom(from),
+    );
+  }
+
   public async deployCommonValidationsLibraryAsync(
     from: Address = this._contractOwnerAddress
   ): Promise<CommonValidationsLibraryMockContract> {
@@ -85,6 +100,14 @@ export class LibraryMockHelper {
     return new ScaleValidationsMockContract(getContractInstance(scaleValidationsMockContract), txnFrom(from));
   }
 
+  public async deployHashUtilsMockAsync(
+    from: Address = this._contractOwnerAddress
+  ): Promise<HashUtilsMockContract> {
+    const hashUtilsMockContract = await HashUtilsMock.new(txnFrom(from));
+
+    return new HashUtilsMockContract(getContractInstance(hashUtilsMockContract), txnFrom(from));
+  }
+
   public async deployBoundsLibraryMockAsync(
     minBound: BigNumber,
     maxBound: BigNumber,