Add airdrop tool

airdrop/.gitignore

@@ -0,0 +1,6 @@
+#Airdrop tool
+airdropd
+balance.json
+rewards.json
+balancenft.json
+.env

airdrop/Makefile

@@ -0,0 +1,3 @@
+build: airdrop-tool
+airdrop-tool:
+	go build -o airdropd ./cmd/airdrop

airdrop/backoff/backoff.go

@@ -0,0 +1,24 @@
+package backoff
+
+import (
+	"context"
+	"time"
+
+	"github.com/cenkalti/backoff/v4"
+)
+
+var globalBackoffOptions = []backoff.ExponentialBackOffOpts{
+	func(b *backoff.ExponentialBackOff) {
+		b.InitialInterval = 1 * time.Second
+	},
+	func(b *backoff.ExponentialBackOff) {
+		b.MaxInterval = 15 * time.Second
+	},
+	func(b *backoff.ExponentialBackOff) {
+		b.Multiplier = 2
+	},
+}
+
+func NewBackoff(ctx context.Context) *backoff.ExponentialBackOff {
+	return backoff.NewExponentialBackOff(globalBackoffOptions...)
+}

airdrop/chains/akash.go

@@ -0,0 +1,125 @@
+package chains
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/eve-network/eve/airdrop/config"
+	"github.com/eve-network/eve/airdrop/utils"
+	"github.com/joho/godotenv"
+
+	sdkmath "cosmossdk.io/math"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
+)
+
+func Akash() ([]banktypes.Balance, []config.Reward, int, error) {
+	// Load environment variables
+	if err := godotenv.Load(); err != nil {
+		log.Printf("Error loading Akash environment variables: %v", err)
+		return nil, nil, 0, fmt.Errorf("failed to load env: %w", err)
+	}
+
+	// Get latest block height
+	blockHeight, err := utils.GetLatestHeight(config.GetAkashConfig().RPC + "/status")
+	if err != nil {
+		log.Printf("Failed to get latest height for Akash: %v", err)
+		return nil, nil, 0, fmt.Errorf("failed to get latest height for Akash: %w", err)
+	}
+
+	// Setup gRPC connection
+	grpcAddr := config.GetAkashConfig().GRPCAddr
+	grpcConn, err := utils.SetupGRPCConnection(grpcAddr)
+	if err != nil {
+		log.Printf("Failed to connect to gRPC Akash: %v", err)
+		return nil, nil, 0, fmt.Errorf("failed to connect to gRPC Akash: %w", err)
+	}
+	defer grpcConn.Close()
+
+	stakingClient := stakingtypes.NewQueryClient(grpcConn)
+	delegators := []stakingtypes.DelegationResponse{}
+
+	// Get validators
+	validators, err := utils.GetValidators(stakingClient, blockHeight)
+	if err != nil {
+		log.Printf("Failed to get Akash validators: %v", err)
+		return nil, nil, 0, fmt.Errorf("failed to get Akash validators: %w", err)
+	}
+	log.Println("Validators: ", len(validators))
+
+	// Get delegations for each validator
+	for validatorIndex, validator := range validators {
+		delegationsResponse, err := utils.GetValidatorDelegations(stakingClient, validator.OperatorAddress, blockHeight)
+		if err != nil {
+			log.Printf("Failed to query delegate info for Akash validator: %v", err)
+			return nil, nil, 0, fmt.Errorf("failed to query delegate info for Akash validator: %w", err)
+		}
+		total := delegationsResponse.Pagination.Total
+		log.Printf("Akash validator %d has %d delegators", validatorIndex, total)
+		delegators = append(delegators, delegationsResponse.DelegationResponses...)
+	}
+
+	// Calculate token price and threshold
+	minimumTokensThreshold, err := utils.GetMinimumTokensThreshold(config.GetAkashConfig().CoinID)
+	if err != nil {
+		log.Printf("Failed to fetch Akash token price: %v", err)
+		return nil, nil, 0, fmt.Errorf("failed to fetch Akash token price: %w", err)
+	}
+
+	// Prepare for airdrop calculation
+	rewardInfo := []config.Reward{}
+	balanceInfo := []banktypes.Balance{}
+	totalTokenDelegate := sdkmath.LegacyMustNewDecFromStr("0")
+
+	for _, delegator := range delegators {
+		validatorIndex := utils.FindValidatorInfo(validators, delegator.Delegation.ValidatorAddress)
+		validatorInfo := validators[validatorIndex]
+		token := (delegator.Delegation.Shares.MulInt(validatorInfo.Tokens)).QuoTruncate(validatorInfo.DelegatorShares)
+		totalTokenDelegate = totalTokenDelegate.Add(token)
+	}
+
+	eveAirdrop, err := sdkmath.LegacyNewDecFromStr(config.EveAirdrop)
+	if err != nil {
+		log.Printf("Failed to convert EveAirdrop string to dec: %v", err)
+		return nil, nil, 0, fmt.Errorf("failed to convert EveAirdrop string to dec: %w", err)
+	}
+
+	testAmount := sdkmath.LegacyMustNewDecFromStr("0")
+
+	for _, delegator := range delegators {
+		validatorIndex := utils.FindValidatorInfo(validators, delegator.Delegation.ValidatorAddress)
+		validatorInfo := validators[validatorIndex]
+		token := (delegator.Delegation.Shares.MulInt(validatorInfo.Tokens)).QuoTruncate(validatorInfo.DelegatorShares)
+
+		if token.LT(minimumTokensThreshold) {
+			continue
+		}
+
+		eveAirdropTokens := (eveAirdrop.MulInt64(int64(config.GetAkashConfig().Percent))).QuoInt64(100).Mul(token).QuoTruncate(totalTokenDelegate)
+		eveBech32Address, err := utils.ConvertBech32Address(delegator.Delegation.DelegatorAddress)
+		if err != nil {
+			log.Printf("Failed to convert Akash bech32 address: %v", err)
+			return nil, nil, 0, fmt.Errorf("failed to convert Bech32Address: %w", err)
+		}
+
+		rewardInfo = append(rewardInfo, config.Reward{
+			Address:         delegator.Delegation.DelegatorAddress,
+			EveAddress:      eveBech32Address,
+			Shares:          delegator.Delegation.Shares,
+			Token:           token,
+			EveAirdropToken: eveAirdropTokens,
+			ChainID:         config.GetAkashConfig().ChainID,
+		})
+		testAmount = eveAirdropTokens.Add(testAmount)
+		balanceInfo = append(balanceInfo, banktypes.Balance{
+			Address: eveBech32Address,
+			Coins:   sdk.NewCoins(sdk.NewCoin("eve", eveAirdropTokens.TruncateInt())),
+		})
+	}
+
+	log.Println("Akash balance: ", testAmount)
+
+	return balanceInfo, rewardInfo, len(balanceInfo), nil
+}

airdrop/chains/bostrom.go

@@ -0,0 +1,104 @@
+package chains
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/eve-network/eve/airdrop/config"
+	"github.com/eve-network/eve/airdrop/utils"
+
+	sdkmath "cosmossdk.io/math"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
+)
+
+func Bostrom() ([]banktypes.Balance, []config.Reward, int, error) {
+	delegators := []stakingtypes.DelegationResponse{}
+
+	// Fetch validators
+	validatorsResponse, err := utils.FetchValidators(config.GetBostromConfig().API, config.LimitPerPage)
+	if err != nil {
+		log.Printf("Failed to fetch Bostrom validators: %v", err)
+		return nil, nil, 0, fmt.Errorf("failed to fetch validators for Bostrom: %w", err)
+	}
+	validators := validatorsResponse.Validators
+	log.Println("Validators: ", len(validators))
+
+	// Fetch delegations for each validator
+	for validatorIndex, validator := range validators {
+		delegations, total, err := utils.FetchDelegations(
+			config.GetBostromConfig().API,
+			validator.OperatorAddress,
+			config.LimitPerPage,
+		)
+		if err != nil {
+			log.Printf("Failed to fetch delegations for Bostrom: %v", err)
+			return nil, nil, 0, fmt.Errorf("failed to fetch delegations for Bostrom: %w", err)
+		}
+		log.Printf("Bostrom validator %d has %d delegations", validatorIndex, total)
+		delegators = append(delegators, delegations...)
+	}
+
+	// Calculate token price and threshold
+	minimumTokensThreshold, err := utils.GetMinimumTokensThreshold(config.GetBostromConfig().CoinID)
+	if err != nil {
+		log.Printf("Failed to fetch Bostrom token price: %v", err)
+		return nil, nil, 0, fmt.Errorf("failed to fetch Bostrom token price: %w", err)
+	}
+
+	rewardInfo := []config.Reward{}
+	balanceInfo := []banktypes.Balance{}
+	totalTokenDelegate := sdkmath.LegacyMustNewDecFromStr("0")
+
+	// Calculate total tokens delegated
+	for _, delegator := range delegators {
+		validatorIndex := utils.FindValidatorInfoCustomType(validators, delegator.Delegation.ValidatorAddress)
+		validatorInfo := validators[validatorIndex]
+		token := (delegator.Delegation.Shares.MulInt(validatorInfo.Tokens)).QuoTruncate(validatorInfo.DelegatorShares)
+		totalTokenDelegate = totalTokenDelegate.Add(token)
+	}
+
+	eveAirdrop, err := sdkmath.LegacyNewDecFromStr(config.EveAirdrop)
+	if err != nil {
+		log.Printf("Failed to convert EveAirdrop string to dec: %v", err)
+		return nil, nil, 0, fmt.Errorf("failed to convert EveAirdrop string to dec: %w", err)
+	}
+
+	testAmount := sdkmath.LegacyMustNewDecFromStr("0")
+
+	// Calculate rewards and balances for delegators
+	for _, delegator := range delegators {
+		validatorIndex := utils.FindValidatorInfoCustomType(validators, delegator.Delegation.ValidatorAddress)
+		validatorInfo := validators[validatorIndex]
+		token := (delegator.Delegation.Shares.MulInt(validatorInfo.Tokens)).QuoTruncate(validatorInfo.DelegatorShares)
+		if token.LT(minimumTokensThreshold) {
+			continue
+		}
+
+		eveAirdropTokens := (eveAirdrop.MulInt64(int64(config.GetBostromConfig().Percent))).QuoInt64(100).Mul(token).QuoTruncate(totalTokenDelegate)
+		eveBech32Address, err := utils.ConvertBech32Address(delegator.Delegation.DelegatorAddress)
+		if err != nil {
+			log.Printf("Failed to convert Bostrom bech32 address: %v", err)
+			return nil, nil, 0, fmt.Errorf("failed to convert Bech32Address: %w", err)
+		}
+
+		rewardInfo = append(rewardInfo, config.Reward{
+			Address:         delegator.Delegation.DelegatorAddress,
+			EveAddress:      eveBech32Address,
+			Shares:          delegator.Delegation.Shares,
+			Token:           token,
+			EveAirdropToken: eveAirdropTokens,
+			ChainID:         config.GetBostromConfig().ChainID,
+		})
+		testAmount = eveAirdropTokens.Add(testAmount)
+		balanceInfo = append(balanceInfo, banktypes.Balance{
+			Address: eveBech32Address,
+			Coins:   sdk.NewCoins(sdk.NewCoin("eve", eveAirdropTokens.TruncateInt())),
+		})
+	}
+
+	log.Println("Bostrom balance: ", testAmount)
+	return balanceInfo, rewardInfo, len(balanceInfo), nil
+}

airdrop/chains/celestia.go

@@ -0,0 +1,124 @@
+package chains
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/eve-network/eve/airdrop/config"
+	"github.com/eve-network/eve/airdrop/utils"
+	"github.com/joho/godotenv"
+
+	sdkmath "cosmossdk.io/math"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
+)
+
+func Celestia() ([]banktypes.Balance, []config.Reward, int, error) {
+	// Load environment variables
+	if err := godotenv.Load(); err != nil {
+		log.Printf("Error loading Celestial environment variables: %v", err)
+		return nil, nil, 0, fmt.Errorf("failed to load env: %w", err)
+	}
+
+	// Get the latest block height
+	blockHeight, err := utils.GetLatestHeight(config.GetCelestiaConfig().RPC + "/status")
+	if err != nil {
+		log.Printf("Failed to get latest height for Celestial: %v", err)
+		return nil, nil, 0, fmt.Errorf("failed to get latest height for Celestia: %w", err)
+	}
+
+	// Setup gRPC connection
+	grpcConn, err := utils.SetupGRPCConnection(config.GetCelestiaConfig().GRPCAddr)
+	if err != nil {
+		log.Printf("Failed to connect to gRPC Celestial: %v", err)
+		return nil, nil, 0, fmt.Errorf("failed to connect to gRPC Celestia: %w", err)
+	}
+	defer grpcConn.Close()
+	stakingClient := stakingtypes.NewQueryClient(grpcConn)
+
+	// Fetch validators
+	validators, err := utils.GetValidators(stakingClient, blockHeight)
+	if err != nil {
+		log.Printf("Failed to get Celestial validators: %v", err)
+		return nil, nil, 0, fmt.Errorf("failed to get Celestia validators: %w", err)
+	}
+	log.Println("Validators: ", len(validators))
+
+	// Fetch delegations for each validator
+	var delegators []stakingtypes.DelegationResponse
+	for validatorIndex, validator := range validators {
+		delegations, total, err := utils.FetchDelegations(
+			config.GetCelestiaConfig().API,
+			validator.OperatorAddress,
+			config.LimitPerPage,
+		)
+		if err != nil {
+			log.Printf("Failed to query delegate info for Celestial validator: %v", err)
+			return nil, nil, 0, fmt.Errorf("failed to fetch delegations for Celestia: %w", err)
+		}
+		log.Println("Validator:", validator.OperatorAddress, "Index:", validatorIndex, "Total:", total)
+		delegators = append(delegators, delegations...)
+	}
+
+	// Calculate token price and threshold
+	minimumTokensThreshold, err := utils.GetMinimumTokensThreshold(config.GetCelestiaConfig().CoinID)
+	if err != nil {
+		log.Printf("Failed to fetch Celestial token price: %v", err)
+		return nil, nil, 0, fmt.Errorf("failed to fetch Celestial token price: %w", err)
+	}
+
+	// Process delegations and calculate rewards
+	totalTokenDelegate := sdkmath.LegacyMustNewDecFromStr("0")
+	for _, delegator := range delegators {
+		validatorIndex := utils.FindValidatorInfo(validators, delegator.Delegation.ValidatorAddress)
+		validatorInfo := validators[validatorIndex]
+		token := delegator.Delegation.Shares.MulInt(validatorInfo.Tokens).QuoTruncate(validatorInfo.DelegatorShares)
+		totalTokenDelegate = totalTokenDelegate.Add(token)
+	}
+
+	eveAirdrop, err := sdkmath.LegacyNewDecFromStr(config.EveAirdrop)
+	if err != nil {
+		log.Printf("Failed to convert EveAirdrop string to dec: %v", err)
+		return nil, nil, 0, fmt.Errorf("failed to convert EveAirdrop string to dec: %w", err)
+	}
+
+	var rewardInfo []config.Reward
+	var balanceInfo []banktypes.Balance
+	testAmount := sdkmath.LegacyMustNewDecFromStr("0")
+
+	for _, delegator := range delegators {
+		validatorIndex := utils.FindValidatorInfo(validators, delegator.Delegation.ValidatorAddress)
+		validatorInfo := validators[validatorIndex]
+		token := delegator.Delegation.Shares.MulInt(validatorInfo.Tokens).QuoTruncate(validatorInfo.DelegatorShares)
+		if token.LT(minimumTokensThreshold) {
+			continue
+		}
+		eveAirdropToken := eveAirdrop.MulInt64(int64(config.GetCelestiaConfig().Percent)).QuoInt64(100).Mul(token).QuoTruncate(totalTokenDelegate)
+		eveBech32Address, err := utils.ConvertBech32Address(delegator.Delegation.DelegatorAddress)
+		if err != nil {
+			log.Printf("Failed to convert Celestial bech32 address: %v", err)
+			return nil, nil, 0, fmt.Errorf("failed to convert Bech32Address: %w", err)
+		}
+
+		rewardInfo = append(rewardInfo, config.Reward{
+			Address:         delegator.Delegation.DelegatorAddress,
+			EveAddress:      eveBech32Address,
+			Shares:          delegator.Delegation.Shares,
+			Token:           token,
+			EveAirdropToken: eveAirdropToken,
+			ChainID:         config.GetCelestiaConfig().ChainID,
+		})
+
+		testAmount = testAmount.Add(eveAirdropToken)
+		balanceInfo = append(balanceInfo, banktypes.Balance{
+			Address: eveBech32Address,
+			Coins:   sdk.NewCoins(sdk.NewCoin("eve", eveAirdropToken.TruncateInt())),
+		})
+	}
+
+	log.Println("Celestia balance: ", testAmount)
+
+	return balanceInfo, rewardInfo, len(balanceInfo), nil
+}