github.com/celestiaorg/celestia-node@v0.15.0-beta.1/nodebuilder/header/constructors.go (about)

     1  package header
     2  
     3  import (
     4  	"context"
     5  
     6  	"github.com/ipfs/go-datastore"
     7  	"github.com/libp2p/go-libp2p/core/host"
     8  	"github.com/libp2p/go-libp2p/core/peer"
     9  	"github.com/libp2p/go-libp2p/core/peerstore"
    10  	"github.com/libp2p/go-libp2p/p2p/net/conngater"
    11  	"go.uber.org/fx"
    12  
    13  	libfraud "github.com/celestiaorg/go-fraud"
    14  	libhead "github.com/celestiaorg/go-header"
    15  	"github.com/celestiaorg/go-header/p2p"
    16  	"github.com/celestiaorg/go-header/store"
    17  	"github.com/celestiaorg/go-header/sync"
    18  
    19  	modfraud "github.com/celestiaorg/celestia-node/nodebuilder/fraud"
    20  	modp2p "github.com/celestiaorg/celestia-node/nodebuilder/p2p"
    21  	"github.com/celestiaorg/celestia-node/share/eds/byzantine"
    22  )
    23  
    24  // newP2PExchange constructs a new Exchange for headers.
    25  func newP2PExchange[H libhead.Header[H]](
    26  	lc fx.Lifecycle,
    27  	cfg Config,
    28  	bpeers modp2p.Bootstrappers,
    29  	network modp2p.Network,
    30  	host host.Host,
    31  	conngater *conngater.BasicConnectionGater,
    32  	pidstore p2p.PeerIDStore,
    33  ) (libhead.Exchange[H], error) {
    34  	peers, err := cfg.trustedPeers(bpeers)
    35  	if err != nil {
    36  		return nil, err
    37  	}
    38  	ids := make([]peer.ID, len(peers))
    39  	for index, peer := range peers {
    40  		ids[index] = peer.ID
    41  		host.Peerstore().AddAddrs(peer.ID, peer.Addrs, peerstore.PermanentAddrTTL)
    42  	}
    43  
    44  	opts := []p2p.Option[p2p.ClientParameters]{
    45  		p2p.WithParams(cfg.Client),
    46  		p2p.WithNetworkID[p2p.ClientParameters](network.String()),
    47  		p2p.WithChainID(network.String()),
    48  		p2p.WithPeerIDStore[p2p.ClientParameters](pidstore),
    49  	}
    50  	if MetricsEnabled {
    51  		opts = append(opts, p2p.WithMetrics[p2p.ClientParameters]())
    52  	}
    53  
    54  	exchange, err := p2p.NewExchange[H](host, ids, conngater, opts...)
    55  	if err != nil {
    56  		return nil, err
    57  	}
    58  	lc.Append(fx.Hook{
    59  		OnStart: func(ctx context.Context) error {
    60  			return exchange.Start(ctx)
    61  		},
    62  		OnStop: func(ctx context.Context) error {
    63  			return exchange.Stop(ctx)
    64  		},
    65  	})
    66  	return exchange, nil
    67  }
    68  
    69  // newSyncer constructs new Syncer for headers.
    70  func newSyncer[H libhead.Header[H]](
    71  	ex libhead.Exchange[H],
    72  	fservice libfraud.Service[H],
    73  	store libhead.Store[H],
    74  	sub libhead.Subscriber[H],
    75  	cfg Config,
    76  ) (*sync.Syncer[H], *modfraud.ServiceBreaker[*sync.Syncer[H], H], error) {
    77  	opts := []sync.Option{sync.WithParams(cfg.Syncer), sync.WithBlockTime(modp2p.BlockTime)}
    78  	if MetricsEnabled {
    79  		opts = append(opts, sync.WithMetrics())
    80  	}
    81  
    82  	syncer, err := sync.NewSyncer[H](ex, store, sub, opts...)
    83  	if err != nil {
    84  		return nil, nil, err
    85  	}
    86  
    87  	return syncer, &modfraud.ServiceBreaker[*sync.Syncer[H], H]{
    88  		Service:   syncer,
    89  		FraudType: byzantine.BadEncoding,
    90  		FraudServ: fservice,
    91  	}, nil
    92  }
    93  
    94  // newInitStore constructs an initialized store
    95  func newInitStore[H libhead.Header[H]](
    96  	lc fx.Lifecycle,
    97  	cfg Config,
    98  	net modp2p.Network,
    99  	ds datastore.Batching,
   100  	ex libhead.Exchange[H],
   101  ) (libhead.Store[H], error) {
   102  	opts := []store.Option{store.WithParams(cfg.Store)}
   103  	if MetricsEnabled {
   104  		opts = append(opts, store.WithMetrics())
   105  	}
   106  
   107  	s, err := store.NewStore[H](ds, opts...)
   108  	if err != nil {
   109  		return nil, err
   110  	}
   111  
   112  	trustedHash, err := cfg.trustedHash(net)
   113  	if err != nil {
   114  		return nil, err
   115  	}
   116  
   117  	lc.Append(fx.Hook{
   118  		OnStart: func(ctx context.Context) error {
   119  			err = store.Init[H](ctx, s, ex, trustedHash)
   120  			if err != nil {
   121  				return err
   122  			}
   123  			return s.Start(ctx)
   124  		},
   125  		OnStop: func(ctx context.Context) error {
   126  			return s.Stop(ctx)
   127  		},
   128  	})
   129  
   130  	return s, nil
   131  }