Use preciseDivCeil (int256) when issuing in #_executePositionTrades

Author: cgewecke

contracts/lib/PreciseUnitMath.sol

@@ -34,6 +34,8 @@ import { SignedSafeMath } from "@openzeppelin/contracts/math/SignedSafeMath.sol"
  * CHANGELOG:
  * - 9/21/20: Added safePower function
  * - 4/21/21: Added approximatelyEquals function
+ * - 12/13/21: Added preciseDivCeil (int overloads) function
+ * - 12/13/21: Added abs function
  */
 library PreciseUnitMath {
     using SafeMath for uint256;
@@ -136,6 +138,22 @@ library PreciseUnitMath {
         return a > 0 ? a.mul(PRECISE_UNIT).sub(1).div(b).add(1) : 0;
     }
 
+    /**
+     * @dev Divides value a by value b (result is rounded up or away from 0). When `a` is 0, 0 is
+     * returned. When `b` is 0, method reverts with divide-by-zero error.
+     */
+    function preciseDivCeil(int256 a, int256 b) internal pure returns (int256) {
+        require(b != 0, "Cant divide by 0");
+
+        if (a == 0 ) {
+            return 0;
+        } else if ((a > 0 && b > 0) || (a < 0 && b < 0)) {
+            return a.mul(PRECISE_UNIT_INT).sub(1).div(b).add(1);
+        } else {
+            return a.mul(PRECISE_UNIT_INT).add(1).div(b).sub(1);
+        }
+    }
+
     /**
      * @dev Divides value a by value b (result is rounded down - positive numbers toward 0 and negative away from 0).
      */

contracts/mocks/PreciseUnitMathMock.sol

@@ -66,6 +66,10 @@ contract PreciseUnitMathMock {
         return a.preciseDivCeil(b);
     }
 
+    function preciseDivCeilInt(int256 a, int256 b) external pure returns(int256) {
+        return a.preciseDivCeil(b);
+    }
+
     function divDown(int256 a, int256 b) external pure returns(int256) {
         return a.divDown(b);
     }

contracts/protocol/modules/PerpV2LeverageModule.sol

@@ -751,12 +751,10 @@ contract PerpV2LeverageModule is ModuleBase, ReentrancyGuard, Ownable, AllowSetT
         }
 
         // Return value in collateral decimals (e.g USDC = 6)
-        //
-        // TODO - we need to add a method to preciseMath to handle the int case for this....
-        //
         // Use preciseDivCeil when issuing to ensure we don't under-collateralize due to rounding error
-        // _isIssue ? accountValueIssued.preciseDivCeil(setTokenQuantityInt) : accountValueIssued.preciseDiv(setTokenQuantityInt),
-        return accountValueIssued.preciseDiv(setTokenQuantityInt).fromPreciseUnitToDecimals(collateralDecimals);
+        return (_isIssue)
+            ? accountValueIssued.preciseDivCeil(setTokenQuantityInt).fromPreciseUnitToDecimals(collateralDecimals)
+            : accountValueIssued.preciseDiv(setTokenQuantityInt).fromPreciseUnitToDecimals(collateralDecimals);
     }
 
     /**

test/lib/preciseUnitMath.spec.ts

@@ -30,6 +30,7 @@ describe("PreciseUnitMath", () => {
 
   // Used to make sure rounding is done correctly, 1020408168544454473
   const preciseNumber = BigNumber.from("0x0e2937d2abffc749");
+  const negativePreciseNumber = preciseNumber.mul(-1);
 
   before(async () => {
     [
@@ -236,6 +237,93 @@ describe("PreciseUnitMath", () => {
     });
   });
 
+  describe("#preciseDivCeil: int256", async () => {
+    let subjectA: BigNumber;
+    let subjectB: BigNumber;
+
+    async function subject(): Promise<BigNumber> {
+      return mathMock.preciseDivCeilInt(subjectA, subjectB);
+    }
+
+    describe("when a and b are positive", () => {
+      beforeEach(async () => {
+        subjectA = preciseNumber;
+        subjectB = ether(.3);
+      });
+
+      it("returns the correct number", async () => {
+        const division = await subject();
+
+        const expectedDivision = preciseDivCeilInt(subjectA, subjectB);
+        expect(division).to.eq(expectedDivision);
+      });
+    });
+
+    describe("when a and b are negative", () => {
+      beforeEach(async () => {
+        subjectA = negativePreciseNumber;
+        subjectB = ether(-.3);
+      });
+
+      it("returns the correct number", async () => {
+        const division = await subject();
+
+        const expectedDivision = preciseDivCeilInt(subjectA, subjectB);
+        expect(division).to.eq(expectedDivision);
+      });
+    });
+
+    describe("when a is positive and b is negative", () => {
+      beforeEach(async () => {
+        subjectA = preciseNumber;
+        subjectB = ether(-.3);
+      });
+
+      it("returns the correct number", async () => {
+        const division = await subject();
+
+        const expectedDivision = preciseDivCeilInt(subjectA, subjectB);
+        expect(division).to.eq(expectedDivision);
+      });
+    });
+
+    describe("when a is negative and b is positive", () => {
+      beforeEach(async () => {
+        subjectA = negativePreciseNumber;
+        subjectB = ether(.3);
+      });
+
+      it("returns the correct number", async () => {
+        const division = await subject();
+
+        const expectedDivision = preciseDivCeilInt(subjectA, subjectB);
+        expect(division).to.eq(expectedDivision);
+      });
+    });
+
+    describe("when a is 0", async () => {
+      beforeEach(async () => {
+        subjectA = ZERO;
+      });
+
+      it("should return 0", async () => {
+        const division = await subject();
+        expect(division).to.eq(ZERO);
+      });
+    });
+
+    describe("when b is 0", async () => {
+      beforeEach(async () => {
+        subjectA = ZERO;
+        subjectB = ZERO;
+      });
+
+      it("should revert", async () => {
+        await expect(subject()).to.be.revertedWith("Cant divide by 0");
+      });
+    });
+  });
+
   describe("#divDown: int256", async () => {
     let subjectA: BigNumber;
     let subjectB: BigNumber;