< Summary - Combined Code Coverage

Information
Class: NLightning.Daemon.Extensions.NodeServiceExtensions
Assembly: NLightning.Daemon
File(s): /home/runner/work/NLightning/NLightning/src/NLightning.Daemon/Extensions/NodeServiceExtensions.cs
Tag: 57_24045730253
Line coverage
0%
Covered lines: 0
Uncovered lines: 125
Coverable lines: 125
Total lines: 175
Line coverage: 0%
Branch coverage
0%
Covered branches: 0
Total branches: 12
Branch coverage: 0%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
ConfigureNltgServices(...)0%156120%

File(s)

/home/runner/work/NLightning/NLightning/src/NLightning.Daemon/Extensions/NodeServiceExtensions.cs

#LineLine coverage
 1using Microsoft.Extensions.Configuration;
 2using Microsoft.Extensions.DependencyInjection;
 3using Microsoft.Extensions.Hosting;
 4using Microsoft.Extensions.Logging;
 5using Microsoft.Extensions.Options;
 6
 7namespace NLightning.Daemon.Extensions;
 8
 9using Application;
 10using Contracts.Utilities;
 11using Daemon.Ipc.Handlers;
 12using Daemon.Ipc.Interfaces;
 13using Domain.Bitcoin.Interfaces;
 14using Domain.Bitcoin.Transactions.Factories;
 15using Domain.Bitcoin.Transactions.Interfaces;
 16using Domain.Channels.Factories;
 17using Domain.Channels.Interfaces;
 18using Domain.Channels.Validators;
 19using Domain.Client.Interfaces;
 20using Domain.Client.Requests;
 21using Domain.Client.Responses;
 22using Domain.Crypto.Hashes;
 23using Domain.Node.Options;
 24using Domain.Protocol.Interfaces;
 25using Domain.Protocol.ValueObjects;
 26using Handlers;
 27using Infrastructure;
 28using Infrastructure.Bitcoin;
 29using Infrastructure.Bitcoin.Builders;
 30using Infrastructure.Bitcoin.Managers;
 31using Infrastructure.Bitcoin.Options;
 32using Infrastructure.Bitcoin.Services;
 33using Infrastructure.Bitcoin.Signers;
 34using Infrastructure.Persistence;
 35using Infrastructure.Repositories;
 36using Infrastructure.Serialization;
 37using Interfaces;
 38using Services;
 39using Services.Ipc;
 40
 41public static class NodeServiceExtensions
 42{
 43    /// <summary>
 44    /// Registers all NLTG application services for dependency injection
 45    /// </summary>
 46    public static IHostBuilder ConfigureNltgServices(this IHostBuilder hostBuilder, SecureKeyManager secureKeyManager,
 47                                                     string configPath)
 48    {
 049        return hostBuilder.ConfigureServices((hostContext, services) =>
 050        {
 051            // Get configuration
 052            var configuration = hostContext.Configuration;
 053
 054            // Register configuration as a service
 055            services.AddSingleton(configuration);
 056
 057            // Register the main daemon service
 058            services.AddHostedService<NltgDaemonService>();
 059
 060            // Register Client Handlers
 061            services
 062               .AddScoped<IClientCommandHandler<OpenChannelClientRequest, OpenChannelClientResponse>,
 063                    OpenChannelClientHandler>();
 064            services
 065               .AddScoped<IClientCommandHandler<OpenChannelClientSubscriptionRequest,
 066                        OpenChannelClientSubscriptionResponse>,
 067                    OpenChannelClientSubscriptionHandler>();
 068
 069            // Register IPC server and handlers
 070            services.AddSingleton<INamedPipeIpcService>(sp =>
 071            {
 072                var ipcAuthenticator = sp.GetRequiredService<IIpcAuthenticator>();
 073                var ipcFraming = sp.GetRequiredService<IIpcFraming>();
 074                var logger = sp.GetRequiredService<ILogger<NamedPipeIpcService>>();
 075                var ipcRequestRouter = sp.GetRequiredService<IIpcRequestRouter>();
 076                return new NamedPipeIpcService(ipcAuthenticator, configPath, ipcFraming, logger, ipcRequestRouter);
 077            });
 078            services.AddSingleton<IIpcFraming, LengthPrefixedIpcFraming>();
 079            services.AddSingleton<IIpcRequestRouter, IpcRequestRouter>();
 080            services.AddSingleton<INodeInfoQueryService, NodeInfoQueryService>();
 081            services.AddSingleton<IIpcCommandHandler, NodeInfoIpcHandler>();
 082            services.AddSingleton<IIpcCommandHandler, ConnectPeerIpcHandler>();
 083            services.AddSingleton<IIpcCommandHandler, ListPeersIpcHandler>();
 084            services.AddSingleton<IIpcCommandHandler, GetAddressIpcHandler>();
 085            services.AddSingleton<IIpcCommandHandler, GetWalletBalanceIpcHandler>();
 086            services.AddSingleton<IIpcCommandHandler, OpenChannelIpcHandler>();
 087            services.AddSingleton<IIpcCommandHandler, OpenChannelSubscriptionIpcHandler>();
 088            services.AddSingleton<IIpcAuthenticator>(sp =>
 089            {
 090                var cookiePath = NodeUtils.GetCookieFilePath(configPath);
 091                var logger = sp.GetRequiredService<ILogger<CookieFileAuthenticator>>();
 092                return new CookieFileAuthenticator(cookiePath, logger);
 093            });
 094
 095            // Add HttpClient for FeeService with configuration
 096            services.AddHttpClient<IFeeService, FeeService>(client =>
 097            {
 098                client.Timeout = TimeSpan.FromSeconds(30);
 099                client.DefaultRequestHeaders.Add("Accept", "application/json");
 0100            });
 0101
 0102            // Singleton services (one instance throughout the application)
 0103            services.AddSingleton<IChannelOpenValidator>(sp =>
 0104            {
 0105                var nodeOptions = sp.GetRequiredService<IOptions<NodeOptions>>().Value;
 0106                return new ChannelOpenValidator(nodeOptions);
 0107            });
 0108            services.AddSingleton<ISecureKeyManager>(secureKeyManager);
 0109            services.AddSingleton<IChannelFactory>(sp =>
 0110            {
 0111                var channelIdFactory = sp.GetRequiredService<IChannelIdFactory>();
 0112                var channelOpenValidator = sp.GetRequiredService<IChannelOpenValidator>();
 0113                var feeService = sp.GetRequiredService<IFeeService>();
 0114                var lightningSigner = sp.GetRequiredService<ILightningSigner>();
 0115                var nodeOptions = sp.GetRequiredService<IOptions<NodeOptions>>().Value;
 0116                var sha256 = sp.GetRequiredService<ISha256>();
 0117                return new ChannelFactory(channelIdFactory, channelOpenValidator, feeService, lightningSigner,
 0118                                          nodeOptions, sha256);
 0119            });
 0120            services.AddSingleton<ICommitmentTransactionModelFactory, CommitmentTransactionModelFactory>();
 0121            services.AddSingleton<IFundingTransactionModelFactory, FundingTransactionModelFactory>();
 0122
 0123            // Add the Signer
 0124            services.AddSingleton<ILightningSigner>(serviceProvider =>
 0125            {
 0126                var fundingOutputBuilder = serviceProvider.GetRequiredService<IFundingOutputBuilder>();
 0127                var keyDerivationService = serviceProvider.GetRequiredService<IKeyDerivationService>();
 0128                var logger = serviceProvider.GetRequiredService<ILogger<LocalLightningSigner>>();
 0129                var nodeOptions = serviceProvider.GetRequiredService<IOptions<NodeOptions>>().Value;
 0130                var utxoMemoryRepository = serviceProvider.GetRequiredService<IUtxoMemoryRepository>();
 0131
 0132                // Create the signer with the correct network
 0133                return new LocalLightningSigner(fundingOutputBuilder, keyDerivationService, logger, nodeOptions,
 0134                                                secureKeyManager, utxoMemoryRepository);
 0135            });
 0136
 0137            // Add the Application services
 0138            services.AddApplicationServices();
 0139
 0140            // Add the Infrastructure services
 0141            services.AddBitcoinInfrastructure();
 0142            services.AddInfrastructureServices();
 0143            services.AddPersistenceInfrastructureServices(configuration);
 0144            services.AddRepositoriesInfrastructureServices();
 0145            services.AddSerializationInfrastructureServices();
 0146
 0147            // Scoped services (one instance per scope)
 0148
 0149            // Transient services (new instance each time)
 0150
 0151            // Register options with values from configuration
 0152            services.AddOptions<BitcoinOptions>().BindConfiguration("Bitcoin").ValidateOnStart();
 0153            services.AddOptions<FeeEstimationOptions>().BindConfiguration("FeeEstimation").ValidateOnStart();
 0154            services.AddOptions<NodeOptions>()
 0155                    .BindConfiguration("Node")
 0156                    .PostConfigure(options =>
 0157                     {
 0158                         var configuredAddresses = configuration.GetSection("Node:ListenAddresses").Get<string[]?>();
 0159                         if (configuredAddresses is { Length: > 0 })
 0160                         {
 0161                             options.ListenAddresses = configuredAddresses.ToList();
 0162                         }
 0163
 0164                         var networkString = configuration.GetValue<string>("Node:Network");
 0165                         if (!string.IsNullOrWhiteSpace(networkString))
 0166                         {
 0167                             options.BitcoinNetwork = new BitcoinNetwork(networkString);
 0168                         }
 0169
 0170                         options.Features.ChainHashes = [options.BitcoinNetwork.ChainHash];
 0171                     })
 0172                    .ValidateOnStart();
 0173        });
 174    }
 175}
Generated by: ReportGenerator 5.2.4.0
04/06/2026 - 18:51:07
GitHub | reportgenerator.io

Methods/Properties

ConfigureNltgServices(Microsoft.Extensions.Hosting.IHostBuilder,NLightning.Infrastructure.Bitcoin.Managers.SecureKeyManager,System.String)