public IEnumerable <GenesisSmartContractDto> GetGenesisSmartContractDtos()
{
var codes = ContractsDeployer.GetContractCodes <MethodFeeTestGenesisSmartContractDtoProvider>();
var deploymentList = _contractDeploymentListProvider.GetDeployContractNameList();
return(_contractInitializationProviders
.Where(p => deploymentList.Contains(p.SystemSmartContractName))
.OrderBy(p => deploymentList.IndexOf(p.SystemSmartContractName))
.Select(p =>
{
var code = codes[p.ContractCodeName];
var methodList = p.GetInitializeMethodList(code);
var genesisSmartContractDto = new GenesisSmartContractDto
{
Code = code,
SystemSmartContractName = p.SystemSmartContractName,
ContractInitializationMethodCallList = new List <ContractInitializationMethodCall>()
};
foreach (var method in methodList)
{
genesisSmartContractDto.AddGenesisTransactionMethodCall(method);
}
return genesisSmartContractDto;
}));
}
public GenesisSmartContractDtoProvider(IOptionsSnapshot <ConsensusOptions> dposOptions,
IOptionsSnapshot <EconomicOptions> economicOptions, IOptionsSnapshot <ContractOptions> contractOptions)
{
_consensusOptions = dposOptions.Value;
_economicOptions = economicOptions.Value;
_contractOptions = contractOptions.Value;
_codes = ContractsDeployer.GetContractCodes <GenesisSmartContractDtoProvider>(_contractOptions
.GenesisContractDir);
}
public GenesisSmartContractDtoProvider(IOptionsSnapshot <ConsensusOptions> consensusOptions,
IOptionsSnapshot <ContractOptions> contractOptions, ISideChainInitializationDataProvider sideChainInitializationDataProvider)
{
_sideChainInitializationDataProvider = sideChainInitializationDataProvider;
_consensusOptions = consensusOptions.Value;
_contractOptions = contractOptions.Value;
_codes = ContractsDeployer.GetContractCodes <GenesisSmartContractDtoProvider>(_contractOptions
.GenesisContractDir);
}
private async Task <Dictionary <Hash, Address> > DeployCommitmentSchemeContract()
{
return(await BlockMiningService.DeploySystemContractsAsync(new Dictionary <Hash, byte[]>
{
{
CommitmentSchemeSmartContractAddressName,
ContractsDeployer.GetContractCodes <AEDPoSExtensionDemoModule>().Last().Value
}
}, false));
}
public SmartContractExecutionHelper(IBlockExecutingService blockExecutingService,
IBlockchainService blockchainService, IBlockchainExecutingService blockchainExecutingService,
IBlockExecutionResultProcessingService blockExecutionResultProcessingService,
IDefaultContractZeroCodeProvider defaultContractZeroCodeProvider)
{
_blockExecutingService = blockExecutingService;
_blockchainService = blockchainService;
_blockchainExecutingService = blockchainExecutingService;
_blockExecutionResultProcessingService = blockExecutionResultProcessingService;
_defaultContractZeroCodeProvider = defaultContractZeroCodeProvider;
ContractCodes = ContractsDeployer.GetContractCodes <SmartContractExecutionTestAElfModule>();
}
/// <summary>
/// Only deploy provided contracts as system contract.
/// Should initial each contract after if necessary.
/// </summary>
/// <param name="nameToCode"></param>
/// <param name="deployConsensusContract"></param>
/// <returns></returns>
public async Task <Dictionary <Hash, Address> > DeploySystemContractsAsync(Dictionary <Hash, byte[]> nameToCode,
bool deployConsensusContract = true)
{
var map = new Dictionary <Hash, Address>();
var zeroContractStub =
_contractTesterFactory.Create <BasicContractZeroContainer.BasicContractZeroStub>(
_smartContractAddressService.GetZeroSmartContractAddress(),
MissionedECKeyPairs.InitialKeyPairs.First());
if (!nameToCode.Keys.Contains(ConsensusSmartContractAddressNameProvider.Name) && deployConsensusContract)
{
nameToCode.Add(ConsensusSmartContractAddressNameProvider.Name,
ContractsDeployer.GetContractCodes <ContractTestAEDPoSExtensionModule>().First().Value);
}
foreach (var(name, code) in nameToCode)
{
var address = (await zeroContractStub.DeploySystemSmartContract.SendAsync(
new SystemContractDeploymentInput
{
Name = name,
Category = KernelConstants.CodeCoverageRunnerCategory,
Code = ByteString.CopyFrom(code),
})).Output;
if (address == null)
{
//throw new Exception($"Failed to deploy contract {name}");
}
map.Add(name, address);
if (name == ConsensusSmartContractAddressNameProvider.Name)
{
_consensusContractAddress = address;
}
if (name == ParliamentSmartContractAddressNameProvider.Name)
{
_parliamentContractAddress = address;
}
}
_isSystemContractsDeployed = true;
var currentBlockTime = TimestampHelper.GetUtcNow().ToDateTime();
_testDataProvider.SetBlockTime(currentBlockTime.ToTimestamp()
.AddMilliseconds(AEDPoSExtensionConstants.MiningInterval));
InitialContractStubs();
await InitialConsensus(currentBlockTime);
return(map);
}
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>();
}
DeployRandomNumberProviderContract()
{
var address = (await BasicContractZeroStub.DeploySmartContract.SendAsync(new ContractDeploymentInput
{
Category = KernelConstants.DefaultRunnerCategory,
Code = ByteString.CopyFrom(ContractsDeployer.GetContractCodes <AEDPoSExtensionDemoModule>()
.Single(kv => kv.Key.EndsWith("RandomNumberProvider"))
.Value)
})).Output;
return(GetTester <RandomNumberProviderContractContainer.RandomNumberProviderContractStub>(address,
Accounts[0].KeyPair));
}
private byte[] GetContractCodes()
{
return(ContractsDeployer.GetContractCodes <DeployContractsSystemTransactionGenerator>(_contractOptions
.GenesisContractDir)["AElf.Contracts.GreeterContract"]);
}
public override void OnPreApplicationInitialization(ApplicationInitializationContext context)
{
var contractCodeProvider = context.ServiceProvider.GetService <IContractCodeProvider>();
contractCodeProvider.Codes = ContractsDeployer.GetContractCodes <MainChainTestModule>();
}
public GenesisSmartContractDtoProvider(IOptionsSnapshot <ConsensusOptions> consensusOptions,
IOptionsSnapshot <EconomicOptions> economicOptions, ContractsDeployer contractsDeployer,
IAccountService accountService, ISmartContractAddressService smartContractAddressService)
{
_accountService = accountService;
_smartContractAddressService = smartContractAddressService;
_consensusOptions = consensusOptions.Value;
_economicOptions = economicOptions.Value;
_codes = contractsDeployer.GetContractCodes <GenesisSmartContractDtoProvider>();
}
protected override IReadOnlyDictionary <string, byte[]> GetContractCodes()
{
return(ContractsDeployer.GetContractCodes <MainChainGenesisSmartContractDtoProvider>(_contractOptions
.GenesisContractDir));
}
public GenesisSmartContractDtoProvider(IOptionsSnapshot <ConsensusOptions> dposOptions,
IOptionsSnapshot <TokenInitialOptions> tokenInitialOptions, ContractsDeployer contractsDeployer)
{
_consensusOptions = dposOptions.Value;
_tokenInitialOptions = tokenInitialOptions.Value;
_codes = contractsDeployer.GetContractCodes <GenesisSmartContractDtoProvider>();
}
