Merge remote-tracking branch 'origin' into fix/improve-pods-name

analytics/cmd/token/token.go

@@ -93,7 +93,7 @@ func (r *TokenResolver) GetTransferredTokenByVaa(ctx context.Context, vaa *sdk.V
 		return nil, nil
 	}
 
-	token, err := createToken(result.StandardizedProperties, vaa.EmitterChain)
+	token, err := createToken(result, vaa.EmitterChain)
 	if err != nil {
 		r.logger.Debug("Creating transferred token",
 			zap.String("vaaId", vaa.MessageID()),
@@ -104,50 +104,60 @@ func (r *TokenResolver) GetTransferredTokenByVaa(ctx context.Context, vaa *sdk.V
 	return token, err
 }
 
-func createToken(s parser.StandardizedProperties, emitterChain sdk.ChainID) (*TransferredToken, error) {
+func createToken(p *parser.ParseVaaWithStandarizedPropertiesdResponse, emitterChain sdk.ChainID) (*TransferredToken, error) {
 
-	if !domain.ChainIdIsValid(s.TokenChain) {
-		return nil, fmt.Errorf("tokenChain is invalid: %d", s.TokenChain)
+	if !domain.ChainIdIsValid(p.StandardizedProperties.TokenChain) {
+		return nil, fmt.Errorf("tokenChain is invalid: %d", p.StandardizedProperties.TokenChain)
 	}
 
-	if !domain.ChainIdIsValid(s.ToChain) {
-		return nil, fmt.Errorf("toChain is invalid: %d", s.ToChain)
+	if !domain.ChainIdIsValid(p.StandardizedProperties.ToChain) {
+		return nil, fmt.Errorf("toChain is invalid: %d", p.StandardizedProperties.ToChain)
 	}
 
 	if !domain.ChainIdIsValid(emitterChain) {
 		return nil, fmt.Errorf("emitterChain is invalid: %d", emitterChain)
 	}
 
-	if s.TokenAddress == "" {
+	if p.StandardizedProperties.TokenAddress == "" {
 		return nil, errors.New("tokenAddress is empty")
 	}
 
-	if s.Amount == "" {
+	if p.StandardizedProperties.Amount == "" {
 		return nil, errors.New("amount is empty")
 	}
 
-	address, err := sdk.StringToAddress(s.TokenAddress)
+	addressHex, err := domain.DecodeNativeAddressToHex(p.StandardizedProperties.TokenChain, p.StandardizedProperties.TokenAddress)
+	if err != nil {
+		if p.ParsedPayload != nil && p.ParsedPayload.TokenAddress != "" {
+			addressHex = p.ParsedPayload.TokenAddress
+		} else {
+			return nil, fmt.Errorf("cannot decode token with tokenChain [%d] tokenAddress [%s] to hex",
+				p.StandardizedProperties.TokenChain, p.StandardizedProperties.TokenAddress)
+		}
+	}
+
+	address, err := sdk.StringToAddress(addressHex)
 	if err != nil {
 		return nil, err
 	}
 
 	n := new(big.Int)
-	n, ok := n.SetString(s.Amount, 10)
+	n, ok := n.SetString(p.StandardizedProperties.Amount, 10)
 	if !ok {
-		return nil, fmt.Errorf("amount [%s] is not a number", s.Amount)
+		return nil, fmt.Errorf("amount [%s] is not a number", p.StandardizedProperties.Amount)
 	}
 
 	appId := domain.AppIdUnkonwn
-	if len(s.AppIds) > 0 {
-		appId = s.AppIds[0]
+	if len(p.StandardizedProperties.AppIds) > 0 {
+		appId = p.StandardizedProperties.AppIds[0]
 	}
 
 	return &TransferredToken{
 		AppId:        appId,
 		FromChain:    emitterChain,
-		ToChain:      s.ToChain,
+		ToChain:      p.StandardizedProperties.ToChain,
 		TokenAddress: address,
-		TokenChain:   s.TokenChain,
+		TokenChain:   p.StandardizedProperties.TokenChain,
 		Amount:       n,
 	}, nil
 }

api/handlers/operations/repository.go

@@ -172,6 +172,8 @@ func (r *Repository) matchOperationByTxHash(ctx context.Context, txHash string)
 		bson.D{{Key: "originTx.nativeTxHash", Value: bson.M{"$eq": txHash}}},
 		bson.D{{Key: "originTx.attribute.value.originTxHash", Value: bson.M{"$eq": txHashHex}}},
 		bson.D{{Key: "originTx.attribute.value.originTxHash", Value: bson.M{"$eq": txHash}}},
+		bson.D{{Key: "originTx.attribute.value.originTxHash", Value: bson.M{"$eq": qLower}}},
+		bson.D{{Key: "originTx.attribute.value.originTxHash", Value: bson.M{"$eq": qHigher}}},
 		bson.D{{Key: "destinationTx.txHash", Value: bson.M{"$eq": txHash}}},
 		bson.D{{Key: "destinationTx.txHash", Value: bson.M{"$eq": qLower}}},
 		bson.D{{Key: "destinationTx.txHash", Value: bson.M{"$eq": qHigher}}},
@@ -204,7 +206,10 @@ func (r *Repository) FindAll(ctx context.Context, query OperationQuery) ([]*Oper
 	}
 
 	// sort
-	pipeline = append(pipeline, bson.D{{Key: "$sort", Value: bson.D{bson.E{Key: "originTx.timestamp", Value: query.Pagination.GetSortInt()}}}})
+	pipeline = append(pipeline, bson.D{{Key: "$sort", Value: bson.D{
+		bson.E{Key: "originTx.timestamp", Value: query.Pagination.GetSortInt()},
+		bson.E{Key: "_id", Value: -1},
+	}}})
 
 	// Skip initial results
 	pipeline = append(pipeline, bson.D{{Key: "$skip", Value: query.Pagination.Skip}})

api/handlers/vaa/service.go

@@ -250,7 +250,7 @@ func (s *Service) discardVaaNotIndexed(ctx context.Context, chain sdk.ChainID, e
 }
 
 // ParseVaa parse a vaa payload.
-func (s *Service) ParseVaa(ctx context.Context, vaaByte []byte) (vaaPayloadParser.ParseVaaWithStandarizedPropertiesdResponse, error) {
+func (s *Service) ParseVaa(ctx context.Context, vaaByte []byte) (any, error) {
 	// unmarshal vaa
 	vaa, err := sdk.Unmarshal(vaaByte)
 	if err != nil {
@@ -263,11 +263,11 @@ func (s *Service) ParseVaa(ctx context.Context, vaaByte []byte) (vaaPayloadParse
 	parsedVaa, err := s.parseVaaFunc(vaa)
 	if err != nil {
 		if errors.Is(err, vaaPayloadParser.ErrNotFound) {
-			return vaaPayloadParser.ParseVaaWithStandarizedPropertiesdResponse{}, errs.ErrNotFound
+			return nil, errs.ErrNotFound
 		}
 		requestID := fmt.Sprintf("%v", ctx.Value("requestid"))
 		s.logger.Error("error parse vaa", zap.Error(err), zap.String("requestID", requestID))
-		return vaaPayloadParser.ParseVaaWithStandarizedPropertiesdResponse{}, errs.ErrInternalError
+		return nil, errs.ErrInternalError
 	}
-	return *parsedVaa, nil
+	return parsedVaa, nil
 }

api/main.go

@@ -356,8 +356,8 @@ func NewRateLimiter(ctx context.Context, cfg *config.AppConfig, logger *zap.Logg
 // NewVaaParserFunc returns a function to parse VAA payload.
 func NewVaaParserFunc(cfg *config.AppConfig, logger *zap.Logger) (vaaPayloadParser.ParseVaaFunc, error) {
 	if cfg.RunMode == config.RunModeDevelopmernt && !cfg.VaaPayloadParser.Enabled {
-		return func(vaa *sdk.VAA) (*vaaPayloadParser.ParseVaaWithStandarizedPropertiesdResponse, error) {
-			return &vaaPayloadParser.ParseVaaWithStandarizedPropertiesdResponse{}, nil
+		return func(vaa *sdk.VAA) (any, error) {
+			return nil, nil
 		}, nil
 	}
 	vaaPayloadParserClient, err := vaaPayloadParser.NewParserVAAAPIClient(cfg.VaaPayloadParser.Timeout,
@@ -365,5 +365,5 @@ func NewVaaParserFunc(cfg *config.AppConfig, logger *zap.Logger) (vaaPayloadPars
 	if err != nil {
 		return nil, fmt.Errorf("failed to initialize VAA parser client: %w", err)
 	}
-	return vaaPayloadParserClient.ParseVaaWithStandarizedProperties, nil
+	return vaaPayloadParserClient.ParseVaa, nil
 }

api/routes/wormscan/operations/controller.go

@@ -31,7 +31,7 @@ func NewController(operationService *operations.Service, logger *zap.Logger) *Co
 // @Param address query string false "address of the emitter"
 // @Param txHash query string false "hash of the transaction"
 // @Param page query integer false "page number"
-// @Param size query integer false "page size"
+// @Param pageSize query integer false "pageSize". Maximum value is 100.
 // @Success 200 {object} []OperationResponse
 // @Failure 400
 // @Failure 500
@@ -43,6 +43,11 @@ func (c *Controller) FindAll(ctx *fiber.Ctx) error {
 		return err
 	}
 
+	// Check pagination max limit
+	if pagination.Limit > 100 {
+		return response.NewInvalidParamError(ctx, "pageSize cannot be greater than 100", nil)
+	}
+
 	address := middleware.ExtractAddressFromQueryParams(ctx, c.logger)
 	txHash, err := middleware.GetTxHash(ctx, c.logger)
 	if err != nil {

common/client/parser/parser.go

@@ -40,7 +40,7 @@ type ParserVAAAPIClient struct {
 }
 
 // ParseVaaFunc represent a parse vaa function.
-type ParseVaaFunc func(vaa *sdk.VAA) (*ParseVaaWithStandarizedPropertiesdResponse, error)
+type ParseVaaFunc func(vaa *sdk.VAA) (any, error)
 
 // NewParserVAAAPIClient create new instances of ParserVAAAPIClient.
 func NewParserVAAAPIClient(timeout int64, baseURL string, logger *zap.Logger) (ParserVAAAPIClient, error) {
@@ -123,9 +123,14 @@ type StandardizedProperties struct {
 	Fee          string      `json:"fee" bson:"fee"`
 }
 
+type ParsedPayload struct {
+	TokenAddress string `json:"tokenAddress"`
+	TokenChain   int    `json:"tokenChain"`
+}
+
 // ParseVaaWithStandarizedPropertiesdResponse represent a parse vaa response.
 type ParseVaaWithStandarizedPropertiesdResponse struct {
-	ParsedPayload          interface{}            `json:"parsedPayload"`
+	ParsedPayload          *ParsedPayload         `json:"parsedPayload"`
 	StandardizedProperties StandardizedProperties `json:"standardizedProperties"`
 }
 
@@ -162,3 +167,37 @@ func (c *ParserVAAAPIClient) ParseVaaWithStandarizedProperties(vaa *sdk.VAA) (*P
 		return nil, ErrInternalError
 	}
 }
+
+// ParseVaa invoke the endpoint to parse a VAA from the VAAParserAPI.
+func (c *ParserVAAAPIClient) ParseVaa(vaa *sdk.VAA) (any, error) {
+	endpointUrl := fmt.Sprintf("%s/vaas/parse", c.BaseURL)
+
+	vaaBytes, err := vaa.Marshal()
+	if err != nil {
+		return nil, errors.New("error marshalling vaa")
+	}
+
+	body := base64.StdEncoding.EncodeToString(vaaBytes)
+	response, err := c.Client.Post(endpointUrl, "text/plain", bytes.NewBuffer([]byte(body)))
+	if err != nil {
+		c.Logger.Error("error call parse vaa endpoint", zap.Error(err), zap.Uint16("chainID", uint16(vaa.EmitterChain)),
+			zap.String("address", vaa.EmitterAddress.String()), zap.Uint64("sequence", vaa.Sequence))
+		return nil, ErrCallEndpoint
+	}
+	defer response.Body.Close()
+
+	switch response.StatusCode {
+	case http.StatusCreated:
+		var parsedVAA any
+		json.NewDecoder(response.Body).Decode(&parsedVAA)
+		return &parsedVAA, nil
+	case http.StatusNotFound:
+		return nil, ErrNotFound
+	case http.StatusBadRequest:
+		return nil, ErrBadRequest
+	case http.StatusUnprocessableEntity:
+		return nil, ErrUnproceesableEntity
+	default:
+		return nil, ErrInternalError
+	}
+}

common/domain/chainid.go

@@ -90,7 +90,12 @@ func TranslateEmitterAddress(chainID sdk.ChainID, address string) (string, error
 		sdk.ChainIDCelo,
 		sdk.ChainIDMoonbeam,
 		sdk.ChainIDArbitrum,
-		sdk.ChainIDOptimism:
+		sdk.ChainIDOptimism,
+		sdk.ChainIDSepolia,
+		sdk.ChainIDArbitrumSepolia,
+		sdk.ChainIDBaseSepolia,
+		sdk.ChainIDOptimismSepolia,
+		sdk.ChainIDHolesky:
 
 		return "0x" + hex.EncodeToString(addressBytes[12:]), nil
 
@@ -223,7 +228,11 @@ func EncodeTrxHashByChainID(chainID sdk.ChainID, txHash []byte) (string, error)
 	case sdk.ChainIDWormchain:
 		//TODO: check if this is correct
 		return hex.EncodeToString(txHash), nil
-	case sdk.ChainIDSepolia:
+	case sdk.ChainIDSepolia,
+		sdk.ChainIDArbitrumSepolia,
+		sdk.ChainIDBaseSepolia,
+		sdk.ChainIDOptimismSepolia,
+		sdk.ChainIDHolesky:
 		return hex.EncodeToString(txHash), nil
 	default:
 		return hex.EncodeToString(txHash), fmt.Errorf("unknown chain id: %d", chainID)
@@ -260,7 +269,12 @@ func DecodeNativeAddressToHex(chainID sdk.ChainID, address string) (string, erro
 		sdk.ChainIDCelo,
 		sdk.ChainIDMoonbeam,
 		sdk.ChainIDArbitrum,
-		sdk.ChainIDOptimism:
+		sdk.ChainIDOptimism,
+		sdk.ChainIDSepolia,
+		sdk.ChainIDArbitrumSepolia,
+		sdk.ChainIDBaseSepolia,
+		sdk.ChainIDOptimismSepolia,
+		sdk.ChainIDHolesky:
 
 		return address, nil
 

deploy/tx-tracker/tx-tracker-service.yaml

@@ -1,3 +1,20 @@
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: {{ .NAME }}
+  namespace: {{ .NAMESPACE }}
+  labels:
+    app: {{ .NAME }}
+spec:
+  selector:
+    app: {{ .NAME }}
+  ports:
+    - port: 80
+      targetPort: 8000
+      name: {{ .NAME }}
+      protocol: TCP
+---
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -262,3 +279,4 @@ spec:
             requests:
               memory: {{ .RESOURCES_REQUESTS_MEMORY }}
               cpu: {{ .RESOURCES_REQUESTS_CPU }}
+

fly/config/config.go

@@ -18,7 +18,7 @@ const defaultMaxHealthTimeSeconds = 60
 const (
 	// mainnet p2p config.
 	MainNetP2ppNetworkID      = "/wormhole/mainnet/2"
-	MainNetP2pBootstrap       = "/dns4/wormhole-v2-mainnet-bootstrap.xlabs.xyz/udp/8999/quic/p2p/12D3KooWNQ9tVrcb64tw6bNs2CaNrUGPM7yRrKvBBheQ5yCyPHKC,/dns4/wormhole.mcf.rocks/udp/8999/quic/p2p/12D3KooWDZVv7BhZ8yFLkarNdaSWaB43D6UbQwExJ8nnGAEmfHcU,/dns4/wormhole-v2-mainnet-bootstrap.staking.fund/udp/8999/quic/p2p/12D3KooWG8obDX9DNi1KUwZNu9xkGwfKqTp2GFwuuHpWZ3nQruS1"
+	MainNetP2pBootstrap       = "/dns4/wormhole-v2-mainnet-bootstrap.xlabs.xyz/udp/8999/quic-v1/p2p/12D3KooWNQ9tVrcb64tw6bNs2CaNrUGPM7yRrKvBBheQ5yCyPHKC,/dns4/wormhole.mcf.rocks/udp/8999/quic-v1/p2p/12D3KooWDZVv7BhZ8yFLkarNdaSWaB43D6UbQwExJ8nnGAEmfHcU,/dns4/wormhole-v2-mainnet-bootstrap.staking.fund/udp/8999/quic-v1/p2p/12D3KooWG8obDX9DNi1KUwZNu9xkGwfKqTp2GFwuuHpWZ3nQruS1"
 	MainNetP2pPort       uint = 8999
 
 	// testnet p2p config.

fly/migration/migration.go

@@ -77,13 +77,32 @@ func Run(db *mongo.Database) error {
 		return err
 	}
 
-	indexVaaByTimestamp := mongo.IndexModel{
+	indexVaaByEmitteChainEmitterAddrSequence := mongo.IndexModel{
 		Keys: bson.D{
 			{Key: "emitterChain", Value: 1},
 			{Key: "emitterAddr", Value: 1},
 			{Key: "sequence", Value: 1},
 		}}
-	_, err = db.Collection("vaas").Indexes().CreateOne(context.TODO(), indexVaaByTimestamp)
+	_, err = db.Collection("vaas").Indexes().CreateOne(context.TODO(), indexVaaByEmitteChainEmitterAddrSequence)
+	if err != nil && isNotAlreadyExistsError(err) {
+		return err
+	}
+
+	indexVaaByTimestampId := mongo.IndexModel{
+		Keys: bson.D{
+			{Key: "timestamp", Value: -1},
+			{Key: "_id", Value: -1},
+		}}
+	_, err = db.Collection("vaas").Indexes().CreateOne(context.TODO(), indexVaaByTimestampId)
+	if err != nil && isNotAlreadyExistsError(err) {
+		return err
+	}
+
+	indexVaaByTxHash := mongo.IndexModel{
+		Keys: bson.D{
+			{Key: "txHash", Value: 1},
+		}}
+	_, err = db.Collection("vaas").Indexes().CreateOne(context.TODO(), indexVaaByTxHash)
 	if err != nil && isNotAlreadyExistsError(err) {
 		return err
 	}
@@ -122,6 +141,62 @@ func Run(db *mongo.Database) error {
 		return err
 	}
 
+	// create index in globaltransactions collection for wormchain nested txHash.
+	indexGlobalTransactionsByOriginTxInAttribute := mongo.IndexModel{
+		Keys: bson.D{{Key: "originTx.attribute.value.originTxHash", Value: 1}}}
+	_, err = db.Collection("globaltransactions").Indexes().CreateOne(context.TODO(), indexGlobalTransactionsByOriginTxInAttribute)
+	if err != nil && isNotAlreadyExistsError(err) {
+		return err
+	}
+
+	// create index in globaltransactions collection by originTx nativeTxHash.
+	indexGlobalTransactionsByOriginNativeTxHash := mongo.IndexModel{
+		Keys: bson.D{{Key: "originTx.nativeTxHash", Value: 1}}}
+	_, err = db.Collection("globaltransactions").Indexes().CreateOne(context.TODO(), indexGlobalTransactionsByOriginNativeTxHash)
+	if err != nil && isNotAlreadyExistsError(err) {
+		return err
+	}
+
+	// create index in globaltransactions collection by destination txHash.
+	indexGlobalTransactionsByDestinationTxHash := mongo.IndexModel{
+		Keys: bson.D{{Key: "destinationTx.txHash", Value: 1}}}
+	_, err = db.Collection("globaltransactions").Indexes().CreateOne(context.TODO(), indexGlobalTransactionsByDestinationTxHash)
+	if err != nil && isNotAlreadyExistsError(err) {
+		return err
+	}
+
+	// create index in globaltransactions collection by timestamp/_id sort.
+	indexGlobalTransactionsByTimestampAndId := mongo.IndexModel{
+		Keys: bson.D{{Key: "originTx.timestamp", Value: -1}, {Key: "_id", Value: -1}}}
+	_, err = db.Collection("globaltransactions").Indexes().CreateOne(context.TODO(), indexGlobalTransactionsByTimestampAndId)
+	if err != nil && isNotAlreadyExistsError(err) {
+		return err
+	}
+
+	// create index in parsedVaa collection by standardizedProperties toAddress.
+	indexParsedVaaByStandardizedPropertiesToAddress := mongo.IndexModel{
+		Keys: bson.D{{Key: "standardizedProperties.toAddress", Value: 1}}}
+	_, err = db.Collection("parsedVaa").Indexes().CreateOne(context.TODO(), indexParsedVaaByStandardizedPropertiesToAddress)
+	if err != nil && isNotAlreadyExistsError(err) {
+		return err
+	}
+
+	// create index in parsedVaa collection by parsedPayload tokenAddress.
+	indexParsedVaaByParsedPayloadTokenAddress := mongo.IndexModel{
+		Keys: bson.D{{Key: "parsedPayload.tokenAddress", Value: 1}}}
+	_, err = db.Collection("parsedVaa").Indexes().CreateOne(context.TODO(), indexParsedVaaByParsedPayloadTokenAddress)
+	if err != nil && isNotAlreadyExistsError(err) {
+		return err
+	}
+
+	// create index in parsedVaa collection by indexedAt.
+	indexParsedVaaByIndexedAt := mongo.IndexModel{
+		Keys: bson.D{{Key: "indexedAt", Value: 1}}}
+	_, err = db.Collection("parsedVaa").Indexes().CreateOne(context.TODO(), indexParsedVaaByIndexedAt)
+	if err != nil && isNotAlreadyExistsError(err) {
+		return err
+	}
+
 	return nil
 }
 

jobs/jobs/migration/migration_source_tx.go

@@ -141,9 +141,8 @@ func (m *MigrateSourceChainTx) runComplexMigration(ctx context.Context) error {
 				m.logger.Error("failed to process vaa", zap.Error(err), zap.String("id", v.ID))
 				continue
 			}
-			time.Sleep(5 * time.Second)
+			time.Sleep(100 * time.Microsecond)
 		}
-		page++
 	}
 	return nil
 }
@@ -277,9 +276,6 @@ func (m *MigrateSourceChainTx) getVaasToMigrate(ctx context.Context, chainID sdk
 	// add match step by chain
 	var matchStage1 bson.D
 	if chainID != sdk.ChainIDUnset {
-		if chainID == sdk.ChainIDSolana || chainID == sdk.ChainIDAptos {
-			return []VAASourceChain{}, errors.New("invalid chainID")
-		}
 		matchStage1 = bson.D{{Key: "$match", Value: bson.D{
 			{Key: "emitterChain", Value: chainID},
 		}}}

tx-tracker/chains/api_solana.go

@@ -11,8 +11,9 @@ import (
 )
 
 type solanaTransactionSignature struct {
-	BlockTime int64  `json:"blockTime"`
-	Signature string `json:"signature"`
+	BlockTime int64       `json:"blockTime"`
+	Signature string      `json:"signature"`
+	Err       interface{} `json:"err"`
 }
 
 type solanaGetTransactionResponse struct {
@@ -32,8 +33,7 @@ type solanaGetTransactionResponse struct {
 				} `json:"parsed"`
 			} `json:"instructions"`
 		} `json:"innerInstructions"`
-
-		Err []interface{} `json:"err"`
+		Err interface{} `json:"err"`
 	} `json:"meta"`
 	Transaction struct {
 		Message struct {
@@ -98,7 +98,8 @@ func (a *apiSolana) fetchSolanaTx(
 				nativeTxHash = sigs[0].Signature
 			} else {
 				for _, sig := range sigs {
-					if a.timestamp != nil && sig.BlockTime == a.timestamp.Unix() {
+
+					if a.timestamp != nil && sig.BlockTime == a.timestamp.Unix() && sig.Err == nil {
 						nativeTxHash = sig.Signature
 						break
 					}