[TRA-81] Check isolated market constraints in UpdateSubaccount.

protocol/testutil/constants/perpetuals.go

@@ -327,6 +327,18 @@ var (
 		},
 		FundingIndex: dtypes.ZeroInt(),
 	}
+	Iso2Usd_IsolatedMarket = perptypes.Perpetual{
+		Params: perptypes.PerpetualParams{
+			Id:                4,
+			Ticker:            "ISO2-USD",
+			MarketId:          uint32(4),
+			AtomicResolution:  int32(-7),
+			DefaultFundingPpm: int32(0),
+			LiquidityTier:     uint32(3),
+			MarketType:        perptypes.PerpetualMarketType_PERPETUAL_MARKET_TYPE_ISOLATED,
+		},
+		FundingIndex: dtypes.ZeroInt(),
+	}
 )
 
 var TestMarketPerpetuals = []perptypes.Perpetual{

protocol/testutil/constants/pricefeed.go

@@ -14,6 +14,7 @@ var (
 	MarketId1 = uint32(1)
 	MarketId2 = uint32(2)
 	MarketId3 = uint32(3)
+	MarketId4 = uint32(4)
 
 	MarketId7  = uint32(7)
 	MarketId8  = uint32(8)

protocol/testutil/constants/prices.go

@@ -27,6 +27,7 @@ const (
 	SolUsdPair   = "SOL-USD"
 	LtcUsdPair   = "LTC-USD"
 	IsoUsdPair   = "ISO-USD"
+	Iso2UsdPair  = "ISO2-USD"
 
 	BtcUsdExponent   = -5
 	EthUsdExponent   = -6
@@ -36,6 +37,7 @@ const (
 	SolUsdExponent   = -8
 	LtcUsdExponent   = -7
 	IsoUsdExponent   = -8
+	Iso2UsdExponent  = -7
 
 	CoinbaseExchangeName  = "Coinbase"
 	BinanceExchangeName   = "Binance"
@@ -212,6 +214,15 @@ var TestMarketExchangeConfigs = map[pricefeedclient.MarketId]string{
 		  }
 		]
 	  }`,
+	exchange_config.MARKET_ISO2_USD: `{
+			"exchanges": [
+				{
+				"exchangeName": "Binance",
+				"ticker": "ISO2USDT",
+				"adjustByMarket": "USDT-USD"
+				}
+			]
+			}`,
 }
 
 var TestMarketParams = []types.MarketParam{
@@ -247,6 +258,14 @@ var TestMarketParams = []types.MarketParam{
 		MinPriceChangePpm:  50,
 		ExchangeConfigJson: TestMarketExchangeConfigs[exchange_config.MARKET_ISO_USD],
 	},
+	{
+		Id:                 4,
+		Pair:               Iso2UsdPair,
+		Exponent:           Iso2UsdExponent,
+		MinExchanges:       1,
+		MinPriceChangePpm:  50,
+		ExchangeConfigJson: TestMarketExchangeConfigs[exchange_config.MARKET_ISO2_USD],
+	},
 }
 
 var TestMarketPrices = []types.MarketPrice{
@@ -270,13 +289,19 @@ var TestMarketPrices = []types.MarketPrice{
 		Exponent: IsoUsdExponent,
 		Price:    FiveBillion, // 50$ == 1 ISO
 	},
+	{
+		Id:       4,
+		Exponent: Iso2UsdExponent,
+		Price:    ThreeBillion, // 300$ == 1 ISO
+	},
 }
 
 var TestMarketIdsToExponents = map[uint32]int32{
 	0: BtcUsdExponent,
 	1: EthUsdExponent,
 	2: SolUsdExponent,
 	3: IsoUsdExponent,
+	4: Iso2UsdExponent,
 }
 
 var TestPricesGenesisState = types.GenesisState{
@@ -290,6 +315,7 @@ var (
 		types.NewMarketPriceUpdate(MarketId1, Price6),
 		types.NewMarketPriceUpdate(MarketId2, Price7),
 		types.NewMarketPriceUpdate(MarketId3, Price4),
+		types.NewMarketPriceUpdate(MarketId4, Price3),
 	}
 
 	// `MsgUpdateMarketPrices`.

protocol/testutil/daemons/pricefeed/exchange_config/market_id.go

@@ -75,8 +75,9 @@ const (
 	// MARKET_TEST_USD is the id used for the TEST-USD market pair.
 	MARKET_TEST_USD types.MarketId = 33
 
-	// Arbitrary isolated market
-	MARKET_ISO_USD types.MarketId = 999_999
+	// Arbitrary isolated markets
+	MARKET_ISO2_USD types.MarketId = 999_998
+	MARKET_ISO_USD  types.MarketId = 999_999
 
 	// Non-trading markets.
 	// MARKET_USDT_USD is the id for the USDT-USD market pair.

protocol/x/subaccounts/keeper/isolated_subaccount.go

@@ -0,0 +1,144 @@
+package keeper
+
+import (
+	errorsmod "cosmossdk.io/errors"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/dydxprotocol/v4-chain/protocol/lib"
+	perptypes "github.com/dydxprotocol/v4-chain/protocol/x/perpetuals/types"
+	"github.com/dydxprotocol/v4-chain/protocol/x/subaccounts/types"
+)
+
+// checkIsolatedSubaccountConstaints will validate all `updates` to the relevant subaccounts against
+// isolated subaccount constraints.
+// The `updates` have to contain `Subaccounts` with unique `SubaccountIds`.
+// The input subaccounts must be settled.
+//
+// Returns a `success` value of `true` if all updates are valid.
+// Returns a `successPerUpdates` value, which is a slice of `UpdateResult`.
+// These map to the updates and are used to indicate which of the updates
+// caused a failure, if any.
+func (k Keeper) checkIsolatedSubaccountConstraints(
+	ctx sdk.Context,
+	settledUpdates []settledUpdate,
+	perpetuals []perptypes.Perpetual,
+) (
+	success bool,
+	successPerUpdate []types.UpdateResult,
+	err error,
+) {
+	success = true
+	successPerUpdate = make([]types.UpdateResult, len(settledUpdates))
+	var idOfSettledUpdates = make(map[types.SubaccountId]struct{})
+	var perpIdToMarketType = make(map[uint32]perptypes.PerpetualMarketType)
+
+	for _, perpetual := range perpetuals {
+		perpIdToMarketType[perpetual.GetId()] = perpetual.Params.MarketType
+	}
+
+	for i, u := range settledUpdates {
+		_, exists := idOfSettledUpdates[*u.SettledSubaccount.Id]
+
+		if exists {
+			return false, nil, types.ErrNonUniqueUpdatesSubaccount
+		}
+
+		result, err := isValidIsolatedPerpetualUpdates(u, perpIdToMarketType)
+		if err != nil {
+			return false, nil, err
+		}
+		if result != types.Success {
+			success = false
+		}
+
+		successPerUpdate[i] = result
+		idOfSettledUpdates[*u.SettledSubaccount.Id] = struct{}{}
+	}
+
+	return success, successPerUpdate, nil
+}
+
+// Checks whether the perpetual updates to a settled subaccount violates constraints for isolated
+// perpetuals. This function assumes the settled subaccount is valid and does not violate the
+// the constraints.
+// The constraint being checked is:
+//   - a subaccount with a position in an isolated perpetual cannot have updates other perpetuals
+//   - a subaccount with a position in a non-isolated perpetual cannot have updates for isolated
+//     perpetuals
+//   - a subaccount with no positions cannot be updated to have positions in multiple isolated
+//     perpetuals or a combination of isolated and non-isolated perpetuals
+func isValidIsolatedPerpetualUpdates(
+	settledUpdate settledUpdate,
+	perpIdToMarketType map[uint32]perptypes.PerpetualMarketType,
+) (types.UpdateResult, error) {
+	// If there are no perpetual updates, then this update does not violate constraints for isolated
+	// markets.
+	if len(settledUpdate.PerpetualUpdates) == 0 {
+		return types.Success, nil
+	}
+
+	// Check if the updates contain an update to an isolated perpetual.
+	hasIsolatedUpdate := false
+	isolatedUpdatePerpetualId := uint32(0)
+	for _, perpetualUpdate := range settledUpdate.PerpetualUpdates {
+		marketType, exists := perpIdToMarketType[perpetualUpdate.PerpetualId]
+		if !exists {
+			return types.UpdateCausedError, errorsmod.Wrap(
+				perptypes.ErrPerpetualDoesNotExist, lib.UintToString(perpetualUpdate.PerpetualId),
+			)
+		}
+
+		if marketType == perptypes.PerpetualMarketType_PERPETUAL_MARKET_TYPE_ISOLATED {
+			hasIsolatedUpdate = true
+			isolatedUpdatePerpetualId = perpetualUpdate.PerpetualId
+		}
+	}
+
+	// Check if the subaccount has a position in an isolated perpetual.
+	// Assumes the subaccount itself does not violate the isolated perpetual constraints.
+	isIsolatedSubaccount := false
+	isolatedPositionPerpetualId := uint32(0)
+	hasPerpetualPositions := len(settledUpdate.SettledSubaccount.PerpetualPositions) > 0
+	for _, perpetualPosition := range settledUpdate.SettledSubaccount.PerpetualPositions {
+		marketType, exists := perpIdToMarketType[perpetualPosition.PerpetualId]
+		if !exists {
+			return types.UpdateCausedError, errorsmod.Wrap(
+				perptypes.ErrPerpetualDoesNotExist, lib.UintToString(perpetualPosition.PerpetualId),
+			)
+		}
+
+		if marketType == perptypes.PerpetualMarketType_PERPETUAL_MARKET_TYPE_ISOLATED {
+			isIsolatedSubaccount = true
+			isolatedPositionPerpetualId = perpetualPosition.PerpetualId
+		}
+	}
+
+	// A subaccount with a perpetual position in an isolated perpetual cannot have updates to other
+	// non-isolated perpetuals.
+	if isIsolatedSubaccount && !hasIsolatedUpdate {
+		return types.ViolatesIsolatedSubaccountConstraints, nil
+	}
+
+	// A subaccount with perpetual positions in non-isolated perpetuals cannot have an update
+	// to an isolated perpetual.
+	if !isIsolatedSubaccount && hasPerpetualPositions && hasIsolatedUpdate {
+		return types.ViolatesIsolatedSubaccountConstraints, nil
+	}
+
+	// There cannot be more than a single perpetual update if an update to an isolated perpetual
+	// exists in the slice of perpetual updates.
+	if hasIsolatedUpdate && len(settledUpdate.PerpetualUpdates) > 1 {
+		return types.ViolatesIsolatedSubaccountConstraints, nil
+	}
+
+	// Note  we can assume that if `hasIsolatedUpdate` is true, there is only a single perpetual
+	// update for the subaccount, given the above check.
+	// A subaccount with a perpetual position in an isolated perpetual cannot have an update to
+	// another isolated perpetual.
+	if isIsolatedSubaccount &&
+		hasIsolatedUpdate &&
+		isolatedPositionPerpetualId != isolatedUpdatePerpetualId {
+		return types.ViolatesIsolatedSubaccountConstraints, nil
+	}
+
+	return types.Success, nil
+}

protocol/x/subaccounts/keeper/subaccount.go

@@ -292,6 +292,13 @@ func (k Keeper) UpdateSubaccounts(
 		perpIdToFundingIndex[perp.Params.Id] = perp.FundingIndex
 	}
 
+	// Check if the updates satisfy the isolated perpetual constraints.
+	success, successPerUpdate, err = k.checkIsolatedSubaccountConstraints(
+		ctx, settledUpdates, allPerps)
+	if !success || err != nil {
+		return success, successPerUpdate, err
+	}
+
 	// Apply the updates to perpetual positions.
 	UpdatePerpetualPositions(
 		settledUpdates,