Update unrealized_pnl based on closing_price if known

If we know the `closing_price` then it is used for updating the unrealized pnl.
Note that the realized pnl is *only* set once we update it based on the closed contract. The realized pnl is not updated based on the execution price, because there is no execution guarantee.

coordinator/migrations/2023-07-21-050135_closing_price_positions/down.sql

@@ -0,0 +1,3 @@
+-- This file should undo anything in `up.sql`
+ALTER TABLE
+    "positions" DROP COLUMN "closing_price";

coordinator/migrations/2023-07-21-050135_closing_price_positions/up.sql

@@ -0,0 +1,5 @@
+-- Your SQL goes here
+ALTER TABLE
+    positions
+ADD
+    COLUMN "closing_price" REAL;

coordinator/src/db/positions.rs

@@ -34,6 +34,7 @@ pub struct Position {
     pub temporary_contract_id: Option<String>,
     pub realized_pnl: Option<i64>,
     pub unrealized_pnl: Option<i64>,
+    pub closing_price: Option<f32>,
 }
 
 impl Position {
@@ -92,12 +93,14 @@ impl Position {
     pub fn set_open_position_to_closing(
         conn: &mut PgConnection,
         trader_pubkey: String,
+        closing_price: f32,
     ) -> Result<()> {
         let effected_rows = diesel::update(positions::table)
             .filter(positions::trader_pubkey.eq(trader_pubkey.clone()))
             .filter(positions::position_state.eq(PositionState::Open))
             .set((
                 positions::position_state.eq(PositionState::Closing),
+                positions::closing_price.eq(Some(closing_price)),
                 positions::update_timestamp.eq(OffsetDateTime::now_utc()),
             ))
             .execute(conn)?;
@@ -178,6 +181,7 @@ impl From<Position> for crate::position::models::Position {
             temporary_contract_id: value.temporary_contract_id.map(|contract_id| {
                 ContractId::from_hex(contract_id.as_str()).expect("contract id to decode")
             }),
+            closing_price: value.closing_price,
         }
     }
 }

coordinator/src/node.rs

@@ -333,6 +333,9 @@ impl Node {
         db::positions::Position::set_open_position_to_closing(
             &mut connection,
             position.trader.to_string(),
+            closing_price
+                .to_f32()
+                .expect("Closing price to fit into f32"),
         )
     }
 

coordinator/src/node/unrealized_pnl.rs

@@ -35,9 +35,14 @@ fn sync_position(
     position: &Position,
     quote: Quote,
 ) -> Result<()> {
-    let current_price = match position.direction {
-        trade::Direction::Long => quote.bid_price,
-        trade::Direction::Short => quote.ask_price,
+    let closing_price = match position.closing_price {
+        None => match position.direction {
+            trade::Direction::Long => quote.bid_price,
+            trade::Direction::Short => quote.ask_price,
+        },
+        Some(closing_price) => {
+            Decimal::try_from(closing_price).expect("f32 closing price to fit into decimal")
+        }
     };
 
     let average_entry_price = Decimal::try_from(position.average_entry_price)
@@ -53,7 +58,7 @@ fn sync_position(
 
     let pnl = calculate_pnl(
         average_entry_price,
-        current_price,
+        closing_price,
         position.quantity,
         long_leverage,
         short_leverage,

coordinator/src/position/models.rs

@@ -49,4 +49,5 @@ pub struct Position {
     /// This field is optional for backwards compatibility because we cannot deterministically
     /// associate already existing contracts with positions.
     pub temporary_contract_id: Option<ContractId>,
+    pub closing_price: Option<f32>,
 }

coordinator/src/schema.rs

@@ -110,6 +110,7 @@ diesel::table! {
         temporary_contract_id -> Nullable<Text>,
         realized_pnl -> Nullable<Int8>,
         unrealized_pnl -> Nullable<Int8>,
+        closing_price -> Nullable<Float4>,
     }
 }