github.com/badrootd/nibiru-cometbft@v0.37.5-0.20240307173500-2a75559eee9b/rpc/core/net.go (about)

     1  package core
     2  
     3  import (
     4  	"errors"
     5  	"fmt"
     6  	"strings"
     7  
     8  	"github.com/badrootd/nibiru-cometbft/p2p"
     9  	ctypes "github.com/badrootd/nibiru-cometbft/rpc/core/types"
    10  	rpctypes "github.com/badrootd/nibiru-cometbft/rpc/jsonrpc/types"
    11  )
    12  
    13  // NetInfo returns network info.
    14  // More: https://docs.cometbft.com/v0.37/rpc/#/Info/net_info
    15  func NetInfo(ctx *rpctypes.Context) (*ctypes.ResultNetInfo, error) {
    16  	peersList := env.P2PPeers.Peers().List()
    17  	peers := make([]ctypes.Peer, 0, len(peersList))
    18  	for _, peer := range peersList {
    19  		nodeInfo, ok := peer.NodeInfo().(p2p.DefaultNodeInfo)
    20  		if !ok {
    21  			return nil, fmt.Errorf("peer.NodeInfo() is not DefaultNodeInfo")
    22  		}
    23  		peers = append(peers, ctypes.Peer{
    24  			NodeInfo:         nodeInfo,
    25  			IsOutbound:       peer.IsOutbound(),
    26  			ConnectionStatus: peer.Status(),
    27  			RemoteIP:         peer.RemoteIP().String(),
    28  		})
    29  	}
    30  	// TODO: Should we include PersistentPeers and Seeds in here?
    31  	// PRO: useful info
    32  	// CON: privacy
    33  	return &ctypes.ResultNetInfo{
    34  		Listening: env.P2PTransport.IsListening(),
    35  		Listeners: env.P2PTransport.Listeners(),
    36  		NPeers:    len(peers),
    37  		Peers:     peers,
    38  	}, nil
    39  }
    40  
    41  // UnsafeDialSeeds dials the given seeds (comma-separated id@IP:PORT).
    42  func UnsafeDialSeeds(ctx *rpctypes.Context, seeds []string) (*ctypes.ResultDialSeeds, error) {
    43  	if len(seeds) == 0 {
    44  		return &ctypes.ResultDialSeeds{}, errors.New("no seeds provided")
    45  	}
    46  	env.Logger.Info("DialSeeds", "seeds", seeds)
    47  	if err := env.P2PPeers.DialPeersAsync(seeds); err != nil {
    48  		return &ctypes.ResultDialSeeds{}, err
    49  	}
    50  	return &ctypes.ResultDialSeeds{Log: "Dialing seeds in progress. See /net_info for details"}, nil
    51  }
    52  
    53  // UnsafeDialPeers dials the given peers (comma-separated id@IP:PORT),
    54  // optionally making them persistent.
    55  func UnsafeDialPeers(ctx *rpctypes.Context, peers []string, persistent, unconditional, private bool) (
    56  	*ctypes.ResultDialPeers, error,
    57  ) {
    58  	if len(peers) == 0 {
    59  		return &ctypes.ResultDialPeers{}, errors.New("no peers provided")
    60  	}
    61  
    62  	ids, err := getIDs(peers)
    63  	if err != nil {
    64  		return &ctypes.ResultDialPeers{}, err
    65  	}
    66  
    67  	env.Logger.Info("DialPeers", "peers", peers, "persistent",
    68  		persistent, "unconditional", unconditional, "private", private)
    69  
    70  	if persistent {
    71  		if err := env.P2PPeers.AddPersistentPeers(peers); err != nil {
    72  			return &ctypes.ResultDialPeers{}, err
    73  		}
    74  	}
    75  
    76  	if private {
    77  		if err := env.P2PPeers.AddPrivatePeerIDs(ids); err != nil {
    78  			return &ctypes.ResultDialPeers{}, err
    79  		}
    80  	}
    81  
    82  	if unconditional {
    83  		if err := env.P2PPeers.AddUnconditionalPeerIDs(ids); err != nil {
    84  			return &ctypes.ResultDialPeers{}, err
    85  		}
    86  	}
    87  
    88  	if err := env.P2PPeers.DialPeersAsync(peers); err != nil {
    89  		return &ctypes.ResultDialPeers{}, err
    90  	}
    91  
    92  	return &ctypes.ResultDialPeers{Log: "Dialing peers in progress. See /net_info for details"}, nil
    93  }
    94  
    95  // Genesis returns genesis file.
    96  // More: https://docs.cometbft.com/v0.37/rpc/#/Info/genesis
    97  func Genesis(ctx *rpctypes.Context) (*ctypes.ResultGenesis, error) {
    98  	if len(env.genChunks) > 1 {
    99  		return nil, errors.New("genesis response is large, please use the genesis_chunked API instead")
   100  	}
   101  
   102  	return &ctypes.ResultGenesis{Genesis: env.GenDoc}, nil
   103  }
   104  
   105  func GenesisChunked(ctx *rpctypes.Context, chunk uint) (*ctypes.ResultGenesisChunk, error) {
   106  	if env.genChunks == nil {
   107  		return nil, fmt.Errorf("service configuration error, genesis chunks are not initialized")
   108  	}
   109  
   110  	if len(env.genChunks) == 0 {
   111  		return nil, fmt.Errorf("service configuration error, there are no chunks")
   112  	}
   113  
   114  	id := int(chunk)
   115  
   116  	if id > len(env.genChunks)-1 {
   117  		return nil, fmt.Errorf("there are %d chunks, %d is invalid", len(env.genChunks)-1, id)
   118  	}
   119  
   120  	return &ctypes.ResultGenesisChunk{
   121  		TotalChunks: len(env.genChunks),
   122  		ChunkNumber: id,
   123  		Data:        env.genChunks[id],
   124  	}, nil
   125  }
   126  
   127  func getIDs(peers []string) ([]string, error) {
   128  	ids := make([]string, 0, len(peers))
   129  
   130  	for _, peer := range peers {
   131  
   132  		spl := strings.Split(peer, "@")
   133  		if len(spl) != 2 {
   134  			return nil, p2p.ErrNetAddressNoID{Addr: peer}
   135  		}
   136  		ids = append(ids, spl[0])
   137  
   138  	}
   139  	return ids, nil
   140  }