chore: cleanup

x/ecocredit/server/marketplace/buy.go

@@ -10,6 +10,7 @@ import (
 	ecocreditv1 "github.com/regen-network/regen-ledger/api/regen/ecocredit/v1"
 	"github.com/regen-network/regen-ledger/types/math"
 	v1 "github.com/regen-network/regen-ledger/x/ecocredit/marketplace"
+	"github.com/regen-network/regen-ledger/x/ecocredit/server"
 )
 
 func (k Keeper) Buy(ctx context.Context, req *v1.MsgBuy) (*v1.MsgBuyResponse, error) {
@@ -33,29 +34,37 @@ func (k Keeper) Buy(ctx context.Context, req *v1.MsgBuy) (*v1.MsgBuyResponse, er
 
 		switch selection := order.Selection.Sum.(type) {
 		case *v1.MsgBuy_Order_Selection_SellOrderId:
-			orderAmt, err := math.NewDecFromString(order.Quantity)
+			sellOrder, err := k.stateStore.SellOrderTable().Get(ctx, selection.SellOrderId)
+			if err != nil {
+				return nil, fmt.Errorf("sell order %d: %w", selection.SellOrderId, err)
+			}
+			batch, err := k.coreStore.BatchInfoTable().Get(ctx, sellOrder.BatchId)
 			if err != nil {
 				return nil, err
 			}
-			// get the sell order
-			sellOrder, err := k.stateStore.SellOrderStore().Get(ctx, selection.SellOrderId)
+			ct, err := server.GetCreditTypeFromBatchDenom(ctx, k.coreStore, k.params, batch.BatchDenom)
 			if err != nil {
-				return nil, fmt.Errorf("sell order %d: %w", selection.SellOrderId, err)
+				return nil, err
+			}
+			orderAmt, err := math.NewPositiveFixedDecFromString(order.Quantity, ct.Precision)
+			if err != nil {
+				return nil, err
 			}
+
 			if sellOrder.DisableAutoRetire != order.DisableAutoRetire {
 				return nil, sdkerrors.ErrInvalidRequest.Wrapf("auto-retire mismatch: sell order set to %t, buy "+
 					"order set to %t", sellOrder.DisableAutoRetire, order.DisableAutoRetire)
 			}
-			// get the market
-			market, err := k.stateStore.MarketStore().Get(ctx, sellOrder.MarketId)
+
+			market, err := k.stateStore.MarketTable().Get(ctx, sellOrder.MarketId)
 			if err != nil {
 				return nil, fmt.Errorf("market id %d: %w", sellOrder.MarketId, err)
 			}
-			// check that the order denoms match
 			if order.BidPrice.Denom != market.BankDenom {
 				return nil, sdkerrors.ErrInvalidRequest.Wrapf("bid price denom does not match ask price denom: "+
 					" %s, expected %s", order.BidPrice.Denom, market.BankDenom)
 			}
+
 			// check that bid price is at least equal to ask price
 			askAmount, ok := sdk.NewIntFromString(sellOrder.AskPrice)
 			if !ok {
@@ -65,6 +74,7 @@ func (k Keeper) Buy(ctx context.Context, req *v1.MsgBuy) (*v1.MsgBuyResponse, er
 				return nil, sdkerrors.ErrInsufficientFunds.Wrapf("bid price too low: got %s, needed at least %s",
 					order.BidPrice.Amount.String(), sellOrder.AskPrice)
 			}
+
 			if err = k.updateBalances(ctx, sellOrder, buyerAcc, orderAmt, *order.BidPrice); err != nil {
 				return nil, fmt.Errorf("error updating balances: %w", err)
 			}
@@ -75,29 +85,37 @@ func (k Keeper) Buy(ctx context.Context, req *v1.MsgBuy) (*v1.MsgBuyResponse, er
 	return &v1.MsgBuyResponse{}, nil
 }
 
+// updateBalances moves credits according to the orders. it will:
+// - update a sell order, removing it if quantity becomes 0 as a result of this purchase.
+// - remove the purchaseQty from the seller's escrowed balance.
+// - add credits to the buyer's tradable/retired address (based on the DisableAutoRetire field).
+// - update the supply accordingly.
+// - send the coins specified in the bid to the seller.
 func (k Keeper) updateBalances(ctx context.Context, sellOrder *api.SellOrder, buyerAcc sdk.AccAddress, purchaseQty math.Dec, bidCoin sdk.Coin) error {
 	// update the sell order
 	sellOrderQty, err := math.NewDecFromString(sellOrder.Quantity)
 	if err != nil {
 		return err
 	}
+	// since we only support direct buy orders at this time, we fail when the requested purchase amount is more than
+	// the available credits for sale, rather than partial filling the buy order.
 	sellOrderQty, err = math.SafeSubBalance(sellOrderQty, purchaseQty)
 	if err != nil {
 		return err
 	}
-	if sellOrderQty.IsZero() { // remove the sell order
-		if err := k.stateStore.SellOrderStore().Delete(ctx, sellOrder); err != nil {
+	if sellOrderQty.IsZero() { // remove the sell order if no credits are left
+		if err := k.stateStore.SellOrderTable().Delete(ctx, sellOrder); err != nil {
 			return err
 		}
-	} else { // update the sell order
+	} else {
 		sellOrder.Quantity = sellOrderQty.String()
-		if err = k.stateStore.SellOrderStore().Update(ctx, sellOrder); err != nil {
+		if err = k.stateStore.SellOrderTable().Update(ctx, sellOrder); err != nil {
 			return err
 		}
 	}
 
-	// update the sellers balance
-	sellerBal, err := k.coreStore.BatchBalanceStore().Get(ctx, sellOrder.Seller, sellOrder.BatchId)
+	// remove the credits from the seller's escrowed balance
+	sellerBal, err := k.coreStore.BatchBalanceTable().Get(ctx, sellOrder.Seller, sellOrder.BatchId)
 	if err != nil {
 		return err
 	}
@@ -110,16 +128,16 @@ func (k Keeper) updateBalances(ctx context.Context, sellOrder *api.SellOrder, bu
 		return err
 	}
 	sellerBal.Escrowed = escrowBal.String()
-	if err = k.coreStore.BatchBalanceStore().Update(ctx, sellerBal); err != nil {
+	if err = k.coreStore.BatchBalanceTable().Update(ctx, sellerBal); err != nil {
 		return err
 	}
 
 	// update the buyers balance and supply
-	supply, err := k.coreStore.BatchSupplyStore().Get(ctx, sellOrder.BatchId)
+	supply, err := k.coreStore.BatchSupplyTable().Get(ctx, sellOrder.BatchId)
 	if err != nil {
 		return err
 	}
-	buyerBal, err := k.coreStore.BatchBalanceStore().Get(ctx, buyerAcc, sellOrder.BatchId)
+	buyerBal, err := k.coreStore.BatchBalanceTable().Get(ctx, buyerAcc, sellOrder.BatchId)
 	if err != nil {
 		if ormerrors.IsNotFound(err) {
 			buyerBal = &ecocreditv1.BatchBalance{
@@ -133,7 +151,7 @@ func (k Keeper) updateBalances(ctx context.Context, sellOrder *api.SellOrder, bu
 			return err
 		}
 	}
-	if sellOrder.DisableAutoRetire {
+	if sellOrder.DisableAutoRetire { // if auto retire is disabled, we move the credits into the buyer's/supply's tradable balance.
 		tradableBalance, err := math.NewDecFromString(buyerBal.Tradable)
 		if err != nil {
 			return err
@@ -174,17 +192,21 @@ func (k Keeper) updateBalances(ctx context.Context, sellOrder *api.SellOrder, bu
 		}
 		supply.RetiredAmount = supplyRetired.String()
 	}
+	// move subtract the purchased credits from the escrowed supply
 	// we can update the escrowed supply outside the condition since its the same either way
 	supplyEscrowed, err := math.NewDecFromString(supply.EscrowedAmount)
+	if err != nil {
+		return err
+	}
 	supplyEscrowed, err = math.SafeSubBalance(supplyEscrowed, purchaseQty)
 	if err != nil {
 		return err
 	}
 	supply.EscrowedAmount = supplyEscrowed.String()
-	if err = k.coreStore.BatchSupplyStore().Update(ctx, supply); err != nil {
+	if err = k.coreStore.BatchSupplyTable().Update(ctx, supply); err != nil {
 		return err
 	}
-	if err = k.coreStore.BatchBalanceStore().Save(ctx, buyerBal); err != nil {
+	if err = k.coreStore.BatchBalanceTable().Save(ctx, buyerBal); err != nil {
 		return err
 	}
 

x/ecocredit/server/marketplace/buy_test.go

@@ -1,6 +1,7 @@
 package marketplace
 
 import (
+	"github.com/cosmos/cosmos-sdk/orm/types/ormerrors"
 	"github.com/cosmos/cosmos-sdk/testutil/testdata"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/golang/mock/gomock"
@@ -55,12 +56,12 @@ func TestBuy_ValidTradable(t *testing.T) {
 	assert.NilError(t, err)
 
 	// sell order should now have quantity 10 - 3 -> 7
-	sellOrder, err := s.marketStore.SellOrderStore().Get(s.ctx, 1)
+	sellOrder, err := s.marketStore.SellOrderTable().Get(s.ctx, 1)
 	assert.NilError(t, err)
 	assert.Equal(t, "7", sellOrder.Quantity)
 
 	// buyer didn't have credits before, so they should now have 3 credits
-	buyerBal, err := s.coreStore.BatchBalanceStore().Get(s.ctx, buyerAddr, 1)
+	buyerBal, err := s.coreStore.BatchBalanceTable().Get(s.ctx, buyerAddr, 1)
 	assert.NilError(t, err)
 	tradableBalance, err := math.NewDecFromString(buyerBal.Tradable)
 	assert.NilError(t, err)
@@ -109,14 +110,65 @@ func TestBuy_ValidRetired(t *testing.T) {
 	assert.NilError(t, err)
 
 	// sell order should now have quantity 10 - 3 -> 7
-	sellOrder, err := s.marketStore.SellOrderStore().Get(s.ctx, 1)
+	sellOrder, err := s.marketStore.SellOrderTable().Get(s.ctx, 1)
 	assert.NilError(t, err)
 	assert.Equal(t, "7", sellOrder.Quantity)
 
 	// buyer didn't have credits before, so they should now have 3 credits
-	buyerBal, err := s.coreStore.BatchBalanceStore().Get(s.ctx, buyerAddr, 1)
+	buyerBal, err := s.coreStore.BatchBalanceTable().Get(s.ctx, buyerAddr, 1)
 	assert.NilError(t, err)
 	retiredBalance, err := math.NewDecFromString(buyerBal.Retired)
 	assert.NilError(t, err)
 	assert.Check(t, retiredBalance.Equal(math.NewDecFromInt64(3)))
 }
+
+func TestBuy_OrderFilled(t *testing.T) {
+	t.Parallel()
+	s := setupBase(t)
+	_, _, buyerAddr := testdata.KeyTestPubAddr()
+	batchDenom := "C01-20200101-20200201-001"
+	start, end := timestamppb.Now(), timestamppb.Now()
+	ask := sdk.NewInt64Coin("ufoo", 10)
+	creditType := ecocredit.CreditType{
+		Name:         "carbon",
+		Abbreviation: "C",
+		Unit:         "tonnes",
+		Precision:    6,
+	}
+	marketTestSetup(t, s, batchDenom, ask.Denom, ask.Denom[1:], "C01", start, end, creditType)
+	// make a sell order
+	any := gomock.Any()
+	s.paramsKeeper.EXPECT().GetParamSet(any, any).Do(func(any interface{}, p *ecocredit.Params) {
+		p.CreditTypes = []*ecocredit.CreditType{&creditType}
+	}).AnyTimes()
+	sellExp := time.Now()
+	res, err := s.k.Sell(s.ctx, &marketplace.MsgSell{
+		Owner:  s.addr.String(),
+		Orders: []*marketplace.MsgSell_Order{
+			{BatchDenom: batchDenom, Quantity: "10", AskPrice: &ask, DisableAutoRetire: false, Expiration: &sellExp},
+		},
+	})
+	assert.NilError(t, err)
+	sellOrderId := res.SellOrderIds[0]
+
+	s.bankKeeper.EXPECT().HasBalance(any, any, any).Return(true).Times(1)
+	s.bankKeeper.EXPECT().SendCoins(any, any, any, any).Return(nil).Times(1)
+
+	_, err = s.k.Buy(s.ctx, &marketplace.MsgBuy{
+		Buyer:  buyerAddr.String(),
+		Orders: []*marketplace.MsgBuy_Order{
+			{Selection: &marketplace.MsgBuy_Order_Selection{Sum: &marketplace.MsgBuy_Order_Selection_SellOrderId{SellOrderId: sellOrderId}},
+				Quantity: "10", BidPrice: &ask, DisableAutoRetire: false, Expiration: &sellExp},
+		},
+	})
+	assert.NilError(t, err)
+
+	// order was filled, so sell order should no longer exist
+	_, err = s.marketStore.SellOrderTable().Get(s.ctx, sellOrderId)
+	assert.ErrorContains(t, err, ormerrors.NotFound.Error())
+	buyerBal, err := s.coreStore.BatchBalanceTable().Get(s.ctx, buyerAddr, 1)
+	assert.NilError(t, err)
+	retiredBal, err := math.NewDecFromString(buyerBal.Retired)
+	assert.NilError(t, err)
+	assert.Check(t, retiredBal.Equal(math.NewDecFromInt64(10)))
+}

x/ecocredit/server/marketplace/sell_test.go

@@ -1,9 +1,7 @@
 package marketplace
 
 import (
-	"github.com/cosmos/cosmos-sdk/orm/types/ormerrors"
-	"github.com/regen-network/regen-ledger/types/math"
-	"github.com/regen-network/regen-ledger/x/ecocredit/server"
+
 	"testing"
 	"time"