Merge pull request #549 from hyperweb-io/anmol/faucet-postcheck

faucet postcheck

Author: Anmol1696

starship/charts/devnet/templates/chains/cosmos/genesis.yaml

@@ -394,7 +394,7 @@ spec:
             httpGet:
               path: /status
               port: {{ $chain.faucet.ports.rest }}
-            initialDelaySeconds: 15
+            initialDelaySeconds: 30
             periodSeconds: 10
         {{- else if eq $chain.faucet.type "starship" }}
         - name: faucet
@@ -463,7 +463,7 @@ spec:
             httpGet:
               path: /status
               port: {{ $chain.faucet.ports.rest }}
-            initialDelaySeconds: 10
+            initialDelaySeconds: 30
             periodSeconds: 10
         {{- end }}
         {{- end }}

starship/faucet/config.go

@@ -20,6 +20,8 @@ func NewDefaultConfig() *Config {
 		RefillFactor:      8,
 		RefillThreshold:   20,
 		RefillEpoch:       100,
+		CreditCheckEpoch:  3,
+		CreditCheckRetry:  3,
 		Verbose:           true,
 	}
 }
@@ -55,6 +57,10 @@ type Config struct {
 	RefillEpoch int `name:"refill-epoch" json:"refill_epoch" env:"REFILL_EPOCH" usage:"after every epoch, holder will distrubute tokens to distributor addresses if required"`
 	// CreditCoins is comma seperated list of amount and denom of tokens to be transfered
 	CreditCoins string `name:"credit-coins" json:"credit_coins" env:"CREDIT_COINS" usage:"comma seperated list of amount and denom of tokens to be transfered. eg: 10000000uosmo,1000000uion"`
+	// CreditCheckEpoch is the time (in secs) to sleep, after which holder will check for credit request
+	CreditCheckEpoch int `name:"credit-check-epoch" json:"credit_check_epoch" env:"CREDIT_CHECK_EPOCH" usage:"after every epoch, holder will check for credit request"`
+	// CreditCheckRetry is the number of retries to check for credit request
+	CreditCheckRetry int `name:"credit-check-retry" json:"credit_check_retry" env:"CREDIT_CHECK_RETRY" usage:"number of retries to check for credit request"`
 	// Mnemonic is the mnemonic of the address used as the faucet address
 	Mnemonic string `name:"mnemonic" json:"mnemonic" env:"MNEMONIC" usage:"mnemonic of the address used as the faucet address"`
 	// Verbose switches on debug logging

starship/faucet/distributor.go

@@ -276,6 +276,23 @@ func (a *Account) String() string {
 	return fmt.Sprintf("name: %s, addr: %s", a.Name, a.Address)
 }
 
+// queryTx queries the tx based on the txhash
+func (a *Account) queryTx(txhash string) (map[string]interface{}, error) {
+	cmdStr := fmt.Sprintf("%s q tx %s --output=json", a.config.ChainBinary, txhash)
+	output, err := runCommand(cmdStr)
+	if err != nil {
+		return nil, err
+	}
+
+	txMap := map[string]interface{}{}
+	err = json.Unmarshal(output, &txMap)
+	if err != nil {
+		return nil, err
+	}
+
+	return txMap, nil
+}
+
 // sendTokens performs chain binary send txn from account
 func (a *Account) sendTokens(address string, denom string, amount string) error {
 	ok := a.mu.TryLock()
@@ -284,7 +301,7 @@ func (a *Account) sendTokens(address string, denom string, amount string) error
 	}
 	defer a.mu.Unlock()
 
-	args := fmt.Sprintf("--chain-id=%s --fees=%s --keyring-backend=test --gas=auto --gas-adjustment=1.5 --yes --node=%s", a.config.ChainId, a.config.ChainFees, a.config.ChainRPCEndpoint)
+	args := fmt.Sprintf("--chain-id=%s --fees=%s --keyring-backend=test --gas=auto --gas-adjustment=1.5 --output=json --yes --node=%s", a.config.ChainId, a.config.ChainFees, a.config.ChainRPCEndpoint)
 	cmdStr := fmt.Sprintf("%s tx bank send %s %s %s%s %s", a.config.ChainBinary, a.Address, address, amount, denom, args)
 	output, err := runCommand(cmdStr)
 	if err != nil {
@@ -293,6 +310,30 @@ func (a *Account) sendTokens(address string, denom string, amount string) error
 	}
 	a.logger.Info("ran cmd to send tokens", zap.String("cmd", cmdStr), zap.String("stdout", string(output)))
 
+	// Find the JSON line and extract the txhash using a regular expression
+	txhash, err := extractTxHash(string(output))
+	if err != nil {
+		a.logger.Error("failed to extract txhash", zap.Error(err))
+		return err
+	}
+
+	a.logger.Debug("send tokens txhash", zap.String("txhash", txhash))
+
+	// query tx to check if the tx was successful
+	txMap, err := a.queryTx(txhash)
+	if err != nil {
+		return err
+	}
+
+	// check if the tx has the event
+	err = hasEvent(txMap, "transfer")
+	if err != nil {
+		a.logger.Error("transfer event not found in tx",
+			zap.String("txhash", txhash),
+			zap.Any("txMap", txMap))
+		return err
+	}
+
 	return nil
 }
 

starship/faucet/handler.go

@@ -2,7 +2,11 @@ package main
 
 import (
 	"context"
+	"fmt"
+	"math/big"
+	"time"
 
+	"go.uber.org/zap"
 	"google.golang.org/protobuf/types/known/emptypb"
 
 	pb "github.com/hyperweb-io/starship/faucet/faucet"
@@ -37,11 +41,64 @@ func (a *AppServer) Status(ctx context.Context, _ *emptypb.Empty) (*pb.State, er
 	return state, nil
 }
 
+func (a *AppServer) getBalance(address, denom string) (*big.Int, error) {
+	account := &Account{config: a.config, logger: a.logger, Address: address}
+	coin, err := account.GetBalanceByDenom(denom)
+	if err != nil {
+		// Log the error, but don't return it
+		a.logger.Debug("Error getting balance, assuming new account", zap.Error(err))
+		return new(big.Int), nil // Return 0 balance
+	}
+	balance, ok := new(big.Int).SetString(coin.Amount, 10)
+	if !ok {
+		return nil, fmt.Errorf("failed to parse balance")
+	}
+	return balance, nil
+}
+
 func (a *AppServer) Credit(ctx context.Context, requestCredit *pb.RequestCredit) (*pb.ResponseCredit, error) {
-	err := a.distributor.SendTokens(requestCredit.GetAddress(), requestCredit.GetDenom())
+	// Get initial balance before sending tokens
+	initialBalance, err := a.getBalance(requestCredit.GetAddress(), requestCredit.GetDenom())
+	if err != nil {
+		return nil, fmt.Errorf("failed to get initial balance: %v", err)
+	}
+
+	err = a.distributor.SendTokens(requestCredit.GetAddress(), requestCredit.GetDenom())
 	if err != nil {
 		return nil, err
 	}
 
+	// Check balance after transfer
+	confirmed, err := a.confirmBalanceUpdate(requestCredit.GetAddress(), requestCredit.GetDenom(), initialBalance)
+	if err != nil {
+		return &pb.ResponseCredit{Status: fmt.Sprintf("error: %v", err)}, err
+	}
+	if !confirmed {
+		return &pb.ResponseCredit{Status: "error: failed to confirm balance update (timeout reached)"}, nil
+	}
+
 	return &pb.ResponseCredit{Status: "ok"}, nil
 }
+
+func (a *AppServer) confirmBalanceUpdate(address, denom string, initialBalance *big.Int) (bool, error) {
+	expectedIncrease, ok := new(big.Int).SetString(a.distributor.CreditCoins.GetDenomAmount(denom), 10)
+	if !ok {
+		return false, fmt.Errorf("failed to parse expected amount")
+	}
+
+	expectedFinalBalance := new(big.Int).Add(initialBalance, expectedIncrease)
+
+	for i := 0; i < a.config.CreditCheckRetry; i++ { // Try x times with t-second intervals
+		currentBalance, err := a.getBalance(address, denom)
+		if err != nil {
+			return false, err
+		}
+		if currentBalance.Cmp(expectedFinalBalance) >= 0 {
+			return true, nil
+		}
+		if i < 2 {
+			time.Sleep(time.Duration(a.config.CreditCheckEpoch) * time.Second)
+		}
+	}
+	return false, nil
+}

starship/faucet/utils.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"os"
 	"os/exec"
+	"regexp"
 )
 
 // runCommand will run the cmdStr as exec and return the results as a []byte
@@ -22,3 +23,53 @@ func runCommand(cmdStr string) ([]byte, error) {
 
 	return outb.Bytes(), nil
 }
+
+// extractTxHash uses a regular expression to extract the txhash from the output
+func extractTxHash(output string) (string, error) {
+	// Regular expression to match the txhash value in the JSON output
+	re := regexp.MustCompile(`"txhash":"([0-9A-Fa-f]{64})"`)
+	match := re.FindStringSubmatch(output)
+	if len(match) < 2 {
+		return "", fmt.Errorf("txhash not found in output")
+	}
+	return match[1], nil
+}
+
+// hasEvent checks for a specific event type in the transaction results.
+// It first tries to fetch the events either from txMap["events"] or from txMap["logs"] and then checks for the event type.
+func hasEvent(txResults map[string]interface{}, eventType string) error {
+	var events []interface{}
+
+	// Attempt to fetch events directly from txMap["events"]
+	if directEvents, ok := txResults["events"].([]interface{}); ok && len(directEvents) > 0 {
+		events = directEvents
+	} else if logs, ok := txResults["logs"].([]interface{}); ok && len(logs) > 0 {
+		// If no direct events, attempt to fetch events from logs
+		for _, log := range logs {
+			logMap, ok := log.(map[string]interface{})
+			if !ok {
+				continue
+			}
+			if logEvents, ok := logMap["events"].([]interface{}); ok && len(logEvents) > 0 {
+				events = append(events, logEvents...)
+			}
+		}
+	}
+
+	// If events are found, check for the specific eventType
+	if len(events) > 0 {
+		for _, event := range events {
+			eventMap, ok := event.(map[string]interface{})
+			if !ok {
+				continue
+			}
+			if eventMap["type"] == eventType {
+				return nil
+			}
+		}
+		return fmt.Errorf("event %s not found in transaction events", eventType)
+	}
+
+	// If no events were found in either place
+	return fmt.Errorf("no events found in transaction")
+}

starship/tests/e2e/Makefile

@@ -36,7 +36,7 @@ delete:
 
 .PHONY: test
 test:
-	TEST_CONFIG_FILE=$(HELM_FILE) go test -v ./... -count=1
+	TEST_CONFIG_FILE=$(HELM_FILE) CGO_ENABLED=0 go test -v ./... -count=1
 
 ###############################################################################
 ###                              Port forward                              ###

starship/tests/e2e/faucet_test.go

@@ -4,11 +4,11 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
-	pb "github.com/hyperweb-io/starship/registry/registry"
 	"net/http"
 	urlpkg "net/url"
 	"strconv"
-	"time"
+
+	pb "github.com/hyperweb-io/starship/registry/registry"
 )
 
 func (s *TestSuite) MakeFaucetRequest(chain *Chain, req *http.Request, unmarshal map[string]interface{}) {
@@ -115,6 +115,28 @@ func (s *TestSuite) getAccountBalance(chain *Chain, address string, denom string
 	return float64(0)
 }
 
+func (s *TestSuite) creditAccount(chain *Chain, addr, denom string) error {
+	body := map[string]string{
+		"denom":   denom,
+		"address": addr,
+	}
+	postBody, err := json.Marshal(body)
+	if err != nil {
+		return err
+	}
+	resp, err := http.Post(
+		fmt.Sprintf("http://0.0.0.0:%d/credit", chain.Ports.Faucet),
+		"application/json",
+		bytes.NewBuffer(postBody))
+	if err != nil {
+		return err
+	}
+	if resp.StatusCode != 200 {
+		return fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+	}
+	return nil
+}
+
 func (s *TestSuite) TestFaucet_Credit() {
 	s.T().Log("running test for /credit endpoint for faucet")
 
@@ -132,20 +154,9 @@ func (s *TestSuite) TestFaucet_Credit() {
 			addr := getAddressFromType(chain.Name)
 			beforeBalance := s.getAccountBalance(chain, addr, denom)
 
-			body := map[string]string{
-				"denom":   denom,
-				"address": addr,
-			}
-			postBody, err := json.Marshal(body)
-			s.Require().NoError(err)
-			resp, err := http.Post(
-				fmt.Sprintf("http://0.0.0.0:%d/credit", chain.Ports.Faucet),
-				"application/json",
-				bytes.NewBuffer(postBody))
+			err := s.creditAccount(chain, addr, denom)
 			s.Require().NoError(err)
-			s.Require().Equal(200, resp.StatusCode)
 
-			time.Sleep(4 * time.Second)
 			afterBalance := s.getAccountBalance(chain, addr, denom)
 			s.T().Log("address:", addr, "after balance: ", afterBalance, "before balance:", beforeBalance)
 			// note sometimes expected difference is 9x expected value (bug due to using holder address for test)
@@ -154,3 +165,40 @@ func (s *TestSuite) TestFaucet_Credit() {
 		})
 	}
 }
+
+func (s *TestSuite) TestFaucet_Credit_MultipleRequests() {
+	s.T().Log("running test for multiple requests to /credit endpoint for faucet")
+
+	// expected amount to be credited via faucet
+	expCreditedAmt := float64(10000000000)
+
+	for _, chain := range s.config.Chains {
+		s.Run(fmt.Sprintf("multiple faucet requests test for: %s", chain.ID), func() {
+			if chain.Ports.Faucet == 0 {
+				s.T().Skip("faucet not exposed via ports")
+			}
+
+			// fetch denom and address from an account on chain
+			denom := s.getChainDenoms(chain)
+			addr := getAddressFromType(chain.Name)
+			beforeBalance := s.getAccountBalance(chain, addr, denom)
+
+			// Send multiple requests
+			numRequests := 3
+			for i := 0; i < numRequests; i++ {
+				err := s.creditAccount(chain, addr, denom)
+				s.Require().NoError(err)
+			}
+
+			afterBalance := s.getAccountBalance(chain, addr, denom)
+			s.T().Log("address:", addr, "after balance: ", afterBalance, "before balance:", beforeBalance)
+
+			// Check that the balance has increased by at least the expected amount times the number of requests
+			expectedIncrease := expCreditedAmt * float64(numRequests)
+			actualIncrease := afterBalance - beforeBalance
+			s.Require().GreaterOrEqual(actualIncrease, expectedIncrease, 
+				"Balance didn't increase as expected. Actual increase: %f, Expected increase: %f", 
+				actualIncrease, expectedIncrease)
+		})
+	}
+}