public static IFullNodeBuilder UsePosConsensus(this IFullNodeBuilder fullNodeBuilder, DbType coindbType = DbType.Leveldb)
{
LoggingConfiguration.RegisterFeatureNamespace <PosConsensusFeature>("posconsensus");
fullNodeBuilder.ConfigureFeature(features =>
{
features
.AddFeature <PosConsensusFeature>()
.FeatureServices(services =>
{
services.ConfigureCoinDatabaseImplementation(coindbType);
services.AddSingleton(provider => (IStakedb)provider.GetService <ICoindb>());
services.AddSingleton <ICoinView, CachedCoinView>();
services.AddSingleton <StakeChainStore>().AddSingleton <IStakeChain, StakeChainStore>(provider => provider.GetService <StakeChainStore>());
services.AddSingleton <IStakeValidator, StakeValidator>();
services.AddSingleton <IRewindDataIndexCache, RewindDataIndexCache>();
services.AddSingleton <IConsensusRuleEngine, PosConsensusRuleEngine>();
services.AddSingleton <IChainState, ChainState>();
services.AddSingleton <ConsensusQuery>()
.AddSingleton <INetworkDifficulty, ConsensusQuery>(provider => provider.GetService <ConsensusQuery>())
.AddSingleton <IGetUnspentTransaction, ConsensusQuery>(provider => provider.GetService <ConsensusQuery>());
services.AddSingleton <IProvenBlockHeaderStore, ProvenBlockHeaderStore>();
if (coindbType == DbType.Leveldb)
{
services.AddSingleton <IProvenBlockHeaderRepository, LevelDbProvenBlockHeaderRepository>();
}
if (coindbType == DbType.RocksDb)
{
services.AddSingleton <IProvenBlockHeaderRepository, RocksDbProvenBlockHeaderRepository>();
}
});
});
return(fullNodeBuilder);
}
/// <summary>
/// Adds a mining feature to the node being initialized.
/// </summary>
/// <param name="fullNodeBuilder">The object used to build the current node.</param>
/// <param name="setup">Callback routine to be called when miner settings are loaded.</param>
/// <returns>The full node builder, enriched with the new component.</returns>
public static IFullNodeBuilder AddMining(this IFullNodeBuilder fullNodeBuilder, Action <MinerSettings> setup = null)
{
LoggingConfiguration.RegisterFeatureNamespace <MiningFeature>("mining");
fullNodeBuilder.ConfigureFeature(features =>
{
features
.AddFeature <MiningFeature>()
.DependOn <MempoolFeature>()
.DependOn <RPCFeature>()
.FeatureServices(services =>
{
services.AddSingleton <PowMining>();
services.AddSingleton <AssemblerFactory, PowAssemblerFactory>();
services.AddSingleton <MinerController>();
services.AddSingleton <MiningRPCController>();
services.AddSingleton <MinerSettings>(new MinerSettings(setup));
});
});
return(fullNodeBuilder);
}
/// <summary>
/// Substitute the <see cref="IDateTimeProvider"/> for a given feature.
/// </summary>
/// <typeparam name="T">The feature to substitute the provider for.</typeparam>
public static IFullNodeBuilder SubstituteDateTimeProviderFor <T>(this IFullNodeBuilder fullNodeBuilder)
{
fullNodeBuilder.ConfigureFeature(features =>
{
IFeatureRegistration feature = features.FeatureRegistrations.FirstOrDefault(f => f.FeatureType == typeof(T));
if (feature != null)
{
feature.FeatureServices(services =>
{
ServiceDescriptor service = services.FirstOrDefault(s => s.ServiceType == typeof(IDateTimeProvider));
if (service != null)
{
services.Remove(service);
}
services.AddSingleton <IDateTimeProvider, GenerateCoinsFastDateTimeProvider>();
});
}
});
return(fullNodeBuilder);
}
public static IFullNodeBuilder Create(string chain, NodeSettings settings)
{
chain = chain.ToUpperInvariant();
IFullNodeBuilder nodeBuilder = CreateBaseBuilder(chain, settings);
switch (chain)
{
case "BTC":
case "XRC":
nodeBuilder.UsePowConsensus().AddMining().UseWallet();
break;
case "X1":
nodeBuilder.UseX1Consensus().UseColdStakingWallet();
break;
case "AMS":
case "X42":
case "BCP":
case "CITY":
case "STRAX":
case "RUTA":
case "EXOS":
case "XDS":
case "XLR":
case "IMPLX":
case "HOME":
case "SERF":
case "CYBITS":
case "CY":
case "SBC":
case "RSC":
nodeBuilder.UsePosConsensus().AddPowPosMining().UseColdStakingWallet();
break;
}
return(nodeBuilder);
}
public static IFullNodeBuilder UseBlockStore(this IFullNodeBuilder fullNodeBuilder, Action <StoreSettings> setup = null)
{
LoggingConfiguration.RegisterFeatureNamespace <BlockStoreFeature>("db");
fullNodeBuilder.ConfigureFeature(features =>
{
features
.AddFeature <BlockStoreFeature>()
.FeatureServices(services =>
{
services.AddSingleton <IBlockRepository, BlockRepository>();
services.AddSingleton <IBlockStoreCache, BlockStoreCache>();
services.AddSingleton <StoreBlockPuller>();
services.AddSingleton <BlockStoreLoop>();
services.AddSingleton <BlockStoreManager>();
services.AddSingleton <BlockStoreSignaled>();
services.AddSingleton <StoreSettings>(new StoreSettings(setup));
});
});
return(fullNodeBuilder);
}
public static IFullNodeBuilder MockIBD(this IFullNodeBuilder fullNodeBuilder)
{
fullNodeBuilder.ConfigureFeature(features =>
{
foreach (IFeatureRegistration feature in features.FeatureRegistrations)
{
feature.FeatureServices(services =>
{
// Get default IBD implementation and replace it with the mock.
ServiceDescriptor ibdService = services.FirstOrDefault(x => x.ServiceType == typeof(IInitialBlockDownloadState));
if (ibdService != null)
{
services.Remove(ibdService);
services.AddSingleton <IInitialBlockDownloadState, InitialBlockDownloadStateMock>();
}
});
}
});
return(fullNodeBuilder);
}
public static IFullNodeBuilder UseMempool(this IFullNodeBuilder fullNodeBuilder)
{
fullNodeBuilder.ConfigureFeature(features =>
{
features
.AddFeature <MempoolFeature>()
.FeatureServices(services =>
{
services.AddSingleton <MempoolScheduler>();
services.AddSingleton <TxMempool>();
services.AddSingleton <FeeRate>(MempoolValidator.MinRelayTxFee);
services.AddSingleton <MempoolValidator>();
services.AddSingleton <MempoolOrphans>();
services.AddSingleton <MempoolManager>();
services.AddSingleton <MempoolBehavior>();
services.AddSingleton <MempoolSignaled>();
services.AddSingleton <IMempoolPersistence, MempoolPersistence>();
});
});
return(fullNodeBuilder);
}
public static IFullNodeBuilder UseStratisConsensus(this IFullNodeBuilder fullNodeBuilder)
{
LoggingConfiguration.RegisterFeatureNamespace <ConsensusFeature>("consensus");
LoggingConfiguration.RegisterFeatureClass <ConsensusStats>("bench");
fullNodeBuilder.ConfigureFeature(features =>
{
features
.AddFeature <ConsensusFeature>()
.FeatureServices(services =>
{
fullNodeBuilder.Network.Consensus.Options = new PosConsensusOptions();
if (fullNodeBuilder.NodeSettings.Testnet)
{
fullNodeBuilder.Network.Consensus.Option <PosConsensusOptions>().CoinbaseMaturity = 10;
fullNodeBuilder.Network.Consensus.Option <PosConsensusOptions>().StakeMinConfirmations = 10;
}
services.AddSingleton <ICheckpoints, Checkpoints>();
services.AddSingleton <PowConsensusValidator, PosConsensusValidator>();
services.AddSingleton <DBreezeCoinView>();
services.AddSingleton <CoinView, CachedCoinView>();
services.AddSingleton <LookaheadBlockPuller>();
services.AddSingleton <ConsensusLoop>();
services.AddSingleton <StakeChainStore>().AddSingleton <StakeChain, StakeChainStore>(provider => provider.GetService <StakeChainStore>());
services.AddSingleton <StakeValidator>();
services.AddSingleton <ConsensusManager>().AddSingleton <IBlockDownloadState, ConsensusManager>().AddSingleton <INetworkDifficulty, ConsensusManager>();
services.AddSingleton <ConsensusController>();
services.AddSingleton <ConsensusStats>();
services.AddSingleton <ConsensusSettings>();
services.AddSingleton <IConsensusRules, ConsensusRules>();
services.AddSingleton <IRuleRegistration, CoreConsensusRules>();
});
});
return(fullNodeBuilder);
}
public static IFullNodeBuilder UsePosConsensus(this IFullNodeBuilder fullNodeBuilder)
{
LoggingConfiguration.RegisterFeatureNamespace <ConsensusFeature>("consensus");
LoggingConfiguration.RegisterFeatureClass <ConsensusStats>("bench");
fullNodeBuilder.ConfigureFeature(features =>
{
features
.AddFeature <ConsensusFeature>()
.FeatureServices(services =>
{
fullNodeBuilder.Network.Consensus.Options = new PosConsensusOptions();
if (fullNodeBuilder.Network.IsTest())
{
fullNodeBuilder.Network.Consensus.Option <PosConsensusOptions>().CoinbaseMaturity = 10;
}
services.AddSingleton <ICheckpoints, Checkpoints>();
services.AddSingleton <DBreezeCoinView>();
services.AddSingleton <CoinView, CachedCoinView>();
services.AddSingleton <LookaheadBlockPuller>().AddSingleton <ILookaheadBlockPuller, LookaheadBlockPuller>(provider => provider.GetService <LookaheadBlockPuller>());;
services.AddSingleton <IConsensusLoop, ConsensusLoop>()
.AddSingleton <INetworkDifficulty, ConsensusLoop>(provider => provider.GetService <IConsensusLoop>() as ConsensusLoop)
.AddSingleton <IGetUnspentTransaction, ConsensusLoop>(provider => provider.GetService <IConsensusLoop>() as ConsensusLoop);
services.AddSingleton <StakeChainStore>().AddSingleton <IStakeChain, StakeChainStore>(provider => provider.GetService <StakeChainStore>());
services.AddSingleton <IStakeValidator, StakeValidator>();
services.AddSingleton <IInitialBlockDownloadState, InitialBlockDownloadState>();
services.AddSingleton <ConsensusController>();
services.AddSingleton <ConsensusStats>();
services.AddSingleton <ConsensusSettings>();
services.AddSingleton <IConsensusRules, PosConsensusRules>();
services.AddSingleton <IRuleRegistration, PosConsensusRulesRegistration>();
});
});
return(fullNodeBuilder);
}
public static IFullNodeBuilder UseFederatedPegPoAMining(this IFullNodeBuilder fullNodeBuilder)
{
fullNodeBuilder.ConfigureFeature(
features =>
{
features.AddFeature <PoAFeature>().DependOn <FederationGatewayFeature>().FeatureServices(
services =>
{
services.AddSingleton <FederationManager>();
services.AddSingleton <PoABlockHeaderValidator>();
services.AddSingleton <IPoAMiner, PoAMiner>();
services.AddSingleton <SlotsManager>();
services.AddSingleton <BlockDefinition, FederatedPegBlockDefinition>();
services.AddSingleton <IBlockBufferGenerator, BlockBufferGenerator>();
});
});
LoggingConfiguration.RegisterFeatureNamespace <ConsensusFeature>("consensus");
fullNodeBuilder.ConfigureFeature(
features =>
{
features.AddFeature <ConsensusFeature>().FeatureServices(
services =>
{
services.AddSingleton <DBreezeCoinView>();
services.AddSingleton <ICoinView, CachedCoinView>();
services.AddSingleton <ConsensusController>();
services.AddSingleton <IConsensusRuleEngine, SmartContractPoARuleEngine>();
services.AddSingleton <IChainState, ChainState>();
services.AddSingleton <ConsensusQuery>()
.AddSingleton <INetworkDifficulty, ConsensusQuery>(provider => provider.GetService <ConsensusQuery>())
.AddSingleton <IGetUnspentTransaction, ConsensusQuery>(provider => provider.GetService <ConsensusQuery>());
new SmartContractPoARuleRegistration(fullNodeBuilder.Network).RegisterRules(fullNodeBuilder.Network.Consensus);
});
});
return(fullNodeBuilder);
}
public static IFullNodeBuilder UseFederatedPegPoAMining(this IFullNodeBuilder fullNodeBuilder)
{
fullNodeBuilder.ConfigureFeature(features =>
{
features.AddFeature <PoAFeature>().DependOn <FederationGatewayFeature>().FeatureServices(services =>
{
services.AddSingleton <FederationManager>();
services.AddSingleton <PoABlockHeaderValidator>();
services.AddSingleton <IPoAMiner, PoAMiner>();
services.AddSingleton <SlotsManager>();
services.AddSingleton <BlockDefinition, FederatedPegBlockDefinition>();
services.AddSingleton <IBlockBufferGenerator, BlockBufferGenerator>();
});
});
// TODO: Consensus and Mining should be separated. Sidechain nodes don't need any of the Federation code but do need Consensus.
// In the dependency tree as it is currently however, consensus is dependent on PoAFeature (needs SlotManager) which is in turn dependent on
// FederationGatewayFeature. https://github.com/stratisproject/FederatedSidechains/issues/273
LoggingConfiguration.RegisterFeatureNamespace <ConsensusFeature>("consensus");
fullNodeBuilder.ConfigureFeature(features =>
{
features.AddFeature <ConsensusFeature>().FeatureServices(services =>
{
services.AddSingleton <DBreezeCoinView>();
services.AddSingleton <ICoinView, CachedCoinView>();
services.AddSingleton <ConsensusController>();
services.AddSingleton <IConsensusRuleEngine, SmartContractPoARuleEngine>();
services.AddSingleton <IChainState, ChainState>();
services.AddSingleton <ConsensusQuery>()
.AddSingleton <INetworkDifficulty, ConsensusQuery>(provider => provider.GetService <ConsensusQuery>())
.AddSingleton <IGetUnspentTransaction, ConsensusQuery>(provider => provider.GetService <ConsensusQuery>());
new SmartContractPoARuleRegistration(fullNodeBuilder.Network).RegisterRules(fullNodeBuilder.Network.Consensus);
});
});
return(fullNodeBuilder);
}
public static IFullNodeBuilder UseWallet(this IFullNodeBuilder fullNodeBuilder)
{
LoggingConfiguration.RegisterFeatureNamespace <WalletFeature>("wallet");
fullNodeBuilder.ConfigureFeature(features =>
{
features
.AddFeature <WalletFeature>()
.FeatureServices(services =>
{
services.AddSingleton <IWalletSyncManager, WalletSyncManager>();
services.AddSingleton <IWalletTransactionHandler, WalletTransactionHandler>();
services.AddSingleton <IWalletManager, WalletManager>();
services.AddSingleton <IWalletFeePolicy, WalletFeePolicy>();
services.AddSingleton <WalletController>();
services.AddSingleton <WalletRPCController>();
services.AddSingleton <IBroadcasterManager, FullNodeBroadcasterManager>();
services.AddSingleton <BroadcasterBehavior>();
});
});
return(fullNodeBuilder);
}
public static IFullNodeBuilder AddSimpleWallet(this IFullNodeBuilder fullNodeBuilder)
{
Stratis.Bitcoin.Configuration.Logging.LoggingConfiguration.RegisterFeatureNamespace <SimpleWalletFeature>("simplewallet");
fullNodeBuilder.ConfigureFeature(features =>
{
features
.AddFeature <SimpleWalletFeature>()
//.DependOn<BlockStoreFeature>()
.DependOn <BlockNotificationFeature>()
.DependOn <TransactionNotificationFeature>()
.FeatureServices(services =>
{
services.AddSingleton(fullNodeBuilder); // We need this?
services.AddSingleton <HubCommands>();
services.AddTransient <SimpleWalletManager>();
services.AddSingleton <SimpleWalletService>();
services.AddSingleton <SimpleWalletSettings>();
});
});
return(fullNodeBuilder);
}
public static IFullNodeBuilder UseApi(this IFullNodeBuilder fullNodeBuilder,
Action <ApiFeatureOptions> optionsAction = null)
{
// TODO: move the options in to the feature builder
var options = new ApiFeatureOptions();
optionsAction?.Invoke(options);
fullNodeBuilder.ConfigureFeature(features =>
{
features
.AddFeature <ApiFeature>()
.FeatureServices(services =>
{
services.AddSingleton(fullNodeBuilder);
services.AddSingleton(options);
services.AddSingleton <ApiSettings>();
services.AddSingleton <ICertificateStore, CertificateStore>();
});
});
return(fullNodeBuilder);
}
/// <summary>
/// Configures the node with the smart contract proof of stake consensus model.
/// </summary>
public static IFullNodeBuilder UseSmartContractPosConsensus(this IFullNodeBuilder fullNodeBuilder)
{
LoggingConfiguration.RegisterFeatureNamespace <ConsensusFeature>("consensus");
fullNodeBuilder.ConfigureFeature(features =>
{
features
.AddFeature <ConsensusFeature>()
.FeatureServices(services =>
{
services.AddSingleton <DBreezeCoinView>();
services.AddSingleton <ICoinView, CachedCoinView>();
services.AddSingleton <StakeChainStore>().AddSingleton <IStakeChain, StakeChainStore>(provider => provider.GetService <StakeChainStore>());
services.AddSingleton <IStakeValidator, StakeValidator>();
services.AddSingleton <ConsensusController>();
services.AddSingleton <IConsensusRuleEngine, SmartContractPosConsensusRuleEngine>();
new SmartContractPosRuleRegistration().RegisterRules(fullNodeBuilder.Network.Consensus);
});
});
return(fullNodeBuilder);
}
public static IFullNodeBuilder UsePowConsensus(this IFullNodeBuilder fullNodeBuilder, DbType coindbType = DbType.Leveldb)
{
LoggingConfiguration.RegisterFeatureNamespace <PowConsensusFeature>("powconsensus");
fullNodeBuilder.ConfigureFeature(features =>
{
features
.AddFeature <PowConsensusFeature>()
.FeatureServices(services =>
{
AddCoindbImplementation(services, coindbType);
services.AddSingleton <ConsensusOptions, ConsensusOptions>();
services.AddSingleton <ICoinView, CachedCoinView>();
services.AddSingleton <IConsensusRuleEngine, PowConsensusRuleEngine>();
services.AddSingleton <IChainState, ChainState>();
services.AddSingleton <ConsensusQuery>()
.AddSingleton <INetworkDifficulty, ConsensusQuery>(provider => provider.GetService <ConsensusQuery>())
.AddSingleton <IGetUnspentTransaction, ConsensusQuery>(provider => provider.GetService <ConsensusQuery>());
});
});
return(fullNodeBuilder);
}
public static IFullNodeBuilder AddRPC(this IFullNodeBuilder fullNodeBuilder, Action <RpcSettings> setup = null)
{
LoggingConfiguration.RegisterFeatureNamespace <RPCFeature>("rpc");
fullNodeBuilder.ConfigureFeature(features =>
{
features
.AddFeature <RPCFeature>()
.DependOn <ConsensusFeature>()
.FeatureServices(services => services.AddSingleton(fullNodeBuilder));
});
fullNodeBuilder.ConfigureServices(service =>
{
service.AddSingleton <FullNodeController>();
service.AddSingleton <ConnectionManagerController>();
service.AddSingleton <RpcSettings>(new RpcSettings(setup));
service.AddSingleton <IRPCClientFactory, RPCClientFactory>();
service.AddSingleton <RPCController>();
});
return(fullNodeBuilder);
}
/// <summary>
/// Configures the node with the smart contract proof of work consensus model.
/// </summary>
public static IFullNodeBuilder UseSmartContractConsensus(this IFullNodeBuilder fullNodeBuilder)
{
LoggingConfiguration.RegisterFeatureNamespace <ConsensusFeature>("consensus");
fullNodeBuilder.ConfigureFeature(features =>
{
features
.AddFeature <ConsensusFeature>()
.DependOn <SmartContractFeature>()
.FeatureServices(services =>
{
services.AddSingleton <ConsensusOptions, ConsensusOptions>();
services.AddSingleton <DBreezeCoinView>();
services.AddSingleton <ICoinView, CachedCoinView>();
services.AddSingleton <ConsensusController>();
services.AddSingleton <IConsensusRuleEngine, SmartContractPowConsensusRuleEngine>();
new SmartContractPowRuleRegistration().RegisterRules(fullNodeBuilder.Network.Consensus);
});
});
return(fullNodeBuilder);
}
/// <summary>
/// Adds mining to the smart contract node.
/// <para>We inject <see cref="IPowMining"/> with a smart contract block provider and definition.</para>
/// </summary>
public static IFullNodeBuilder UseSmartContractPowMining(this IFullNodeBuilder fullNodeBuilder)
{
LoggingConfiguration.RegisterFeatureNamespace <MiningFeature>("mining");
fullNodeBuilder.ConfigureFeature(features =>
{
features
.AddFeature <MiningFeature>()
.DependOn <MempoolFeature>()
.DependOn <RPCFeature>()
.DependOn <SmartContractWalletFeature>()
.FeatureServices(services =>
{
services.AddSingleton <IPowMining, PowMining>();
services.AddSingleton <IBlockProvider, SmartContractBlockProvider>();
services.AddSingleton <BlockDefinition, SmartContractBlockDefinition>();
services.AddSingleton <IBlockBufferGenerator, BlockBufferGenerator>();
services.AddSingleton <MinerSettings>();
});
});
return(fullNodeBuilder);
}
public static IFullNodeBuilder UseColdStakingWallet(this IFullNodeBuilder fullNodeBuilder)
{
// Ensure that this feature is only used on a Stratis network.
if (!fullNodeBuilder.Network.Consensus.IsProofOfStake)
{
throw new InvalidOperationException("Cold staking can only be used on a Stratis network.");
}
// Register the cold staking script template.
fullNodeBuilder.Network.StandardScriptsRegistry.RegisterStandardScriptTemplate(ColdStakingScriptTemplate.Instance);
LoggingConfiguration.RegisterFeatureNamespace <ColdStakingFeature>("wallet");
fullNodeBuilder.UseWallet();
fullNodeBuilder.ConfigureFeature(features =>
{
features
.AddFeature <ColdStakingFeature>()
.DependOn <MempoolFeature>()
.DependOn <BlockStoreFeature>()
.DependOn <RPCFeature>()
.FeatureServices(services =>
{
services.RemoveSingleton <IWalletManager>();
services.AddSingleton <IWalletManager, ColdStakingManager>();
services.RemoveSingleton <IWalletService>();
services.AddSingleton <IWalletService, ColdStakingWalletService>();
services.AddSingleton <ScriptAddressReader>();
services.Replace(new ServiceDescriptor(typeof(IScriptAddressReader), typeof(ColdStakingDestinationReader), ServiceLifetime.Singleton));
});
});
return(fullNodeBuilder);
}
public static IFullNodeBuilder UseSmartContractWallet(this IFullNodeBuilder fullNodeBuilder, bool addVanillaWallet = true)
{
LoggingConfiguration.RegisterFeatureNamespace <WalletFeature>("smart contract wallet");
if (addVanillaWallet)
{
fullNodeBuilder.UseWallet();
}
fullNodeBuilder.ConfigureFeature(features =>
{
features
.AddFeature <SmartContractWalletFeature>()
.DependOn <BaseWalletFeature>()
.FeatureServices(services =>
{
// Registers the ScriptAddressReader concrete type and replaces the IScriptAddressReader implementation
// with SmartContractScriptAddressReader, which depends on the ScriptAddressReader concrete type.
services.AddSingleton <ScriptAddressReader>();
services.Replace(new ServiceDescriptor(typeof(IScriptAddressReader), typeof(SmartContractScriptAddressReader), ServiceLifetime.Singleton));
services.RemoveAll(typeof(StandardTransactionPolicy));
services.AddSingleton <StandardTransactionPolicy, SmartContractTransactionPolicy>();
services.RemoveAll(typeof(WalletTransactionHandler));
services.RemoveAll(typeof(IWalletTransactionHandler));
services.AddSingleton <IWalletTransactionHandler, SmartContractWalletTransactionHandler>();
services.RemoveAll(typeof(ISmartContractTransactionService));
services.AddSingleton <ISmartContractTransactionService, SmartContractTransactionService>();
services.AddTransient <WalletRPCController>();
});
});
return(fullNodeBuilder);
}
/// <summary>
/// Configures the node with the smart contract proof of work consensus model.
/// </summary>
public static IFullNodeBuilder UseSmartContractConsensus(this IFullNodeBuilder fullNodeBuilder)
{
LoggingConfiguration.RegisterFeatureNamespace <ConsensusFeature>("consensus");
LoggingConfiguration.RegisterFeatureClass <ConsensusStats>("bench");
fullNodeBuilder.ConfigureFeature(features =>
{
features
.AddFeature <ConsensusFeature>()
.DependOn <SmartContractFeature>()
.FeatureServices(services =>
{
fullNodeBuilder.Network.Consensus.Options = new ConsensusOptions();
services.AddSingleton <ICheckpoints, Checkpoints>();
services.AddSingleton <ConsensusOptions, ConsensusOptions>();
services.AddSingleton <DBreezeCoinView>();
services.AddSingleton <ICoinView, CachedCoinView>();
services.AddSingleton <LookaheadBlockPuller>().AddSingleton <ILookaheadBlockPuller, LookaheadBlockPuller>(provider => provider.GetService <LookaheadBlockPuller>());
services.AddSingleton <IConsensusLoop, ConsensusLoop>()
.AddSingleton <INetworkDifficulty, ConsensusLoop>(provider => provider.GetService <IConsensusLoop>() as ConsensusLoop)
.AddSingleton <IGetUnspentTransaction, ConsensusLoop>(provider => provider.GetService <IConsensusLoop>() as ConsensusLoop);
services.AddSingleton <IInitialBlockDownloadState, InitialBlockDownloadState>();
services.AddSingleton <ConsensusController>();
services.AddSingleton <ConsensusStats>();
services.AddSingleton <ConsensusSettings>();
services.AddSingleton <IConsensusRules, SmartContractPowConsensusRuleEngine>();
fullNodeBuilder.Network.Consensus.Rules = new SmartContractPowRuleRegistration().GetRules();
});
});
return(fullNodeBuilder);
}
/// <summary>
/// Include the memory pool feature and related services in the full node.
/// </summary>
/// <param name="fullNodeBuilder">Full node builder.</param>
/// <returns>Full node builder.</returns>
public static IFullNodeBuilder UseMempool(this IFullNodeBuilder fullNodeBuilder)
{
LoggingConfiguration.RegisterFeatureNamespace <MempoolFeature>("mempool");
LoggingConfiguration.RegisterFeatureNamespace <BlockPolicyEstimator>("estimatefee");
fullNodeBuilder.ConfigureFeature(features =>
{
features
.AddFeature <MempoolFeature>()
.DependOn <ConsensusFeature>()
.FeatureServices(services =>
{
services.AddSingleton <MempoolSchedulerLock>();
services.AddSingleton <ITxMempool, TxMempool>();
services.AddSingleton <BlockPolicyEstimator>();
services.AddSingleton <IMempoolValidator, MempoolValidator>();
services.AddSingleton <MempoolOrphans>();
services.AddSingleton <MempoolManager>()
.AddSingleton <IPooledTransaction, MempoolManager>(provider => provider.GetService <MempoolManager>())
.AddSingleton <IPooledGetUnspentTransaction, MempoolManager>(provider => provider.GetService <MempoolManager>());
services.AddSingleton <MempoolBehavior>();
services.AddSingleton <FeeFilterBehavior>();
services.AddSingleton <MempoolSignaled>();
services.AddSingleton <BlocksDisconnectedSignaled>();
services.AddSingleton <IMempoolPersistence, MempoolPersistence>();
services.AddSingleton <MempoolSettings>();
services.AddSingleton <IBroadcastCheck, MempoolBroadcastCheck>();
foreach (var ruleType in fullNodeBuilder.Network.Consensus.MempoolRules)
{
services.AddSingleton(typeof(IMempoolRule), ruleType);
}
});
});
return(fullNodeBuilder);
}
public static IFullNodeBuilder UseX1Wallet(this IFullNodeBuilder fullNodeBuilder)
{
if (!fullNodeBuilder.Network.Consensus.IsProofOfStake)
{
throw new InvalidOperationException("A Proof-of-Stake network is required.");
}
// Register the cold staking script template.
fullNodeBuilder.Network.StandardScriptsRegistry.RegisterStandardScriptTemplate(ColdStakingScriptTemplate.Instance);
LoggingConfiguration.RegisterFeatureNamespace <X1WalletFeature>(nameof(X1WalletFeature));
fullNodeBuilder.ConfigureFeature(features =>
{
features
.AddFeature <X1WalletFeature>()
.DependOn <MempoolFeature>()
.DependOn <BlockStoreFeature>()
.FeatureServices(services =>
{
services.AddSingleton <NodeServices>();
services.AddSingleton <WalletManagerFactory>();
services.AddSingleton <BlockDefinition, PowBlockDefinition>();
services.AddSingleton <BlockDefinition, PosBlockDefinition>();
services.AddSingleton <BlockDefinition, PosPowBlockDefinition>();
services.AddSingleton <IBlockProvider, BlockProvider>();
services.AddSingleton <IPowMining, PowMining>();
services.AddSingleton <WalletSettings>();
services.AddTransient <WalletController>();
services.AddSingleton <IBroadcasterManager, FullNodeBroadcasterManager>();
services.AddSingleton <BroadcasterBehavior>();
services.AddSingleton <MinerSettings>();
});
});
return(fullNodeBuilder);
}
/// <summary>
/// Makes the full node use all the required features - <see cref="BaseFeature"/>.
/// </summary>
/// <param name="fullNodeBuilder">Builder responsible for creating the node.</param>
/// <returns>Full node builder's interface to allow fluent code.</returns>
public static IFullNodeBuilder UseBaseFeature(this IFullNodeBuilder fullNodeBuilder)
{
fullNodeBuilder.ConfigureFeature(features =>
{
features
.AddFeature <BaseFeature>()
.FeatureServices(services =>
{
services.AddSingleton <DBreezeSerializer>();
services.AddSingleton(fullNodeBuilder.NodeSettings.LoggerFactory);
services.AddSingleton(fullNodeBuilder.NodeSettings.DataFolder);
services.AddSingleton <INodeLifetime, NodeLifetime>();
services.AddSingleton <IPeerBanning, PeerBanning>();
services.AddSingleton <FullNodeFeatureExecutor>();
services.AddSingleton <Signals.Signals>().AddSingleton <ISignals, Signals.Signals>(provider => provider.GetService <Signals.Signals>());
services.AddSingleton <FullNode>().AddSingleton((provider) => { return(provider.GetService <FullNode>() as IFullNode); });
services.AddSingleton <ConcurrentChain>(new ConcurrentChain(fullNodeBuilder.Network));
services.AddSingleton <IDateTimeProvider>(DateTimeProvider.Default);
services.AddSingleton <IInvalidBlockHashStore, InvalidBlockHashStore>();
services.AddSingleton <ChainState>();
services.AddSingleton <ChainRepository>();
services.AddSingleton <TimeSyncBehaviorState>();
services.AddSingleton <IAsyncLoopFactory, AsyncLoopFactory>();
services.AddSingleton <NodeDeployments>();
// Connection
services.AddSingleton <INetworkPeerFactory, NetworkPeerFactory>();
services.AddSingleton <NetworkPeerConnectionParameters>(new NetworkPeerConnectionParameters());
services.AddSingleton <IConnectionManager, ConnectionManager>();
// Peer address manager
services.AddSingleton <IPeerAddressManager, PeerAddressManager>();
});
});
return(fullNodeBuilder);
}
/// <summary>
/// Adds a mining feature to the node being initialized.
/// </summary>
/// <param name="fullNodeBuilder">The object used to build the current node.</param>
/// <param name="setup">Callback routine to be called when miner settings are loaded.</param>
/// <returns>The full node builder, enriched with the new component.</returns>
public static IFullNodeBuilder AddMining(this IFullNodeBuilder fullNodeBuilder, Action <MinerSettings> setup = null)
{
LoggingConfiguration.RegisterFeatureNamespace <MiningFeature>("mining");
fullNodeBuilder.ConfigureFeature(features =>
{
features
.AddFeature <MiningFeature>()
.DependOn <MempoolFeature>()
.DependOn <RPCFeature>()
.DependOn <WalletFeature>()
.FeatureServices(services =>
{
services.AddSingleton <IPowMining, PowMining>();
services.AddSingleton <IBlockProvider, BlockProvider>();
services.AddSingleton <BlockDefinition, PowBlockDefinition>();
services.AddSingleton <MinerController>();
services.AddSingleton <MiningRPCController>();
services.AddSingleton <MinerSettings>(new MinerSettings(setup));
});
});
return(fullNodeBuilder);
}
public static IFullNodeBuilder UseTumbleBit(this IFullNodeBuilder fullNodeBuilder, Uri serverAddress)
{
fullNodeBuilder.ConfigureFeature(features =>
{
features
.AddFeature <TumbleBitFeature>()
.FeatureServices(services =>
{
JsonConvert.DefaultSettings = () => new JsonSerializerSettings
{
Formatting = Formatting.Indented,
ContractResolver = new CamelCasePropertyNamesContractResolver(),
Converters = new List <JsonConverter> {
new NetworkConverter()
}
};
services.AddSingleton <ITumbleBitManager, TumbleBitManager> ();
services.AddSingleton <TumbleBitController>();
});
});
return(fullNodeBuilder);
}
public static IFullNodeBuilder AddFederationGateway(this IFullNodeBuilder fullNodeBuilder)
{
LoggingConfiguration.RegisterFeatureNamespace <FederationGatewayFeature>(
FederationGatewayFeature.FederationGatewayFeatureNamespace);
fullNodeBuilder.ConfigureFeature(features =>
{
features.AddFeature <FederationGatewayFeature>().DependOn <BlockNotificationFeature>().FeatureServices(
services =>
{
services.AddSingleton <IHttpClientFactory, HttpClientFactory>();
services.AddSingleton <IMaturedBlockReceiver, MaturedBlockReceiver>();
services.AddSingleton <IMaturedBlocksRequester, RestMaturedBlockRequester>();
services.AddSingleton <IMaturedBlockSender, RestMaturedBlockSender>();
services.AddSingleton <IMaturedBlocksProvider, MaturedBlocksProvider>();
services.AddSingleton <IBlockTipSender, RestBlockTipSender>();
services.AddSingleton <IFederationGatewaySettings, FederationGatewaySettings>();
services.AddSingleton <IOpReturnDataReader, OpReturnDataReader>();
services.AddSingleton <IDepositExtractor, DepositExtractor>();
services.AddSingleton <IWithdrawalExtractor, WithdrawalExtractor>();
services.AddSingleton <IWithdrawalReceiver, WithdrawalReceiver>();
services.AddSingleton <IEventPersister, EventsPersister>();
services.AddSingleton <FederationGatewayController>();
services.AddSingleton <IFederationWalletSyncManager, FederationWalletSyncManager>();
services.AddSingleton <IFederationWalletTransactionHandler, FederationWalletTransactionHandler>();
services.AddSingleton <IFederationWalletManager, FederationWalletManager>();
services.AddSingleton <ILeaderProvider, LeaderProvider>();
services.AddSingleton <FederationWalletController>();
services.AddSingleton <ICrossChainTransferStore, CrossChainTransferStore>();
services.AddSingleton <ILeaderReceiver, LeaderReceiver>();
services.AddSingleton <ISignedMultisigTransactionBroadcaster, SignedMultisigTransactionBroadcaster>();
services.AddSingleton <IPartialTransactionRequester, PartialTransactionRequester>();
});
});
return(fullNodeBuilder);
}
/// <summary>This is mandatory for all PoA networks.</summary>
public static IFullNodeBuilder UsePoAConsensus(this IFullNodeBuilder fullNodeBuilder)
{
fullNodeBuilder.ConfigureFeature(features =>
{
features
.AddFeature <PoAFeature>()
.DependOn <ConsensusFeature>()
.FeatureServices(services =>
{
services.AddSingleton <FederationManager>();
services.AddSingleton <PoABlockHeaderValidator>();
services.AddSingleton <PoAMiner>();
});
});
LoggingConfiguration.RegisterFeatureNamespace <ConsensusFeature>("consensus");
fullNodeBuilder.ConfigureFeature(features =>
{
features
.AddFeature <ConsensusFeature>()
.FeatureServices(services =>
{
services.AddSingleton <DBreezeCoinView>();
services.AddSingleton <ICoinView, CachedCoinView>();
services.AddSingleton <ConsensusController>();
services.AddSingleton <IConsensusRuleEngine, PowConsensusRuleEngine>(); // TODO POA: PoA rule engine?
services.AddSingleton <IChainState, ChainState>();
services.AddSingleton <ConsensusQuery>()
.AddSingleton <INetworkDifficulty, ConsensusQuery>(provider => provider.GetService <ConsensusQuery>())
.AddSingleton <IGetUnspentTransaction, ConsensusQuery>(provider => provider.GetService <ConsensusQuery>());
new PoAConsensusRulesRegistration().RegisterRules(fullNodeBuilder.Network.Consensus);
});
});
return(fullNodeBuilder);
}
/// <summary>
/// Adds POW and POS miner components to the node, so that it can mine or stake.
/// </summary>
/// <param name="fullNodeBuilder">The object used to build the current node.</param>
/// <returns>The full node builder, enriched with the new component.</returns>
public static IFullNodeBuilder AddPowPosMining(this IFullNodeBuilder fullNodeBuilder, bool straxMode)
{
LoggingConfiguration.RegisterFeatureNamespace <MiningFeature>("mining");
fullNodeBuilder.ConfigureFeature(features =>
{
features
.AddFeature <MiningFeature>()
.DependOn <MempoolFeature>()
.DependOn <RPCFeature>()
// TODO: Need a better way to check dependencies. This is really just dependent on IWalletManager...
// Alternatively "DependsOn" should take a list of features that will satisfy the dependency.
//.DependOn<WalletFeature>()
.FeatureServices(services =>
{
services.AddSingleton <IPowMining, PowMining>();
if (straxMode)
{
services.AddSingleton <IPosMinting, StraxMinting>();
}
else
{
services.AddSingleton <IPosMinting, PosMinting>();
}
services.AddSingleton <IBlockProvider, BlockProvider>();
services.AddSingleton <BlockDefinition, PowBlockDefinition>();
services.AddSingleton <BlockDefinition, PosBlockDefinition>();
services.AddSingleton <BlockDefinition, PosPowBlockDefinition>();
services.AddSingleton <MinerSettings>();
});
});
return(fullNodeBuilder);
}
