Merge 374d0c3 into 6734253

packages/actus-solidity/contracts/Core/Utils/CycleUtils.sol

@@ -47,14 +47,13 @@ contract CycleUtils is ACTUSConstants, PeriodUtils {
     }
 
     /**
-     * This function computes an array of UNIX timestamps that
-     * represent dates in a cycle falling within a given segment.
+     * Computes an array of timestamps that represent dates in a cycle falling within a given segment.
      * @dev There are some notable edge cases: If the cycle is "not set" we return the start end end dates
      * of the cycle if they lie within the segment. Otherwise and empty array is returned.
-     * @param cycleStart the start time of the cycle
-     * @param cycleEnd the end time of the cycle
-     * @param cycle struct that describe sthe cycle
-     * @param addEndTime specifies if the timestamp of the end of the cycle should be added to the result if it falls in the segment
+     * @param cycleStart start time of the cycle
+     * @param cycleEnd end time of the cycle
+     * @param cycle IPS cycle
+     * @param addEndTime timestamp of the end of the cycle should be added to the result if it falls in the segment
      * @param segmentStart start time of the segment
      * @param segmentEnd end time of the segment
      * @return an array of timestamps from the given cycle that fall within the specified segement
@@ -102,9 +101,7 @@ contract CycleUtils is ACTUSConstants, PeriodUtils {
 
             cycleIndex++;
 
-
             date = getNextCycleDate(cycle, cycleStart, cycleIndex);
-
         }
 
         // add additional time at the end if addEndTime
@@ -126,6 +123,27 @@ contract CycleUtils is ACTUSConstants, PeriodUtils {
     }
 
     /**
+     * Computes the next date for a given an IPS cycle.
+     * @param cycle IPS cycle
+     * @param precedingDate the previous date of the cycle
+     * @return next date of the cycle
+     */
+    function computeNextCycleDateFromPrecedingDate(
+        IPS memory cycle,
+        uint256 precedingDate
+    )
+        internal
+        pure
+        returns (uint256)
+    {
+        if (cycle.isSet == false) {
+            return 0;
+        }
+
+        return getNextCycleDate(cycle, precedingDate, 1);
+    }
+
+    /*
      * @notice Checks if a timestamp is in a given range.
      */
     function isInSegment(

packages/actus-solidity/contracts/Engines/ANN/ANNEngine.sol

@@ -286,6 +286,82 @@ contract ANNEngine is Core, ANNSTF, ANNPOF, IANNEngine {
         return schedule;
     }
 
+    /**
+     * @notice Computes a schedule segment of cyclic contract events based on the contract terms
+     * and the specified timestamps.
+     * @param terms terms of the contract
+     * @param lastScheduleTime last occurrence of cyclic event
+     * @param eventType eventType of the cyclic schedule
+     * @return event schedule segment
+     */
+    function computeNextCyclicEvent(
+        ANNTerms calldata terms,
+        uint256 lastScheduleTime,
+        EventType eventType
+    )
+        external
+        pure
+        override
+        returns(bytes32)
+    {
+        // IP
+        if (eventType == EventType.IP) {
+            // interest payment related (starting with PRANX interest is paid following the PR schedule)
+            if (
+                terms.cycleOfInterestPayment.isSet == true && terms.cycleAnchorDateOfInterestPayment != 0) {
+                uint256 nextInterestPaymentDate = computeNextCycleDateFromPrecedingDate(
+                    terms.cycleOfInterestPayment,
+                    (lastScheduleTime == 0) ? terms.cycleAnchorDateOfInterestPayment : lastScheduleTime
+                );
+                if (nextInterestPaymentDate == 0) return bytes32(0);
+                if (nextInterestPaymentDate <= terms.capitalizationEndDate) return bytes32(0);
+                return encodeEvent(EventType.IP, nextInterestPaymentDate);
+            }
+        }
+
+        // IPCI
+        if (eventType == EventType.IPCI) {
+            if (
+                terms.cycleOfInterestPayment.isSet == true
+                && terms.cycleAnchorDateOfInterestPayment != 0
+                && terms.capitalizationEndDate != 0
+            ) {
+                IPS memory cycleOfInterestCapitalization = terms.cycleOfInterestPayment;
+                cycleOfInterestCapitalization.s = S.SHORT;
+                uint256 nextInterestCapitalizationDate = computeNextCycleDateFromPrecedingDate(
+                    cycleOfInterestCapitalization,
+                    (lastScheduleTime == 0) ? terms.cycleAnchorDateOfInterestPayment : lastScheduleTime
+                );
+                if (nextInterestCapitalizationDate == 0) return bytes32(0);
+                return encodeEvent(EventType.IPCI, nextInterestCapitalizationDate);
+            }
+        }
+
+        // fees
+        if (eventType == EventType.FP) {
+            if (terms.cycleOfFee.isSet == true && terms.cycleAnchorDateOfFee != 0) {
+                uint256 nextFeeDate = computeNextCycleDateFromPrecedingDate(
+                    terms.cycleOfFee,
+                    (lastScheduleTime == 0) ? terms.cycleAnchorDateOfFee : lastScheduleTime
+                );
+                if (nextFeeDate == 0) return bytes32(0);
+                return encodeEvent(EventType.FP, nextFeeDate);
+            }
+        }
+
+        // principal redemption
+        if (eventType == EventType.PR) {
+            uint256 nextPrincipalRedemptionDate = computeNextCycleDateFromPrecedingDate(
+                terms.cycleOfPrincipalRedemption,
+                (lastScheduleTime == 0) ? terms.cycleAnchorDateOfPrincipalRedemption : lastScheduleTime
+            );
+            if (nextPrincipalRedemptionDate == 0) return bytes32(0);
+            return encodeEvent(EventType.PR, nextPrincipalRedemptionDate);
+        }
+
+        return bytes32(0);
+    }
+
     /**
      * @notice Verifies that the provided event is still scheduled under the terms, the current state of the
      * contract and the current state of the underlying.

packages/actus-solidity/contracts/Engines/ANN/IANNEngine.sol

@@ -75,6 +75,23 @@ interface IANNEngine is IEngine {
         pure
         returns (bytes32[] memory);
 
+    /**
+     * @notice Computes a schedule segment of cyclic contract events based on the contract terms
+     * and the specified timestamps.
+     * @param terms terms of the contract
+     * @param lastScheduleTime last occurrence of cyclic event
+     * @param eventType eventType of the cyclic schedule
+     * @return event schedule segment
+     */
+    function computeNextCyclicEvent(
+        ANNTerms calldata terms,
+        uint256 lastScheduleTime,
+        EventType eventType
+    )
+        external
+        pure
+        returns(bytes32);
+
     /**
      * @notice Computes a schedule segment of cyclic contract events based on the contract terms
      * and the specified timestamps.

packages/actus-solidity/contracts/Engines/CEC/CECEngine.sol

@@ -166,6 +166,27 @@ contract CECEngine is Core, CECSTF, CECPOF, ICECEngine {
         return schedule;
     }
 
+    /**
+     * @notice Computes a schedule segment of cyclic contract events based on the contract terms
+     * and the specified timestamps.
+     * @param terms terms of the contract
+     * @param lastScheduleTime last occurrence of cyclic event
+     * @param eventType eventType of the cyclic schedule
+     * @return event schedule segment
+     */
+    function computeNextCyclicEvent(
+        CECTerms calldata terms,
+        uint256 lastScheduleTime,
+        EventType eventType
+    )
+        external
+        pure
+        override
+        returns(bytes32)
+    {
+        return bytes32(0);
+    }
+
     /**
      * @notice Verifies that the provided event is still scheduled under the terms, the current state of the
      * contract and the current state of the underlying.

packages/actus-solidity/contracts/Engines/CEC/ICECEngine.sol

@@ -94,6 +94,23 @@ interface ICECEngine is IEngine {
         pure
         returns (bytes32[] memory);
 
+    /**
+     * @notice Computes a schedule segment of cyclic contract events based on the contract terms
+     * and the specified timestamps.
+     * @param terms terms of the contract
+     * @param lastScheduleTime last occurrence of cyclic event
+     * @param eventType eventType of the cyclic schedule
+     * @return event schedule segment
+     */
+    function computeNextCyclicEvent(
+        CECTerms calldata terms,
+        uint256 lastScheduleTime,
+        EventType eventType
+    )
+        external
+        pure
+        returns(bytes32);
+
     /**
      * @notice Verifies that the provided event is still scheduled under the terms, the current state of the
      * contract and the current state of the underlying.

packages/actus-solidity/contracts/Engines/CEG/CEGEngine.sol

@@ -202,6 +202,39 @@ contract CEGEngine is Core, CEGSTF, CEGPOF, ICEGEngine {
         return schedule;
     }
 
+    /**
+     * @notice Computes a schedule segment of cyclic contract events based on the contract terms
+     * and the specified timestamps.
+     * @param terms terms of the contract
+     * @param lastScheduleTime last occurrence of cyclic event
+     * @param eventType eventType of the cyclic schedule
+     * @return event schedule segment
+     */
+    function computeNextCyclicEvent(
+        CEGTerms calldata terms,
+        uint256 lastScheduleTime,
+        EventType eventType
+    )
+        external
+        pure
+        override
+        returns(bytes32)
+    {
+        if (eventType == EventType.FP) {
+            // fees
+            if (terms.cycleOfFee.isSet == true && terms.cycleAnchorDateOfFee != 0) {
+                uint256 nextFeeDate = computeNextCycleDateFromPrecedingDate(
+                    terms.cycleOfFee,
+                    (lastScheduleTime == 0) ? terms.cycleAnchorDateOfFee : lastScheduleTime
+                );
+                if (nextFeeDate == 0) return bytes32(0);
+                return encodeEvent(EventType.FP, nextFeeDate);
+            }
+        }
+
+        return bytes32(0);
+    }
+
     /**
      * @notice Verifies that the provided event is still scheduled under the terms, the current state of the
      * contract and the current state of the underlying.

packages/actus-solidity/contracts/Engines/CEG/ICEGEngine.sol

@@ -94,6 +94,23 @@ interface ICEGEngine is IEngine {
         pure
         returns (bytes32[] memory);
 
+    /**
+     * @notice Computes a schedule segment of cyclic contract events based on the contract terms
+     * and the specified timestamps.
+     * @param terms terms of the contract
+     * @param lastScheduleTime last occurrence of cyclic event
+     * @param eventType eventType of the cyclic schedule
+     * @return event schedule segment
+     */
+    function computeNextCyclicEvent(
+        CEGTerms calldata terms,
+        uint256 lastScheduleTime,
+        EventType eventType
+    )
+        external
+        pure
+        returns(bytes32);
+
     /**
      * @notice Verifies that the provided event is still scheduled under the terms, the current state of the
      * contract and the current state of the underlying.

packages/actus-solidity/contracts/Engines/CERTF/CERTFEngine.sol

@@ -294,6 +294,86 @@ contract CERTFEngine is Core, CERTFSTF, CERTFPOF, ICERTFEngine {
         return schedule;
     }
 
+    /**
+     * @notice Computes a schedule segment of cyclic contract events based on the contract terms
+     * and the specified timestamps.
+     * @param terms terms of the contract
+     * @param lastScheduleTime last occurrence of cyclic event
+     * @param eventType eventType of the cyclic schedule
+     * @return event schedule segment
+     */
+    function computeNextCyclicEvent(
+        CERTFTerms calldata terms,
+        uint256 lastScheduleTime,
+        EventType eventType
+    )
+        external
+        pure
+        override
+        returns(bytes32)
+    {
+        if (eventType == EventType.CFD) {
+            if (terms.cycleOfCoupon.isSet == true && terms.cycleAnchorDateOfCoupon != 0) {
+                uint256 nextCouponDate = computeNextCycleDateFromPrecedingDate(
+                    terms.cycleOfCoupon,
+                    (lastScheduleTime == 0) ? terms.cycleAnchorDateOfCoupon : lastScheduleTime
+                );
+                if (nextCouponDate == uint256(0)) return bytes32(0);
+                return encodeEvent(EventType.CFD, nextCouponDate);
+            }
+        }
+
+         if (eventType == EventType.CPD) {
+            if (terms.cycleOfCoupon.isSet == true && terms.cycleAnchorDateOfCoupon != 0) {
+                uint256 nextCouponDate = computeNextCycleDateFromPrecedingDate(
+                    terms.cycleOfCoupon,
+                    (lastScheduleTime == 0) ? terms.cycleAnchorDateOfCoupon : lastScheduleTime
+                );
+                if (nextCouponDate == uint256(0)) return bytes32(0);
+                uint256 couponPaymentDayScheduleTime = getTimestampPlusPeriod(terms.settlementPeriod, nextCouponDate);
+                return encodeEvent(EventType.CFD, couponPaymentDayScheduleTime);
+            }
+        }
+
+        if (eventType == EventType.RFD) {
+            if (terms.cycleOfRedemption.isSet == true && terms.cycleAnchorDateOfRedemption != 0) {
+                uint256 nextRedemptionDate = computeNextCycleDateFromPrecedingDate(
+                    terms.cycleOfRedemption,
+                    (lastScheduleTime == 0) ? terms.cycleAnchorDateOfRedemption : lastScheduleTime
+                );
+                if (nextRedemptionDate == uint256(0)) return bytes32(0);
+                return encodeEvent(EventType.RFD, nextRedemptionDate);
+            }
+        }
+
+        if (eventType == EventType.RPD) {
+            if (terms.cycleOfRedemption.isSet == true && terms.cycleAnchorDateOfRedemption != 0) {
+                uint256 nextRedemptionDate = computeNextCycleDateFromPrecedingDate(
+                    terms.cycleOfRedemption,
+                    (lastScheduleTime == 0) ? terms.cycleAnchorDateOfRedemption : lastScheduleTime
+                );
+                if (nextRedemptionDate == uint256(0)) return bytes32(0);
+                uint256 redemptionPaymentDayScheduleTime = getTimestampPlusPeriod(terms.settlementPeriod, nextRedemptionDate);
+                return encodeEvent(EventType.RPD, redemptionPaymentDayScheduleTime);
+            }
+        }
+
+        if (eventType == EventType.XD) {
+            if (terms.cycleOfRedemption.isSet == true && terms.cycleAnchorDateOfRedemption != 0) {
+                uint256 nextRedemptionDate = computeNextCycleDateFromPrecedingDate(
+                    terms.cycleOfRedemption,
+                    (lastScheduleTime == 0) ? terms.cycleAnchorDateOfRedemption : lastScheduleTime
+                );
+                if (nextRedemptionDate == uint256(0)) return bytes32(0);
+                if (nextRedemptionDate == terms.maturityDate) return bytes32(0);
+                uint256 executionDateScheduleTime = getTimestampPlusPeriod(terms.exercisePeriod, nextRedemptionDate);
+                return encodeEvent(EventType.XD, executionDateScheduleTime);
+            }
+        }
+
+       return bytes32(0);
+    }
+
     /**
      * @notice Verifies that the provided event is still scheduled under the terms, the current state of the
      * contract and the current state of the underlying.

packages/actus-solidity/contracts/Engines/CERTF/ICERTFEngine.sol

@@ -94,6 +94,23 @@ interface ICERTFEngine is IEngine {
         pure
         returns (bytes32[] memory);
 
+    /**
+     * @notice Computes a schedule segment of cyclic contract events based on the contract terms
+     * and the specified timestamps.
+     * @param terms terms of the contract
+     * @param lastScheduleTime last occurrence of cyclic event
+     * @param eventType eventType of the cyclic schedule
+     * @return event schedule segment
+     */
+    function computeNextCyclicEvent(
+        CERTFTerms calldata terms,
+        uint256 lastScheduleTime,
+        EventType eventType
+    )
+        external
+        pure
+        returns(bytes32);
+
     /**
      * @notice Verifies that the provided event is still scheduled under the terms, the current state of the
      * contract and the current state of the underlying.