Add Cardano chain

core/chains/cardano.go

@@ -0,0 +1,75 @@
+package chains
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"math/big"
+	"net/http"
+
+	utils "github.com/xenowits/nakamoto-coefficient-calculator/core/utils"
+)
+
+type ChartData struct {
+    AvgStake      float64 `json:"avgstake"`
+    DelegateCount int     `json:"delegatecount"`
+    Epoch         int     `json:"epoch"`
+    Label         string  `json:"label"`
+    Leverage      string  `json:"leverage"`
+    MavGroup      string  `json:"mavgroup"`
+    Pledge        float64 `json:"pledge"`
+    PoolCount     int     `json:"poolcount"`
+    PrctStake     float64 `json:"prctstake"`
+    Stake         float64 `json:"stake"`
+}
+
+func Cardano() (int, error) {
+    url := "https://api.balanceanalytics.io/rpc/pool_group_stake_donut"
+
+    req, err := http.NewRequest("GET", url, nil)
+    if err != nil {
+        log.Println("Error creating request:", err)
+        return 0, err
+    }
+
+    // This is the PUBLIC_BALANCE_API_TOKEN taken from https://www.balanceanalytics.io/chartboards/donut_shop
+    req.Header.Set("Authorization", "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJyb2xlIjoid2ViYXBwX3VzZXIifQ.eg3Zb9ZduibYJr1pgUrfqy4PFhkVU1uO_F9gFPBZnBI")
+	req.Header.Set("Content-Type", "application/json")
+
+    client := &http.Client{}
+    resp, err := client.Do(req)
+    if err != nil {
+        log.Println("Error making request:", err)
+        return 0, err
+    }
+    defer resp.Body.Close()
+
+    var responseData []struct {
+        Chartdata []ChartData `json:"chartdata"`
+    }
+    err = json.NewDecoder(resp.Body).Decode(&responseData)
+    if err != nil {
+        log.Println("Error decoding JSON:", err)
+        return 0, err
+    }
+
+	var votingPowers []big.Int
+		for _, data := range responseData {
+			for _, chartData := range data.Chartdata {
+			stakeInt := big.NewInt(int64(chartData.Stake))
+			votingPowers = append(votingPowers, *stakeInt)
+		}
+	}
+
+	// Calculate total voting power
+	totalVotingPower := utils.CalculateTotalVotingPowerBigNums(votingPowers)
+
+	// Calculate Nakamoto coefficient
+	nakamotoCoefficient := utils.CalcNakamotoCoefficientBigNums51(totalVotingPower, votingPowers)
+
+	fmt.Println("Total voting power:", totalVotingPower)
+	fmt.Println("The Nakamoto coefficient for Cardano is", nakamotoCoefficient)
+
+	// Return Nakamoto coefficient
+	return nakamotoCoefficient, nil
+}

core/chains/chain.go

@@ -24,6 +24,7 @@ const (
 	AVAX  Token = "AVAX"
 	BLD   Token = "BLD"
 	BNB   Token = "BNB"
+	ADA   Token = "ADA"
 	ETH2  Token = "ETH2"
 	GRT   Token = "GRT"
 	HBAR  Token = "HBAR"
@@ -52,6 +53,8 @@ func (t Token) ChainName() string {
 		return "Agoric"
 	case BNB:
 		return "Binance"
+	case ADA:
+		return "Cardano"
 	case ETH2:
 		return "Ethereum Proof-of-Stake"
 	case GRT:
@@ -87,7 +90,7 @@ func (t Token) ChainName() string {
 	}
 }
 
-var Tokens = []Token{ATOM, AVAX, BLD, BNB, ETH2, GRT, HBAR, JUNO, MATIC, MINA, NEAR, OSMO, PLS, REGEN, RUNE, SOL, STARS, SUI, TIA}
+var Tokens = []Token{ATOM, AVAX, BLD, BNB, ADA, ETH2, GRT, HBAR, JUNO, MATIC, MINA, NEAR, OSMO, PLS, REGEN, RUNE, SOL, STARS, SUI, TIA}
 
 // NewState returns a new fresh state.
 func NewState() ChainState {
@@ -129,6 +132,8 @@ func newValues(token Token) (int, error) {
 		currVal, err = Agoric()
 	case BNB:
 		currVal, err = Binance()
+	case ADA:
+		currVal, err = Cardano()
 	case ETH2:
 		currVal, err = Eth2()
 	case GRT:

core/utils/calc_nakamoto_coefficient_big_nums.go

@@ -19,5 +19,23 @@ func CalcNakamotoCoefficientBigNums(totalVotingPower *big.Int, votingPowers []bi
 		}
 	}
 
+	return nakamotoCoefficient
+}
+
+func CalcNakamotoCoefficientBigNums51(totalVotingPower *big.Int, votingPowers []big.Int) int {
+	thresholdPercent := big.NewFloat(0.51)
+	thresholdVal := new(big.Float).Mul(new(big.Float).SetInt(totalVotingPower), thresholdPercent)
+	cumulativeVal := big.NewFloat(0.00)
+	nakamotoCoefficient := 0
+
+	for _, vp := range votingPowers {
+		z := new(big.Float).Add(cumulativeVal, new(big.Float).SetInt(&vp))
+		cumulativeVal = z
+		nakamotoCoefficient += 1
+		if cumulativeVal.Cmp(thresholdVal) == +1 {
+			break
+		}
+	}
+
 	return nakamotoCoefficient
 }