TRCL-3644 Static Typing: TriggerOrder/SL/TP

build.gradle.kts

@@ -52,7 +52,7 @@ allprojects {
 }
 
 group = "exchange.dydx.abacus"
-version = "1.8.101"
+version = "1.8.105"
 
 repositories {
     google()

src/commonMain/kotlin/exchange.dydx.abacus/calculator/MarginCalculator.kt

@@ -26,11 +26,11 @@ import kotlin.math.min
 
 internal object MarginCalculator {
     fun findExistingPosition(
-        account: InternalAccountState,
+        account: InternalAccountState?,
         marketId: String?,
         subaccountNumber: Int,
     ): InternalPerpetualPosition? {
-        val position = account.groupedSubaccounts[subaccountNumber]?.openPositions?.get(marketId)
+        val position = account?.groupedSubaccounts?.get(subaccountNumber)?.openPositions?.get(marketId)
         return if (
             (position?.size ?: 0.0) != 0.0
         ) {
@@ -420,6 +420,16 @@ internal object MarginCalculator {
     }
 
     fun getChildSubaccountNumberForIsolatedMarginClosePosition(
+        account: InternalAccountState?,
+        subaccountNumber: Int,
+        tradeInput: InternalTradeInputState?
+    ): Int {
+        val marketId = tradeInput?.marketId ?: return subaccountNumber
+        val position = findExistingPosition(account, marketId, subaccountNumber)
+        return position?.subaccountNumber ?: subaccountNumber
+    }
+
+    fun getChildSubaccountNumberForIsolatedMarginClosePositionDeprecated(
         parser: ParserProtocol,
         account: Map<String, Any>?,
         subaccountNumber: Int,

src/commonMain/kotlin/exchange.dydx.abacus/calculator/V2/AccountCalculatorV2.kt

@@ -113,10 +113,8 @@ internal class AccountCalculatorV2(
         val modifiedOpenPositions = parentOpenPositions?.toMutableMap() ?: mutableMapOf()
         val childOpenPositions = childSubaccount.openPositions
         for ((market, childOpenPosition) in childOpenPositions ?: emptyMap()) {
-//            modifiedChildOpenPosition?.safeSet(
-//                "childSubaccountNumber",
-//                childSubaccountNumber,
-//            )
+            childOpenPosition.childSubaccountNumber = childSubaccountNumber
+
             modifiedOpenPositions[market] = childOpenPosition
         }
         parentSubaccount.openPositions = modifiedOpenPositions

src/commonMain/kotlin/exchange.dydx.abacus/calculator/V2/TradeInput/TradeInputCalculatorV2.kt

@@ -1,11 +1,14 @@
 package exchange.dydx.abacus.calculator.v2.tradeinput
 
+import abs
 import exchange.dydx.abacus.calculator.CalculationPeriod
 import exchange.dydx.abacus.calculator.TradeCalculation
 import exchange.dydx.abacus.calculator.v2.AccountTransformerV2
 import exchange.dydx.abacus.output.FeeTier
 import exchange.dydx.abacus.output.input.MarginMode
+import exchange.dydx.abacus.output.input.OrderSide
 import exchange.dydx.abacus.output.input.OrderType
+import exchange.dydx.abacus.output.input.TradeInputSize
 import exchange.dydx.abacus.protocols.ParserProtocol
 import exchange.dydx.abacus.state.internalstate.InternalAccountState
 import exchange.dydx.abacus.state.internalstate.InternalConfigsState
@@ -16,12 +19,16 @@ import exchange.dydx.abacus.state.internalstate.InternalSubaccountState
 import exchange.dydx.abacus.state.internalstate.InternalTradeInputState
 import exchange.dydx.abacus.state.internalstate.InternalUserState
 import exchange.dydx.abacus.state.internalstate.InternalWalletState
+import exchange.dydx.abacus.state.internalstate.safeCreate
+import exchange.dydx.abacus.state.model.ClosePositionInputField
+import exchange.dydx.abacus.utils.Numeric
+import exchange.dydx.abacus.utils.Rounder
 
 internal class TradeInputCalculatorV2(
     private val parser: ParserProtocol,
     private val calculation: TradeCalculation,
     private val marginModeCalculator: TradeInputMarginModeCalculator = TradeInputMarginModeCalculator(),
-    private val marketOrderCalculator: TradeInputMarketOrderCalculator = TradeInputMarketOrderCalculator(calculation),
+    private val marketOrderCalculator: TradeInputMarketOrderCalculator = TradeInputMarketOrderCalculator(),
     private val nonMarketOrderCalculator: TradeInputNonMarketOrderCalculator = TradeInputNonMarketOrderCalculator(),
     private val optionsCalculator: TradeInputOptionsCalculator = TradeInputOptionsCalculator(parser),
     private val summaryCalculator: TradeInputSummaryCalculator = TradeInputSummaryCalculator(),
@@ -52,6 +59,9 @@ internal class TradeInputCalculatorV2(
         )
 
         if (input != null) {
+            if (calculation == TradeCalculation.closePosition) {
+                calculateClosePositionSize(trade, markets[trade.marketId], subaccount)
+            }
             when (trade.type) {
                 OrderType.Market,
                 OrderType.StopMarket,
@@ -103,6 +113,41 @@ internal class TradeInputCalculatorV2(
         return trade
     }
 
+    private fun calculateClosePositionSize(
+        trade: InternalTradeInputState,
+        market: InternalMarketState?,
+        subaccount: InternalSubaccountState?,
+    ): InternalTradeInputState {
+        val inputType = ClosePositionInputField.invoke(trade.size?.input)
+        val marketId = trade.marketId ?: return trade
+        val position = subaccount?.openPositions?.get(marketId) ?: return trade
+        val positionSize = position.calculated[CalculationPeriod.current]?.size ?: return trade
+        val positionSizeAbs = positionSize.abs()
+        trade.side = if (positionSize > Numeric.double.ZERO) OrderSide.Sell else OrderSide.Buy
+        when (inputType) {
+            ClosePositionInputField.percent -> {
+                val percent = trade.sizePercent ?: return trade
+                val size =
+                    if (percent > Numeric.double.ONE) positionSizeAbs else positionSizeAbs * percent
+                val stepSize = market?.perpetualMarket?.configs?.stepSize ?: return trade
+                trade.size =
+                    TradeInputSize.safeCreate(trade.size).copy(size = Rounder.round(size, stepSize))
+                return trade
+            }
+
+            ClosePositionInputField.size -> {
+                trade.sizePercent = null
+                val size = trade.size?.size ?: return trade
+                if (size > positionSizeAbs) {
+                    trade.size = TradeInputSize.safeCreate(trade.size).copy(size = positionSizeAbs)
+                }
+            }
+
+            else -> {}
+        }
+        return trade
+    }
+
     private fun finalize(
         trade: InternalTradeInputState,
         account: InternalAccountState,

src/commonMain/kotlin/exchange.dydx.abacus/calculator/V2/TradeInput/TradeInputMarketOrderCalculator.kt

@@ -4,7 +4,6 @@ package exchange.dydx.abacus.calculator.v2.tradeinput
 
 import abs
 import exchange.dydx.abacus.calculator.CalculationPeriod
-import exchange.dydx.abacus.calculator.TradeCalculation
 import exchange.dydx.abacus.output.input.OrderSide
 import exchange.dydx.abacus.output.input.OrderbookUsage
 import exchange.dydx.abacus.output.input.TradeInputMarketOrder
@@ -16,24 +15,18 @@ import exchange.dydx.abacus.state.internalstate.InternalSubaccountState
 import exchange.dydx.abacus.state.internalstate.InternalTradeInputState
 import exchange.dydx.abacus.state.internalstate.InternalUserState
 import exchange.dydx.abacus.state.internalstate.safeCreate
-import exchange.dydx.abacus.state.model.ClosePositionInputField
 import exchange.dydx.abacus.utils.Numeric
 import exchange.dydx.abacus.utils.Rounder
 import kollections.toIList
 
-internal class TradeInputMarketOrderCalculator(
-    private val calculation: TradeCalculation,
-) {
+internal class TradeInputMarketOrderCalculator() {
     fun calculate(
         trade: InternalTradeInputState,
         market: InternalMarketState?,
         subaccount: InternalSubaccountState?,
         user: InternalUserState?,
         input: String?,
     ): InternalTradeInputState {
-        if (calculation == TradeCalculation.closePosition) {
-            calculateClosePositionSize(trade, market, subaccount)
-        }
         val marketOrder = createMarketOrder(
             trade = trade,
             market = market,
@@ -87,41 +80,6 @@ internal class TradeInputMarketOrderCalculator(
         }
     }
 
-    private fun calculateClosePositionSize(
-        trade: InternalTradeInputState,
-        market: InternalMarketState?,
-        subaccount: InternalSubaccountState?,
-    ): InternalTradeInputState {
-        val inputType = ClosePositionInputField.invoke(trade.size?.input)
-        val marketId = trade.marketId ?: return trade
-        val position = subaccount?.openPositions?.get(marketId) ?: return trade
-        val positionSize = position.calculated[CalculationPeriod.current]?.size ?: return trade
-        val positionSizeAbs = positionSize.abs()
-        trade.side = if (positionSize > Numeric.double.ZERO) OrderSide.Sell else OrderSide.Buy
-        when (inputType) {
-            ClosePositionInputField.percent -> {
-                val percent = trade.sizePercent ?: return trade
-                val size =
-                    if (percent > Numeric.double.ONE) positionSizeAbs else positionSizeAbs * percent
-                val stepSize = market?.perpetualMarket?.configs?.stepSize ?: return trade
-                trade.size =
-                    TradeInputSize.safeCreate(trade.size).copy(size = Rounder.round(size, stepSize))
-                return trade
-            }
-
-            ClosePositionInputField.size -> {
-                trade.sizePercent = null
-                val size = trade.size?.size ?: return trade
-                if (size > positionSizeAbs) {
-                    trade.size = TradeInputSize.safeCreate(trade.size).copy(size = positionSizeAbs)
-                }
-            }
-
-            else -> {}
-        }
-        return trade
-    }
-
     private fun createMarketOrder(
         trade: InternalTradeInputState,
         market: InternalMarketState?,

src/commonMain/kotlin/exchange.dydx.abacus/calculator/V2/TradeInput/TradeInputNonMarketOrderCalculator.kt

@@ -20,7 +20,7 @@ internal class TradeInputNonMarketOrderCalculator {
             val stepSize = market?.perpetualMarket?.configs?.stepSize ?: 0.001
             val price = getNonMarketOrderPrice(tradePrices, market, trade.type, isBuying)
             when (input) {
-                "size.size" -> {
+                "size.size", "size.percent" -> {
                     val size = tradeSize.size
                     val usdcSize =
                         if (price != null && size != null) (price * size) else null

src/commonMain/kotlin/exchange.dydx.abacus/calculator/V2/TradeInput/TradeInputOptionsCalculator.kt

@@ -276,7 +276,8 @@ internal class TradeInputOptionsCalculator(
             market = market,
         )
         if (options.executionOptions != null) {
-            if (trade.execution == null) {
+            val types = options.executionOptions?.map { it.type }
+            if (trade.execution == null || types?.contains(trade.execution) == false) {
                 trade.execution = options.executionOptions?.firstOrNull()?.type
             }
         }
@@ -289,7 +290,8 @@ internal class TradeInputOptionsCalculator(
             market = market,
         )
         if (options.marginModeOptions != null) {
-            if (trade.marginMode == null) {
+            val types = options.marginModeOptions?.map { MarginMode.invoke(it.type) }
+            if (trade.marginMode == null || types?.contains(trade.marginMode) == false) {
                 trade.marginMode = MarginMode.invoke(options.marginModeOptions?.firstOrNull()?.type)
             }
         }