Merge branch 'develop' into sish/cs-feeTokn

stackman27 · web-flow · commit 8fc16fac7acc · 2025-11-21T17:08:33.000-05:00
diff --git a/relayer/chainreader/chainreader_util/hasher.go b/relayer/chainreader/chainreader_util/hasher.go
@@ -82,6 +82,10 @@ func (h *MessageHasherV1) Hash(ctx context.Context, report *codec.ExecutionRepor
 		return [32]byte{}, fmt.Errorf("compute metadata hash: %w", err)
 	}
 
+	if len(report.Message.Header.MessageID) != 32 {
+		h.lggr.Warnw("Invalid message ID length, messageID will be padded or truncated", "messageID", report.Message.Header.MessageID)
+	}
+
 	var messageID [32]byte
 	copy(messageID[:], report.Message.Header.MessageID)
 
@@ -169,13 +173,21 @@ func computeMessageDataHash(
 
 	// Manually encode tokens to match the Move implementation
 	var tokenHashData []byte
-	tokenHashData = append(tokenHashData, encodeUint256(big.NewInt(int64(len(tokenAmounts))))...)
+	encodedLen, err := encodeUint256(big.NewInt(int64(len(tokenAmounts))))
+	if err != nil {
+		return [32]byte{}, fmt.Errorf("failed to encode token length: %w", err)
+	}
+	tokenHashData = append(tokenHashData, encodedLen...)
 	for _, token := range tokenAmounts {
 		tokenHashData = append(tokenHashData, encodeBytes(token.SourcePoolAddress)...)
 		tokenHashData = append(tokenHashData, token.DestTokenAddress[:]...)
 		tokenHashData = append(tokenHashData, encodeUint32(token.DestGasAmount)...)
 		tokenHashData = append(tokenHashData, encodeBytes(token.ExtraData)...)
-		tokenHashData = append(tokenHashData, encodeUint256(token.Amount)...)
+		encodedAmount, err := encodeUint256(token.Amount)
+		if err != nil {
+			return [32]byte{}, fmt.Errorf("failed to encode token amount: %w", err)
+		}
+		tokenHashData = append(tokenHashData, encodedAmount...)
 	}
 	tokenAmountsHash := crypto.Keccak256Hash(tokenHashData)
 
@@ -242,8 +254,12 @@ func computeMetadataHash(
 	return metadataHash, nil
 }
 
-func encodeUint256(n *big.Int) []byte {
-	return common.LeftPadBytes(n.Bytes(), 32)
+func encodeUint256(n *big.Int) ([]byte, error) {
+	if n == nil {
+		return []byte{}, fmt.Errorf("nil big.Int cannot be encoded")
+	}
+
+	return common.LeftPadBytes(n.Bytes(), 32), nil
 }
 
 func encodeUint32(n uint32) []byte {
diff --git a/relayer/chainreader/chainreader_util/package_resolver.go b/relayer/chainreader/chainreader_util/package_resolver.go
@@ -243,6 +243,12 @@ func (pr *PackageResolver) InvalidateCache(moduleName string) {
 	packageAddress := pr.packageAddresses[moduleName]
 	pr.mutex.RUnlock()
 
+	// If the package address is not found, do not invalidate the cache
+	if packageAddress == "" {
+		pr.log.Debugw("Package address not found for module, skipping cache invalidation", "module", moduleName)
+		return
+	}
+
 	keys := []string{
 		packageAddressCachePrefix + moduleName,
 		packageIDsCachePrefix + packageAddress + ":" + moduleName,
diff --git a/relayer/chainreader/indexer/transactions_indexer.go b/relayer/chainreader/indexer/transactions_indexer.go
@@ -371,7 +371,16 @@ func (tIndexer *TransactionsIndexer) syncTransmitterTransactions(ctx context.Con
 			tIndexer.logger.Debugw("Report arg", "reportArg", reportArg)
 
 			// Handle the conversion from []interface{} to []byte
-			reportValue := reportArg["value"].([]any)
+			reportValue, ok := reportArg["value"].([]any)
+			if !ok {
+				tIndexer.logger.Errorw("Expected report value to be a []any",
+					"transmitter", transmitter,
+					"txDigest", transactionRecord.Digest,
+					"reportArg", reportArg,
+					"valueType", fmt.Sprintf("%T", reportArg["value"]))
+				continue
+			}
+
 			reportBytes := make([]byte, len(reportValue))
 			for i, val := range reportValue {
 				num, ok := val.(float64)
diff --git a/relayer/chainreader/reader/chainreader.go b/relayer/chainreader/reader/chainreader.go
@@ -164,10 +164,12 @@ func (s *suiChainReader) Unbind(ctx context.Context, bindings []pkgtypes.BoundCo
 			return fmt.Errorf("failed to unbind package %s: %w", binding.Name, err)
 		}
 
+		modulePrefix := fmt.Sprintf("%s::%s::", binding.Address, binding.Name)
+
 		// Clear cached parent object IDs for this unbound contract
 		s.parentObjectIDsMutex.Lock()
 		for key := range s.parentObjectIDs {
-			if strings.HasPrefix(key, binding.Address+"::") {
+			if strings.HasPrefix(key, modulePrefix) {
 				delete(s.parentObjectIDs, key)
 			}
 		}
@@ -1047,7 +1049,11 @@ func (s *suiChainReader) transformEventsToSequences(eventRecords []database.Even
 	}
 
 	for _, record := range eventRecords {
-		eventData := reflect.New(reflect.TypeOf(expectedEventType).Elem()).Interface()
+		t := reflect.TypeOf(expectedEventType)
+		if t == nil || t.Kind() != reflect.Ptr {
+			return nil, fmt.Errorf("sequenceDataType must be a non-nil pointer type")
+		}
+		eventData := reflect.New(t.Elem()).Interface()
 
 		s.logger.Debugw("Processing database event record", "data", record.Data, "offset", record.EventOffset, "eventDataType", reflect.TypeOf(eventData).Elem())
 
diff --git a/relayer/client/ptb_client.go b/relayer/client/ptb_client.go
@@ -8,6 +8,7 @@ import (
 	"net/http"
 	"strconv"
 	"strings"
+	"testing"
 	"time"
 
 	"github.com/aptos-labs/aptos-go-sdk/bcs"
@@ -139,6 +140,11 @@ func NewPTBClient(
 ) (*PTBClient, error) {
 	log.Infof("Creating new SUI client with blockvision SDK")
 
+	if maxConcurrentRequests <= 0 {
+		log.Warnw("maxConcurrentRequests is less than 0, setting to default value", "maxConcurrentRequests", maxConcurrentRequests)
+		maxConcurrentRequests = 500 // Default value
+	}
+
 	httpClient := &http.Client{
 		Timeout: DefaultHTTPTimeout,
 		Transport: &http.Transport{
@@ -149,10 +155,6 @@ func NewPTBClient(
 	}
 	client := sui.NewSuiClientWithCustomClient(rpcUrl, httpClient)
 
-	if maxConcurrentRequests <= 0 {
-		maxConcurrentRequests = 500 // Default value
-	}
-
 	log.Infof(
 		"PTBClient config configs transactionTimeout: %s,  maxConcurrentRequests: %d",
 		transactionTimeout,
@@ -825,7 +827,14 @@ func (c *PTBClient) QueryCoinsByAddress(ctx context.Context, address string, coi
 	return result, err
 }
 
+// FinishPTBAndSend finishes the PTB transaction and sends it to the network.
+// IMPORTANT: This method is only used for testing purposes.
 func (c *PTBClient) FinishPTBAndSend(ctx context.Context, txnSigner *signer.Signer, tx *transaction.Transaction, requestType TransactionRequestType) (SuiTransactionBlockResponse, error) {
+	// This method should only be used in test environments
+	if !testing.Testing() {
+		return SuiTransactionBlockResponse{}, fmt.Errorf("FinishPTBAndSend is only available in test environments")
+	}
+
 	gasPrice, err := c.GetReferenceGasPrice(ctx)
 	if err != nil {
 		return SuiTransactionBlockResponse{}, fmt.Errorf("failed to get reference gas price: %w", err)
diff --git a/relayer/codec/decoder_test.go b/relayer/codec/decoder_test.go
@@ -475,8 +475,8 @@ func TestHexStringHook(t *testing.T) {
 		{
 			name:     "hex to byte array",
 			data:     "0x123456",
-			target:   new([4]uint8),
-			expected: []uint8{0x12, 0x34, 0x56, 0x00},
+			target:   new([3]uint8),
+			expected: []uint8{0x12, 0x34, 0x56},
 		},
 	}
 
diff --git a/relayer/codec/encoder.go b/relayer/codec/encoder.go
@@ -92,9 +92,21 @@ func encodeAddress(value any) (string, error) {
 			v = "0x" + v
 		}
 
-		return v, nil
+		normalizedAddress, err := bind.ToSuiAddress(v)
+		if err != nil {
+			return "", fmt.Errorf("failed to convert address to Sui address: %w", err)
+		}
+
+		return normalizedAddress, nil
 	case []byte:
-		return "0x" + hex.EncodeToString(v), nil
+		stringAddr := "0x" + hex.EncodeToString(v)
+
+		normalizedAddress, err := bind.ToSuiAddress(stringAddr)
+		if err != nil {
+			return "", fmt.Errorf("failed to convert address to Sui address: %w", err)
+		}
+
+		return normalizedAddress, nil
 	default:
 		return "", fmt.Errorf("cannot convert %T to address", value)
 	}
@@ -298,9 +310,17 @@ func encodeVector(typeName string, value any) ([]any, error) {
 	}
 	innerType := typeName[len("vector<") : len(typeName)-1]
 
-	// Use reflection to ensure 'value' is a slice or array
+	if value == nil {
+		return nil, fmt.Errorf("nil value cannot be encoded in encodeVector")
+	}
 	rv := reflect.ValueOf(value)
+
+	if !rv.IsValid() {
+		return nil, fmt.Errorf("invalid reflect value for vector type %s in encodeVector", typeName)
+	}
 	kind := rv.Kind()
+
+	// Use reflection to ensure 'value' is a slice or array
 	if kind != reflect.Slice && kind != reflect.Array {
 		return nil, fmt.Errorf("expected a slice/array for vector type %s, got %T", typeName, value)
 	}
diff --git a/relayer/codec/type_converters.go b/relayer/codec/type_converters.go
@@ -375,6 +375,11 @@ func (tc *TypeConverter) hexToArray(from, to reflect.Type, data any) (any, error
 
 	byteSlice := bytes.([]byte)
 	out := make([]uint8, to.Len())
+
+	if len(byteSlice) != to.Len() {
+		return nil, fmt.Errorf("hex to array: byte slice length %d is not equal to output array length %d", len(byteSlice), to.Len())
+	}
+
 	copy(out, byteSlice)
 
 	return out, nil
diff --git a/relayer/config/toml_config.go b/relayer/config/toml_config.go
@@ -97,6 +97,11 @@ func (cs TOMLConfigs) validateKeys() error {
 }
 
 func (cs *TOMLConfigs) SetFrom(fs *TOMLConfigs) error {
+	// Avoids panics if the source TOMLConfigs is nil
+	if fs == nil {
+		return nil
+	}
+
 	if err1 := fs.validateKeys(); err1 != nil {
 		return err1
 	}
@@ -118,6 +123,11 @@ func (cs *TOMLConfigs) SetFrom(fs *TOMLConfigs) error {
 type NodeConfigs []*NodeConfig
 
 func (ns *NodeConfigs) SetFrom(fs *NodeConfigs) {
+	// Avoids panics if the source NodeConfigs is nil
+	if fs == nil {
+		return
+	}
+
 	for _, f := range *fs {
 		if f.Name == nil {
 			*ns = append(*ns, f)
diff --git a/relayer/signer/signer.go b/relayer/signer/signer.go
@@ -6,7 +6,6 @@ import (
 	"encoding/base64"
 	"encoding/hex"
 	"fmt"
-	"log"
 
 	"golang.org/x/crypto/blake2b"
 )
@@ -104,7 +103,7 @@ func (s *PrivateKeySigner) Sign(message []byte) ([]string, error) {
 	var noHash crypto.Hash
 	sigBytes, err := s.privateKey.Sign(nil, digest[:], noHash)
 	if err != nil {
-		log.Fatal(err)
+		return nil, fmt.Errorf("failed to sign message with ed25519: %w", err)
 	}
 	pubKey := s.privateKey.Public().(ed25519.PublicKey)
 	serializedSignature := SerializeSuiSignature(sigBytes, pubKey)
diff --git a/relayer/txm/confirmer.go b/relayer/txm/confirmer.go
@@ -89,6 +89,7 @@ func checkConfirmations(loopCtx context.Context, txm *SuiTxm) {
 		txm.lggr.Errorw("Error getting in-flight transactions", "error", err)
 		return
 	}
+
 	for _, tx := range inFlightTransactions {
 		txm.lggr.Debugw("Checking transaction confirmations", "transactionID", tx.TransactionID)
 		switch tx.State {
@@ -115,10 +116,7 @@ func checkConfirmations(loopCtx context.Context, txm *SuiTxm) {
 			default:
 				txm.lggr.Infow("Unknown transaction status", "transactionID", tx.TransactionID, "status", resp.Status)
 			}
-		case StateRetriable:
-			// TODO check if the transaction is still retriable
-			txm.lggr.Debugw("Transaction is still retriable")
-		case StatePending, StateFinalized, StateFailed:
+		case StateRetriable, StatePending, StateFinalized, StateFailed:
 			// Do nothing for pending, finalized and failed transactions
 		}
 	}
@@ -149,8 +147,8 @@ func handleTransactionError(ctx context.Context, txm *SuiTxm, tx SuiTx, result *
 		txm.lggr.Infow("Transaction is retriable", "transactionID", tx.TransactionID, "strategy", strategy)
 		switch strategy {
 		case ExponentialBackoff:
-			// TODO: for another PR implement exponential backoff
-			txm.lggr.Infow("Exponential backoff strategy not implemented")
+			txm.lggr.Errorw("Exponential backoff strategy not implemented", "transactionID", tx.TransactionID)
+			return errors.New("exponential backoff strategy not implemented")
 		case GasBump:
 			txm.lggr.Infow("Gas bump strategy", "transactionID", tx.TransactionID)
 			updatedGas, err := txm.gasManager.GasBump(ctx, &tx)
diff --git a/relayer/txm/gas_manager.go b/relayer/txm/gas_manager.go
@@ -8,6 +8,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"math"
 	"math/big"
 
 	"github.com/smartcontractkit/chainlink-common/pkg/logger"
@@ -194,6 +195,11 @@ func (s *SuiGasManager) GasBump(ctx context.Context, tx *SuiTx) (big.Int, error)
 	// The max amount of the gas that the Gas manager will allow
 	gasManagerMaxGasBudget := big.NewInt(int64(s.maxGasBudget.Uint64()))
 
+	// Check if tx.GasBudget exceeds int64 max value to prevent overflow
+	if tx.GasBudget > math.MaxInt64 {
+		return *big.NewInt(0), fmt.Errorf("tx.GasBudget %d exceeds maximum int64 value", tx.GasBudget)
+	}
+
 	// the max amount of the gas that the transaction will allow
 	txGasBudget := big.NewInt(int64(tx.GasBudget))
 
@@ -212,7 +218,7 @@ func (s *SuiGasManager) GasBump(ctx context.Context, tx *SuiTx) (big.Int, error)
 
 	s.lggr.Debugw("GasBump", "txGasLimit", txGasLimit, "maxGasLimit", maxGasLimit)
 
-	// Check if the current gas limit is at or above the maximum allowed budget.
+	// Check if the current gas limit is greater than the maximum allowed budget.
 	if txGasLimit.Cmp(maxGasLimit) > 0 {
 		return *big.NewInt(0), errors.New("gas budget is already at max gas limit")
 	}
diff --git a/relayer/txm/reaper.go b/relayer/txm/reaper.go
@@ -13,6 +13,7 @@ func (txm *SuiTxm) reaperLoop() {
 
 	basePeriod := txm.configuration.ReaperPollSecs
 	ticker, jitteredDuration := GetTicker(uint(basePeriod))
+	defer ticker.Stop()
 
 	txm.lggr.Infow("Created reaper ticker",
 		"basePeriod", basePeriod,
@@ -47,6 +48,11 @@ func cleanupTransactions(txm *SuiTxm) {
 
 	currentTimestamp := GetCurrentUnixTimestamp()
 
+	if currentTimestamp == 0 {
+		txm.lggr.Errorw("Found a 0 timestamp, skipping cleanup")
+		return
+	}
+
 	for _, tx := range finalizedTransactions {
 		txm.lggr.Debugw("Cleaning up finalized transaction", "transactionID", tx.TransactionID)
 		timeDiff := currentTimestamp - tx.LastUpdatedAt

Original file line number	Diff line number	Diff line change
`@@ -164,10 +164,12 @@ func (s *suiChainReader) Unbind(ctx context.Context, bindings []pkgtypes.BoundCo`
`164`	`164`	`return fmt.Errorf("failed to unbind package %s: %w", binding.Name, err)`
`165`	`165`	`}`
`166`	`166`
	`167`	`+ modulePrefix := fmt.Sprintf("%s::%s::", binding.Address, binding.Name)`
	`168`	`+`
`167`	`169`	`// Clear cached parent object IDs for this unbound contract`
`168`	`170`	`s.parentObjectIDsMutex.Lock()`
`169`	`171`	`for key := range s.parentObjectIDs {`
`170`		`- if strings.HasPrefix(key, binding.Address+"::") {`
	`172`	`+ if strings.HasPrefix(key, modulePrefix) {`
`171`	`173`	`delete(s.parentObjectIDs, key)`
`172`	`174`	`}`
`173`	`175`	`}`
`@@ -1047,7 +1049,11 @@ func (s *suiChainReader) transformEventsToSequences(eventRecords []database.Even`
`1047`	`1049`	`}`
`1048`	`1050`
`1049`	`1051`	`for _, record := range eventRecords {`
`1050`		`- eventData := reflect.New(reflect.TypeOf(expectedEventType).Elem()).Interface()`
	`1052`	`+ t := reflect.TypeOf(expectedEventType)`
	`1053`	`+ if t == nil \|\| t.Kind() != reflect.Ptr {`
	`1054`	`+ return nil, fmt.Errorf("sequenceDataType must be a non-nil pointer type")`
	`1055`	`+ }`
	`1056`	`+ eventData := reflect.New(t.Elem()).Interface()`
`1051`	`1057`
`1052`	`1058`	`s.logger.Debugw("Processing database event record", "data", record.Data, "offset", record.EventOffset, "eventDataType", reflect.TypeOf(eventData).Elem())`
`1053`	`1059`
Original file line number	Diff line number	Diff line change
`@@ -475,8 +475,8 @@ func TestHexStringHook(t *testing.T) {`
`475`	`475`	`{`
`476`	`476`	`name: "hex to byte array",`
`477`	`477`	`data: "0x123456",`
`478`		`- target: new([4]uint8),`
`479`		`- expected: []uint8{0x12, 0x34, 0x56, 0x00},`
	`478`	`+ target: new([3]uint8),`
	`479`	`+ expected: []uint8{0x12, 0x34, 0x56},`
`480`	`480`	`},`
`481`	`481`	`}`
`482`	`482`