feat: claim rewards and rebalance commands

Makefile

@@ -9,6 +9,12 @@ start-alliance-oracle-feeder:
 start-alliance-rebalance-feeder:
 	go run ./cmd/feeder/feeder.go alliance-rebalance-feeder
 
+start-alliance-update-rewards:
+	go run ./cmd/feeder/feeder.go alliance-update-rewards
+
+start-alliance-rebalance-emissions:
+	go run ./cmd/feeder/feeder.go alliance-rebalance-emissions
+
 start-price-server:
 	go run ./cmd/price-server/price_server.go
 

cmd/feeder/feeder.go

@@ -39,10 +39,10 @@ func main() {
 	alliancesQuerierProvider := alliance_provider.NewAlliancesQuerierProvider(feederType)
 
 	for attempt := 1; attempt <= retries; attempt++ {
-		_, err := alliancesQuerierProvider.QueryAndSubmitOnChain(ctx)
+		txHash, err := alliancesQuerierProvider.SubmitTx(ctx)
 
 		if err == nil {
-			// Code executed successfully
+			fmt.Printf("Transaction Submitted successfully txHash: %s \n", txHash)
 			break
 		} else {
 			// Code execution failed

internal/provider/alliance/alliance_querier.go

@@ -26,27 +26,34 @@ func NewAlliancesQuerierProvider(feederType types.FeederType) *alliancesQuerierP
 	}
 }
 
-func (a alliancesQuerierProvider) QueryAndSubmitOnChain(ctx context.Context) (res []byte, err error) {
-	res, err = a.requestData()
+func (a alliancesQuerierProvider) SubmitTx(ctx context.Context) (string, error) {
+	if a.feederType == types.AllianceOracleFeeder ||
+		a.feederType == types.AllianceRebalanceFeeder {
+		return a.QueryAndSubmitOnChain(ctx)
+	}
+
+	return a.SubmitOnChain(ctx)
+}
+
+func (a alliancesQuerierProvider) QueryAndSubmitOnChain(ctx context.Context) (string, error) {
+	res, err := a.requestData()
 	if err != nil {
-		return nil, fmt.Errorf("ERROR requesting alliances data %w", err)
+		return "", fmt.Errorf("ERROR requesting alliances data %w", err)
 	}
 	txHash, err := a.transactionsProvider.SubmitAlliancesTransaction(ctx, res)
 	if err != nil {
-		return nil, fmt.Errorf("ERROR submitting alliances data on chain %w", err)
+		return "", fmt.Errorf("ERROR submitting alliances data on chain %w", err)
 	}
-
-	fmt.Printf("Transaction Submitted successfully txHash: %s \n", txHash)
-	return res, nil
+	return txHash, nil
 }
 
-func (a alliancesQuerierProvider) SubmitOnChain(ctx context.Context) (datxHashta string, err error) {
+func (a alliancesQuerierProvider) SubmitOnChain(ctx context.Context) (string, error) {
 	var sdkMsg wasmtypes.RawContractMessage
 
 	switch a.feederType {
-	case types.AllianceHubRebalanceEmissions:
+	case types.AllianceRebalanceEmissions:
 		sdkMsg, _ = json.Marshal(pkgtypes.MsgRebalanceEmissions{})
-	case types.AllianceHubUpdateRewards:
+	case types.AllianceUpdateRewards:
 		sdkMsg, _ = json.Marshal(pkgtypes.MsgUpdateRewards{})
 	}
 

internal/provider/transactions_provider.go

@@ -257,12 +257,13 @@ func (p *TransactionsProvider) getRPCConnection(nodeUrl string, interfaceRegistr
 }
 
 func (p *TransactionsProvider) getContractAddress() string {
-	switch p.feederType {
-	case types.AllianceOracleFeeder:
-		return p.oracleAddress
-	case types.AllianceRebalanceFeeder:
+	if p.feederType == types.AllianceUpdateRewards ||
+		p.feederType == types.AllianceRebalanceEmissions ||
+		p.feederType == types.AllianceRebalanceFeeder {
 		return p.allianceHubContractAddress
+	} else if p.feederType == types.AllianceOracleFeeder {
+		return p.oracleAddress
 	}
 
-	panic("Unknown feeder type")
+	panic("Unknown feeder type " + p.feederType)
 }

internal/types/feeder_type.go

@@ -5,23 +5,23 @@ import "fmt"
 type FeederType string
 
 const (
-	AllianceHubUpdateRewards      FeederType = "alliance-hub-update-rewards"
-	AllianceHubRebalanceEmissions FeederType = "Alliance-hub-rebalance-emissions"
-	AllianceOracleFeeder          FeederType = "alliance-oracle-feeder"
-	AllianceRebalanceFeeder       FeederType = "alliance-rebalance-feeder"
+	AllianceUpdateRewards      FeederType = "alliance-update-rewards"
+	AllianceRebalanceEmissions FeederType = "alliance-rebalance-emissions"
+	AllianceOracleFeeder       FeederType = "alliance-oracle-feeder"
+	AllianceRebalanceFeeder    FeederType = "alliance-rebalance-feeder"
 )
 
 // parse from string to FeederType
 func ParseFeederTypeFromString(s string) (FeederType, error) {
 	switch s {
+	case string(AllianceUpdateRewards):
+		return AllianceUpdateRewards, nil
+	case string(AllianceRebalanceEmissions):
+		return AllianceRebalanceEmissions, nil
 	case string(AllianceOracleFeeder):
 		return AllianceOracleFeeder, nil
 	case string(AllianceRebalanceFeeder):
 		return AllianceRebalanceFeeder, nil
-	case string(AllianceHubUpdateRewards):
-		return AllianceHubUpdateRewards, nil
-	case string(AllianceHubRebalanceEmissions):
-		return AllianceHubRebalanceEmissions, nil
 	default:
 		return "", fmt.Errorf(
 			`invalid feeder type: "%s", expected types are "%s" | "%s"`,