WIP: Pay commission to validators only after outgoing batch execution

chain/proto/minter/v1/pool.proto

@@ -8,10 +8,18 @@ option go_package = "github.com/MinterTeam/mhub/chain/x/minter/types";
 
 // OutgoingTx is a withdrawal on the bridged contract
 // TODO: can this type be replaced by outgoing transfer tx
+message OutgoingTxDeprecated {
+  string sender = 1;
+  string dest_addr = 2;
+  cosmos.base.v1beta1.Coin amount = 3 [(gogoproto.nullable) = false];
+  string tx_hash = 7;
+}
+
 message OutgoingTx {
   string sender = 1;
   string dest_addr = 2;
   cosmos.base.v1beta1.Coin amount = 3 [(gogoproto.nullable) = false];
+  cosmos.base.v1beta1.Coin val_fee = 4 [(gogoproto.nullable) = false];
   string tx_hash = 7;
 }
 

chain/proto/peggy/v1/pool.proto

@@ -8,7 +8,7 @@ option go_package = "github.com/MinterTeam/mhub/chain/x/peggy/types";
 
 // OutgoingTx is a withdrawal on the bridged contract
 // TODO: can this type be replaced by outgoing transfer tx
-message OutgoingTx {
+message OutgoingTxDeprecated {
   string sender = 1;
   string dest_addr = 2;
   string refund_addr = 3;
@@ -18,5 +18,16 @@ message OutgoingTx {
   string tx_hash = 7;
 }
 
+message OutgoingTx {
+  string sender = 1;
+  string dest_addr = 2;
+  string refund_addr = 3;
+  int64 expiration_time = 4;
+  cosmos.base.v1beta1.Coin amount = 5 [(gogoproto.nullable) = false];
+  cosmos.base.v1beta1.Coin bridge_fee = 6 [(gogoproto.nullable) = false];
+  cosmos.base.v1beta1.Coin val_fee = 7 [(gogoproto.nullable) = false];
+  string tx_hash = 8;
+}
+
 // IDSet represents a set of IDs
 message IDSet { repeated uint64 ids = 1; }

chain/x/minter/handler.go

@@ -278,7 +278,8 @@ func handleMsgSendToMinter(ctx sdk.Context, keeper keeper.Keeper, msg *types.Msg
 	}
 
 	sender, _ := sdk.AccAddressFromBech32(msg.Sender)
-	txID, err := keeper.AddToOutgoingPool(ctx, sender, msg.MinterDest, "todo", msg.Amount) // todo: txhash
+	commission := sdk.NewCoin(msg.Amount.Denom, msg.Amount.Amount.ToDec().Mul(keeper.OracleKeeper().GetCommissionForDemon(ctx, msg.Amount.Denom)).RoundInt())
+	txID, err := keeper.AddToOutgoingPool(ctx, sender, msg.MinterDest, "todo", msg.Amount.Sub(commission), commission) // todo: txhash
 	if err != nil {
 		return &sdk.Result{}, nil // todo log
 	}

chain/x/minter/keeper/attestation_handler.go

@@ -48,34 +48,6 @@ func (a *AttestationHandler) Handle(ctx sdk.Context, att types.Attestation, clai
 			return sdkerrors.Wrap(err, "invalid receiver address")
 		}
 
-		// pay commissions
-		{
-			valset := a.keeper.GetCurrentValset(ctx)
-			commission := sdk.NewCoin(coin.Denom, coin.Amount.ToDec().Mul(a.keeper.oracleKeeper.GetCommissionForDemon(ctx, coin.Denom)).RoundInt()) // total commission
-			if commission.IsPositive() {
-				vouchers = sdk.Coins{coin.Sub(commission)}
-
-				if err = a.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, sdk.AccAddress{}, sdk.Coins{commission}); err != nil {
-					return sdkerrors.Wrap(err, "transfer vouchers")
-				}
-
-				var totalPower uint64
-				for _, val := range valset.Members {
-					totalPower += val.Power
-				}
-
-				for _, val := range valset.Members {
-					amount := commission.Amount.Mul(sdk.NewIntFromUint64(val.Power)).Quo(sdk.NewIntFromUint64(totalPower))
-					_, err := a.keeper.AddToOutgoingPool(ctx, sdk.AccAddress{}, val.MinterAddress, "#commission", sdk.NewCoin(commission.Denom, amount))
-					if err != nil {
-						return sdkerrors.Wrap(err, "commission withdrawal")
-					}
-				}
-
-				a.keeper.BuildOutgoingTXBatch(ctx, OutgoingTxBatchSize)
-			}
-		}
-
 		if err = a.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, addr, vouchers); err != nil {
 			return sdkerrors.Wrap(err, "transfer vouchers")
 		}
@@ -147,7 +119,7 @@ func (a *AttestationHandler) Handle(ctx sdk.Context, att types.Attestation, clai
 		}
 
 		if feeIsOk {
-			_, err := a.peggyKeeper.AddToOutgoingPool(ctx, receiver, claim.EthReceiver, claim.MinterSender, claim.TxHash, sdk.NewCoin(denom, claim.Amount).Sub(commission).Sub(fee), fee)
+			_, err := a.peggyKeeper.AddToOutgoingPool(ctx, receiver, claim.EthReceiver, claim.MinterSender, claim.TxHash, sdk.NewCoin(denom, claim.Amount).Sub(commission).Sub(fee), fee, commission)
 			if err != nil {
 				return sdkerrors.Wrap(err, "withdraw")
 			}
@@ -161,7 +133,7 @@ func (a *AttestationHandler) Handle(ctx sdk.Context, att types.Attestation, clai
 
 			a.keeper.oracleKeeper.SetTxStatus(ctx, claim.TxHash, oracletypes.TX_STATUS_REFUNDED, "")
 
-			_, err := a.keeper.AddToOutgoingPool(ctx, receiver, claim.MinterSender, claim.TxHash, sdk.NewCoin(denom, claim.Amount).Sub(commission))
+			_, err := a.keeper.AddToOutgoingPool(ctx, receiver, claim.MinterSender, claim.TxHash, sdk.NewCoin(denom, claim.Amount), sdk.NewInt64Coin(denom, 0))
 			if err != nil {
 				return sdkerrors.Wrap(err, "refund")
 			}

chain/x/minter/keeper/batch.go

@@ -62,11 +62,43 @@ func (k Keeper) OutgoingTxBatchExecuted(ctx sdk.Context, nonce uint64, hash stri
 		return sdkerrors.Wrap(types.ErrUnknown, "nonce")
 	}
 
-	// cleanup outgoing TX pool
+	fees := sdk.Coins{}
+	// cleanup outgoing TX pool and calculate total fees
 	for _, tx := range b.Transactions {
+		pe, _ := k.getPoolEntry(ctx, tx.Id)
+		if !pe.ValFee.Amount.IsNil() {
+			fees = fees.Add(pe.ValFee)
+		}
 		k.removePoolEntry(ctx, tx.Id)
 	}
 
+	if !fees.IsZero() {
+		if err := k.bankKeeper.MintCoins(ctx, types.ModuleName, fees); err != nil {
+			return sdkerrors.Wrapf(err, "mint vouchers coins: %s", fees)
+		}
+		if err := k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, sdk.AccAddress{}, fees); err != nil {
+			return sdkerrors.Wrap(err, "transfer vouchers")
+		}
+
+		valset := k.GetCurrentValset(ctx)
+		var totalPower uint64
+		for _, val := range valset.Members {
+			totalPower += val.Power
+		}
+
+		for _, fee := range fees {
+			if fee.IsPositive() {
+				for _, val := range valset.Members {
+					amount := fee.Amount.Mul(sdk.NewIntFromUint64(val.Power)).Quo(sdk.NewIntFromUint64(totalPower))
+					_, err := k.AddToOutgoingPool(ctx, sdk.AccAddress{}, val.MinterAddress, "#commission", sdk.NewCoin(fee.Denom, amount), sdk.NewInt64Coin(fee.Denom, 0))
+					if err != nil {
+						return sdkerrors.Wrap(err, "commission withdrawal")
+					}
+				}
+			}
+		}
+	}
+
 	// Iterate through remaining batches
 	k.IterateOutgoingTXBatches(ctx, func(key []byte, iter_batch *types.OutgoingTxBatch) bool {
 		// If the iterated batches nonce is lower than the one that was just executed, cancel it

chain/x/minter/keeper/keeper.go

@@ -436,7 +436,7 @@ func (k Keeper) ColdStorageTransfer(ctx sdk.Context, c *types.ColdStorageTransfe
 			return sdkerrors.Wrap(err, "transfer vouchers")
 		}
 
-		txID, err := k.AddToOutgoingPool(ctx, defaultSender, coldStorageAddr, "", coin)
+		txID, err := k.AddToOutgoingPool(ctx, defaultSender, coldStorageAddr, "", coin, sdk.NewInt64Coin(coin.Denom, 0))
 		if err != nil {
 			return err
 		}

chain/x/minter/keeper/pool.go

@@ -16,8 +16,9 @@ import (
 // - burns the voucher for transfer amount and fees
 // - persists an OutgoingTx
 // - adds the TX to the `available` TX pool via a second index
-func (k Keeper) AddToOutgoingPool(ctx sdk.Context, sender sdk.AccAddress, counterpartReceiver string, txHash string, amount sdk.Coin) (uint64, error) {
+func (k Keeper) AddToOutgoingPool(ctx sdk.Context, sender sdk.AccAddress, counterpartReceiver string, txHash string, amount sdk.Coin, valFee sdk.Coin) (uint64, error) {
 	totalInVouchers := sdk.Coins{amount}
+	totalInVouchers.Add(valFee)
 
 	// Ensure that the coin is a peggy voucher
 	if _, err := types.ValidatePeggyCoin(amount, ctx, k.oracleKeeper); err != nil {
@@ -42,6 +43,7 @@ func (k Keeper) AddToOutgoingPool(ctx sdk.Context, sender sdk.AccAddress, counte
 		Sender:   sender.String(),
 		DestAddr: counterpartReceiver,
 		Amount:   amount,
+		ValFee:   valFee,
 		TxHash:   txHash,
 	}
 

chain/x/minter/module.go

@@ -171,6 +171,8 @@ func (am AppModule) EndBlock(ctx sdk.Context, _ abci.RequestEndBlock) []abci.Val
 		}
 	}
 
+	am.keeper.BuildOutgoingTXBatch(ctx, keeper.OutgoingTxBatchSize)
+
 	return []abci.ValidatorUpdate{}
 }
 

chain/x/minter/types/expected_keepers.go

@@ -23,5 +23,5 @@ type BankKeeper interface {
 
 // PeggyKeeper defines the expected peggy keeper methods
 type PeggyKeeper interface {
-	AddToOutgoingPool(ctx sdk.Context, sender sdk.AccAddress, counterpartReceiver string, refundAddr string, txHash string, amount sdk.Coin, fee sdk.Coin) (uint64, error)
+	AddToOutgoingPool(ctx sdk.Context, sender sdk.AccAddress, counterpartReceiver string, refundAddr string, txHash string, amount sdk.Coin, fee sdk.Coin, valFee sdk.Coin) (uint64, error)
 }