Merge pull request #1559 from get10101/feat/hacky-resize

Allow app trader to resize open position

coordinator/migrations/2023-10-25-120015_add_fee_to_channel/up.sql

@@ -1,6 +1,5 @@
--- Your SQL goes here
 ALTER TABLE channels ADD COLUMN "fee_sats" BIGINT DEFAULT null;
 
 ALTER TABLE
     channels DROP COLUMN open_channel_fee_payment_hash;
-DROP INDEX IF EXISTS channels_funding_txid;
+DROP INDEX IF EXISTS channels_funding_txid;

coordinator/migrations/2023-11-07-073206_add_expiry_timestamp_to_trades/down.sql

@@ -0,0 +1,6 @@
+ALTER TABLE trades
+DROP COLUMN dlc_expiry_timestamp;
+
+-- Note: There is no down migration for removing the `Resizing`
+-- variant that was added to `PositionState_Type` because it is not
+-- feasible to remove enum variants in the db!

coordinator/migrations/2023-11-07-073206_add_expiry_timestamp_to_trades/up.sql

@@ -0,0 +1,5 @@
+ALTER TABLE trades
+ADD COLUMN dlc_expiry_timestamp timestamp WITH TIME ZONE;
+
+ALTER TYPE "PositionState_Type"
+ADD VALUE IF NOT EXISTS 'Resizing';

coordinator/src/db/custom_types.rs

@@ -45,6 +45,7 @@ impl ToSql<PositionStateType, Pg> for PositionState {
             PositionState::Closing => out.write_all(b"Closing")?,
             PositionState::Closed => out.write_all(b"Closed")?,
             PositionState::Rollover => out.write_all(b"Rollover")?,
+            PositionState::Resizing => out.write_all(b"Resizing")?,
         }
         Ok(IsNull::No)
     }
@@ -57,6 +58,7 @@ impl FromSql<PositionStateType, Pg> for PositionState {
             b"Closing" => Ok(PositionState::Closing),
             b"Closed" => Ok(PositionState::Closed),
             b"Rollover" => Ok(PositionState::Rollover),
+            b"Resizing" => Ok(PositionState::Resizing),
             _ => Err("Unrecognized enum variant".into()),
         }
     }

coordinator/src/db/positions.rs

@@ -141,6 +141,70 @@ impl Position {
         Ok(())
     }
 
+    #[allow(clippy::too_many_arguments)]
+    pub fn set_open_position_to_resizing(
+        conn: &mut PgConnection,
+        trader_pubkey: String,
+    ) -> Result<()> {
+        let affected_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::Resizing),
+                positions::update_timestamp.eq(OffsetDateTime::now_utc()),
+            ))
+            .execute(conn)?;
+
+        if affected_rows == 0 {
+            bail!("Could not update position to Resizing for {trader_pubkey}")
+        }
+
+        Ok(())
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn update_resized_position(
+        conn: &mut PgConnection,
+        trader_pubkey: String,
+        quantity: f32,
+        direction: Direction,
+        coordinator_leverage: f32,
+        trader_leverage: f32,
+        coordinator_margin: i64,
+        trader_margin: i64,
+        average_entry_price: f32,
+        liquidation_price: f32,
+        expiry_timestamp: OffsetDateTime,
+        temporary_contract_id: ContractId,
+        stable: bool,
+    ) -> Result<()> {
+        let affected_rows = diesel::update(positions::table)
+            .filter(positions::trader_pubkey.eq(trader_pubkey.clone()))
+            .filter(positions::position_state.eq(PositionState::Resizing))
+            .set((
+                positions::position_state.eq(PositionState::Open),
+                positions::update_timestamp.eq(OffsetDateTime::now_utc()),
+                positions::quantity.eq(quantity),
+                positions::direction.eq(direction),
+                positions::trader_leverage.eq(trader_leverage),
+                positions::coordinator_leverage.eq(coordinator_leverage),
+                positions::coordinator_margin.eq(coordinator_margin),
+                positions::trader_margin.eq(trader_margin),
+                positions::average_entry_price.eq(average_entry_price),
+                positions::liquidation_price.eq(liquidation_price),
+                positions::expiry_timestamp.eq(expiry_timestamp),
+                positions::temporary_contract_id.eq(temporary_contract_id.to_hex()),
+                positions::stable.eq(stable),
+            ))
+            .execute(conn)?;
+
+        if affected_rows == 0 {
+            bail!("Could not update position to Resizing for {trader_pubkey}")
+        }
+
+        Ok(())
+    }
+
     pub fn set_position_to_closed_with_pnl(
         conn: &mut PgConnection,
         id: i32,
@@ -185,7 +249,11 @@ impl Position {
     ) -> Result<()> {
         let affected_rows = diesel::update(positions::table)
             .filter(positions::trader_pubkey.eq(trader_pubkey))
-            .filter(positions::position_state.eq(PositionState::Rollover))
+            .filter(
+                positions::position_state
+                    .eq(PositionState::Rollover)
+                    .or(positions::position_state.eq(PositionState::Resizing)),
+            )
             .set((
                 positions::position_state.eq(PositionState::Open),
                 positions::temporary_contract_id.eq(temporary_contract_id.to_hex()),
@@ -254,6 +322,7 @@ impl From<crate::position::models::PositionState> for PositionState {
             crate::position::models::PositionState::Closing { .. } => PositionState::Closing,
             crate::position::models::PositionState::Closed { .. } => PositionState::Closed,
             crate::position::models::PositionState::Rollover => PositionState::Rollover,
+            crate::position::models::PositionState::Resizing { .. } => PositionState::Resizing,
         }
     }
 }
@@ -303,6 +372,7 @@ struct NewPosition {
     pub expiry_timestamp: OffsetDateTime,
     pub trader_pubkey: String,
     pub temporary_contract_id: String,
+    pub coordinator_leverage: f32,
     pub trader_margin: i64,
     pub stable: bool,
 }
@@ -321,6 +391,7 @@ impl From<crate::position::models::NewPosition> for NewPosition {
             expiry_timestamp: value.expiry_timestamp,
             trader_pubkey: value.trader.to_string(),
             temporary_contract_id: value.temporary_contract_id.to_hex(),
+            coordinator_leverage: value.coordinator_leverage,
             trader_margin: value.trader_margin,
             stable: value.stable,
         }
@@ -334,6 +405,7 @@ pub enum PositionState {
     Closing,
     Rollover,
     Closed,
+    Resizing,
 }
 
 impl QueryId for PositionStateType {
@@ -362,6 +434,7 @@ impl From<(PositionState, Option<i64>, Option<f32>)> for crate::position::models
                 pnl: realized_pnl.unwrap_or(0),
             },
             PositionState::Rollover => crate::position::models::PositionState::Rollover,
+            PositionState::Resizing => crate::position::models::PositionState::Resizing,
         }
     }
 }

coordinator/src/db/trades.rs

@@ -24,6 +24,7 @@ struct Trade {
     average_price: f32,
     timestamp: OffsetDateTime,
     fee_payment_hash: String,
+    dlc_expiry_timestamp: Option<OffsetDateTime>,
 }
 
 #[derive(Insertable, Debug, Clone)]
@@ -37,6 +38,7 @@ struct NewTrade {
     collateral: i64,
     direction: Direction,
     average_price: f32,
+    dlc_expiry_timestamp: Option<OffsetDateTime>,
 }
 
 pub fn insert(
@@ -50,6 +52,19 @@ pub fn insert(
     Ok(trade.into())
 }
 
+pub fn get_latest_for_position(
+    conn: &mut PgConnection,
+    position_id: i32,
+) -> Result<Option<crate::trade::models::Trade>> {
+    let trade = trades::table
+        .filter(trades::position_id.eq(position_id))
+        .order_by(trades::id.desc())
+        .first::<Trade>(conn)
+        .optional()?;
+
+    Ok(trade.map(crate::trade::models::Trade::from))
+}
+
 /// Returns the position by trader pub key
 pub fn is_payment_hash_registered_as_trade_fee(
     conn: &mut PgConnection,
@@ -76,6 +91,7 @@ impl From<crate::trade::models::NewTrade> for NewTrade {
             collateral: value.coordinator_margin,
             direction: value.direction.into(),
             average_price: value.average_price,
+            dlc_expiry_timestamp: value.dlc_expiry_timestamp,
         }
     }
 }
@@ -97,6 +113,7 @@ impl From<Trade> for crate::trade::models::Trade {
             fee_payment_hash: PaymentHash(
                 <[u8; 32]>::from_hex(value.fee_payment_hash).expect("payment hash to decode"),
             ),
+            dlc_expiry_timestamp: value.dlc_expiry_timestamp,
         }
     }
 }