Esempio n. 1
0
        public async Task ValidateBlock_Success()
        {
            var chain = await _blockchainService.GetChainAsync();

            var block = _osTestHelper.GenerateBlockWithTransactions(chain.LastIrreversibleBlockHash,
                                                                    chain.LastIrreversibleBlockHeight);

            var validateResult = await _blockSyncValidationService.ValidateBlockAsync(chain, block, GetEncodedPubKeyString());

            validateResult.ShouldBeTrue();
        }
        public async Task ValidateBlock_Success()
        {
            var chain = await _blockchainService.GetChainAsync();

            var block = _osTestHelper.GenerateBlockWithTransactions(chain.LastIrreversibleBlockHash,
                                                                    chain.LastIrreversibleBlockHeight);
            var pubkey = (await _accountService.GetPublicKeyAsync()).ToHex();

            var validateResult = await _blockSyncValidationService.ValidateBlockBeforeSyncAsync(chain, block, pubkey);

            validateResult.ShouldBeTrue();
        }
        public async Task ValidateBlockBeforeAttach_InvalidBlock_ReturnFalse()
        {
            var invalidBlock = _osTestHelper.GenerateBlockWithTransactions(HashHelper.ComputeFrom("BadBlock"), 10000);
            var result       = await _blockSyncValidationService.ValidateBlockBeforeAttachAsync(invalidBlock);

            result.ShouldBeFalse();
        }
Esempio n. 4
0
        public async Task BroadcastBlockWithTxs_ShouldAddToBlockCache()
        {
            var peer     = _peerPool.GetPeers(true).First();
            var pubkey   = peer.Info.Pubkey;
            var metadata = new Metadata {
                { GrpcConstants.PubkeyMetadataKey, pubkey }
            };

            var block = _osTestHelper.GenerateBlockWithTransactions(Hash.FromString("block1"), 1,
                                                                    (await _osTestHelper.GenerateTransferTransactions(1)).ToList());

            var requestStream = new TestAsyncStreamReader <BlockWithTransactions>(new List <BlockWithTransactions> {
                block
            });
            await _serverService.BlockBroadcastStream(requestStream, BuildServerCallContext(metadata));

            peer.TryAddKnownBlock(block.GetHash()).ShouldBeFalse();
        }
        public async Task BlockBroadcastStream_UnknownPeer_Test()
        {
            var metadata = new Metadata {
                { GrpcConstants.PubkeyMetadataKey, "UnknownPeerPubkey" }
            };

            var block = _osTestHelper.GenerateBlockWithTransactions(HashHelper.ComputeFrom("block1"), 1,
                                                                    (await _osTestHelper.GenerateTransferTransactions(1)).ToList());

            var requestStream = new TestAsyncStreamReader <BlockWithTransactions>(new List <BlockWithTransactions> {
                block
            });
            await _serverService.BlockBroadcastStream(requestStream, BuildServerCallContext(metadata))
            .ShouldThrowAsync <RpcException>();
        }
        public async Task Attach_InvalidBlock()
        {
            var badPeerPubkey = "BadPeerPubkey";
            var badBlock      = _osTestHelper.GenerateBlockWithTransactions(Hash.FromString("BadBlock"), 10000);

            var badPeer = _networkService.GetPeerByPubkey(badPeerPubkey);

            badPeer.ShouldNotBeNull();

            await _blockSyncAttachService.AttachBlockWithTransactionsAsync(badBlock, badPeerPubkey);

            badPeer = _networkService.GetPeerByPubkey(badPeerPubkey);
            badPeer.ShouldBeNull();
        }
Esempio n. 7
0
        public async Task Attach_InvalidBlock()
        {
            var abnormalPeerPubkey = "AbnormalPeerPubkey";
            var badBlock           = _osTestHelper.GenerateBlockWithTransactions(HashHelper.ComputeFrom("BadBlock"), 10000);

            var abnormalPeer = _networkService.GetPeerByPubkey(abnormalPeerPubkey);

            abnormalPeer.ShouldNotBeNull();

            await _blockSyncAttachService.AttachBlockWithTransactionsAsync(badBlock, abnormalPeerPubkey);

            abnormalPeer = _networkService.GetPeerByPubkey(abnormalPeerPubkey);
            abnormalPeer.ShouldBeNull();
        }
Esempio n. 8
0
        public async Task BroadcastBlockWithTxs_FromStream_Test()
        {
            var received = new List <BlockReceivedEvent>();

            _eventBus.Subscribe <BlockReceivedEvent>(a =>
            {
                received.Add(a);
                return(Task.CompletedTask);
            });

            var blocks = new List <BlockWithTransactions>();

            blocks.Add(_osTestHelper.GenerateBlockWithTransactions(Hash.FromString("block1"), 1, (await _osTestHelper.GenerateTransferTransactions(1)).ToList()));
            blocks.Add(_osTestHelper.GenerateBlockWithTransactions(Hash.FromString("block2"), 2, (await _osTestHelper.GenerateTransferTransactions(2)).ToList()));
            blocks.Add(_osTestHelper.GenerateBlockWithTransactions(Hash.FromString("block3"), 3, (await _osTestHelper.GenerateTransferTransactions(3)).ToList()));

            var context       = BuildServerCallContext();
            var requestStream = new TestAsyncStreamReader <BlockWithTransactions>(blocks.ToArray());

            var result = await _service.BlockBroadcastStream(requestStream, context);

            result.ShouldBe(new VoidReply());
            received.Count.ShouldBe(3);
        }
        public async Task SyncByBlock_MoreThenFetchLimit_Success()
        {
            var chain = await _blockchainService.GetChainAsync();

            var peerBlockHash   = HashHelper.ComputeFrom("PeerBlock");
            var peerBlockHeight = chain.LongestChainHeight + BlockSyncConstants.BlockSyncModeHeightOffset + 1;

            var block = _osTestHelper.GenerateBlockWithTransactions(peerBlockHash, peerBlockHeight);

            await _blockSyncService.SyncByBlockAsync(chain,
                                                     new SyncBlockDto
            {
                BlockWithTransactions = block, BatchRequestBlockCount = 10,
                SuggestedPeerPubkey   = "SuggestedPeerPubkey"
            });

            var jobInfo = await _blockDownloadJobStore.GetFirstWaitingJobAsync();

            jobInfo.TargetBlockHeight.ShouldBe(block.Height);
            jobInfo.TargetBlockHash.ShouldBe(block.GetHash());
        }