@@ -66,7 +66,81 @@ contract CERTFActor is BaseActor {
             extension
         );
 
-        emit InitializedAsset(assetId, ContractType.CEG, ownership.creatorObligor, ownership.counterpartyObligor);
+        emit InitializedAsset(assetId, ContractType.CERTF, ownership.creatorObligor, ownership.counterpartyObligor);
+    }
+
+    function computePayoffForEvent(
+        bytes32 assetId,
+        address engine,
+        CERTFTerms memory terms,
+        CERTFState memory state,
+        bytes32 _event
+    )
+        internal
+        view
+        returns (int256)
+    {
+        (EventType eventType, uint256 scheduleTime) = decodeEvent(_event);
+
+        uint256 timestamp;
+        {
+            // apply shift calc to schedule time
+            timestamp = shiftCalcTime(
+                scheduleTime,
+                terms.businessDayConvention,
+                terms.calendar,
+                terms.maturityDate
+            );
+        }
+        
+        bytes memory externalDataPOF;
+        { externalDataPOF = getExternalDataForPOF(assetId, eventType, timestamp); }
+
+        return (
+            ICERTFEngine(engine).computePayoffForEvent(
+                terms,
+                state,
+                _event,
+                externalDataPOF
+            )
+        );
+    }
+
+    function computeStateForEvent(
+        bytes32 assetId,
+        address engine,
+        CERTFTerms memory terms,
+        CERTFState memory state,
+        bytes32 _event
+    )
+        internal
+        view
+        returns (CERTFState memory)
+    {
+        (EventType eventType, uint256 scheduleTime) = decodeEvent(_event);
+
+        uint256 timestamp;
+        {
+            // apply shift calc to schedule time
+            timestamp = shiftCalcTime(
+                scheduleTime,
+                terms.businessDayConvention,
+                terms.calendar,
+                terms.maturityDate
+            );
+        }
+        
+        bytes memory externalDataSTF;
+        { externalDataSTF = getExternalDataForSTF(assetId, eventType, timestamp); }
+
+        return (
+            ICERTFEngine(engine).computeStateForEvent(
+                terms,
+                state,
+                _event,
+                externalDataSTF
+            )
+        );
     }
 
     /**
@@ -87,30 +161,12 @@ contract CERTFActor is BaseActor {
             state = ICERTFRegistry(address(assetRegistry)).getFinalizedState(assetId);
         }
 
-        (EventType eventType, uint256 scheduleTime) = decodeEvent(_event);
+        (, uint256 scheduleTime) = decodeEvent(_event);
 
         // get external data for the next event
         // compute payoff and the next state by applying the event to the current state
-        int256 payoff = ICERTFEngine(engine).computePayoffForEvent(
-            terms,
-            state,
-            _event,
-            getExternalDataForPOF(
-                assetId,
-                eventType,
-                shiftCalcTime(scheduleTime, terms.businessDayConvention, terms.calendar, terms.maturityDate)
-            )
-        );
-        CERTFState memory nextState = ICERTFEngine(engine).computeStateForEvent(
-            terms,
-            state,
-            _event,
-            getExternalDataForSTF(
-                assetId,
-                eventType,
-                shiftCalcTime(scheduleTime, terms.businessDayConvention, terms.calendar, terms.maturityDate)
-            )
-        );
+        int256 payoff = computePayoffForEvent(assetId, engine, terms, state, _event);
+        CERTFState memory nextState = computeStateForEvent(assetId, engine, terms, state, _event);
 
         // try to settle payoff of event
         bool settledPayoff = settlePayoffForEvent(assetId, _event, payoff);
@@ -131,16 +187,7 @@ contract CERTFActor is BaseActor {
             bytes32 ceEvent = encodeEvent(EventType.CE, scheduleTime);
 
             // derive the actual state of the asset by applying the CreditEvent (updates performance of asset)
-            nextState = ICERTFEngine(engine).computeStateForEvent(
-                terms,
-                state,
-                ceEvent,
-                getExternalDataForSTF(
-                    assetId,
-                    EventType.CE,
-                    shiftCalcTime(scheduleTime, terms.businessDayConvention, terms.calendar, terms.maturityDate)
-                )
-            );
+            nextState = computeStateForEvent(assetId, engine, terms, state, ceEvent);
         }
 
         // store the resulting state