public TransactionResultService(ITransactionResultManager transactionResultManager,
ITransactionBlockIndexManager transactionBlockIndexManager, IBlockchainService blockchainService)
{
_transactionResultManager = transactionResultManager;
_transactionBlockIndexManager = transactionBlockIndexManager;
_blockchainService = blockchainService;
}
private void Initialize()
{
_transactionManager = new TransactionManager(_dataStore, _logger);
_transactionReceiptManager = new TransactionReceiptManager(_database);
_smartContractManager = new SmartContractManager(_dataStore);
_transactionResultManager = new TransactionResultManager(_dataStore);
_transactionTraceManager = new TransactionTraceManager(_dataStore);
_functionMetadataService = new FunctionMetadataService(_dataStore, _logger);
_chainManagerBasic = new ChainManagerBasic(_dataStore);
_chainService = new ChainService(_chainManagerBasic, new BlockManagerBasic(_dataStore),
_transactionManager, _transactionTraceManager, _dataStore, StateStore);
_smartContractRunnerFactory = new SmartContractRunnerFactory();
/*var runner = new SmartContractRunner("../../../../AElf.SDK.CSharp/bin/Debug/netstandard2.0/");
* _smartContractRunnerFactory.AddRunner(0, runner);*/
var runner = new SmartContractRunner(ContractCodes.TestContractFolder);
_smartContractRunnerFactory.AddRunner(0, runner);
_concurrencyExecutingService = new SimpleExecutingService(
new SmartContractService(_smartContractManager, _smartContractRunnerFactory, StateStore,
_functionMetadataService), _transactionTraceManager, StateStore,
new ChainContextService(_chainService));
_chainCreationService = new ChainCreationService(_chainService,
new SmartContractService(new SmartContractManager(_dataStore), _smartContractRunnerFactory,
StateStore, _functionMetadataService), _logger);
_binaryMerkleTreeManager = new BinaryMerkleTreeManager(_dataStore);
_chainContextService = new ChainContextService(_chainService);
_stateStore = new StateStore(_database);
}
public async Task GlobalSetup()
{
_chains = GetRequiredService <IBlockchainStore <Chain> >();
_chainStateInfoCollection = GetRequiredService <IStateStore <ChainStateInfo> >();
_blockchainStateManager = GetRequiredService <IBlockchainStateManager>();
_blockchainStateService = GetRequiredService <IBlockchainStateService>();
_blockchainService = GetRequiredService <IBlockchainService>();
_osTestHelper = GetRequiredService <OSTestHelper>();
_chainManager = GetRequiredService <IChainManager>();
_blockManager = GetRequiredService <IBlockManager>();
_transactionManager = GetRequiredService <ITransactionManager>();
_transactionResultManager = GetRequiredService <ITransactionResultManager>();
_txHub = GetRequiredService <ITxHub>();
_blockStateSets = new List <BlockStateSet>();
_blocks = new List <Block>();
_chain = await _blockchainService.GetChainAsync();
var blockHash = _chain.BestChainHash;
while (true)
{
var blockState = await _blockchainStateManager.GetBlockStateSetAsync(blockHash);
_blockStateSets.Add(blockState);
var blockHeader = await _blockchainService.GetBlockHeaderByHashAsync(blockHash);
blockHash = blockHeader.PreviousBlockHash;
if (blockHash == _chain.LastIrreversibleBlockHash)
{
break;
}
}
await _blockchainStateService.MergeBlockStateAsync(_chain.BestChainHeight, _chain.BestChainHash);
for (var i = 0; i < BlockCount; i++)
{
var transactions = await _osTestHelper.GenerateTransferTransactions(TransactionCount);
await _osTestHelper.BroadcastTransactions(transactions);
var block = await _osTestHelper.MinedOneBlock();
_blocks.Add(block);
var blockState = await _blockchainStateManager.GetBlockStateSetAsync(block.GetHash());
_blockStateSets.Add(blockState);
}
var chain = await _blockchainService.GetChainAsync();
await _chainManager.SetIrreversibleBlockAsync(chain, chain.BestChainHash);
_chainStateInfo = await _chainStateInfoCollection.GetAsync(chain.Id.ToStorageKey());
}
public async Task GlobalSetup()
{
_blockchainService = GetRequiredService <IBlockchainService>();
_blockExecutingService = GetRequiredService <IBlockExecutingService>();
_transactionResultManager = GetRequiredService <ITransactionResultManager>();
_blockStateSets = GetRequiredService <INotModifiedCachedStateStore <BlockStateSet> >();
_osTestHelper = GetRequiredService <OSTestHelper>();
}
public BestChainFoundEventHandler(ITransactionResultManager transactionResultManager,
ITransactionBlockIndexManager transactionBlockIndexManager,
IBlockchainService blockchainService)
{
_transactionResultManager = transactionResultManager;
_transactionBlockIndexManager = transactionBlockIndexManager;
_blockchainService = blockchainService;
}
public NewIrreversibleBlockFoundEventHandler(ITransactionResultManager transactionResultManager,
ITransactionBlockIndexManager transactionBlockIndexManager,
IBlockchainService blockchainService)
{
_transactionResultManager = transactionResultManager;
_transactionBlockIndexManager = transactionBlockIndexManager;
_blockchainService = blockchainService;
}
public ContractBasicTests()
{
_blockchainService = GetRequiredService <IBlockchainService>();
_miningService = GetRequiredService <IMiningService>();
_blockAttachService = GetRequiredService <IBlockAttachService>();
_transactionResultManager = GetRequiredService <ITransactionResultManager>();
InitializeTestContracts();
}
public TransactionResultServiceTests()
{
_kernelTestHelper = GetRequiredService <KernelTestHelper>();
_blockchainService = GetRequiredService <IBlockchainService>();
_transactionResultService = GetRequiredService <ITransactionResultService>();
_transactionResultManager = GetRequiredService <ITransactionResultManager>();
_transacionBlockIndexManager = GetRequiredService <ITransactionBlockIndexManager>();
_localEventBus = GetRequiredService <ILocalEventBus>();
}
public BlockExecutingServiceTests()
{
_blockExecutingService = GetRequiredService <BlockExecutingService>();
_kernelTestHelper = GetRequiredService <KernelTestHelper>();
_smartContractExecutionHelper = GetRequiredService <SmartContractExecutionHelper>();
_smartContractAddressService = GetRequiredService <ISmartContractAddressService>();
_blockStateSetManger = GetRequiredService <IBlockStateSetManger>();
_transactionResultManager = GetRequiredService <ITransactionResultManager>();
_systemTransactionExtraDataProvider = GetRequiredService <ISystemTransactionExtraDataProvider>();
}
public BlockExecutor(IChainService chainService, IExecutingService executingService,
ITransactionResultManager transactionResultManager, ClientManager clientManager,
IBinaryMerkleTreeManager binaryMerkleTreeManager, ITxHub txHub, IChainManagerBasic chainManagerBasic, IStateStore stateStore)
{
_chainService = chainService;
_executingService = executingService;
_transactionResultManager = transactionResultManager;
_clientManager = clientManager;
_binaryMerkleTreeManager = binaryMerkleTreeManager;
_txHub = txHub;
_chainManagerBasic = chainManagerBasic;
_stateStore = stateStore;
_dpoSInfoProvider = new DPoSInfoProvider(_stateStore);
_logger = LogManager.GetLogger(nameof(BlockExecutor));
MessageHub.Instance.Subscribe <DPoSStateChanged>(inState => _isMining = inState.IsMining);
_executing = false;
_prepareTerminated = false;
_terminated = false;
MessageHub.Instance.Subscribe <TerminationSignal>(signal =>
{
if (signal.Module == TerminatedModuleEnum.BlockExecutor)
{
if (!_executing)
{
_terminated = true;
MessageHub.Instance.Publish(new TerminatedModule(TerminatedModuleEnum.BlockExecutor));
}
else
{
_prepareTerminated = true;
}
}
});
MessageHub.Instance.Subscribe <StateEvent>(inState =>
{
if (inState == StateEvent.RollbackFinished)
{
_isLimitExecutionTime = false;
}
if (inState == StateEvent.MiningStart)
{
_isLimitExecutionTime = true;
}
_logger?.Trace($"Current Event: {inState.ToString()} ,IsLimitExecutionTime: {_isLimitExecutionTime}");
});
}
public ParallelTests()
{
_blockchainService = GetRequiredService <IBlockchainService>();
_blockExecutingService = GetRequiredService <IBlockExecutingService>();
_transactionResultManager = GetRequiredService <ITransactionResultManager>();
_grouper = GetRequiredService <ITransactionGrouper>();
_contractRemarksService = GetRequiredService <IContractRemarksService>();
_txHub = GetRequiredService <ITxHub>();
_blockAttachService = GetRequiredService <IBlockAttachService>();
_accountService = GetRequiredService <IAccountService>();
_parallelTestHelper = GetRequiredService <ParallelTestHelper>();
_smartContractAddressService = GetRequiredService <ISmartContractAddressService>();
}
public ParallelTests()
{
_blockchainService = GetRequiredService <IBlockchainService>();
_blockExecutingService = GetRequiredService <IBlockExecutingService>();
_minerService = GetRequiredService <IMinerService>();
_transactionResultManager = GetRequiredService <ITransactionResultManager>();
_grouper = GetRequiredService <ITransactionGrouper>();
_codeRemarksManager = GetRequiredService <ICodeRemarksManager>();
_txHub = GetRequiredService <ITxHub>();
_blockAttachService = GetRequiredService <IBlockAttachService>();
_accountService = GetRequiredService <IAccountService>();
_parallelTestHelper = GetRequiredService <ParallelTestHelper>();
}
public async Task GlobalSetup()
{
_blockchainService = GetRequiredService <IBlockchainService>();
_osTestHelper = GetRequiredService <OSTestHelper>();
_minerService = GetRequiredService <IMinerService>();
_transactionResultManager = GetRequiredService <ITransactionResultManager>();
_blockStateSets = GetRequiredService <INotModifiedCachedStateStore <BlockStateSet> >();
_transactionManager = GetRequiredService <ITransactionManager>();
_txHub = GetRequiredService <ITxHub>();
_transactions = new List <Transaction>();
_chain = await _blockchainService.GetChainAsync();
}
public SmartContractHelper(ITransactionExecutingService transactionExecutingService,
IDefaultContractZeroCodeProvider defaultContractZeroCodeProvider, IBlockStateSetManger blockStateSetManger,
IBlockchainService blockchainService, ITransactionResultManager transactionResultManager,
KernelTestHelper kernelTestHelper)
{
_transactionExecutingService = transactionExecutingService;
_defaultContractZeroCodeProvider = defaultContractZeroCodeProvider;
_blockStateSetManger = blockStateSetManger;
_blockchainService = blockchainService;
_transactionResultManager = transactionResultManager;
_kernelTestHelper = kernelTestHelper;
Codes = ContractsDeployer.GetContractCodes <SmartContractTestAElfModule>();
}
public async Task GlobalSetup()
{
_blockchainService = GetRequiredService <IBlockchainService>();
_blockExecutingService = GetRequiredService <IBlockExecutingService>();
_minerService = GetRequiredService <IMinerService>();
_transactionResultManager = GetRequiredService <ITransactionResultManager>();
_blockStateSets = GetRequiredService <INotModifiedCachedStateStore <BlockStateSet> >();
_osTestHelper = GetRequiredService <OSTestHelper>();
_prepareTransactions = new List <Transaction>();
_systemTransactions = new List <Transaction>();
_cancellableTransactions = new List <Transaction>();
_keyPairs = new List <ECKeyPair>();
}
public async Task GlobalSetup()
{
_chains = GetRequiredService <IBlockchainStore <Chain> >();
_blockStateSets = GetRequiredService <INotModifiedCachedStateStore <BlockStateSet> >();
_chainManager = GetRequiredService <IChainManager>();
_blockManager = GetRequiredService <IBlockManager>();
_transactionResultManager = GetRequiredService <ITransactionResultManager>();
_blockchainService = GetRequiredService <IBlockchainService>();
_blockAttachService = GetRequiredService <IBlockAttachService>();
_transactionManager = GetRequiredService <ITransactionManager>();
_osTestHelper = GetRequiredService <OSTestHelper>();
_chain = await _blockchainService.GetChainAsync();
}
public TransactionResultTest(ITxPoolConfig txPoolConfig, IChainService chainService,
ITxSignatureVerifier signatureVerifier, ITxRefBlockValidator refBlockValidator,
ITransactionResultManager transactionResultManager, ITxHub txHub)
{
ChainConfig.Instance.ChainId = Hash.Generate().DumpHex();
NodeConfig.Instance.NodeAccount = Address.Generate().DumpHex();
_transactionResultManager = transactionResultManager;
_signatureVerifier = signatureVerifier;
_refBlockValidator = refBlockValidator;
_txHub = txHub;
// _transactionResultService = new TransactionResultService(
// new TxPool(logger,
// new NewTxHub(transactionManager, chainService, signatureVerifier, refBlockValidator)), transactionResultManager);
_transactionResultService = new TransactionResultService(_txHub, _transactionResultManager);
}
public BlockExecutionService(IExecutingService executingService, ITxPoolService txPoolService,
IChainService chainService, ITransactionManager transactionManager,
ITransactionResultManager transactionResultManager, IStateDictator stateDictator,
IBinaryMerkleTreeManager binaryMerkleTreeManager)
{
_executingService = executingService;
_txPoolService = txPoolService;
_chainService = chainService;
_transactionManager = transactionManager;
_transactionResultManager = transactionResultManager;
_stateDictator = stateDictator;
_binaryMerkleTreeManager = binaryMerkleTreeManager;
_logger = LogManager.GetLogger(nameof(BlockExecutionService));
}
public MockSetup(IDataStore dataStore, IStateStore stateStore, ITxHub txHub)
{
_dataStore = dataStore;
_stateStore = stateStore;
_smartContractManager = new SmartContractManager(_dataStore);
_transactionManager = new TransactionManager(_dataStore);
_transactionTraceManager = new TransactionTraceManager(_dataStore);
_transactionResultManager = new TransactionResultManager(_dataStore);
_smartContractRunnerFactory = new SmartContractRunnerFactory();
_concurrencyExecutingService = new SimpleExecutingService(
new SmartContractService(_smartContractManager, _smartContractRunnerFactory, _stateStore,
_functionMetadataService), _transactionTraceManager, _stateStore,
new ChainContextService(GetChainService()));
_txHub = txHub;
_chainManagerBasic = new ChainManagerBasic(dataStore);
}
public ParallelTests()
{
_blockchainService = GetRequiredService <IBlockchainService>();
_blockExecutingService = GetRequiredService <IBlockExecutingService>();
_transactionResultManager = GetRequiredService <ITransactionResultManager>();
_grouper = GetRequiredService <ITransactionGrouper>();
_blockchainStateService = GetRequiredService <IBlockchainStateService>();
_txHub = GetRequiredService <ITxHub>();
_blockAttachService = GetRequiredService <IBlockAttachService>();
_accountService = GetRequiredService <IAccountService>();
_parallelTestHelper = GetRequiredService <ParallelTestHelper>();
_smartContractAddressService = GetRequiredService <ISmartContractAddressService>();
_blockchainStateManager = GetRequiredService <IBlockchainStateManager>();
_versionedStates = GetRequiredService <IStateStore <VersionedState> >();
_nonparallelContractCodeProvider = GetRequiredService <INonparallelContractCodeProvider>();
_blockStateSetManger = GetRequiredService <IBlockStateSetManger>();
}
public ChainCreationEventListener(ILogger logger, ITransactionResultManager transactionResultManager,
IChainCreationService chainCreationService, IChainManagerBasic chainManagerBasic)
{
_logger = logger;
TransactionResultManager = transactionResultManager;
ChainCreationService = chainCreationService;
_chainManagerBasic = chainManagerBasic;
_interestedLogEvent = new LogEvent()
{
Address = GetGenesisContractHash(),
Topics =
{
ByteString.CopyFrom("SideChainCreationRequestApproved".CalculateHash())
}
};
_bloom = _interestedLogEvent.GetBloom();
InitializeClient();
}
public Miner(IMinerConfig config, ITxHub txHub, IChainService chainService,
IExecutingService executingService, ITransactionResultManager transactionResultManager,
ILogger logger, ClientManager clientManager,
IBinaryMerkleTreeManager binaryMerkleTreeManager, ServerManager serverManager,
IBlockValidationService blockValidationService, IChainContextService chainContextService, IChainManagerBasic chainManagerBasic, IStateStore stateStore)
{
Config = config;
_txHub = txHub;
_chainService = chainService;
_executingService = executingService;
_transactionResultManager = transactionResultManager;
_logger = logger;
_clientManager = clientManager;
_binaryMerkleTreeManager = binaryMerkleTreeManager;
_serverManager = serverManager;
_blockValidationService = blockValidationService;
_chainContextService = chainContextService;
_chainManagerBasic = chainManagerBasic;
_txFilter = new TransactionFilter();
_dpoSInfoProvider = new DPoSInfoProvider(stateStore);
_maxMineTime = ConsensusConfig.Instance.DPoSMiningInterval * NodeConfig.Instance.RatioMine;
}
public TransactionResultService(ITxHub txHub, ITransactionResultManager transactionResultManager)
{
_txHub = txHub;
_transactionResultManager = transactionResultManager;
}
