re-gen

Author: albertchon

chain/exchange/types/codec.go

@@ -18,11 +18,15 @@ func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) {
 	cdc.RegisterConcrete(&MsgInstantPerpetualMarketLaunch{}, "exchange/MsgInstantPerpetualMarketLaunch", nil)
 	cdc.RegisterConcrete(&MsgInstantExpiryFuturesMarketLaunch{}, "exchange/MsgInstantExpiryFuturesMarketLaunch", nil)
 	cdc.RegisterConcrete(&MsgCreateSpotLimitOrder{}, "exchange/MsgCreateSpotLimitOrder", nil)
+	cdc.RegisterConcrete(&MsgBatchCreateSpotLimitOrders{}, "exchange/MsgBatchCreateSpotLimitOrders", nil)
 	cdc.RegisterConcrete(&MsgCreateSpotMarketOrder{}, "exchange/MsgCreateSpotMarketOrder", nil)
 	cdc.RegisterConcrete(&MsgCancelSpotOrder{}, "exchange/MsgCancelSpotOrder", nil)
+	cdc.RegisterConcrete(&MsgBatchCancelSpotOrders{}, "exchange/MsgBatchCancelSpotOrders", nil)
 	cdc.RegisterConcrete(&MsgCreateDerivativeLimitOrder{}, "exchange/MsgCreateDerivativeLimitOrder", nil)
+	cdc.RegisterConcrete(&MsgBatchCreateDerivativeLimitOrders{}, "exchange/MsgBatchCreateDerivativeLimitOrders", nil)
 	cdc.RegisterConcrete(&MsgCreateDerivativeMarketOrder{}, "exchange/MsgCreateDerivativeMarketOrder", nil)
 	cdc.RegisterConcrete(&MsgCancelDerivativeOrder{}, "exchange/MsgCancelDerivativeOrder", nil)
+	cdc.RegisterConcrete(&MsgBatchCancelDerivativeOrders{}, "exchange/MsgBatchCancelDerivativeOrders", nil)
 	cdc.RegisterConcrete(&MsgSubaccountTransfer{}, "exchange/MsgSubaccountTransfer", nil)
 	cdc.RegisterConcrete(&MsgExternalTransfer{}, "exchange/MsgExternalTransfer", nil)
 	cdc.RegisterConcrete(&MsgIncreasePositionMargin{}, "exchange/MsgIncreasePositionMargin", nil)
@@ -45,11 +49,15 @@ func RegisterInterfaces(registry types.InterfaceRegistry) {
 		&MsgInstantPerpetualMarketLaunch{},
 		&MsgInstantExpiryFuturesMarketLaunch{},
 		&MsgCreateSpotLimitOrder{},
+		&MsgBatchCreateSpotLimitOrders{},
 		&MsgCreateSpotMarketOrder{},
 		&MsgCancelSpotOrder{},
+		&MsgBatchCancelSpotOrders{},
 		&MsgCreateDerivativeLimitOrder{},
+		&MsgBatchCreateDerivativeLimitOrders{},
 		&MsgCreateDerivativeMarketOrder{},
 		&MsgCancelDerivativeOrder{},
+		&MsgBatchCancelDerivativeOrders{},
 		&MsgSubaccountTransfer{},
 		&MsgExternalTransfer{},
 		&MsgIncreasePositionMargin{},

chain/exchange/types/deposit.go

@@ -2,9 +2,10 @@ package types
 
 import (
 	"bytes"
+	"sort"
+
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/ethereum/go-ethereum/common"
-	"sort"
 )
 
 func NewDeposit() *Deposit {

chain/exchange/types/derivative_orderbook.go

@@ -15,6 +15,6 @@ type DerivativeOrderbook interface {
 }
 
 type DerivativeOrderbookFills struct {
-	Orders               []*DerivativeLimitOrder
-	FillQuantities       []sdk.Dec
+	Orders         []*DerivativeLimitOrder
+	FillQuantities []sdk.Dec
 }

chain/exchange/types/derivative_orders.go

@@ -6,7 +6,6 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 )
 
-
 func NewMarketOrderForLiquidation(position *Position, positionSubaccountID common.Hash, liquidator sdk.Address) *DerivativeMarketOrder {
 
 	// if long position, market sell order at price 0
@@ -87,6 +86,25 @@ func NewDerivativeLimitOrder(o *DerivativeOrder, orderHash common.Hash) *Derivat
 	}
 }
 
+func (o *DerivativeLimitOrder) ToDerivativeOrder(marketID string) *DerivativeOrder {
+	return &DerivativeOrder{
+		MarketId:     marketID,
+		OrderInfo:    o.OrderInfo,
+		OrderType:    o.OrderType,
+		Margin:       o.Margin,
+		TriggerPrice: o.TriggerPrice,
+	}
+}
+func (o *DerivativeMarketOrder) ToDerivativeOrder(marketID string) *DerivativeOrder {
+	return &DerivativeOrder{
+		MarketId:     marketID,
+		OrderInfo:    o.OrderInfo,
+		OrderType:    o.OrderType,
+		Margin:       o.Margin,
+		TriggerPrice: o.TriggerPrice,
+	}
+}
+
 func (o *DerivativeLimitOrder) GetCancelDepositDelta(feeRate sdk.Dec) *DepositDelta {
 	depositDelta := NewDepositDelta()
 	if o.IsVanilla() {
@@ -122,17 +140,24 @@ func (o *DerivativeOrder) CheckMarginAndGetMarginHold(market *DerivativeMarket,
 		return sdk.Dec{}, sdkerrors.Wrapf(ErrInsufficientOrderMargin, "InitialMarginRatio Check: need at least %s but got %s", market.InitialMarginRatio.Mul(notional).String(), o.Margin.String())
 	}
 
-	markPriceThreshold := o.ComputeInitialMarginRequirementMarkPriceThreshold(market.InitialMarginRatio)
+	if err = o.CheckInitialMarginRequirementMarkPriceThreshold(market.InitialMarginRatio, markPrice); err != nil {
+		return sdk.Dec{}, err
+	}
+
+	return o.Margin.Add(feeAmount), nil
+}
+
+func (o *DerivativeOrder) CheckInitialMarginRequirementMarkPriceThreshold(initialMarginRatio, markPrice sdk.Dec) (err error) {
+	markPriceThreshold := o.ComputeInitialMarginRequirementMarkPriceThreshold(initialMarginRatio)
 	// For Buys: MarkPrice ≥ (Margin - Price * Quantity) / ((InitialMarginRatio - 1) * Quantity)
 	// For Sells: MarkPrice ≤ (Margin + Price * Quantity) / ((1+ InitialMarginRatio) * Quantity)
 	if o.OrderType.IsBuy() && markPrice.LT(markPriceThreshold) {
-		return sdk.Dec{}, sdkerrors.Wrapf(ErrInsufficientOrderMargin, "Buy MarkPriceThreshold Check: mark price %s must be GTE %s", markPrice.String(), markPriceThreshold.String())
+		return sdkerrors.Wrapf(ErrInsufficientOrderMargin, "Buy MarkPriceThreshold Check: mark price %s must be GTE %s", markPrice.String(), markPriceThreshold.String())
 	} else if !o.OrderType.IsBuy() && markPrice.GT(markPriceThreshold) {
-
-		return sdk.Dec{}, sdkerrors.Wrapf(ErrInsufficientOrderMargin, "Sell MarkPriceThreshold Check: mark price %s must be LTE %s", markPrice.String(), markPriceThreshold.String())
+		return sdkerrors.Wrapf(ErrInsufficientOrderMargin, "Sell MarkPriceThreshold Check: mark price %s must be LTE %s", markPrice.String(), markPriceThreshold.String())
 	}
 
-	return o.Margin.Add(feeAmount), nil
+	return nil
 }
 
 func (o *DerivativeOrder) ComputeInitialMarginRequirementMarkPriceThreshold(initialMarginRatio sdk.Dec) sdk.Dec {
@@ -148,6 +173,14 @@ func (o *DerivativeOrder) ComputeInitialMarginRequirementMarkPriceThreshold(init
 	return numerator.Quo(denominator)
 }
 
+func (o *DerivativeLimitOrder) CheckInitialMarginRequirementMarkPriceThreshold(initialMarginRatio, markPrice sdk.Dec) (err error) {
+	return o.ToDerivativeOrder("").CheckInitialMarginRequirementMarkPriceThreshold(initialMarginRatio, markPrice)
+}
+
+func (o *DerivativeMarketOrder) CheckInitialMarginRequirementMarkPriceThreshold(initialMarginRatio, markPrice sdk.Dec) (err error) {
+	return o.ToDerivativeOrder("").CheckInitialMarginRequirementMarkPriceThreshold(initialMarginRatio, markPrice)
+}
+
 func (o *DerivativeMarketOrder) ComputeOrderHash(nonce uint32, marketId string) (common.Hash, error) {
 	triggerPrice := ""
 	if o.TriggerPrice != nil {

chain/exchange/types/derivative_positions.go

@@ -2,7 +2,6 @@ package types
 
 import (
 	"bytes"
-	"fmt"
 	"sort"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -35,7 +34,7 @@ func GetPositionSliceData(p map[common.Hash]*PositionState) ([]*Position, []comm
 			positions = append(positions, position.Position)
 			nonNilPositionSubaccountIDs = append(nonNilPositionSubaccountIDs, subaccountID)
 		} else {
-			fmt.Println("❌ position is nil for subaccount", subaccountID.Hex())
+			//fmt.Println("❌ position is nil for subaccount", subaccountID.Hex())
 		}
 	}
 

chain/exchange/types/derivatives_market.go

@@ -0,0 +1,13 @@
+package types
+
+func (m *DerivativeMarket) IsTimeExpiry() bool {
+	return !m.IsPerpetual
+}
+
+func (m *DerivativeMarket) IsActive() bool {
+	return m.Status != MarketStatus_Active
+}
+
+func (m *DerivativeMarket) IsInactive() bool {
+	return !m.IsActive()
+}

chain/exchange/types/exchange.go

@@ -20,4 +20,29 @@ func (m *SpotMarket) MarketID() common.Hash {
 
 func (e ExecutionType) IsMarket() bool {
 	return e == ExecutionType_Market
-}
+}
+
+func (m *SpotMarket) StatusSupportsOrderCancellations() bool {
+	if m == nil {
+		return false
+	}
+	return m.Status.supportsOrderCancellations()
+}
+
+func (m *DerivativeMarket) StatusSupportsOrderCancellations() bool {
+	if m == nil {
+		return false
+	}
+	return m.Status.supportsOrderCancellations()
+}
+
+func (s MarketStatus) supportsOrderCancellations() bool {
+	switch s {
+	case MarketStatus_Active, MarketStatus_Suspended, MarketStatus_Demolished, MarketStatus_Expired:
+		return true
+	case MarketStatus_Paused:
+		return false
+	default:
+		return false
+	}
+}