public DeltaHistoryRequestObserver(IPeerSettings peerSettings,
ILogger logger,
IHashProvider hashProvider)
: base(logger, peerSettings)
{
_hashProvider = hashProvider;
}
public GetMempoolRequestObserver(IPeerSettings peerSettings,
IMempool <MempoolDocument> mempool,
ILogger logger)
: base(logger, peerSettings)
{
_mempool = mempool;
}
public PoaDiscovery(IPeerSettings peerSettings, IPeerRepository peerRepository, IFileSystem fileSystem, ILogger logger)
{
_peerSettings = peerSettings;
_peerRepository = peerRepository;
_fileSystem = fileSystem;
_logger = logger;
}
public Web3EthApi(IStateReader stateReader,
IDeltaResolver deltaResolver,
IDeltaCache deltaCache,
IDeltaExecutor executor,
IStorageProvider storageProvider,
IStateProvider stateProvider,
ITransactionRepository receipts,
ITransactionReceivedEvent transactionReceived,
IPeerRepository peerRepository,
IMempool <PublicEntryDao> mempoolRepository,
IDfsService dfsService,
IHashProvider hashProvider,
SyncState syncState,
IMapperProvider mapperProvider,
IPeerSettings peerSettings)
{
_receipts = receipts;
_transactionReceived = transactionReceived ?? throw new ArgumentNullException(nameof(transactionReceived));
HashProvider = hashProvider;
_peerId = peerSettings.PeerId;
_mempoolRepository = mempoolRepository;
PeerRepository = peerRepository;
_mapperProvider = mapperProvider;
StateReader = stateReader ?? throw new ArgumentNullException(nameof(stateReader));
DeltaResolver = deltaResolver ?? throw new ArgumentNullException(nameof(deltaResolver));
DeltaCache = deltaCache ?? throw new ArgumentNullException(nameof(deltaCache));
Executor = executor ?? throw new ArgumentNullException(nameof(executor));
StorageProvider = storageProvider ?? throw new ArgumentNullException(nameof(storageProvider));
StateProvider = stateProvider ?? throw new ArgumentNullException(nameof(stateProvider));
DfsService = dfsService;
SyncState = syncState;
}
public BroadcastRawTransactionRequestObserver(ILogger logger,
IPeerSettings peerSettings,
ITransactionReceivedEvent transactionReceivedEvent)
: base(logger, peerSettings)
{
_transactionReceivedEvent = transactionReceivedEvent;
}
public PeerBlackListingRequestObserver(IPeerSettings peerSettings,
ILogger logger,
IPeerRepository peerRepository)
: base(logger, peerSettings)
{
_peerRepository = peerRepository;
}
protected RequestObserverBase(ILogger logger, IPeerSettings peerSettings) : base(logger, typeof(TProtoReq).ShortenedProtoFullName())
{
Guard.Argument(typeof(TProtoReq), nameof(TProtoReq)).Require(t => t.IsRequestType(),
t => $"{nameof(TProtoReq)} is not of type {MessageTypes.Request.Name}");
PeerSettings = peerSettings;
logger.Verbose("{interface} instantiated", nameof(IRequestMessageObserver));
}
public DeltaBuilderTests()
{
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256"));
_random = new Random();
_randomFactory = Substitute.For <IDeterministicRandomFactory>();
_randomFactory.GetDeterministicRandomFromSeed(Arg.Any <byte[]>())
.Returns(ci => new IsaacRandom(((byte[])ci[0]).ToHex()));
_producerId = PeerIdHelper.GetPeerId("producer");
_peerSettings = _producerId.ToSubstitutedPeerSettings();
_previousDeltaHash = _hashProvider.ComputeUtf8MultiHash("previousDelta").CreateCid();
_zeroCoinbaseEntry = new CoinbaseEntry
{
Amount = UInt256.Zero.ToUint256ByteString(),
ReceiverPublicKey = _producerId.PublicKey.ToByteString()
};
_logger = Substitute.For <ILogger>();
_cache = Substitute.For <IDeltaCache>();
_dateTimeProvider = new DateTimeProvider();
}
public CatalystNodePoa(IKeySigner keySigner,
IPeerService peer,
IConsensus consensus,
IDfsService dfsService,
ILedger ledger,
ILogger logger,
IPeerClient peerClient,
IPeerSettings peerSettings,
IMempool <PublicEntryDao> memPool,
ISynchroniser synchronizer,
IPeerRepository peerRepository,
IContract contract = null)
{
Guard.Argument(peerRepository, nameof(peerRepository)).NotNull();
_peer = peer;
_peerClient = peerClient;
_peerSettings = peerSettings;
Consensus = consensus;
_dfsService = dfsService;
_ledger = ledger;
_keySigner = keySigner;
_logger = logger;
_memPool = memPool;
_contract = contract;
_synchronizer = synchronizer;
_peerRepository = peerRepository;
var privateKey = keySigner.KeyStore.KeyStoreDecrypt(KeyRegistryTypes.DefaultKey);
_publicKey = keySigner.CryptoContext.GetPublicKeyFromPrivateKey(privateKey);
}
public PeerReputationRequestObserver(IPeerSettings peerSettings,
ILogger logger,
IPeerRepository peerRepository)
: base(logger, peerSettings)
{
_peerRepository = peerRepository;
}
/// <summary>Initializes a new instance of the <see cref="PeerCountRequestObserver" /> class.</summary>
/// <param name="peerSettings"></param>
/// <param name="peerRepository">The peer discovery.</param>
/// <param name="logger">The logger.</param>
public PeerCountRequestObserver(IPeerSettings peerSettings,
IPeerRepository peerRepository,
ILogger logger) :
base(logger, peerSettings)
{
_peerRepository = peerRepository;
}
public GetPeerInfoRequestObserver(IPeerSettings peerSettings,
ILogger logger,
IPeerRepository peerRepository)
: base(logger, peerSettings)
{
_peerRepository = peerRepository;
}
public VerifyMessageRequestObserver(IPeerSettings peerSettings,
ILogger logger,
IKeySigner keySigner)
: base(logger, peerSettings)
{
_keySigner = keySigner;
}
public CatalystNodePoa(IKeySigner keySigner,
IPeerService peer,
IConsensus consensus,
IDfs dfs,
ILedger ledger,
ILogger logger,
IPeerClient peerClient,
IPeerSettings peerSettings,
IMempool <PublicEntryDao> memPool,
IContract contract = null)
{
_peer = peer;
_peerClient = peerClient;
_peerSettings = peerSettings;
Consensus = consensus;
_dfs = dfs;
_ledger = ledger;
_keySigner = keySigner;
_logger = logger;
_memPool = memPool;
_contract = contract;
var privateKey = keySigner.KeyStore.KeyStoreDecrypt(KeyRegistryTypes.DefaultKey);
_publicKey = keySigner.CryptoContext.GetPublicKeyFromPrivateKey(privateKey);
}
/// <summary>Initializes a new instance of the <see cref="TransferFileBytesRequestObserver"/> class.</summary>
/// <param name="fileTransferFactory">The download transfer factory.</param>
/// <param name="peerSettings"></param>
/// <param name="logger">The logger.</param>
public TransferFileBytesRequestObserver(IDownloadFileTransferFactory fileTransferFactory,
IPeerSettings peerSettings,
ILogger logger)
: base(logger, peerSettings)
{
_fileTransferFactory = fileTransferFactory;
}
public GetNeighbourRequestObserver(IPeerSettings peerSettings,
IPeerRepository repository,
ILogger logger)
: base(logger, peerSettings)
{
_repository = repository;
}
public static IHastingsMemento MockSeedState(PeerId ownNode, IPeerSettings peerSettings)
{
return(MockMemento(ownNode, MockDnsClient(peerSettings)
.GetSeedNodesFromDns(peerSettings.SeedServers)
.ToNeighbours()
));
}
public DeltaHubWithFastRetryPolicy(IBroadcastManager broadcastManager,
IPeerSettings peerSettings,
IDfs dfs,
IHashProvider hashProvider,
ILogger logger) : base(broadcastManager, peerSettings, dfs, hashProvider, logger)
{
}
public PoaTestNode(string name,
IPrivateKey privateKey,
IPeerSettings nodeSettings,
IDfsService dfsService,
IEnumerable <PeerId> knownPeerIds,
IFileSystem parentTestFileSystem)
{
Name = name;
_nodeSettings = nodeSettings;
_nodeDirectory = parentTestFileSystem.GetCatalystDataDir();
_dfsService = dfsService;
_rpcSettings = RpcSettingsHelper.GetRpcServerSettings(nodeSettings.Port + 100);
_nodePeerId = nodeSettings.PeerId;
_memPool = new Mempool(new MempoolService(new InMemoryRepository <PublicEntryDao, string>()));
_peerRepository = new PeerRepository(new InMemoryRepository <Peer, string>());
var peersInRepo = knownPeerIds.Select(p => new Peer
{
PeerId = p,
IsPoaNode = true,
LastSeen = DateTime.UtcNow
}).ToList();
_peerRepository.Add(peersInRepo);
_deltaByNumber = new DeltaByNumberRepository(new InMemoryRepository <DeltaByNumber, string>());
_containerProvider = new ContainerProvider(new[]
{
Constants.NetworkConfigFile(NetworkType.Devnet),
Constants.SerilogJsonConfigFile
}
.Select(f => Path.Combine(Constants.ConfigSubFolder, f)), parentTestFileSystem, TestContext.CurrentContext);
RegisterNodeDependencies(_containerProvider.ContainerBuilder,
excludedModules: new List <Type>
{
typeof(ApiModule),
typeof(RpcServerModule)
}
);
_containerProvider.ConfigureContainerBuilder(true, true);
OverrideContainerBuilderRegistrations();
_scope = _containerProvider.Container.BeginLifetimeScope(Name);
_node = _scope.Resolve <ICatalystNode>();
var keyStore = _scope.Resolve <IKeyStore>();
var keyRegistry = _scope.Resolve <IKeyRegistry>();
keyRegistry.RemoveItemFromRegistry(KeyRegistryTypes.DefaultKey);
keyRegistry.AddItemToRegistry(KeyRegistryTypes.DefaultKey, privateKey);
keyStore.KeyStoreEncryptAsync(privateKey, nodeSettings.NetworkType, KeyRegistryTypes.DefaultKey)
.ConfigureAwait(false).GetAwaiter()
.GetResult();
}
public PeerDeltaHistoryRequest(ILogger logger,
IPeerClient peerClient,
IPeerSettings peerSettings,
ICancellationTokenProvider cancellationTokenProvider,
IScheduler observableScheduler = null) : base(logger, peerSettings.PeerId, cancellationTokenProvider, peerClient)
{
DeltaHistoryResponseMessageStreamer = new ReplaySubject <IPeerDeltaHistoryResponse>(1, observableScheduler ?? Scheduler.Default);
}
/// <summary>
/// Protocol for querying a peers current delta height.
/// </summary>
/// <param name="logger"></param>
/// <param name="peerClient"></param>
/// <param name="peerSettings"></param>
/// <param name="cancellationTokenProvider"></param>
/// <param name="scheduler"></param>
public PeerQueryTipRequestRequest(ILogger logger,
IPeerClient peerClient,
IPeerSettings peerSettings,
ICancellationTokenProvider cancellationTokenProvider,
IScheduler scheduler = null) : base(logger, peerSettings.PeerId, cancellationTokenProvider, peerClient)
{
QueryTipResponseMessageStreamer = new ReplaySubject <IPeerQueryTipResponse>(1, scheduler ?? Scheduler.Default);
}
/// <summary>Initializes a new instance of the <see cref="AddFileToDfsRequestObserver"/> class.</summary>
/// <param name="dfs">The DFS.</param>
/// <param name="peerSettings"></param>
/// <param name="fileTransferFactory">The download file transfer factory.</param>
/// <param name="logger">The logger.</param>
public AddFileToDfsRequestObserver(IDfs dfs,
IPeerSettings peerSettings,
IDownloadFileTransferFactory fileTransferFactory,
ILogger logger) : base(logger, peerSettings)
{
_fileTransferFactory = fileTransferFactory;
_dfs = dfs;
}
public static IHastingsMemento SubSeedState(PeerId ownNode, IPeerSettings peerSettings)
{
var neighbours = MockDnsClient(peerSettings)
.GetSeedNodesFromDns(peerSettings.SeedServers)
.ToNeighbours();
return(SubMemento(ownNode, neighbours));
}
public GetDeltaRequestObserver(IHashProvider hashProvider,
IDeltaCache deltaCache,
IPeerSettings peerSettings,
ILogger logger) : base(logger, peerSettings)
{
_hashProvider = hashProvider;
_deltaCache = deltaCache;
}
/// <summary>Initializes a new instance of the <see cref="AddFileToDfsRequestObserver" /> class.</summary>
/// <param name="dfsService">The DFS.</param>
/// <param name="peerSettings"></param>
/// <param name="fileTransferFactory">The upload file transfer factory.</param>
/// <param name="logger">The logger.</param>
public GetFileFromDfsRequestObserver(IDfsService dfsService,
IPeerSettings peerSettings,
IUploadFileTransferFactory fileTransferFactory,
ILogger logger) : base(logger, peerSettings)
{
_fileTransferFactory = fileTransferFactory;
_dfsService = dfsService;
}
public void Init()
{
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256"));
_random = new Random(1);
_randomFactory = Substitute.For <IDeterministicRandomFactory>();
_randomFactory.GetDeterministicRandomFromSeed(Arg.Any <byte[]>())
.Returns(ci => new IsaacRandom(((byte[])ci[0]).ToHex()));
_producerId = PeerIdHelper.GetPeerId("producer");
_peerSettings = _producerId.ToSubstitutedPeerSettings();
_previousDeltaHash = _hashProvider.ComputeUtf8MultiHash("previousDelta").ToCid();
_zeroCoinbaseEntry = new CoinbaseEntry
{
Amount = UInt256.Zero.ToUint256ByteString(),
ReceiverPublicKey = _producerId.PublicKey.ToByteString()
};
_logger = Substitute.For <ILogger>();
_cache = Substitute.For <IDeltaCache>();
Delta previousDelta = new Delta();
previousDelta.StateRoot = ByteString.CopyFrom(Keccak.EmptyTreeHash.Bytes);
_cache.TryGetOrAddConfirmedDelta(Arg.Any <Cid>(), out Arg.Any <Delta>()).Returns(x =>
{
x[1] = previousDelta;
return(true);
});
_dateTimeProvider = new DateTimeProvider();
IDb codeDb = new MemDb();
ISnapshotableDb stateDb = new StateDb();
ISpecProvider specProvider = new CatalystSpecProvider();
_cryptoContext = new FfiWrapper();
_stateProvider = new StateProvider(stateDb, codeDb, LimboLogs.Instance);
IStorageProvider storageProvider = new StorageProvider(stateDb, _stateProvider, LimboLogs.Instance);
KatVirtualMachine virtualMachine = new KatVirtualMachine(_stateProvider,
storageProvider,
new StateUpdateHashProvider(),
specProvider,
new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256")),
new FfiWrapper(),
LimboLogs.Instance);
_deltaExecutor = new DeltaExecutor(specProvider,
_stateProvider,
storageProvider,
virtualMachine,
_cryptoContext,
_logger);
}
public GetMempoolRequestObserver(IPeerSettings peerSettings,
IMempool <PublicEntryDao> mempool,
IMapperProvider mappingProvider,
ILogger logger)
: base(logger, peerSettings)
{
_mempool = mempool;
_mappingProvider = mappingProvider;
}
public TestPeerClientChannelFactory(IKeySigner keySigner,
IPeerMessageCorrelationManager correlationManager,
IPeerIdValidator peerIdValidator,
IPeerSettings peerSettings,
IScheduler scheduler)
: base(keySigner, correlationManager, peerIdValidator, peerSettings, scheduler)
{
_handlers = HandlerGenerationFunction();
}
public DeltaHistoryRequestObserver(IPeerSettings peerSettings,
IDeltaIndexService deltaIndexService,
IMapperProvider mapperProvider,
ILogger logger)
: base(logger, peerSettings)
{
_deltaIndexService = deltaIndexService;
_mapperProvider = mapperProvider;
}
/// <param name="clientChannelFactory">A factory used to build the appropriate kind of channel for a udp client.</param>
/// <param name="eventLoopGroupFactory"></param>
/// <param name="peerSettings"></param>
public PeerClient(IUdpClientChannelFactory clientChannelFactory,
IUdpClientEventLoopGroupFactory eventLoopGroupFactory,
IPeerSettings peerSettings)
: base(clientChannelFactory,
Log.Logger.ForContext(MethodBase.GetCurrentMethod().DeclaringType),
eventLoopGroupFactory)
{
_peerSettings = peerSettings;
}
