public override TwoUserMoneyOut QueryTwoUserWinMoney(QueryTwoUserWinMoneyInput input) { return(new TwoUserMoneyOut { FirstInt64Value = State.WinerHistory[input.First], SecondInt64Value = State.WinerHistory[input.Second] }); }
public async Task WrongParallelTest() { var chain = await _blockchainService.GetChainAsync(); await _blockchainService.SetIrreversibleBlockAsync(chain, chain.BestChainHeight, chain.BestChainHash); //prepare token for tx verify var(tokenTransactions, groupUsers) = await _parallelTestHelper.PrepareTokenForParallel(_groupCount, 1000_00000000); await _parallelTestHelper.BroadcastTransactions(tokenTransactions); var prepareBlock = _parallelTestHelper.GenerateBlock(chain.BestChainHash, chain.BestChainHeight, tokenTransactions); prepareBlock = await _blockExecutingService.ExecuteBlockAsync(prepareBlock.Header, tokenTransactions); await _blockchainService.AddBlockAsync(prepareBlock); await _blockAttachService.AttachBlockAsync(prepareBlock); chain = await _blockchainService.GetChainAsync(); var transactions = _parallelTestHelper.GenerateBasicFunctionWithParallelTransactions(groupUsers, _transactionCount); await _parallelTestHelper.BroadcastTransactions(transactions); var otherTransactions = _parallelTestHelper.GenerateBasicFunctionWithParallelTransactions(groupUsers, _transactionCount); await _parallelTestHelper.BroadcastTransactions(otherTransactions); var transferTransactions = await _parallelTestHelper.GenerateTransferTransactions(16); await _parallelTestHelper.BroadcastTransactions(transferTransactions); var poolSize = await _txHub.GetAllTransactionCountAsync(); poolSize.ShouldBe(transactions.Count * 2 + transferTransactions.Count); var groupedTransactions = await _grouper.GroupAsync( new ChainContext { BlockHash = chain.BestChainHash, BlockHeight = chain.BestChainHeight }, transactions); groupedTransactions.Parallelizables.Count.ShouldBe(_transactionCount); groupedTransactions.NonParallelizables.Count.ShouldBe(0); for (var i = 0; i < transactions.Count; i++) { transactions[i].GetHash().ShouldBe(groupedTransactions.Parallelizables[i][0].GetHash()); } var otherGroupedTransactions = await _grouper.GroupAsync( new ChainContext { BlockHash = chain.BestChainHash, BlockHeight = chain.BestChainHeight }, otherTransactions); otherGroupedTransactions.Parallelizables.Count.ShouldBe(_transactionCount); otherGroupedTransactions.NonParallelizables.Count.ShouldBe(0); var groupedTransferTransactions = await _grouper.GroupAsync( new ChainContext { BlockHash = chain.BestChainHash, BlockHeight = chain.BestChainHeight }, transferTransactions); groupedTransferTransactions.Parallelizables.Count.ShouldBe(1); groupedTransferTransactions.Parallelizables[0].Count.ShouldBe(transferTransactions.Count); groupedTransferTransactions.NonParallelizables.Count.ShouldBe(0); var block = _parallelTestHelper.GenerateBlock(chain.BestChainHash, chain.BestChainHeight, transactions); block = await _blockExecutingService.ExecuteBlockAsync(block.Header, transactions); block.TransactionIds.Count().ShouldBe(_transactionCount); var transactionResults = await GetTransactionResultsAsync(block.Body.TransactionIds.ToList(), block.Header); transactionResults.Count(t => t.Status == TransactionResultStatus.Mined).ShouldBe(_groupCount); transactionResults.Count(t => t.Status == TransactionResultStatus.Conflict).ShouldBe(_groupCount); await _blockchainService.AddBlockAsync(block); await _blockAttachService.AttachBlockAsync(block); var accountAddress = await _accountService.GetAccountAsync(); foreach (var transaction in transactions) { var param = IncreaseWinMoneyInput.Parser.ParseFrom(transaction.Params); var input = new QueryTwoUserWinMoneyInput { First = param.First, Second = param.Second }; var queryTransaction = _parallelTestHelper.GenerateTransaction(accountAddress, ParallelTestHelper.BasicFunctionWithParallelContractAddress, nameof(BasicFunctionWithParallelContract.QueryTwoUserWinMoney), input); var byteString = await _parallelTestHelper.ExecuteReadOnlyAsync(queryTransaction, block.GetHash(), block.Height); var output = TwoUserMoneyOut.Parser.ParseFrom(byteString); output.FirstInt64Value.ShouldBe(1); var result = transactionResults.First(t => t.TransactionId == transaction.GetHash()); if (result.Status == TransactionResultStatus.Mined) { output.SecondInt64Value.ShouldBe(1); } else if (result.Status == TransactionResultStatus.Conflict) { output.SecondInt64Value.ShouldBe(0); } } var codeRemark = await _contractRemarksService.GetCodeRemarkAsync(new ChainContext { BlockHash = block.GetHash(), BlockHeight = block.Height }, ParallelTestHelper.BasicFunctionWithParallelContractAddress, Hash.FromRawBytes(_parallelTestHelper.BasicFunctionWithParallelContractCode)); codeRemark.CodeHash.ShouldBe(Hash.FromRawBytes(_parallelTestHelper.BasicFunctionWithParallelContractCode)); codeRemark.NonParallelizable.ShouldBeTrue(); groupedTransactions = await _grouper.GroupAsync( new ChainContext { BlockHash = block.GetHash(), BlockHeight = block.Height }, transactions); groupedTransactions.Parallelizables.Count.ShouldBe(0); groupedTransactions.NonParallelizables.Count.ShouldBe(_transactionCount); otherGroupedTransactions = await _grouper.GroupAsync( new ChainContext { BlockHash = block.GetHash(), BlockHeight = block.Height }, otherTransactions); otherGroupedTransactions.Parallelizables.Count.ShouldBe(0); otherGroupedTransactions.NonParallelizables.Count.ShouldBe(_transactionCount); groupedTransferTransactions = await _grouper.GroupAsync( new ChainContext { BlockHash = chain.BestChainHash, BlockHeight = chain.BestChainHeight }, transferTransactions); groupedTransferTransactions.Parallelizables.Count.ShouldBe(1); groupedTransferTransactions.Parallelizables[0].Count.ShouldBe(transferTransactions.Count); groupedTransferTransactions.NonParallelizables.Count.ShouldBe(0); poolSize = await _txHub.GetAllTransactionCountAsync(); poolSize.ShouldBe(transactions.Count * 2 + transferTransactions.Count - block.TransactionIds.Count()); }
public async Task DeployContract_With_Two_Branch() { var blockHeader = await _blockchainService.GetBestChainLastBlockHeaderAsync(); var startBlockHeight = blockHeader.Height; var startBlockHash = blockHeader.GetHash(); Address contractAddress; //branch one { var t = (await BasicContractZeroStub.DeploySmartContract.SendAsync( new Acs0.ContractDeploymentInput { Code = ByteString.CopyFrom(Codes.Single(kv => kv.Key.EndsWith("BasicFunctionWithParallel")).Value), Category = KernelConstants.CodeCoverageRunnerCategory } )); var transactionResult = t.TransactionResult; transactionResult.Status.ShouldBe(TransactionResultStatus.Mined); contractAddress = Address.Parser.ParseFrom(transactionResult.ReturnValue); blockHeader = await _blockchainService.GetBestChainLastBlockHeaderAsync(); var queryTwoUserWinMoneyInput = new QueryTwoUserWinMoneyInput { First = SampleAddress.AddressList[0], Second = SampleAddress.AddressList[1] }.ToByteString(); var queryTwoUserWinMoneyTransaction = CreateTransaction(DefaultSender, contractAddress, "QueryTwoUserWinMoney", queryTwoUserWinMoneyInput, blockHeader.Height, blockHeader.GetHash()); var branchOneBlock = await ExecuteAsync(queryTwoUserWinMoneyTransaction, blockHeader.Height, blockHeader.GetHash()); await _blockAttachService.AttachBlockAsync(branchOneBlock); var queryTwoUserWinMoneyTransactionResult = await _transactionResultManager.GetTransactionResultAsync(queryTwoUserWinMoneyTransaction .GetHash(), branchOneBlock.Header.GetPreMiningHash()); queryTwoUserWinMoneyTransactionResult.Status.ShouldBe(TransactionResultStatus.Mined); } //branch two { var transaction = CreateTransaction(DefaultSender, BasicFunctionContractAddress, nameof(TestBasicFunctionContractStub.QueryWinMoney), new Empty().ToByteString(), startBlockHeight, startBlockHash); var branchTwoBlock = await ExecuteAsync(transaction, startBlockHeight, startBlockHash); await _blockAttachService.AttachBlockAsync(branchTwoBlock); transaction = CreateTransaction(DefaultSender, BasicFunctionContractAddress, nameof(TestBasicFunctionContractStub.QueryWinMoney), new Empty().ToByteString(), branchTwoBlock.Height, branchTwoBlock.GetHash()); branchTwoBlock = await ExecuteAsync(transaction, branchTwoBlock.Height, branchTwoBlock.GetHash()); await _blockAttachService.AttachBlockAsync(branchTwoBlock); transaction = CreateTransaction(DefaultSender, BasicFunctionContractAddress, nameof(TestBasicFunctionContractStub.QueryWinMoney), new Empty().ToByteString(), branchTwoBlock.Height, branchTwoBlock.GetHash()); branchTwoBlock = await ExecuteAsync(transaction, branchTwoBlock.Height, branchTwoBlock.GetHash()); await _blockAttachService.AttachBlockAsync(branchTwoBlock); var queryTwoUserWinMoneyInput = new QueryTwoUserWinMoneyInput { First = SampleAddress.AddressList[0], Second = SampleAddress.AddressList[1] }.ToByteString(); var queryTwoUserWinMoneyTransaction = CreateTransaction(DefaultSender, contractAddress, "QueryTwoUserWinMoney", queryTwoUserWinMoneyInput, branchTwoBlock.Height, branchTwoBlock.GetHash()); branchTwoBlock = await ExecuteAsync(queryTwoUserWinMoneyTransaction, branchTwoBlock.Height, branchTwoBlock.GetHash()); await _blockAttachService.AttachBlockAsync(branchTwoBlock); var queryTwoUserWinMoneyTransactionResult = await _transactionResultManager.GetTransactionResultAsync(queryTwoUserWinMoneyTransaction.GetHash(), branchTwoBlock.Header.GetPreMiningHash()); queryTwoUserWinMoneyTransactionResult.Status.ShouldBe(TransactionResultStatus.Failed); queryTwoUserWinMoneyTransactionResult.Error.ShouldContain("Invalid contract address"); } }
public async Task UpdateContract_With_Two_Different_Contract_Code() { var blockHeader = await _blockchainService.GetBestChainLastBlockHeaderAsync(); var startBlockHeight = blockHeader.Height; var startBlockHash = blockHeader.GetHash(); var basic11ContractStub = GetTestBasicUpdateContractStub(DefaultSenderKeyPair); //First branch { var transactionResult = (await BasicContractZeroStub.UpdateSmartContract.SendAsync( new Acs0.ContractUpdateInput { Address = BasicFunctionContractAddress, Code = ByteString.CopyFrom(Codes.Single(kv => kv.Key.EndsWith("BasicUpdate")).Value) } )).TransactionResult; transactionResult.Status.ShouldBe(TransactionResultStatus.Mined); transactionResult = (await basic11ContractStub.UpdateStopBet.SendAsync( new Empty())).TransactionResult; transactionResult.Status.ShouldBe(TransactionResultStatus.Mined); } //Second branch { var input = new Acs0.ContractUpdateInput { Address = BasicFunctionContractAddress, Code = ByteString.CopyFrom(Codes.Single(kv => kv.Key.EndsWith("BasicFunctionWithParallel")).Value) }.ToByteString(); var transaction = CreateTransaction(DefaultSender, ContractZeroAddress, nameof(BasicContractZeroStub.UpdateSmartContract), input, startBlockHeight, startBlockHash); var branchTwoBlock = await ExecuteAsync(transaction, startBlockHeight, startBlockHash); await _blockAttachService.AttachBlockAsync(branchTwoBlock); var basicFunctionContractStub = GetTestBasicFunctionContractStub(DefaultSenderKeyPair); await basicFunctionContractStub.QueryWinMoney.CallAsync(new Empty()); _smartContractExecutiveService.ClearContractInfoCache(100); var queryTwoUserWinMoneyInput = new QueryTwoUserWinMoneyInput { First = SampleAddress.AddressList[0], Second = SampleAddress.AddressList[1] }.ToByteString(); var queryTwoUserWinMoneyTransaction = CreateTransaction(DefaultSender, BasicFunctionContractAddress, "QueryTwoUserWinMoney", queryTwoUserWinMoneyInput, branchTwoBlock.Height, branchTwoBlock.GetHash()); branchTwoBlock = await ExecuteAsync(queryTwoUserWinMoneyTransaction, branchTwoBlock.Height, branchTwoBlock.GetHash()); await _blockAttachService.AttachBlockAsync(branchTwoBlock); var queryTwoUserWinMoneyTransactionResult = await _transactionResultManager.GetTransactionResultAsync(queryTwoUserWinMoneyTransaction.GetHash(), branchTwoBlock.Header.GetPreMiningHash()); queryTwoUserWinMoneyTransactionResult.Status.ShouldBe(TransactionResultStatus.Failed); queryTwoUserWinMoneyTransactionResult.Error.ShouldContain("Failed to find handler for QueryTwoUserWinMoney"); await _smartContractExecutiveService.InitContractInfoCacheAsync(); queryTwoUserWinMoneyInput = new QueryTwoUserWinMoneyInput { First = SampleAddress.AddressList[0], Second = SampleAddress.AddressList[1] }.ToByteString(); queryTwoUserWinMoneyTransaction = CreateTransaction(DefaultSender, BasicFunctionContractAddress, "QueryTwoUserWinMoney", queryTwoUserWinMoneyInput, branchTwoBlock.Height, branchTwoBlock.GetHash()); branchTwoBlock = await ExecuteAsync(queryTwoUserWinMoneyTransaction, branchTwoBlock.Height, branchTwoBlock.GetHash()); await _blockAttachService.AttachBlockAsync(branchTwoBlock); queryTwoUserWinMoneyTransactionResult = await _transactionResultManager.GetTransactionResultAsync(queryTwoUserWinMoneyTransaction .GetHash(), branchTwoBlock.Header.GetPreMiningHash()); queryTwoUserWinMoneyTransactionResult.Status.ShouldBe(TransactionResultStatus.Mined); } //Third branch { var updateStopBetTransaction = CreateTransaction(DefaultSender, BasicFunctionContractAddress, nameof(basic11ContractStub.UpdateStopBet), new Empty().ToByteString(), startBlockHeight, startBlockHash); var branchThreeBlock = await ExecuteAsync(updateStopBetTransaction, startBlockHeight, startBlockHash); await _blockAttachService.AttachBlockAsync(branchThreeBlock); var updateStopBetTransactionResult = await _transactionResultManager.GetTransactionResultAsync(updateStopBetTransaction.GetHash(), branchThreeBlock.Header.GetPreMiningHash()); updateStopBetTransactionResult.Status.ShouldBe(TransactionResultStatus.Failed); updateStopBetTransactionResult.Error.ShouldContain("Failed to find handler for UpdateStopBet."); var queryTwoUserWinMoneyInput = new QueryTwoUserWinMoneyInput { First = SampleAddress.AddressList[0], Second = SampleAddress.AddressList[1] }.ToByteString(); var queryTwoUserWinMoneyTransaction = CreateTransaction(DefaultSender, BasicFunctionContractAddress, "QueryTwoUserWinMoney", queryTwoUserWinMoneyInput, branchThreeBlock.Height, branchThreeBlock.GetHash()); branchThreeBlock = await ExecuteAsync(queryTwoUserWinMoneyTransaction, branchThreeBlock.Height, branchThreeBlock.GetHash()); await _blockAttachService.AttachBlockAsync(branchThreeBlock); var queryTwoUserWinMoneyTransactionResult = await _transactionResultManager.GetTransactionResultAsync(queryTwoUserWinMoneyTransaction.GetHash(), branchThreeBlock.Header.GetPreMiningHash()); queryTwoUserWinMoneyTransactionResult.Status.ShouldBe(TransactionResultStatus.Failed); queryTwoUserWinMoneyTransactionResult.Error.ShouldContain("Failed to find handler for QueryTwoUserWinMoney."); } }
public async Task WrongParallelTest() { var chain = await _blockchainService.GetChainAsync(); await _blockchainService.SetIrreversibleBlockAsync(chain, chain.BestChainHeight, chain.BestChainHash); //prepare token for tx verify var(tokenTransactions, groupUsers) = await _parallelTestHelper.PrepareTokenForParallel(_groupCount, 1000_00000000); await _parallelTestHelper.BroadcastTransactions(tokenTransactions); var prepareBlock = _parallelTestHelper.GenerateBlock(chain.BestChainHash, chain.BestChainHeight, tokenTransactions); prepareBlock = (await _blockExecutingService.ExecuteBlockAsync(prepareBlock.Header, tokenTransactions)).Block; await _blockchainService.AddBlockAsync(prepareBlock); await _blockAttachService.AttachBlockAsync(prepareBlock); chain = await _blockchainService.GetChainAsync(); var transactions = _parallelTestHelper.GenerateBasicFunctionWithParallelTransactions(groupUsers, _transactionCount); var transferTransaction = await _parallelTestHelper.GenerateTransferTransaction(Address.FromPublicKey(groupUsers[1].PublicKey) , "ELF", 10); transactions.Add(transferTransaction); await _parallelTestHelper.BroadcastTransactions(transactions); var otherTransactions = _parallelTestHelper.GenerateBasicFunctionWithParallelTransactions(groupUsers, _transactionCount); var otherTransferTransaction = await _parallelTestHelper.GenerateTransferTransaction(Address.FromPublicKey(groupUsers[2].PublicKey) , "ELF", 10); otherTransactions.Add(otherTransferTransaction); await _parallelTestHelper.BroadcastTransactions(otherTransactions); var transferTransactions = await _parallelTestHelper.GenerateTransferTransactions(16); await _parallelTestHelper.BroadcastTransactions(transferTransactions); var poolSize = (await _txHub.GetTransactionPoolStatusAsync()).AllTransactionCount; poolSize.ShouldBe(transactions.Count * 2 + transferTransactions.Count); var groupedTransactions = await _grouper.GroupAsync( new ChainContext { BlockHash = chain.BestChainHash, BlockHeight = chain.BestChainHeight }, transactions); groupedTransactions.Parallelizables.Count.ShouldBe(_transactionCount + 1); groupedTransactions.NonParallelizables.Count.ShouldBe(0); for (var i = 0; i < transactions.Count; i++) { transactions[i].GetHash().ShouldBe(groupedTransactions.Parallelizables[i][0].GetHash()); } var otherGroupedTransactions = await _grouper.GroupAsync( new ChainContext { BlockHash = chain.BestChainHash, BlockHeight = chain.BestChainHeight }, otherTransactions); otherGroupedTransactions.Parallelizables.Count.ShouldBe(_transactionCount + 1); otherGroupedTransactions.NonParallelizables.Count.ShouldBe(0); var groupedTransferTransactions = await _grouper.GroupAsync( new ChainContext { BlockHash = chain.BestChainHash, BlockHeight = chain.BestChainHeight }, transferTransactions); groupedTransferTransactions.Parallelizables.Count.ShouldBe(1); groupedTransferTransactions.Parallelizables[0].Count.ShouldBe(transferTransactions.Count); groupedTransferTransactions.NonParallelizables.Count.ShouldBe(0); _localEventBus.Subscribe <ConflictingTransactionsFoundInParallelGroupsEvent>(e => { e.ConflictingSets.Count.ShouldBe(_groupCount + 1); e.ExistingSets.Count.ShouldBe(_groupCount); return(Task.CompletedTask); }); var block = _parallelTestHelper.GenerateBlock(chain.BestChainHash, chain.BestChainHeight, transactions); block = (await _blockExecutingService.ExecuteBlockAsync(block.Header, transactions)).Block; block.TransactionIds.Count().ShouldBe(_transactionCount + 1); var transactionResults = await GetTransactionResultsAsync(block.Body.TransactionIds.ToList(), block.Header); transactionResults.Count(t => t.Status == TransactionResultStatus.Mined).ShouldBe(_groupCount); transactionResults.Count(t => t.Status == TransactionResultStatus.Conflict).ShouldBe(_groupCount + 1); await _blockchainService.AddBlockAsync(block); await _blockAttachService.AttachBlockAsync(block); var accountAddress = await _accountService.GetAccountAsync(); var chainContext = new ChainContext { BlockHash = block.GetHash(), BlockHeight = block.Height }; var tokenContractAddress = await _smartContractAddressService.GetAddressByContractNameAsync(chainContext, TokenSmartContractAddressNameProvider.StringName); var nonparallelContractCode = await _nonparallelContractCodeProvider.GetNonparallelContractCodeAsync(chainContext, tokenContractAddress); nonparallelContractCode.ShouldBeNull(); foreach (var transaction in transactions) { if (transaction.To == tokenContractAddress) { continue; } var param = IncreaseWinMoneyInput.Parser.ParseFrom(transaction.Params); var input = new QueryTwoUserWinMoneyInput { First = param.First, Second = param.Second }; var queryTransaction = _parallelTestHelper.GenerateTransaction(accountAddress, ParallelTestHelper.BasicFunctionWithParallelContractAddress, nameof(BasicFunctionWithParallelContract.QueryTwoUserWinMoney), input); var byteString = await _parallelTestHelper.ExecuteReadOnlyAsync(queryTransaction, block.GetHash(), block.Height); var output = TwoUserMoneyOut.Parser.ParseFrom(byteString); output.FirstInt64Value.ShouldBe(1); var result = transactionResults.First(t => t.TransactionId == transaction.GetHash()); if (result.Status == TransactionResultStatus.Mined) { output.SecondInt64Value.ShouldBe(1); } else if (result.Status == TransactionResultStatus.Conflict) { output.SecondInt64Value.ShouldBe(0); } } nonparallelContractCode = await _nonparallelContractCodeProvider.GetNonparallelContractCodeAsync(new ChainContext { BlockHash = block.GetHash(), BlockHeight = block.Height }, ParallelTestHelper.BasicFunctionWithParallelContractAddress); nonparallelContractCode.CodeHash.ShouldBe(HashHelper.ComputeFrom(_parallelTestHelper.BasicFunctionWithParallelContractCode)); var blockStateSet = await _blockStateSetManger.GetBlockStateSetAsync(block.GetHash()); blockStateSet.Changes.Count.ShouldBeGreaterThan(0); var blockExecutedData = blockStateSet.BlockExecutedData.First(); var versionedState = await _versionedStates.GetAsync(blockExecutedData.Key); versionedState.ShouldBeNull(); await _blockchainStateService.MergeBlockStateAsync(block.Height, block.GetHash()); blockStateSet = await _blockStateSetManger.GetBlockStateSetAsync(block.GetHash()); blockStateSet.ShouldBeNull(); nonparallelContractCode = await _nonparallelContractCodeProvider.GetNonparallelContractCodeAsync(new ChainContext { BlockHash = block.GetHash(), BlockHeight = block.Height }, ParallelTestHelper.BasicFunctionWithParallelContractAddress); nonparallelContractCode.CodeHash.ShouldBe(HashHelper.ComputeFrom(_parallelTestHelper.BasicFunctionWithParallelContractCode)); versionedState = await _versionedStates.GetAsync(blockExecutedData.Key); versionedState.Key.ShouldBe(blockExecutedData.Key); versionedState.Value.ShouldBe(blockExecutedData.Value); groupedTransactions = await _grouper.GroupAsync( new ChainContext { BlockHash = block.GetHash(), BlockHeight = block.Height }, transactions); groupedTransactions.Parallelizables.Count.ShouldBe(1); groupedTransactions.Parallelizables[0][0].To.ShouldBe(tokenContractAddress); groupedTransactions.NonParallelizables.Count.ShouldBe(_transactionCount); otherGroupedTransactions = await _grouper.GroupAsync( new ChainContext { BlockHash = block.GetHash(), BlockHeight = block.Height }, otherTransactions); otherGroupedTransactions.Parallelizables.Count.ShouldBe(1); otherGroupedTransactions.Parallelizables[0][0].To.ShouldBe(tokenContractAddress); otherGroupedTransactions.NonParallelizables.Count.ShouldBe(_transactionCount); groupedTransferTransactions = await _grouper.GroupAsync( new ChainContext { BlockHash = chain.BestChainHash, BlockHeight = chain.BestChainHeight }, transferTransactions); groupedTransferTransactions.Parallelizables.Count.ShouldBe(1); groupedTransferTransactions.Parallelizables[0].Count.ShouldBe(transferTransactions.Count); groupedTransferTransactions.NonParallelizables.Count.ShouldBe(0); poolSize = (await _txHub.GetTransactionPoolStatusAsync()).AllTransactionCount; poolSize.ShouldBe(transactions.Count * 2 + transferTransactions.Count - block.TransactionIds.Count()); }