/// <summary>
/// Uses the bitcoin chain.
/// </summary>
/// <param name="forgeBuilder">The forge builder.</param>
/// <param name="networkName"></param>
/// <param name="minimumSupportedVersion">The minimum version local nodes requires in order to connect to other peers.</param>
/// <param name="currentVersion">The current version local peer aim to use with connected peers.</param>
/// <returns></returns>
public static IForgeBuilder UseBitcoinChain(this IForgeBuilder forgeBuilder,
string networkName,
int minimumSupportedVersion,
int currentVersion)
{
if (forgeBuilder is null)
{
throw new ArgumentNullException(nameof(forgeBuilder));
}
Type?chainDefinitionType = networkName.ToLowerInvariant() switch
{
"bitcoin-main" => typeof(BitcoinMainDefinition),
"bitcoin-testnet" => typeof(BitcoinTestnetDefinition),
"bitcoin-regtest" => typeof(BitcoinRegtestDefinition),
_ => null
};
if (chainDefinitionType == null)
{
ThrowHelper.ThrowArgumentException($"Unknown Network {networkName.ToLowerInvariant()}");
}
forgeBuilder.AddShard <BitcoinShard, BitcoinSettings>(
(hostBuildContext, services) =>
{
services
.AddSingleton(typeof(IChainDefinition), chainDefinitionType)
.AddSingleton <IConsensusParameters>(serviceProvider => serviceProvider.GetRequiredService <IChainDefinition>().Consensus)
.AddSingleton <INetworkDefinition>(serviceProvider => serviceProvider.GetRequiredService <IChainDefinition>().NetworkDefinition)
.AddSingleton(new NodeImplementation(minimumSupportedVersion, currentVersion))
.AddSingleton <IHeadersTree, HeadersTree>()
.AddSingleton <IDateTimeProvider, DateTimeProvider>()
.AddSingleton <IChainState, ChainState>()
.AddSingleton <ICoinsView, CoinsView>()
.AddSingleton <IInitialBlockDownloadTracker, InitialBlockDownloadTracker>()
.AddSingleton <IHeaderMedianTimeCalculator, HeaderMedianTimeCalculator>()
.AddSingleton <IBlockHeaderRepository, InMemoryBlockHeaderRepository>()
.AddSingleton <IProofOfWorkCalculator, ProofOfWorkCalculator>()
.AddSingleton <IBlockFetcherManager, BlockFetcherManager>()
.AddHostedService(sp => sp.GetRequiredService <IBlockFetcherManager>())
.AddSingleton <ILocalServiceProvider, LocalServiceProvider>()
.AddSingleton <SelfConnectionTracker>()
.AddSingleton <IBlockHeaderHashCalculator, BlockHeaderHashCalculator>()
.AddSingleton <ITransactionHashCalculator, TransactionHashCalculator>()
.AddSingleton <IMerkleRootCalculator, BitcoinFlawedMerkleRootCalculator>()
.AddPeerGuards()
.AddMessageSerializers()
.AddProtocolTypeSerializers()
.AddHeaderValidation()
.AddBlockValidation()
.AddMessageProcessors()
.ReplaceServices();
});
return(forgeBuilder);
}
/// <summary>
/// Uses the bitcoin chain.
/// </summary>
/// <param name="forgeBuilder">The forge builder.</param>
/// <returns></returns>
public static IForgeBuilder UseBlazorServer(this IForgeBuilder forgeBuilder)
{
forgeBuilder.AddShard <BlazorServerShard, BlazorServerSettings>(
(hostBuildContext, services) =>
{
});
return(forgeBuilder);
}
public static IForgeBuilder UseBitcoinChain(this IForgeBuilder forgeBuilder)
{
forgeBuilder.AddShard <BitcoinShard, BitcoinSettings>(
(hostBuildContext, services) => {
services
.AddSingleton <IChainDefinition, BitcoinMainDefinition>()
.AddSingleton <INetworkMessageSerializer, VersionMessageSerializer>()
.AddPeerGuards();
});
return(forgeBuilder);
}
public static IForgeBuilder UseBedrockForgeServer(this IForgeBuilder forgeBuilder)
{
forgeBuilder.AddShard <BedrockForgeServer, ForgeServerSettings>(
(hostBuildContext, services) => {
services
.Replace(ServiceDescriptor.Transient <IForgeServer, BedrockForgeServer>())
.AddSingleton <IServerPeerStats, ServerPeerStats>()
;
});
return(forgeBuilder);
}
public static IForgeBuilder UseSerilog(this IForgeBuilder forgeBuilder, string?configurationFile = null)
{
LevelSwitcherManager levelSwitcherManager = new LevelSwitcherManager();
forgeBuilder.AddShard <SerilogShard>((builder, services) =>
{
services.AddSingleton <LevelSwitcherManager>(levelSwitcherManager);
});
forgeBuilder.ExtendInnerHostBuilder(builder =>
{
/// Add and configure Serilog
builder.UseSerilog((hostingContext, loggerConfiguration) =>
{
configurationFile ??= forgeBuilder.ConfigurationFileName;
string absoluteDirectoryPath = Path.GetDirectoryName(Path.GetFullPath(configurationFile)) !;
var configurationFileProvider = new PhysicalFileProvider(absoluteDirectoryPath);
IConfigurationRoot logConfiguration = new ConfigurationBuilder()
.AddJsonFile(configurationFileProvider, Path.GetFileName(configurationFile), false, true)
.SetFileLoadExceptionHandler(fileContext =>
{
using Logger logger = new LoggerConfiguration()
.MinimumLevel.Warning()
.WriteTo.Console()
.CreateLogger();
logger.Warning("Missing log configuration file {MissingLogFileName}, using console and Information level", fileContext.Provider.Source.Path);
fileContext.Ignore = true;
})
.Build();
loggerConfiguration.ReadFrom.Configuration(logConfiguration);
if (!logConfiguration.GetSection("Serilog").Exists())
{
//set default logging if the log file is missing
loggerConfiguration
.MinimumLevel.Information()
.WriteTo.Console();
}
else
{
//create log level switch
levelSwitcherManager.LoadLoggingLevelSwitches(logConfiguration);
levelSwitcherManager.BindLevelSwitches(loggerConfiguration);
}
});
});
return(forgeBuilder);
}
public static IForgeBuilder UseP2PForgeServer(this IForgeBuilder forgeBuilder)
{
forgeBuilder.AddShard <P2PForgeServer, ForgeServerSettings>(
(hostBuildContext, services) => {
services
.Replace(ServiceDescriptor.Transient <IForgeServer, P2PForgeServer>()) //replace fake forgeServer with real one
.AddSingleton <IServerPeerFactory, ServerPeerFactory>()
.AddSingleton <IServerPeerStats, ServerPeerStats>()
.AddSingleton <IPeerConnectionFactory, PeerConnectionFactory>()
;
});
return(forgeBuilder);
}
public static IForgeBuilder UseSerilog(this IForgeBuilder forgeBuilder, string configurationFile = null)
{
forgeBuilder
.ExtendInnerHostBuilder(builder => {
builder.UseSerilog((hostingContext, loggerConfiguration) => {
IConfigurationRoot logConfiguration = new ConfigurationBuilder()
.AddJsonFile(configurationFile ?? forgeBuilder.ConfigurationFileName)
.Build();
loggerConfiguration.ReadFrom.Configuration(logConfiguration);
});
});
return(forgeBuilder);
}
/// <summary>
/// Uses the bitcoin chain.
/// </summary>
/// <param name="forgeBuilder">The forge builder.</param>
/// Useful to include these assemblies that didn't have an entry point and wouldn't be loaded.
/// <returns></returns>
public static IForgeBuilder UseDevController(this IForgeBuilder forgeBuilder)
{
forgeBuilder.AddShard <DevControllerShard, DevControllerSettings>((context, services) =>
{
if (context.GetShardSettings <DevControllerSettings>() !.Enabled)
{
services.AddApiServiceDefinition(new ApiServiceDefinition
{
Area = WebApiArea.AREA_DEV,
Name = "Dev API",
Description = "API useful for debug purpose.",
Version = "v1",
});
}
});
return(forgeBuilder);
}
/// <summary>
/// Uses the bitcoin chain.
/// </summary>
/// <param name="forgeBuilder">The forge builder.</param>
/// <param name="options"></param>
/// <returns></returns>
public static IForgeBuilder UseApi(this IForgeBuilder forgeBuilder, Action <WebApiOptions>?options = null)
{
var optionsInstance = new WebApiOptions();
options?.Invoke(optionsInstance);
optionsInstance.DiscoverControllers();
forgeBuilder.AddShard <WebApiShard, WebApiSettings>((context, services) =>
{
if (optionsInstance.EnablePublicApi)
{
services.AddApiServiceDefinition(new ApiServiceDefinition
{
Enabled = context.GetShardSettings <WebApiSettings>() !.Enabled,
Area = WebApiArea.AREA_API,
Name = "API",
Description = optionsInstance.PublicApiDescription,
Version = "v1",
});
}
/// <summary>
/// Uses the bitcoin chain.
/// </summary>
/// <param name="forgeBuilder">The forge builder.</param>
/// <param name="configuration">The action to configure the collector.</param>
/// <returns></returns>
public static IForgeBuilder UseStatisticsCollector(this IForgeBuilder forgeBuilder, Action <StatisticsCollectorOptions>?configuration = null)
{
var options = new StatisticsCollectorOptions();
configuration?.Invoke(options);
forgeBuilder.AddShard <StatisticsCollectorShard, StatisticsCollectorSettings>(
(hostBuildContext, services) =>
{
services
.AddSingleton <IStatisticFeedsCollector, StatisticFeedsCollector>()
.AddHostedService(sp => sp.GetRequiredService <IStatisticFeedsCollector>())
;
if (options.DumpOnConsoleOnKeyPress == true)
{
services.AddSingleton <ConsoleKeyDumper>();
}
});
return(forgeBuilder);
}
/// <summary>
/// Inject the Example shard.
/// </summary>
/// <param name="forgeBuilder">The forge builder.</param>
/// <param name="minimumSupportedVersion">The minimum version local nodes requires in order to connect to other peers.</param>
/// <param name="currentVersion">The current version local peer aim to use with connected peers.</param>
/// <returns></returns>
public static IForgeBuilder UseExample(this IForgeBuilder forgeBuilder, int minimumSupportedVersion, int currentVersion)
{
if (forgeBuilder is null)
{
throw new ArgumentNullException(nameof(forgeBuilder));
}
forgeBuilder.AddShard <ExampleShard, ExampleSettings>(
(hostBuildContext, services) =>
{
services
.AddSingleton(new NodeImplementation(minimumSupportedVersion, currentVersion))
.AddSingleton <IDateTimeProvider, DateTimeProvider>()
.AddSingleton <IQuoteService, QuoteService>()
.AddPeerGuards()
.AddMessageSerializers()
.AddProtocolTypeSerializers()
.AddMessageProcessors()
.ReplaceServices();
});
return(forgeBuilder);
}
public static IForgeBuilder UseLightningNetwork(this IForgeBuilder forgeBuilder)
{
if (forgeBuilder is null)
{
throw new ArgumentNullException(nameof(forgeBuilder));
}
forgeBuilder.AddShard <LightningNode, LightningNodeSettings>(
(hostBuildContext, services) =>
{
services
.AddSingleton <IDateTimeProvider, DateTimeProvider>()
.AddSingleton <NodeContext>()
.AddMessageSerializers()
.AddProtocolTypeSerializers()
.AddMessageProcessors()
.AddTlvComponents()
.ReplaceServices()
.AddNoiseComponents();
});
return(forgeBuilder);
}
/// <summary>
/// Uses the bedrock framework shard implementation as connectivity provider.
/// </summary>
/// <typeparam name="TNetworkProtocolMessageSerializer">The type of the network message protocol to use to serialize and deserialize messages.
/// It has to implement <see cref="INetworkProtocolMessageSerializer"/>.</typeparam>
/// <param name="forgeBuilder">The forge builder.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException">forgeBuilder</exception>
public static IForgeBuilder UseBedrockNetwork <TNetworkProtocolMessageSerializer>(this IForgeBuilder forgeBuilder) where TNetworkProtocolMessageSerializer : class, INetworkProtocolMessageSerializer
{
if (forgeBuilder is null)
{
throw new System.ArgumentNullException(nameof(forgeBuilder));
}
forgeBuilder.AddShard <BedrockNetworkShard, ForgeConnectivitySettings>(
(hostBuildContext, services) =>
{
services
.Replace(ServiceDescriptor.Singleton <IForgeClientConnectivity, BedrockForgeConnectivity>())
.AddSingleton <IConnectivityPeerStats, ConnectivityPeerStats>()
.AddSingleton <MithrilForgeClientConnectionHandler>()
.AddSingleton <ClientBuilder>()
.AddTransient <INetworkProtocolMessageSerializer, TNetworkProtocolMessageSerializer>()
;
});
return(forgeBuilder);
}
/// <summary>
/// Inject the BitcoinDev shard.
/// </summary>
/// <param name="forgeBuilder">The forge builder.</param>
/// <returns></returns>
public static IForgeBuilder UseBitcoinDev(this IForgeBuilder forgeBuilder)
{
forgeBuilder.AddShard <BitcoinDevShard>((hostBuildContext, services) => { });
return(forgeBuilder);
}
