implement redeem excluded

Author: felix2feng

contracts/SetToken.sol

@@ -237,6 +237,22 @@ contract SetToken is StandardToken, DetailedERC20("", "", 18), Set {
     return true;
   }
 
+  function redeemExcluded(uint quantity, address excludedComponent)
+    public
+    returns (bool success)
+  {
+    // Check there is enough balance
+    uint remainingBalance = unredeemedComponents[excludedComponent][msg.sender].unredeemedBalance;
+    require(remainingBalance >= quantity);
+
+    // To prevent re-entrancy attacks, decrement the user's Set balance
+    unredeemedComponents[excludedComponent][msg.sender].unredeemedBalance = remainingBalance.sub(quantity);
+
+    assert(ERC20(excludedComponent).transfer(msg.sender, quantity));
+
+    return true;
+  }
+
   function componentCount() public view returns(uint componentsLength) {
     return components.length;
   }

test/setToken-base.spec.ts

@@ -263,7 +263,7 @@ contract("{Set}", (accounts) => {
         );
       });
     });
-    
+
     describe("of overflow units", async () => {
       it("should disallow issuing a quantity of tokens that would trigger an overflow", async () => {
         const overflowUnits = gWei(2).div(5);
@@ -295,7 +295,7 @@ contract("{Set}", (accounts) => {
   });
 
   describe("Partial Redemption", async () => {
-    const quantityIssued = new BigNumber(10);
+    const quantityIssued = ether(10);
     let quantityA: BigNumber;
     let quantityB: BigNumber;
 
@@ -343,4 +343,47 @@ contract("{Set}", (accounts) => {
       expect(postRedeemBalanceBofOwner).to.be.bignumber.equal(initialTokens, "Post Balance B");
     });
   });
+
+  describe("Redeem Excluded", async () => {
+    const quantityIssued = ether(10);
+    let quantityA: BigNumber;
+    let quantityB: BigNumber;
+
+    // Create a Set two components with set tokens issued
+    beforeEach(async () => {
+      componentA = await StandardTokenMock.new(testAccount, initialTokens, "Component A", "A");
+      componentB = await StandardTokenMock.new(testAccount, initialTokens, "Component B", "B");
+
+      setToken = await SetToken.new(
+        [componentA.address, componentB.address],
+        [unitsA, unitsB],
+        TX_DEFAULTS,
+      );
+
+      // Expected Quantities of tokens moved are divided by a gWei
+      // to reflect the new units in set instantiation
+      quantityA = unitsA.mul(quantityIssued).div(gWei(1));
+      quantityB = unitsB.mul(quantityIssued).div(gWei(1));
+
+      await componentA.approve(setToken.address, quantityA, TX_DEFAULTS);
+      await componentB.approve(setToken.address, quantityB, TX_DEFAULTS);
+
+      await setToken.issue(quantityIssued, TX_DEFAULTS);
+
+      // Perform a partial redeem
+      await setToken.partialRedeem(quantityIssued, [componentA.address], TX_DEFAULTS);
+    });
+
+    it("should successfully redeem excluded a standard Set", async () => {
+      await setToken.redeemExcluded(quantityA, componentA.address, TX_DEFAULTS);
+
+      // The user should have a balance of TokenA
+      const postRedeemBalanceAofOwner = await componentA.balanceOf(testAccount);
+      expect(postRedeemBalanceAofOwner).to.be.bignumber.equal(initialTokens);
+
+      // The user should have no balance of Token A in excluded Tokens
+      const [excludedBalanceAofOwner] = await setToken.unredeemedComponents(componentA.address, testAccount);
+      expect(excludedBalanceAofOwner).to.be.bignumber.equal(0);
+    });
+  });
 });