Mining/pkg/node/lethean.go

// Copyright (c) 2017-2026 Lethean (https://lt.hn)
// SPDX-License-Identifier: EUPL-1.2

package node

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"strings"
)

// LetheanDefaults for chain connectivity.
const (
	LetheanTestnetDaemon = "http://127.0.0.1:46941"
	LetheanMainnetDaemon = "http://127.0.0.1:36941"
	LetheanTestnetPool   = "stratum+tcp://pool.lthn.io:5555"
	LetheanMainnetPool   = "stratum+tcp://pool.lthn.io:3333"
)

// ChainInfo holds basic chain state from the daemon RPC.
//
//	info, err := node.GetChainInfo("http://127.0.0.1:46941")
type ChainInfo struct {
	Height    uint64 `json:"height"`
	Aliases   int    `json:"alias_count"`
	Synced    bool   `json:"synced"`
	PoolSize  int    `json:"tx_pool_size"`
	Difficulty uint64 `json:"difficulty"`
}

// PoolGateway is a mining pool discovered from chain aliases.
//
//	pools := node.DiscoverPools("http://127.0.0.1:46941")
type PoolGateway struct {
	Name     string `json:"name"`
	Address  string `json:"address"`
	Caps     string `json:"caps"`
	Endpoint string `json:"endpoint"`
}

// GetChainInfo queries the daemon for basic chain state.
//
//	info, err := node.GetChainInfo("http://127.0.0.1:46941")
func GetChainInfo(daemonURL string) (*ChainInfo, error) {
	body := `{"jsonrpc":"2.0","id":"0","method":"getinfo","params":{}}`
	resp, err := http.Post(daemonURL+"/json_rpc", "application/json", strings.NewReader(body))
	if err != nil {
		return nil, fmt.Errorf("daemon RPC failed: %w", err)
	}
	defer resp.Body.Close()
	raw, _ := io.ReadAll(resp.Body)

	var result struct {
		Result ChainInfo `json:"result"`
	}
	if err := json.Unmarshal(raw, &result); err != nil {
		return nil, fmt.Errorf("parse getinfo: %w", err)
	}
	result.Result.Synced = result.Result.Height > 0
	return &result.Result, nil
}

// DiscoverPools queries the chain for aliases with cap=pool and returns
// pool endpoints that miners can connect to.
//
//	pools := node.DiscoverPools("http://127.0.0.1:46941")
func DiscoverPools(daemonURL string) []PoolGateway {
	body := `{"jsonrpc":"2.0","id":"0","method":"get_all_alias_details","params":{}}`
	resp, err := http.Post(daemonURL+"/json_rpc", "application/json", strings.NewReader(body))
	if err != nil {
		return nil
	}
	defer resp.Body.Close()
	raw, _ := io.ReadAll(resp.Body)

	var result struct {
		Result struct {
			Aliases []struct {
				Alias   string `json:"alias"`
				Address string `json:"address"`
				Comment string `json:"comment"`
			} `json:"aliases"`
		} `json:"result"`
	}
	json.Unmarshal(raw, &result)

	var pools []PoolGateway
	for _, a := range result.Result.Aliases {
		if !strings.Contains(a.Comment, "pool") {
			continue
		}
		parsed := parseComment(a.Comment)
		pools = append(pools, PoolGateway{
			Name:     a.Alias,
			Address:  a.Address,
			Caps:     parsed["cap"],
			Endpoint: fmt.Sprintf("stratum+tcp://%s.lthn:5555", a.Alias),
		})
	}
	return pools
}

// DiscoverGateways returns all gateway nodes from chain aliases.
//
//	gateways := node.DiscoverGateways("http://127.0.0.1:46941")
func DiscoverGateways(daemonURL string) []PoolGateway {
	body := `{"jsonrpc":"2.0","id":"0","method":"get_all_alias_details","params":{}}`
	resp, err := http.Post(daemonURL+"/json_rpc", "application/json", strings.NewReader(body))
	if err != nil {
		return nil
	}
	defer resp.Body.Close()
	raw, _ := io.ReadAll(resp.Body)

	var result struct {
		Result struct {
			Aliases []struct {
				Alias   string `json:"alias"`
				Address string `json:"address"`
				Comment string `json:"comment"`
			} `json:"aliases"`
		} `json:"result"`
	}
	json.Unmarshal(raw, &result)

	var gateways []PoolGateway
	for _, a := range result.Result.Aliases {
		if !strings.Contains(a.Comment, "type=gateway") {
			continue
		}
		parsed := parseComment(a.Comment)
		gateways = append(gateways, PoolGateway{
			Name:     a.Alias,
			Address:  a.Address,
			Caps:     parsed["cap"],
			Endpoint: fmt.Sprintf("%s.lthn", a.Alias),
		})
	}
	return gateways
}

func parseComment(comment string) map[string]string {
	result := make(map[string]string)
	for _, part := range strings.Split(comment, ";") {
		idx := strings.IndexByte(part, '=')
		if idx > 0 {
			result[part[:idx]] = part[idx+1:]
		}
	}
	return result
}