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); }