Merge branch 'main' into features/notification

# Conflicts:
#	build.gradle.kts
#	integration/iOS/Pods/Pods.xcodeproj/project.pbxproj
#	src/commonMain/kotlin/exchange.dydx.abacus/state/manager/StateManagerAdaptor.kt
#	src/commonMain/kotlin/exchange.dydx.abacus/state/v2/supervisor/SubaccountSupervisor.kt
#	v4_abacus.podspec

.pre-commit-config.yaml

@@ -0,0 +1,14 @@
+# See https://pre-commit.com for more information
+# See https://pre-commit.com/hooks.html for more hooks
+
+default_install_hook_types:
+   [pre-push]
+
+repos:
+-   repo: local
+    hooks:
+    -   id: spotless-apply
+        name: spotless-apply
+        entry: ./run_spotless_apply.sh
+        language: script
+        stages: [pre-push]

README.md

@@ -87,6 +87,13 @@ Integration tests can be written to call Abacus from non-Kotlin code (i.e., Swif
 
 > ./bump_version.sh
 
+# Auto-lint
+
+Enable pre-commit to auto-lint/auto-format your changes before git commit:
+
+> brew install pre-commit
+> pre-commit install
+
 # How to use
 
 ```

build.gradle.kts

@@ -49,7 +49,7 @@ allprojects {
 }
 
 group = "exchange.dydx.abacus"
-version = "1.6.52"
+version = "1.7.7"
 
 repositories {
     google()

detekt.yml

@@ -4,6 +4,9 @@ naming:
     # /exchange -> /dydx -> /abacus
     # didn't seem worth the potential thrash in PRs to fix (feel free to fix if you feel differently)
     active: false
+  MatchingDeclarationName:
+    # Affects a lot of the TradingStateMachine+_.kt files
+    active: false
 
 complexity:
   CognitiveComplexMethod:

docs/API/Actions.md

@@ -240,4 +240,30 @@ Take profit order trigger price's percentage difference from the position's aver
 
 ### takeProfitUsdcDiff
 
-Take profit order trigger price's usdc difference from the position's average entry price
+Take profit order trigger price's usdc difference from the position's average entry price
+
+# AdjustIsolatedMargin
+
+    fun adjustIsolatedMargin(data: String?, type: AdjustIsolatedMarginInputField?): AppStateResponse
+
+The input state is in `response.state.input.adjustIsolatedMargin` as a [AdjustIsolatedMarginInput](../Input/AdjustIsolatedMarginInput.md).
+
+### data
+
+Data input in string format
+
+## AdjustIsolatedMarginInputField
+
+### Type
+
+IsolatedMarginAdjustmentType
+Add - Add margin to the child's isolated margin account from the parent's cross margin account
+Remove - Remove margin from the child's isolated margin account to the parent's cross margin account
+
+### Amount
+
+Amount of USDC to remove or add
+
+### ChildSubaccountNumber
+
+Subaccount number for the child whose margin is to be adjusted

docs/Input/AdjustIsolatedMarginInput.md

@@ -0,0 +1,21 @@
+# AdjustIsolatedMarginInput
+
+data class AdjustIsolatedMarginInput(  
+ val type: String?, // "ADD" or "REMOVE"
+ val amount: Double?,
+ val childSubaccountNumber: Int?,
+)
+
+## type
+
+ADD - Add margin to the child's isolated margin account from the parent's cross margin account
+REMOVE - Remove margin from the child's isolated margin account to the parent's cross margin account
+
+## amount
+
+Amount of USDC to remove or add
+
+## childSubaccountNumber
+
+Subaccount number for the child whose margin is to be adjusted
+

integration/iOS/Podfile

@@ -4,7 +4,7 @@
 source 'https://github.com/CocoaPods/Specs.git'
 
 def abacus_pods
-  pod 'abacus', :path => '~/v4-abacus'
+  pod 'abacus', :path => '../../v4-abacus'
   #pod 'abacus', :git => 'https://github.com/dydxprotocol/v4-abacus.git'
 end
 

integration/iOS/Podfile.lock

@@ -15,9 +15,9 @@ EXTERNAL SOURCES:
     :path: "~/v4-abacus"
 
 SPEC CHECKSUMS:
-  abacus: 46f62be6dc9b3f888093eb2c9952d0267ab40670
+  abacus: a57d55b0ca0d3514389573a87c47507f88eb6b0a
   CryptoSwift: 562f8eceb40e80796fffc668b0cad9313284cfa6
 
 PODFILE CHECKSUM: 37d72c15b180e62a4c42b8fb41b4836c89aa63c9
 
-COCOAPODS: 1.15.2
+COCOAPODS: 1.12.1

run_spotless_apply.sh

@@ -0,0 +1,5 @@
+#!/bin/sh
+
+./gradlew spotlessApply
+
+exit 0

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

@@ -0,0 +1,136 @@
+package exchange.dydx.abacus.calculator
+
+import exchange.dydx.abacus.output.input.IsolatedMarginAdjustmentType
+import exchange.dydx.abacus.protocols.ParserProtocol
+import exchange.dydx.abacus.utils.Numeric
+import exchange.dydx.abacus.utils.mutable
+import exchange.dydx.abacus.utils.safeSet
+
+@Suppress("UNCHECKED_CAST")
+internal class AdjustIsolatedMarginInputCalculator(val parser: ParserProtocol) {
+    private val subaccountTransformer = SubaccountTransformer()
+
+    internal fun calculate(
+        state: Map<String, Any>,
+        parentSubaccountNumber: Int?,
+    ): Map<String, Any> {
+        val wallet = parser.asNativeMap(state["wallet"])
+        val isolatedMarginAdjustment = parser.asNativeMap(state["adjustIsolatedMargin"])
+        val childSubaccountNumber = parser.asInt(isolatedMarginAdjustment?.get("ChildSubaccountNumber"))
+        val type = parser.asString(isolatedMarginAdjustment?.get("Type"))?.let {
+            IsolatedMarginAdjustmentType.valueOf(it)
+        } ?: IsolatedMarginAdjustmentType.Add
+
+        return if (wallet != null && isolatedMarginAdjustment != null && type != null) {
+            val modified = state.mutable()
+            val parentTransferDelta = getModifiedTransferDelta(isolatedMarginAdjustment, true)
+            val childTransferDelta = getModifiedTransferDelta(isolatedMarginAdjustment, false)
+
+            val walletPostParentSubaccountTransfer =
+                subaccountTransformer.applyIsolatedMarginAdjustmentToWallet(
+                    wallet,
+                    subaccountNumber = parentSubaccountNumber,
+                    parentTransferDelta,
+                    parser,
+                    "postOrder",
+                )
+
+            val walletPostChildSubaccountTransfer =
+                subaccountTransformer.applyIsolatedMarginAdjustmentToWallet(
+                    wallet = walletPostParentSubaccountTransfer,
+                    subaccountNumber = childSubaccountNumber,
+                    childTransferDelta,
+                    parser,
+                    "postOrder",
+                )
+
+            val modifiedParentSubaccount = parser.asNativeMap(parser.value(walletPostChildSubaccountTransfer, "accounts.subaccounts.$parentSubaccountNumber"))
+            val modifiedChildSubaccount = parser.asNativeMap(parser.value(walletPostChildSubaccountTransfer, "accounts.subaccounts.$childSubaccountNumber"))
+            val modifiedIsolatedMarginAdjustment = finalize(isolatedMarginAdjustment, modifiedParentSubaccount, modifiedChildSubaccount, type)
+
+            modified["adjustIsolatedMargin"] = modifiedIsolatedMarginAdjustment
+            modified["wallet"] = walletPostChildSubaccountTransfer
+            modified
+        } else {
+            state
+        }
+    }
+
+    private fun getModifiedTransferDelta(
+        isolatedMarginAdjustment: Map<String, Any>,
+        isParentSubaccount: Boolean,
+    ): Map<String, Double> {
+        val type = parser.asString(isolatedMarginAdjustment["Type"])?.let {
+            IsolatedMarginAdjustmentType.valueOf(it)
+        } ?: IsolatedMarginAdjustmentType.Add
+        val amount = parser.asDouble(isolatedMarginAdjustment["Amount"])
+
+        when (type) {
+            IsolatedMarginAdjustmentType.Add -> {
+                val multiplier =
+                    if (isParentSubaccount) Numeric.double.NEGATIVE else Numeric.double.POSITIVE
+                val usdcSize = (amount ?: Numeric.double.ZERO) * multiplier
+
+                return mapOf(
+                    "usdcSize" to usdcSize,
+                )
+            }
+
+            IsolatedMarginAdjustmentType.Remove -> {
+                val multiplier =
+                    if (isParentSubaccount) Numeric.double.POSITIVE else Numeric.double.NEGATIVE
+                val usdcSize = (amount ?: Numeric.double.ZERO) * multiplier
+
+                return mapOf(
+                    "usdcSize" to usdcSize,
+                )
+            }
+        }
+    }
+
+    private fun summaryForType(
+        parentSubaccount: Map<String, Any>?,
+        childSubaccount: Map<String, Any>?,
+        type: IsolatedMarginAdjustmentType,
+    ): Map<String, Any> {
+        val summary = mutableMapOf<String, Any>()
+        val crossCollateral = parser.asDouble(parser.value(parentSubaccount, "freeCollateral.postOrder"))
+        val crossMarginUsage = parser.asDouble(parser.value(parentSubaccount, "marginUsage.postOrder"))
+        val openPositions = parser.asNativeMap(childSubaccount?.get("openPositions"))
+        val marketId = openPositions?.keys?.firstOrNull()
+        val positionMargin = parser.asDouble(parser.value(childSubaccount, "freeCollateral.postOrder"))
+        val positionLeverage = parser.asDouble(parser.value(childSubaccount, "openPositions.$marketId.leverage.postOrder"))
+        val liquidationPrice = parser.asDouble(parser.value(childSubaccount, "openPositions.$marketId.liquidationPrice.postOrder"))
+
+        when (type) {
+            IsolatedMarginAdjustmentType.Add -> {
+                summary.safeSet("crossFreeCollateral", crossCollateral)
+                summary.safeSet("crossMarginUsage", crossMarginUsage)
+                summary.safeSet("positionMargin", positionMargin)
+                summary.safeSet("positionLeverage", positionLeverage)
+                summary.safeSet("liquidationPrice", liquidationPrice)
+            }
+
+            IsolatedMarginAdjustmentType.Remove -> {
+                summary.safeSet("crossFreeCollateral", crossCollateral)
+                summary.safeSet("crossMarginUsage", crossMarginUsage)
+                summary.safeSet("positionMargin", positionMargin)
+                summary.safeSet("positionLeverage", positionLeverage)
+                summary.safeSet("liquidationPrice", liquidationPrice)
+            }
+        }
+
+        return summary
+    }
+
+    private fun finalize(
+        isolatedMarginAdjustment: Map<String, Any>,
+        parentSubaccount: Map<String, Any>?,
+        childSubaccount: Map<String, Any>?,
+        type: IsolatedMarginAdjustmentType,
+    ): Map<String, Any> {
+        val modified = isolatedMarginAdjustment.mutable()
+        modified.safeSet("summary", summaryForType(parentSubaccount, childSubaccount, type))
+        return modified
+    }
+}

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

@@ -199,6 +199,26 @@ internal class SubaccountTransformer {
         }
     }
 
+    internal fun applyIsolatedMarginAdjustmentToWallet(
+        wallet: Map<String, Any>,
+        subaccountNumber: Int?,
+        delta: Map<String, Double>,
+        parser: ParserProtocol,
+        period: String
+    ): Map<String, Any> {
+        val key = "account.subaccounts.$subaccountNumber"
+        val subaccount = parser.asNativeMap(parser.value(wallet, key))
+
+        if (subaccount != null) {
+            val modifiedSubaccount = applyDeltaToSubaccount(subaccount, delta, parser, period)
+            val modifiedWallet = wallet.mutable()
+            modifiedWallet.safeSet(key, modifiedSubaccount)
+            return modifiedWallet
+        }
+
+        return wallet
+    }
+
     internal fun applyTradeToSubaccount(
         subaccount: Map<String, Any>?,
         trade: Map<String, Any>,

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

@@ -1217,7 +1217,7 @@ internal class TradeInputCalculator(
             return parser.asDouble(parser.value(position, "maxLeverage.current"))
         } else {
             val initialMarginFraction =
-                parser.asDouble(parser.value(market, "configs.initialMarginFraction"))
+                parser.asDouble(parser.value(market, "configs.effectiveInitialMarginFraction"))
                     ?: return null
             return 1.0 / initialMarginFraction
         }

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

@@ -13,6 +13,10 @@ import exchange.dydx.abacus.utils.mutable
 import exchange.dydx.abacus.utils.safeSet
 import kotlin.math.abs
 
+internal object TriggerOrdersConstants {
+    const val TRIGGER_ORDER_DEFAULT_DURATION_DAYS = 90.0
+}
+
 @Suppress("UNCHECKED_CAST")
 internal class TriggerOrdersInputCalculator(val parser: ParserProtocol) {
     internal fun calculate(