add expected fee to order fulfillment (#40)

* Add expected fee to order fulfillment

* Add expected fee to order fulfillment

* Fix event subscriptions: order-created, order-finalized

* Fix linter issue

* Fix linter issue

* Fix more linter issues

* feat: fee rule functionality (#38)

Fee rule functionality, refactor

* Fix fee parsing

config.go

@@ -17,8 +17,9 @@ type Config struct {
 	Gas          GasConfig          `mapstructure:"gas"`
 	OrderPolling OrderPollingConfig `mapstructure:"order_polling"`
 
-	Whale whaleConfig `mapstructure:"whale"`
-	Bots  botConfig   `mapstructure:"bots"`
+	Whale           whaleConfig     `mapstructure:"whale"`
+	Bots            botConfig       `mapstructure:"bots"`
+	FulfillCriteria fulfillCriteria `mapstructure:"fulfill_criteria"`
 
 	LogLevel    string      `mapstructure:"log_level"`
 	SlackConfig slackConfig `mapstructure:"slack"`
@@ -52,6 +53,15 @@ type whaleConfig struct {
 	AllowedBalanceThresholds map[string]string            `mapstructure:"allowed_balance_thresholds"`
 }
 
+type fulfillCriteria struct {
+	MinFeePercentage minFeePercentage `mapstructure:"min_fee_percentage"`
+}
+
+type minFeePercentage struct {
+	Chain map[string]float32 `mapstructure:"chain"`
+	Asset map[string]float32 `mapstructure:"asset"`
+}
+
 type slackConfig struct {
 	Enabled   bool   `mapstructure:"enabled"`
 	BotToken  string `mapstructure:"bot_token"`

order_client.go

@@ -71,24 +71,19 @@ func newOrderClient(ctx context.Context, config Config) (*orderClient, error) {
 	fulfilledOrdersCh := make(chan *orderBatch, newOrderBufferSize) // TODO: make buffer size configurable
 	bstore := store.NewBotStore(db)
 
-	denomsWhitelist := make(map[string]struct{}, len(config.Whale.AllowedBalanceThresholds))
-	for denom := range config.Whale.AllowedBalanceThresholds {
-		denomsWhitelist[denom] = struct{}{}
-	}
-
 	ordTracker := newOrderTracker(
 		fetcherCosmosClient,
 		bstore,
 		fulfilledOrdersCh,
 		subscriberID,
-		denomsWhitelist,
+		&config.FulfillCriteria,
 		logger,
 	)
 
 	eventer := newOrderEventer(
 		fetcherCosmosClient,
 		subscriberID,
-		ordTracker,
+		ordTracker.canFulfillOrder,
 		config.Bots.MaxOrdersPerTx,
 		orderCh,
 		logger,
@@ -173,7 +168,7 @@ func newOrderClient(ctx context.Context, config Config) (*orderClient, error) {
 	if config.OrderPolling.Enabled {
 		oc.orderPoller = newOrderPoller(
 			fetcherCosmosClient,
-			ordTracker,
+			ordTracker.canFulfillOrder,
 			config.OrderPolling,
 			config.Bots.MaxOrdersPerTx,
 			orderCh,

order_eventer.go

@@ -15,27 +15,27 @@ type orderEventer struct {
 	client cosmosclient.Client
 	logger *zap.Logger
 
-	batchSize    int
-	newOrders    chan []*demandOrder
-	tracker      *orderTracker
-	subscriberID string
+	batchSize       int
+	newOrders       chan []*demandOrder
+	canFulfillOrder func(*demandOrder) bool
+	subscriberID    string
 }
 
 func newOrderEventer(
 	client cosmosclient.Client,
 	subscriberID string,
-	tracker *orderTracker,
+	canFulfillOrder func(*demandOrder) bool,
 	batchSize int,
 	newOrders chan []*demandOrder,
 	logger *zap.Logger,
 ) *orderEventer {
 	return &orderEventer{
-		client:       client,
-		subscriberID: subscriberID,
-		batchSize:    batchSize,
-		logger:       logger.With(zap.String("module", "order-eventer")),
-		newOrders:    newOrders,
-		tracker:      tracker,
+		client:          client,
+		subscriberID:    subscriberID,
+		batchSize:       batchSize,
+		logger:          logger.With(zap.String("module", "order-eventer")),
+		newOrders:       newOrders,
+		canFulfillOrder: canFulfillOrder,
 	}
 }
 
@@ -52,10 +52,7 @@ func (e *orderEventer) start(ctx context.Context) error {
 }
 
 func (e *orderEventer) enqueueEventOrders(res tmtypes.ResultEvent) error {
-	newOrders, err := e.parseOrdersFromEvents(res)
-	if err != nil {
-		return fmt.Errorf("failed to parse orders from events: %w", err)
-	}
+	newOrders := e.parseOrdersFromEvents(res)
 
 	if e.logger.Level() <= zap.DebugLevel {
 		ids := make([]string, 0, len(newOrders))
@@ -87,38 +84,50 @@ func (e *orderEventer) enqueueEventOrders(res tmtypes.ResultEvent) error {
 
 const createdEvent = "dymensionxyz.dymension.eibc.EventDemandOrderCreated"
 
-func (e *orderEventer) parseOrdersFromEvents(res tmtypes.ResultEvent) ([]*demandOrder, error) {
+func (e *orderEventer) parseOrdersFromEvents(res tmtypes.ResultEvent) []*demandOrder {
 	ids := res.Events[createdEvent+".order_id"]
 
 	if len(ids) == 0 {
-		return nil, nil
+		return nil
 	}
 
 	prices := res.Events[createdEvent+".price"]
 	fees := res.Events[createdEvent+".fee"]
 	statuses := res.Events[createdEvent+".packet_status"]
+	rollapps := res.Events[createdEvent+".rollapp_id"]
 	newOrders := make([]*demandOrder, 0, len(ids))
 
 	for i, id := range ids {
-		price, err := sdk.ParseCoinNormalized(prices[i])
+		price, err := sdk.ParseCoinsNormalized(prices[i])
 		if err != nil {
-			return nil, fmt.Errorf("failed to parse price: %w", err)
+			e.logger.Error("failed to parse price", zap.Error(err))
+			continue
 		}
 
-		if !e.tracker.canFulfillOrder(id, price.Denom) {
+		fee, err := sdk.ParseCoinsNormalized(fees[i])
+		if err != nil {
+			e.logger.Error("failed to parse fee", zap.Error(err))
 			continue
 		}
 
 		order := &demandOrder{
-			id:     id,
-			amount: sdk.NewCoins(price),
-			fee:    fees[i],
-			status: statuses[i],
+			id:        id,
+			denom:     fee.GetDenomByIndex(0),
+			amount:    price,
+			fee:       fee,
+			status:    statuses[i],
+			rollappId: rollapps[i],
+			// blockHeight: height,
 		}
+
+		if !e.canFulfillOrder(order) {
+			continue
+		}
+
 		newOrders = append(newOrders, order)
 	}
 
-	return newOrders, nil
+	return newOrders
 }
 
 func (e *orderEventer) subscribeToPendingDemandOrders(ctx context.Context) error {

order_fulfiller.go

@@ -7,9 +7,8 @@ import (
 	"time"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"go.uber.org/zap"
-
 	"github.com/dymensionxyz/cosmosclient/cosmosclient"
+	"go.uber.org/zap"
 
 	"github.com/dymensionxyz/eibc-client/types"
 )
@@ -185,16 +184,7 @@ func (ol *orderFulfiller) fulfillDemandOrders(demandOrder ...*demandOrder) error
 	msgs := make([]sdk.Msg, len(demandOrder))
 
 	for i, order := range demandOrder {
-		if order.fee == "" {
-			continue
-		}
-		fee, err := sdk.ParseCoinNormalized(order.fee)
-		if err != nil {
-			return fmt.Errorf("failed to parse fee: %w", err)
-		}
-		feeAmount := fee.Amount.String()
-
-		msgs[i] = types.NewMsgFulfillOrder(ol.accountSvc.account.GetAddress().String(), order.id, feeAmount)
+		msgs[i] = types.NewMsgFulfillOrder(ol.accountSvc.account.GetAddress().String(), order.id, order.feeStr)
 	}
 
 	_, err := ol.client.BroadcastTx(ol.accountSvc.accountName, msgs...)