[1659]: Set the partial order and emit events during settlement.

x/exchange/events.go

@@ -26,7 +26,7 @@ func NewEventOrderFilled(orderID uint64) *EventOrderFilled {
 	}
 }
 
-func NewEventOrderPartiallyFilled(orderID uint64, assetsFilled, feesFilled sdk.Coins) *EventOrderPartiallyFilled {
+func NewEventOrderPartiallyFilled(orderID uint64, assetsFilled, feesFilled sdk.Coin) *EventOrderPartiallyFilled {
 	return &EventOrderPartiallyFilled{
 		OrderId:      orderID,
 		AssetsFilled: assetsFilled.String(),

x/exchange/events_test.go

@@ -100,8 +100,8 @@ func TestNewEventOrderFilled(t *testing.T) {
 
 func TestNewEventOrderPartiallyFilled(t *testing.T) {
 	orderID := uint64(18)
-	assetsFilled := sdk.NewCoins(sdk.NewInt64Coin("first", 111), sdk.NewInt64Coin("second", 22))
-	feesFilled := sdk.NewCoins(sdk.NewInt64Coin("charge", 8), sdk.NewInt64Coin("fee", 15))
+	assetsFilled := sdk.NewInt64Coin("acoin", 111)
+	feesFilled := sdk.NewInt64Coin("fcoin", 8)
 
 	event := NewEventOrderPartiallyFilled(orderID, assetsFilled, feesFilled)
 	assert.Equal(t, orderID, event.OrderId, "OrderId")
@@ -299,8 +299,10 @@ func TestTypedEventToEvent(t *testing.T) {
 	updatedByQ := quoteBz(updatedBy.String())
 	coins1 := sdk.NewCoins(sdk.NewInt64Coin("onecoin", 1), sdk.NewInt64Coin("twocoin", 2))
 	coins1Q := quoteBz(coins1.String())
-	coins2 := sdk.NewCoins(sdk.NewInt64Coin("threecoin", 3), sdk.NewInt64Coin("fourcoin", 4))
-	coins2Q := quoteBz(coins2.String())
+	acoin := sdk.NewInt64Coin("acoin", 5)
+	acoinQ := quoteBz(acoin.String())
+	fcoin := sdk.NewInt64Coin("fcoin", 5)
+	fcoinQ := quoteBz(fcoin.String())
 
 	tests := []struct {
 		name     string
@@ -352,12 +354,12 @@ func TestTypedEventToEvent(t *testing.T) {
 		},
 		{
 			name: "EventOrderPartiallyFilled",
-			tev:  NewEventOrderPartiallyFilled(5, coins1, coins2),
+			tev:  NewEventOrderPartiallyFilled(5, acoin, fcoin),
 			expEvent: sdk.Event{
 				Type: "provenance.exchange.v1.EventOrderPartiallyFilled",
 				Attributes: []abci.EventAttribute{
-					{Key: []byte("assets_filled"), Value: coins1Q},
-					{Key: []byte("fees_filled"), Value: coins2Q},
+					{Key: []byte("assets_filled"), Value: acoinQ},
+					{Key: []byte("fees_filled"), Value: fcoinQ},
 					{Key: []byte("order_id"), Value: quoteBz("5")},
 				},
 			},

x/exchange/fulfillment.go

@@ -505,8 +505,63 @@ func getFulfillmentAssetsAmt(askOF, bidOF *OrderFulfillment) (sdkmath.Int, error
 	return bidAmtLeft, nil
 }
 
+type PartialFulfillment struct {
+	NewOrder     *Order
+	AssetsFilled sdk.Coin
+	PriceFilled  sdk.Coin
+}
+
+func NewPartialFulfillment(f *OrderFulfillment) *PartialFulfillment {
+	order := NewOrder(f.GetOrderID())
+	if f.IsAskOrder() {
+		askOrder := &AskOrder{
+			MarketId:     f.GetMarketID(),
+			Seller:       f.GetOwner(),
+			Assets:       f.GetAssetsLeft(),
+			Price:        f.GetPriceLeft(),
+			AllowPartial: f.PartialFillAllowed(),
+		}
+		if !f.FeesLeft.IsZero() {
+			if len(f.FeesLeft) > 1 {
+				panic(fmt.Errorf("partially filled ask order %d somehow has multiple denoms in fees left %q",
+					order.OrderId, f.FeesLeft))
+			}
+			askOrder.SellerSettlementFlatFee = &f.FeesLeft[0]
+		}
+		return &PartialFulfillment{
+			NewOrder:     order,
+			AssetsFilled: f.GetAssetsFilled(),
+			PriceFilled:  f.GetPriceFilled(),
+		}
+	}
+
+	if f.IsBidOrder() {
+		bidOrder := &BidOrder{
+			MarketId:            f.GetMarketID(),
+			Buyer:               f.GetOwner(),
+			Assets:              f.GetAssetsLeft(),
+			Price:               f.GetPriceLeft(),
+			BuyerSettlementFees: f.FeesLeft,
+			AllowPartial:        f.PartialFillAllowed(),
+		}
+		return &PartialFulfillment{
+			NewOrder:     order.WithBid(bidOrder),
+			AssetsFilled: f.GetAssetsFilled(),
+			PriceFilled:  f.GetPriceFilled(),
+		}
+	}
+
+	panic(fmt.Errorf("order %d has unknown type %q", order.OrderId, f.GetOrderType()))
+}
+
+type Fulfillments struct {
+	AskOFs       []*OrderFulfillment
+	BidOFs       []*OrderFulfillment
+	PartialOrder *PartialFulfillment
+}
+
 // BuildFulfillments creates all of the ask and bid order fulfillments.
-func BuildFulfillments(askOrders, bidOrders []*Order, sellerFeeRatio *FeeRatio) ([]*OrderFulfillment, []*OrderFulfillment, error) {
+func BuildFulfillments(askOrders, bidOrders []*Order, sellerFeeRatio *FeeRatio) (*Fulfillments, error) {
 	askOFs := make([]*OrderFulfillment, len(askOrders))
 	for i, askOrder := range askOrders {
 		askOFs[i] = NewOrderFulfillment(askOrder)
@@ -520,12 +575,12 @@ func BuildFulfillments(askOrders, bidOrders []*Order, sellerFeeRatio *FeeRatio)
 	for a < len(askOFs) && b < len(bidOFs) {
 		err := Fulfill(askOFs[a], bidOFs[b])
 		if err != nil {
-			return nil, nil, err
+			return nil, err
 		}
 		askFilled := askOFs[a].IsFullyFilled()
 		bidFilled := bidOFs[b].IsFullyFilled()
 		if !askFilled && !bidFilled {
-			return nil, nil, fmt.Errorf("neither ask order %d nor bid order %d could be filled in full",
+			return nil, fmt.Errorf("neither ask order %d nor bid order %d could be filled in full",
 				askOFs[a].GetOrderID(), bidOFs[b].GetOrderID())
 		}
 		if askFilled {
@@ -539,27 +594,37 @@ func BuildFulfillments(askOrders, bidOrders []*Order, sellerFeeRatio *FeeRatio)
 	// Need to finalize bid orders first due to possible extra price distribution.
 	for _, bidOF := range bidOFs {
 		if err := bidOF.Finalize(sellerFeeRatio); err != nil {
-			return nil, nil, err
+			return nil, err
 		}
 	}
 	for _, askOF := range askOFs {
 		if err := askOF.Finalize(sellerFeeRatio); err != nil {
-			return nil, nil, err
+			return nil, err
 		}
 	}
 
 	for _, bidOF := range bidOFs {
 		if err := bidOF.Validate(); err != nil {
-			return nil, nil, err
+			return nil, err
 		}
 	}
 	for _, askOF := range askOFs {
 		if err := askOF.Validate(); err != nil {
-			return nil, nil, err
+			return nil, err
 		}
 	}
 
-	return askOFs, bidOFs, nil
+	rv := &Fulfillments{
+		AskOFs: askOFs,
+		BidOFs: bidOFs,
+	}
+	if !askOFs[len(askOFs)-1].IsFullyFilled() {
+		rv.PartialOrder = NewPartialFulfillment(askOFs[len(askOFs)-1])
+	} else if !bidOFs[len(bidOFs)-1].IsFullyFilled() {
+		rv.PartialOrder = NewPartialFulfillment(bidOFs[len(bidOFs)-1])
+	}
+
+	return rv, nil
 }
 
 // Transfer contains bank inputs and outputs indicating a transfer that needs to be made.

x/exchange/keeper/fulfillment.go

@@ -329,11 +329,12 @@ func (k Keeper) SettleOrders(ctx sdk.Context, marketID uint32, askOrderIDs, bidO
 		return errors.Join(errs...)
 	}
 
-	if !expectPartial && !exchange.CoinsEquals(totalAssetsForSale, totalAssetsToBuy) {
+	isPartial := !exchange.CoinsEquals(totalAssetsForSale, totalAssetsToBuy)
+	if !expectPartial && isPartial {
 		return fmt.Errorf("total assets for sale %q does not equal total assets to buy %q and partial settlement not expected",
 			totalAssetsForSale, totalAssetsToBuy)
 	}
-	if expectPartial && exchange.CoinsEquals(totalAssetsForSale, totalAssetsToBuy) {
+	if expectPartial && !isPartial {
 		return fmt.Errorf("total assets for sale %q equals total assets to buy %q but partial settlement is expected",
 			totalAssetsForSale, totalAssetsToBuy)
 	}
@@ -343,12 +344,12 @@ func (k Keeper) SettleOrders(ctx sdk.Context, marketID uint32, askOrderIDs, bidO
 		return err
 	}
 
-	askOFs, bidOfs, err := exchange.BuildFulfillments(askOrders, bidOrders, sellerFeeRatio)
+	fulfillments, err := exchange.BuildFulfillments(askOrders, bidOrders, sellerFeeRatio)
 	if err != nil {
 		return err
 	}
 
-	transfers := exchange.BuildSettlementTransfers(askOFs, bidOfs)
+	transfers := exchange.BuildSettlementTransfers(fulfillments.AskOFs, fulfillments.BidOFs)
 
 	for _, transfer := range transfers.OrderTransfers {
 		if err = k.DoTransfer(ctx, transfer.Inputs, transfer.Outputs); err != nil {
@@ -360,6 +361,31 @@ func (k Keeper) SettleOrders(ctx sdk.Context, marketID uint32, askOrderIDs, bidO
 		return err
 	}
 
-	// TODO[1658]: Update the partial order and emit events.
-	panic("not finished")
+	if fulfillments.PartialOrder != nil {
+		if err = k.setOrderInStore(store, *fulfillments.PartialOrder.NewOrder); err != nil {
+			return fmt.Errorf("could not update partial %s order %d: %w",
+				fulfillments.PartialOrder.NewOrder.GetOrderType(), fulfillments.PartialOrder.NewOrder.OrderId, err)
+		}
+	}
+
+	events := make([]proto.Message, 0, len(askOrders)+len(bidOrders))
+	for _, order := range askOrders {
+		if fulfillments.PartialOrder != nil && fulfillments.PartialOrder.NewOrder.OrderId != order.OrderId {
+			events = append(events, exchange.NewEventOrderFilled(order.OrderId))
+		}
+	}
+	for _, order := range bidOrders {
+		if fulfillments.PartialOrder != nil && fulfillments.PartialOrder.NewOrder.OrderId != order.OrderId {
+			events = append(events, exchange.NewEventOrderFilled(order.OrderId))
+		}
+	}
+	if fulfillments.PartialOrder != nil {
+		events = append(events, exchange.NewEventOrderPartiallyFilled(
+			fulfillments.PartialOrder.NewOrder.OrderId,
+			fulfillments.PartialOrder.AssetsFilled,
+			fulfillments.PartialOrder.PriceFilled,
+		))
+	}
+
+	return ctx.EventManager().EmitTypedEvents(events...)
 }