Add getAllowedTraders method and make tradersHistory contain unique elements

Author: cgewecke

contracts/protocol/modules/GeneralIndexModule.sol

@@ -572,6 +572,22 @@ contract GeneralIndexModule is ModuleBase, ReentrancyGuard {
         return _isAllowedTrader(_setToken, _trader);
     }
 
+    /**
+     * Get the list of traders who are allowed to call trade(), tradeRemainingWeth(), and raiseAssetTarget()
+     *
+     * @param _setToken         Address of the SetToken
+     *
+     * @return address[]
+     */
+    function getAllowedTraders(ISetToken _setToken)
+        external
+        view
+        onlyValidAndInitializedSet(_setToken)
+        returns (address[] memory)
+    {
+        return permissionInfo[_setToken].tradersHistory;
+    }
+
     /* ============ Internal Functions ============ */
 
     /**
@@ -1050,9 +1066,9 @@ contract GeneralIndexModule is ModuleBase, ReentrancyGuard {
 
      */
     function _updateTradersHistory(ISetToken _setToken, address _trader, bool _status) internal {
-        if (_status) {
+        if (_status && !permissionInfo[_setToken].tradersHistory.contains(_trader)) {
             permissionInfo[_setToken].tradersHistory.push(_trader);
-        } else if(permissionInfo[_setToken].tradersHistory.contains(_trader)) {
+        } else if(!_status && permissionInfo[_setToken].tradersHistory.contains(_trader)) {
             permissionInfo[_setToken].tradersHistory.removeStorage(_trader);
         }
     }

test/protocol/modules/generalIndexModule.spec.ts

@@ -1906,6 +1906,45 @@ describe("GeneralIndexModule", () => {
       });
     });
 
+    describe("#getAllowedTraders", async () => {
+      let subjectTraders: Address[];
+      let subjectStatuses: boolean[];
+
+      beforeEach(async () => {
+        subjectCaller = owner;
+        subjectSetToken = index;
+        subjectTraders = [trader.address];
+        subjectStatuses = [true];
+
+        return await indexModule.connect(subjectCaller.wallet).setTraderStatus(
+          subjectSetToken.address,
+          subjectTraders,
+          subjectStatuses
+        );
+      });
+
+      async function subject(): Promise<Boolean> {
+        return await indexModule.connect(subjectCaller.wallet).getAllowedTraders(subjectSetToken.address);
+      }
+
+      it("returns trader status", async () => {
+        await subject();
+
+        const expectedTraders = await subject();
+        expect(expectedTraders).to.deep.equal(subjectTraders);
+      });
+
+      describe("when the setToken is not valid", async () => {
+        beforeEach(() => {
+          subjectSetToken = { address: ADDRESS_ZERO } as SetToken;
+        });
+
+        it("should revert", async () => {
+          expect(subject()).to.be.revertedWith("Must be a valid and initialized SetToken");
+        });
+      });
+    });
+
     describe("#setRaiseTargetPercentage", async () => {
       let subjectRaiseTargetPercentage: BigNumber;
 
@@ -2197,12 +2236,27 @@ describe("GeneralIndexModule", () => {
           const preConditionTrader = await indexModule.getIsAllowedTrader(subjectSetToken.address, subjectTraders[0]);
           expect(preConditionTrader).to.be.true;
 
-
           await subject();
 
           const postConditionTrader = await indexModule.getIsAllowedTrader(subjectSetToken.address, subjectTraders[0]);
           expect(postConditionTrader).to.be.false;
         });
+
+        it("the tradersHistory should be updated correctly", async() => {
+          const preConditionTraders = await indexModule.getAllowedTraders(subjectSetToken.address);
+          expect(preConditionTraders).to.deep.equal(subjectTraders);
+
+          await subject();
+
+          const postConditionTraders = await indexModule.getAllowedTraders(subjectSetToken.address);
+          const expectedTraders = subjectTraders.slice(1);
+
+          expect(expectedTraders[0]).to.not.equal(expectedTraders[1]);
+          expect(postConditionTraders[0]).to.not.equal(postConditionTraders[1]);
+
+          expect(postConditionTraders.includes(expectedTraders[0])).to.be.true;
+          expect(postConditionTraders.includes(expectedTraders[1])).to.be.true;
+        });
       });
 
       describe("when array lengths don't match", async () => {