public async Task SmartContractAddress_Set_And_Get_Test()
{
var chain = await _smartContractHelper.CreateChainAsync();
var contractName = Hash.Empty.ToStorageKey();
var chainContext = new ChainContext
{
BlockHash = chain.BestChainHash,
BlockHeight = chain.BestChainHeight
};
var smartContractAddress =
await _smartContractAddressProvider.GetSmartContractAddressAsync(chainContext, contractName);
smartContractAddress.ShouldBeNull();
await _smartContractAddressProvider.SetSmartContractAddressAsync(chainContext, contractName,
SampleAddress.AddressList[0]);
var blockExecutedDataKey = $"BlockExecutedData/SmartContractAddress/{contractName}";
var blockStateSet = await _blockStateSetManger.GetBlockStateSetAsync(chain.BestChainHash);
blockStateSet.BlockExecutedData.ShouldContainKey(blockExecutedDataKey);
smartContractAddress =
await _smartContractAddressProvider.GetSmartContractAddressAsync(chainContext, contractName);
smartContractAddress.Address.ShouldBe(SampleAddress.AddressList[0]);
smartContractAddress.BlockHeight = chainContext.BlockHeight;
smartContractAddress.BlockHash = chainContext.BlockHash;
}
/// <summary>
/// Get consensus system tx list.
/// </summary>
/// <param name="chainContext"></param>
/// <returns></returns>
public async Task <List <Transaction> > GenerateConsensusTransactionsAsync(ChainContext chainContext)
{
_blockTimeProvider.SetBlockTime(_nextMiningTime);
Logger.LogDebug(
$"Set block time to next mining time: {_nextMiningTime.ToDateTime():hh:mm:ss.ffffff}. Txs.");
var contractReaderContext =
await _consensusReaderContextService.GetContractReaderContextAsync(chainContext);
var generatedTransactions =
(await _contractReaderFactory
.Create(contractReaderContext)
.GenerateConsensusTransactions
.CallAsync(_triggerInformationProvider.GetTriggerInformationForConsensusTransactions(
_consensusCommand.ToBytesValue())))
.Transactions
.ToList();
// Complete these transactions.
foreach (var generatedTransaction in generatedTransactions)
{
generatedTransaction.RefBlockNumber = chainContext.BlockHeight;
generatedTransaction.RefBlockPrefix =
BlockHelper.GetRefBlockPrefix(chainContext.BlockHash);
Logger.LogDebug($"Consensus transaction generated: \n{generatedTransaction.GetHash()}");
}
return(generatedTransactions);
}
public async Task SmartContractAddress_Get_WithFork_Test()
{
var chain = await _smartContractHelper.CreateChainAsync();
var block = await _kernelTestHelper.AttachBlockToBestChain();
await _blockchainService.SetIrreversibleBlockAsync(chain, block.Height,
block.GetHash());
block = _kernelTestHelper.GenerateBlock(block.Header.Height - 1, block.Header.PreviousBlockHash);
await _blockStateSetManger.SetBlockStateSetAsync(new BlockStateSet
{
BlockHash = block.GetHash(),
BlockHeight = block.Height
});
var chainContext = new ChainContext
{
BlockHash = block.GetHash(),
BlockHeight = block.Height
};
var contractName = Hash.Empty.ToStorageKey();
await _smartContractAddressService.SetSmartContractAddressAsync(chainContext, contractName,
SampleAddress.AddressList[0]);
var smartContractAddressDto = await _smartContractAddressService.GetSmartContractAddressAsync(chainContext, contractName);
smartContractAddressDto.SmartContractAddress.ShouldBe(new SmartContractAddress
{
Address = SampleAddress.AddressList[0],
BlockHash = block.GetHash(),
BlockHeight = block.Height
});
smartContractAddressDto.Irreversible.ShouldBeFalse();
}
public async Task SmartContractAddress_Get_WithHeightLargeThanLIB_Test()
{
await _smartContractHelper.CreateChainAsync();
var block = await _kernelTestHelper.AttachBlockToBestChain();
var chainContext = new ChainContext
{
BlockHash = block.GetHash(),
BlockHeight = block.Height
};
var contractName = Hash.Empty.ToStorageKey();
await _smartContractAddressService.SetSmartContractAddressAsync(chainContext, contractName,
SampleAddress.AddressList[0]);
var address = await _smartContractAddressService.GetAddressByContractNameAsync(chainContext, contractName);
address.ShouldBe(SampleAddress.AddressList[0]);
var smartContractAddressDto = await _smartContractAddressService.GetSmartContractAddressAsync(chainContext, contractName);
smartContractAddressDto.SmartContractAddress.ShouldBe(new SmartContractAddress
{
Address = SampleAddress.AddressList[0],
BlockHash = block.GetHash(),
BlockHeight = block.Height
});
smartContractAddressDto.Irreversible.ShouldBeFalse();
}
/// <inheritdoc />
/// <summary>
/// Mine process.
/// </summary>
/// <returns></returns>
public async Task <BlockExecutedSet> MineAsync(Hash previousBlockHash, long previousBlockHeight,
Timestamp blockTime,
Duration blockExecutionTime)
{
var txList = new List <Transaction>();
var chainContext = new ChainContext
{
BlockHash = previousBlockHash,
BlockHeight = previousBlockHeight
};
var limit = await _blockTransactionLimitProvider.GetLimitAsync(chainContext);
if (_transactionPackingOptionProvider.IsTransactionPackable(chainContext))
{
var executableTransactionSet = await _transactionPoolService.GetExecutableTransactionSetAsync(
previousBlockHash, limit);
txList.AddRange(executableTransactionSet.Transactions);
}
Logger.LogInformation(
$"Start mining with previous hash: {previousBlockHash}, previous height: {previousBlockHeight}.");
return(await _miningService.MineAsync(
new RequestMiningDto
{
PreviousBlockHash = previousBlockHash,
PreviousBlockHeight = previousBlockHeight,
BlockExecutionTime = blockExecutionTime,
TransactionCountLimit = limit
}, txList, blockTime));
}
public async Task HandleEventAsync(ConflictingTransactionsFoundInParallelGroupsEvent eventData)
{
var chainContext = new ChainContext
{
BlockHash = eventData.BlockHeader.PreviousBlockHash,
BlockHeight = eventData.BlockHeader.Height - 1
};
var wrongTxWithResources = await _conflictingTransactionIdentificationService.IdentifyConflictingTransactionsAsync(
chainContext, eventData.ExistingSets, eventData.ConflictingSets);
var wrongTransactionIds = wrongTxWithResources.Select(t => t.Transaction.GetHash()).ToArray();
var dic = wrongTxWithResources.GroupBy(t => t.Transaction.To)
.ToDictionary(g => g.Key, g => new NonparallelContractCode
{
CodeHash = g.First().TransactionResourceInfo.ContractHash
});
await _nonparallelContractCodeProvider.SetNonparallelContractCodeAsync(new BlockIndex
{
BlockHash = eventData.BlockHeader.GetHash(),
BlockHeight = eventData.BlockHeader.Height
}, dic);
_resourceExtractionService.ClearConflictingTransactionsResourceCache(wrongTransactionIds);
}
async ValueTask IConnector <TInput> .ProcessAsync(TInput input, ChainContext context)
{
TOutput result;
var startTickCount = Environment.TickCount64;
try
{
context.EventBroker.Publish(new ConnectorStartingEvent(context, this));
context.CancellationToken.ThrowIfCancellationRequested();
result = await ProcessAsync(input, context);
}
catch (Exception exception)
{
context.SetResult(ExecutionResult.Faulted, exception);
return;
}
finally
{
var duration = TimeSpan.FromMilliseconds(Environment.TickCount64 - startTickCount);
context.EventBroker.Publish(new ConnectorStoppedEvent(context, this, duration));
}
if (context.Result == ExecutionResult.Unknown)
{
await _nextConnector.ProcessAsync(result, context);
}
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var functions = Sql.ExtensionAttribute.GetExtensionAttributes(methodCall, builder.MappingSchema);
var root = methodCall.SkipMethodChain(builder.MappingSchema);
// evaluating IQueryableContainer
while (root.NodeType == ExpressionType.Constant && typeof(Sql.IQueryableContainer).IsSameOrParentOf(root.Type))
{
root = ((Sql.IQueryableContainer)root.EvaluateExpression() !).Query.Expression;
root = root.SkipMethodChain(builder.MappingSchema);
}
root = builder.ConvertExpressionTree(root);
var prevSequence = builder.BuildSequence(new BuildInfo(buildInfo, root)
{
CreateSubQuery = true
});
var finalFunction = functions.First();
var sequence = prevSequence;
if (finalFunction.IsAggregate)
{
// Wrap by subquery to handle aggregate limitations, especially for SQL Server
//
sequence = new SubQueryContext(sequence);
}
var context = new ChainContext(buildInfo.Parent, sequence, methodCall);
var sqlExpression = finalFunction.GetExpression((builder, context), builder.DataContext, context.SelectQuery, methodCall,
// Token: 0x06001C2E RID: 7214 RVA: 0x0006FA44 File Offset: 0x0006DC44
internal string EncodeCertChain(ChainContext chainContext, bool includeRootCert, X509Certificate2 signersCertificate)
{
uint count = (uint)chainContext.GetChains().Count;
List <byte[]>[] array = new List <byte[]> [count];
uint[] array2 = new uint[count];
uint[] array3 = new uint[count];
uint num = 16U;
int num2 = 0;
foreach (CertificateChain certificateChain in chainContext.GetChains())
{
array3[num2] = 16U;
array2[num2] = 0U;
array[num2] = new List <byte[]>(certificateChain.Elements.Count);
foreach (ChainElement chainElement in certificateChain.Elements)
{
if (!signersCertificate.Equals(chainElement.Certificate) && (includeRootCert || (chainElement.TrustInformation & TrustInformation.IsSelfSigned) == TrustInformation.None))
{
array3[num2] += 12U;
byte[] rawData = chainElement.Certificate.RawData;
array[num2].Add(rawData);
array3[num2] += (uint)rawData.Length;
array2[num2] += 1U;
}
}
num += array3[num2];
num2++;
}
byte[] array4 = new byte[num];
int num3 = 0;
num3 += ExBitConverter.Write(num, array4, num3);
num3 += ExBitConverter.Write((uint)chainContext.Status, array4, num3);
num3 += ExBitConverter.Write((uint)chainContext.TrustInformation, array4, num3);
num3 += ExBitConverter.Write(count, array4, num3);
num2 = 0;
foreach (CertificateChain certificateChain2 in chainContext.GetChains())
{
num3 += ExBitConverter.Write(array3[num2], array4, num3);
num3 += ExBitConverter.Write((uint)certificateChain2.Status, array4, num3);
num3 += ExBitConverter.Write((uint)certificateChain2.TrustInformation, array4, num3);
num3 += ExBitConverter.Write(array2[num2], array4, num3);
int num4 = 0;
foreach (ChainElement chainElement2 in certificateChain2.Elements)
{
if (!signersCertificate.Equals(chainElement2.Certificate) && (includeRootCert || (chainElement2.TrustInformation & TrustInformation.IsSelfSigned) == TrustInformation.None))
{
num3 += ExBitConverter.Write((uint)(array[num2][num4].Length + 12), array4, num3);
num3 += ExBitConverter.Write((uint)chainElement2.Status, array4, num3);
num3 += ExBitConverter.Write((uint)chainElement2.TrustInformation, array4, num3);
Array.Copy(array[num2][num4], 0, array4, num3, array[num2][num4].Length);
num3 += array[num2][num4].Length;
num4++;
}
}
num2++;
}
return(Convert.ToBase64String(array4));
}
public async Task IsViewTransactionAsync_Test()
{
var chain = await BlockchainService.GetChainAsync();
var context = new ChainContext
{
BlockHash = chain.BestChainHash,
BlockHeight = chain.BestChainHeight
};
var transaction = OsTestHelper.GenerateTransaction(SampleAddress.AddressList[0],
await SmartContractAddressService.GetAddressByContractNameAsync(context, TokenSmartContractAddressNameProvider.StringName),
"GetBalance", new GetBalanceInput
{
Owner = SampleAddress.AddressList[0],
Symbol = "ELF"
});
var result = await TransactionReadOnlyExecutionService.IsViewTransactionAsync(context, transaction);
result.ShouldBeTrue();
transaction = OsTestHelper.GenerateTransaction(SampleAddress.AddressList[0],
await SmartContractAddressService.GetAddressByContractNameAsync(context,
TokenSmartContractAddressNameProvider.StringName),
"Transfer", new TransferInput
{
To = SampleAddress.AddressList[1],
Symbol = "ELF",
Amount = 10
});
result = await TransactionReadOnlyExecutionService.IsViewTransactionAsync(context, transaction);
result.ShouldBeFalse();
}
public async Task <List <ExecutionReturnSet> > ExecuteAsync(TransactionExecutingDto transactionExecutingDto,
CancellationToken cancellationToken)
{
Logger.LogTrace("Entered parallel ExecuteAsync.");
var transactions = transactionExecutingDto.Transactions.ToList();
var blockHeader = transactionExecutingDto.BlockHeader;
var chainContext = new ChainContext
{
BlockHash = blockHeader.PreviousBlockHash,
BlockHeight = blockHeader.Height - 1
};
var groupedTransactions = await _grouper.GroupAsync(chainContext, transactions);
var returnSets = new List <ExecutionReturnSet>();
var nonParallelizableReturnSets = await _planTransactionExecutingService.ExecuteAsync(
new TransactionExecutingDto
{
BlockHeader = blockHeader,
Transactions = groupedTransactions.NonParallelizables,
PartialBlockStateSet = transactionExecutingDto.PartialBlockStateSet
},
cancellationToken);
Logger.LogTrace("Merged results from non-parallelizables.");
returnSets.AddRange(nonParallelizableReturnSets);
var returnSetCollection = new ReturnSetCollection(returnSets);
var updatedPartialBlockStateSet = GetUpdatedBlockStateSet(returnSetCollection, transactionExecutingDto);
var tasks = groupedTransactions.Parallelizables.Select(
txns => ExecuteAndPreprocessResult(new TransactionExecutingDto
{
BlockHeader = blockHeader,
Transactions = txns,
PartialBlockStateSet = updatedPartialBlockStateSet,
}, cancellationToken));
var results = await Task.WhenAll(tasks);
Logger.LogTrace("Executed parallelizables.");
returnSets.AddRange(MergeResults(results, out var conflictingSets));
Logger.LogTrace("Merged results from parallelizables.");
var transactionWithoutContractReturnSets = await ProcessTransactionsWithoutContract(
groupedTransactions.TransactionsWithoutContract, blockHeader);
Logger.LogTrace("Merged results from transactions without contract.");
returnSets.AddRange(transactionWithoutContractReturnSets);
if (conflictingSets.Count > 0 &&
returnSets.Count + conflictingSets.Count == transactionExecutingDto.Transactions.Count())
{
await ProcessConflictingSetsAsync(conflictingSets, blockHeader);
returnSets.AddRange(conflictingSets);
}
return(returnSets);
}
public async Task <IEnumerable <string> > GetCurrentMinerList(ChainContext chainContext)
{
var minersWithRoundNumber =
await _readerFactory.Create(chainContext).GetCurrentMinerList.CallAsync(new Empty());
return(minersWithRoundNumber.Pubkeys.Select(k => k.ToHex()));
}
private void CheckBlockExecutedData(BlockStateSet blockStateSet, Chain chain,
TransactionResult transactionResult, Dictionary <string, Transaction> transactionDic)
{
var chainContext = new ChainContext
{
BlockHash = blockStateSet.BlockHash,
BlockHeight = blockStateSet.BlockHeight
};
var chainFromBlockExecutedData =
_chainBlockchainExecutedDataService.GetBlockExecutedData(chainContext,
GetBlockExecutedDataKey <Chain>());
chainFromBlockExecutedData.ShouldBe(chain);
var transactionResultFromBlockExecutedData =
_transactionResultBlockchainExecutedDataService.GetBlockExecutedData(chainContext,
GetBlockExecutedDataKey <TransactionResult>(transactionResult.TransactionId));
transactionResultFromBlockExecutedData.ShouldBe(transactionResult);
foreach (var keyPair in transactionDic)
{
var transaction =
_transactionBlockchainExecutedDataService.GetBlockExecutedData(chainContext, keyPair.Key);
transaction.ShouldBe(keyPair.Value);
}
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var functions = Sql.ExtensionAttribute.GetExtensionAttributes(methodCall, builder.MappingSchema);
var root = methodCall.SkipMethodChain(builder.MappingSchema);
// evaluating IQueryableContainer
while (root.NodeType == ExpressionType.Constant && typeof(Sql.IQueryableContainer).IsSameOrParentOf(root.Type))
{
root = ((Sql.IQueryableContainer)root.EvaluateExpression() !).Query.Expression;
root = root.SkipMethodChain(builder.MappingSchema);
}
root = builder.ConvertExpressionTree(root);
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, root)
{
CreateSubQuery = true
});
var finalFunction = functions.First();
var sqlExpression = finalFunction.GetExpression(builder.DataContext, buildInfo.SelectQuery, methodCall,
(e, descriptor) => builder.ConvertToExtensionSql(sequence, e, descriptor));
var context = new ChainContext(buildInfo.Parent, sequence, methodCall);
context.Sql = context.SelectQuery;
context.FieldIndex = context.SelectQuery.Select.Add(sqlExpression, methodCall.Method.Name);
return(context);
}
public async Task TransactionReadOnlyExecutionServiceExtensions_Test()
{
var chain = await BlockchainService.GetChainAsync();
var context = new ChainContext
{
BlockHash = chain.BestChainHash,
BlockHeight = chain.BestChainHeight
};
var transaction = OsTestHelper.GenerateTransaction(SampleAddress.AddressList[0],
SmartContractAddressService.GetAddressByContractName(TokenSmartContractAddressNameProvider.Name),
"GetBalance", new GetBalanceInput
{
Owner = SampleAddress.AddressList[0],
Symbol = "ELF"
});
var result = await TransactionReadOnlyExecutionService.ExecuteAsync <GetBalanceOutput>(context, transaction,
TimestampHelper.GetUtcNow(),
true);
result.Balance.ShouldBe(0);
result.Symbol.ShouldBe("ELF");
//without such method and call
transaction.MethodName = "NotExist";
await Should.ThrowAsync <SmartContractExecutingException>(async() =>
{
await TransactionReadOnlyExecutionService.ExecuteAsync <GetBalanceOutput>(context, transaction,
TimestampHelper.GetUtcNow(),
true);
});
}
public async Task <byte[]> GetInformationToUpdateConsensusAsync(ChainContext chainContext,
DateTime nextMiningTime)
{
return((await ExecuteContractAsync <DPoSHeaderInformation>(chainContext,
ConsensusConsts.GetInformationToUpdateConsensus,
GetTriggerInformation(TriggerType.BlockHeaderExtraData), nextMiningTime)).ToByteArray());
}
public async Task <IEnumerable <string> > GetCurrentMiners(ChainContext chainContext)
{
var minersWithRoundNumber = await _consensusInformationGenerationService.ExecuteContractAsync <MinerListWithRoundNumber>(chainContext,
"GetCurrentMiners", new Empty(), DateTime.UtcNow);
return(minersWithRoundNumber.MinerList.PublicKeys);
}
public async Task <List <Transaction> > GenerateConsensusTransactionsAsync(ChainContext chainContext)
{
_blockTimeProvider.SetBlockTime(_nextMiningTime);
Logger.LogTrace(
$"Set block time to next mining time: {_nextMiningTime.ToDateTime():hh:mm:ss.ffffff}. Txs.");
var generatedTransactions =
(await _readerFactory.Create(chainContext).GenerateConsensusTransactions
.CallAsync(_triggerInformationProvider.GetTriggerInformationForConsensusTransactions(
_consensusCommand.ToBytesValue())))
.Transactions
.ToList();
// Complete these transactions.
foreach (var generatedTransaction in generatedTransactions)
{
generatedTransaction.RefBlockNumber = chainContext.BlockHeight;
generatedTransaction.RefBlockPrefix =
ByteString.CopyFrom(chainContext.BlockHash.Value.Take(4).ToArray());
}
Logger.LogInformation("Consensus transaction generated.");
return(generatedTransactions);
}
public async Task <bool> ValidateConsensusBeforeExecutionAsync(ChainContext chainContext,
byte[] consensusExtraData)
{
var now = TimestampHelper.GetUtcNow();
_blockTimeProvider.SetBlockTime(now);
Logger.LogTrace($"Set block time to utc now: {now.ToDateTime():hh:mm:ss.ffffff}. Validate Before.");
var validationResult = await _readerFactory.Create(chainContext).ValidateConsensusBeforeExecution
.CallAsync(new BytesValue {
Value = ByteString.CopyFrom(consensusExtraData)
});
if (validationResult == null)
{
Logger.LogWarning("Validation of consensus failed before execution.");
return(false);
}
if (!validationResult.Success)
{
Logger.LogWarning($"Consensus validating before execution failed: {validationResult.Message}");
await LocalEventBus.PublishAsync(new ConsensusValidationFailedEventData
{
ValidationResultMessage = validationResult.Message
});
}
return(validationResult.Success);
}
public async Task Net_Token_Fee_Calculate_After_Update_Piecewise_Function_Test()
{
await InitializeCoefficientAsync();
var calculateNetCostStrategy = Application.ServiceProvider.GetRequiredService <ICalculateTrafficCostStrategy>();
var ps = await GetCoefficientByType(FeeTypeEnum.Traffic);
var apiParam = new CalculateFeeCoefficient
{
FeeType = FeeTypeEnum.Traffic,
FunctionType = CalculateFunctionTypeEnum.Liner,
PieceKey = 1000000,
CoefficientDic = { { "numerator", 1 }, { "denominator", 400 } }
};
var blockIndex = new BlockIndex();
IChainContext chainContext = new ChainContext
{
BlockHash = blockIndex.BlockHash,
BlockHeight = blockIndex.BlockHeight
};
var theOne = ps.Coefficients.SingleOrDefault(x => x.PieceKey == 1000000);
ps.Coefficients.Remove(theOne);
ps.Coefficients.Add(apiParam);
await HandleTestAsync(ps, blockIndex);
var size = 10000;
var updatedFee = await calculateNetCostStrategy.GetCostAsync(chainContext, size);
updatedFee.ShouldBe(25_0000_0000);
}
internal static List <ChainValidityStatus> ValidateCertificates(List <string> trustedCertificateList, List <string> certificateChainList, List <string> certificateList, bool checkCRL, int hashCodeForTracing, MailboxLogger mailboxLogger, bool againstADConfiguration, string organizationId)
{
X509Store trustedStore = CertificateManager.AddChainCertsToStore(trustedCertificateList, hashCodeForTracing);
X509Store chainBuildStore = CertificateManager.AddChainCertsToStore(certificateChainList, hashCodeForTracing);
List <ChainValidityStatus> list = new List <ChainValidityStatus>(certificateList.Count);
foreach (string text in certificateList)
{
ChainContext chainContext = null;
try
{
X509Certificate2 certificate = new X509Certificate2(Convert.FromBase64String(text));
ChainValidityStatus item = X509CertificateCollection.ValidateCertificate(certificate, null, X509KeyUsageFlags.NonRepudiation | X509KeyUsageFlags.DigitalSignature, checkCRL, trustedStore, chainBuildStore, ref chainContext, againstADConfiguration, organizationId);
list.Add(item);
}
catch (CryptographicException ex)
{
if (mailboxLogger != null)
{
mailboxLogger.SetData(MailboxLogDataName.ValidateCertCommand_ProcessCommand_Per_Cert_Exception, ex.ToString());
}
AirSyncDiagnostics.TraceError <string, CryptographicException>(ExTraceGlobals.RequestTracer, null, "Failed to validate certificate: '{0}', Error: '{1}'", text, ex);
list.Add((ChainValidityStatus)2148098052U);
}
finally
{
if (chainContext != null)
{
chainContext.Dispose();
}
}
}
return(list);
}
public async Task TriggerConsensusAsync(ChainContext chainContext)
{
var now = TimestampHelper.GetUtcNow();
_blockTimeProvider.SetBlockTime(now);
Logger.LogTrace($"Set block time to utc now: {now:hh:mm:ss.ffffff}. Trigger.");
var triggerInformation = _triggerInformationProvider.GetTriggerInformationForConsensusCommand(new BytesValue());
// Upload the consensus command.
_consensusCommand = await _readerFactory.Create(chainContext)
.GetConsensusCommand.CallAsync(triggerInformation);
Logger.LogDebug($"Updated consensus command: {_consensusCommand}");
// Update next mining time, also block time of both getting consensus extra data and txs.
_nextMiningTime =
TimestampHelper.GetUtcNow().AddMilliseconds(_consensusCommand
.NextBlockMiningLeftMilliseconds);
// Initial consensus scheduler.
var blockMiningEventData = new ConsensusRequestMiningEventData(chainContext.BlockHash,
chainContext.BlockHeight,
_nextMiningTime,
TimestampHelper.DurationFromMilliseconds(_consensusCommand.LimitMillisecondsOfMiningBlock));
_consensusScheduler.CancelCurrentEvent();
_consensusScheduler.NewEvent(_consensusCommand.NextBlockMiningLeftMilliseconds,
blockMiningEventData);
Logger.LogTrace($"Set next mining time to: {_nextMiningTime:hh:mm:ss.ffffff}");
}
public async Task TriggerConsensusAsync(ChainContext chainContext)
{
var triggerInformation = _consensusInformationGenerationService.GetTriggerInformation(TriggerType.ConsensusCommand);
// Upload the consensus command.
_consensusControlInformation.ConsensusCommand =
await _consensusInformationGenerationService.ExecuteContractAsync <ConsensusCommand>(chainContext,
ConsensusConsts.GetConsensusCommand, triggerInformation, DateTime.UtcNow);
Logger.LogDebug($"Updated consensus command: {_consensusControlInformation.ConsensusCommand}");
// Initial consensus scheduler.
var blockMiningEventData = new ConsensusRequestMiningEventData(chainContext.BlockHash,
chainContext.BlockHeight,
_consensusControlInformation.ConsensusCommand.ExpectedMiningTime.ToDateTime(),
TimeSpan.FromMilliseconds(_consensusControlInformation.ConsensusCommand
.LimitMillisecondsOfMiningBlock));
_consensusScheduler.CancelCurrentEvent();
// TODO: Remove NextBlockMiningLeftMilliseconds.
_consensusScheduler.NewEvent(_consensusControlInformation.ConsensusCommand.NextBlockMiningLeftMilliseconds,
blockMiningEventData);
// Update next mining time, also block time of both getting consensus extra data and txs.
_nextMiningTime =
DateTime.UtcNow.AddMilliseconds(_consensusControlInformation.ConsensusCommand
.NextBlockMiningLeftMilliseconds);
}
protected override async Task ProcessLogEventAsync(Block block, LogEvent logEvent)
{
var eventData = new ContractDeployed();
eventData.MergeFrom(logEvent);
var chainContext = new ChainContext
{
BlockHash = block.GetHash(),
BlockHeight = block.Height
};
var smartContractRegistration =
await _smartContractRegistrationInStateProvider.GetSmartContractRegistrationAsync(chainContext
, eventData.Address);
await _smartContractRegistrationProvider.SetSmartContractRegistrationAsync(chainContext, eventData.Address,
smartContractRegistration);
if (block.Height > AElfConstants.GenesisBlockHeight)
{
_smartContractExecutiveService.CleanExecutive(eventData.Address);
}
if (eventData.Name != null)
{
await _smartContractAddressService.SetSmartContractAddressAsync(chainContext, eventData.Name.ToStorageKey(),
eventData.Address);
}
Logger.LogDebug($"Deployed contract {eventData}");
}
public async Task Test()
{
var preBlockHeader = await _blockchainService.GetBestChainLastBlockHeaderAsync();
var chainContext = new ChainContext
{
BlockHash = preBlockHeader.GetHash(),
BlockHeight = preBlockHeader.Height
};
var contractMapping = await ContractAddressService.GetSystemContractNameToAddressMappingAsync(chainContext);
var tokenStub = GetTester <TokenContractContainer.TokenContractStub>(
contractMapping[TokenSmartContractAddressNameProvider.Name], Accounts[0].KeyPair);
var balance = await tokenStub.GetBalance.CallAsync(new GetBalanceInput
{
Owner = Accounts[0].Address,
Symbol = "ELF"
});
balance.Balance.ShouldBe(88000000000000000L);
var electionStub = GetTester <ElectionContractContainer.ElectionContractStub>(
contractMapping[ElectionSmartContractAddressNameProvider.Name], Accounts[0].KeyPair);
var minerCount = await electionStub.GetMinersCount.CallAsync(new Empty());
minerCount.Value.ShouldBe(1);
}
public async Task <IEnumerable <Transaction> > GetPostTransactionsAsync(
IReadOnlyList <ServiceDescriptor> descriptors, ITransactionContext transactionContext)
{
if (!IsTargetAcsSymbol(descriptors))
{
return(new List <Transaction>());
}
var chainContext = new ChainContext
{
BlockHash = transactionContext.PreviousBlockHash,
BlockHeight = transactionContext.BlockHeight - 1
};
// Generate token contract stub.
var tokenContractAddress =
await _smartContractAddressService.GetAddressByContractNameAsync(chainContext,
TokenSmartContractAddressNameProvider.StringName);
if (tokenContractAddress == null)
{
return(new List <Transaction>());
}
var tokenStub = _contractReaderFactory.Create(new ContractReaderContext
{
ContractAddress = tokenContractAddress,
Sender = transactionContext.Transaction.To
});
if (transactionContext.Transaction.To == tokenContractAddress &&
transactionContext.Transaction.MethodName == nameof(tokenStub.ChargeResourceToken))
{
return(new List <Transaction>());
}
if (transactionContext.Transaction.MethodName == nameof(ResourceConsumptionContractContainer
.ResourceConsumptionContractStub.BuyResourceToken))
{
return(new List <Transaction>());
}
var chargeResourceTokenInput = new ChargeResourceTokenInput
{
Caller = transactionContext.Transaction.From
};
var feeCalculationResult =
await _resourceTokenFeeService.CalculateFeeAsync(transactionContext, chainContext);
chargeResourceTokenInput.CostDic.Add(feeCalculationResult);
var chargeResourceTokenTransaction = tokenStub.ChargeResourceToken.GetTransaction(chargeResourceTokenInput);
return(new List <Transaction>
{
chargeResourceTokenTransaction
});
}
// Token: 0x06001C2A RID: 7210 RVA: 0x0006F4BC File Offset: 0x0006D6BC
public ChainValidityStatus ValidateCertificate(X509Certificate2 certificate, bool isSend)
{
this.response.PolicyFlag = 0U;
this.response.ChainData = null;
ChainContext chainContext = null;
ChainValidityStatus chainValidityStatus;
try
{
X509KeyUsageFlags expectedUsage = X509KeyUsageFlags.NonRepudiation | X509KeyUsageFlags.DigitalSignature;
bool checkCRLOnSend = this.smimeAdminOptions.CheckCRLOnSend;
bool disableCRLCheck = this.smimeAdminOptions.DisableCRLCheck;
uint crlconnectionTimeout = this.smimeAdminOptions.CRLConnectionTimeout;
uint crlretrievalTimeout = this.smimeAdminOptions.CRLRetrievalTimeout;
bool flag = disableCRLCheck || (isSend && !checkCRLOnSend);
if (string.IsNullOrEmpty(this.smimeAdminOptions.SMIMECertificateIssuingCAFull))
{
bool enabled = VariantConfiguration.GetSnapshot(MachineSettingsContext.Local, null, null).Global.MultiTenancy.Enabled;
if (enabled)
{
chainValidityStatus = (ChainValidityStatus)2148204809U;
this.response.PolicyFlag = 65536U;
}
else
{
chainValidityStatus = X509CertificateCollection.ValidateCertificate(certificate, null, expectedUsage, !flag, null, null, TimeSpan.FromMilliseconds(crlconnectionTimeout), TimeSpan.FromMilliseconds(crlretrievalTimeout), ref chainContext, false, null);
this.response.PolicyFlag = (uint)this.MapChainStatusToChainFlag(chainValidityStatus);
}
}
else
{
X509Store x509Store = CertificateStore.Open(StoreType.Memory, null, OpenFlags.ReadWrite);
X509Certificate2Collection x509Certificate2Collection = new X509Certificate2Collection();
x509Certificate2Collection.Import(Convert.FromBase64String(this.smimeAdminOptions.SMIMECertificateIssuingCAFull));
x509Store.AddRange(x509Certificate2Collection);
chainValidityStatus = X509CertificateCollection.ValidateCertificate(certificate, null, expectedUsage, !flag, x509Store, null, TimeSpan.FromMilliseconds(crlconnectionTimeout), TimeSpan.FromMilliseconds(crlretrievalTimeout), ref chainContext, true, base.CallContext.AccessingPrincipal.MailboxInfo.OrganizationId.ToString());
this.response.PolicyFlag = (uint)this.MapChainStatusToChainFlag(chainValidityStatus);
}
if (!isSend)
{
this.response.DisplayedId = this.GetIdFromCertificate(certificate);
if (this.response.DisplayedId == null)
{
chainValidityStatus = ChainValidityStatus.SubjectMismatch;
}
this.response.DisplayName = X509PartialCertificate.GetDisplayName(certificate);
this.response.Issuer = this.GetIssuerDisplayNameFromCertificate(certificate);
}
}
finally
{
if (chainContext != null)
{
chainContext.Dispose();
}
}
this.response.ChainValidityStatus = (uint)chainValidityStatus;
return(chainValidityStatus);
}
public async Task GetExecutive_With_SmartContractRegistrationProvider_Test()
{
var chain = await _smartContractHelper.CreateChainWithGenesisContractAsync();
var chainContext = new ChainContext
{
BlockHash = chain.BestChainHash,
BlockHeight = chain.BestChainHeight
};
//Get executive by smartContractRegistration in SmartContractRegistrationProvider
await _smartContractRegistrationProvider.SetSmartContractRegistrationAsync(chainContext,
_defaultContractZeroCodeProvider.ContractZeroAddress,
_defaultContractZeroCodeProvider.DefaultContractZeroRegistration);
var executive = await _smartContractExecutiveService
.GetExecutiveAsync(chainContext, _defaultContractZeroCodeProvider.ContractZeroAddress);
executive.ContractHash.ShouldBe(_defaultContractZeroCodeProvider.DefaultContractZeroRegistration.CodeHash);
await _smartContractExecutiveService.PutExecutiveAsync(chainContext,
_defaultContractZeroCodeProvider.ContractZeroAddress, executive);
//Get executive from executive pool
executive = await _smartContractExecutiveService
.GetExecutiveAsync(chainContext, _defaultContractZeroCodeProvider.ContractZeroAddress);
executive.ContractHash.ShouldBe(_defaultContractZeroCodeProvider.DefaultContractZeroRegistration.CodeHash);
var otherExecutive = await _smartContractExecutiveService
.GetExecutiveAsync(chainContext, _defaultContractZeroCodeProvider.ContractZeroAddress);
await _smartContractExecutiveService.PutExecutiveAsync(chainContext,
_defaultContractZeroCodeProvider.ContractZeroAddress, executive);
await _smartContractExecutiveService.PutExecutiveAsync(chainContext,
_defaultContractZeroCodeProvider.ContractZeroAddress, otherExecutive);
_smartContractExecutiveProvider.GetExecutivePools()[_defaultContractZeroCodeProvider.ContractZeroAddress]
.Count.ShouldBe(2);
//Make codeHash different between smartContractRegistration and executive
var code = _smartContractHelper.Codes["AElf.Contracts.Configuration"];
var codeHash = HashHelper.ComputeFrom(code);
await _smartContractRegistrationProvider.SetSmartContractRegistrationAsync(chainContext,
_defaultContractZeroCodeProvider.ContractZeroAddress, new SmartContractRegistration
{
Category = KernelConstants.DefaultRunnerCategory,
Code = ByteString.CopyFrom(code),
CodeHash = HashHelper.ComputeFrom(code)
});
executive = await _smartContractExecutiveService
.GetExecutiveAsync(chainContext, _defaultContractZeroCodeProvider.ContractZeroAddress);
executive.ContractHash.ShouldBe(codeHash);
_smartContractExecutiveProvider.GetExecutivePools()
.TryGetValue(_defaultContractZeroCodeProvider.ContractZeroAddress, out _).ShouldBeFalse();
}
protected override async ValueTask <TInput> ProcessAsync(TInput input, ChainContext context)
{
if (_predicate(input))
{
await _conditionalConnector.ProcessAsync(input, context);
}
return(input);
}
private async Task <SmartContractRegistrationCache> GetSmartContractRegistrationCacheFromLibCache(
IChainContext chainContext, Address address)
{
if (_smartContractRegistrationCacheProvider.TryGetLibCache(address,
out var smartContractRegistrationCache))
{
return(smartContractRegistrationCache);
}
if (chainContext.BlockHeight > 0 && _initLibBlockHeight == 0)
{
var chain = await _blockchainService.GetChainAsync();
_initLibBlockHash = chain.LastIrreversibleBlockHash;
_initLibBlockHeight = chain.LastIrreversibleBlockHeight;
}
//Use lib chain context to set lib cache. Genesis block need to execute with state cache
var context = new ChainContext
{
BlockHash = _initLibBlockHash,
BlockHeight = _initLibBlockHeight,
StateCache = chainContext.BlockHeight == 0 ? chainContext.StateCache : null
};
if (!_deployedContractAddressProvider.CheckContractAddress(context, address))
{
return(null);
}
SmartContractRegistration smartContractRegistration;
if (address == _defaultContractZeroCodeProvider.ContractZeroAddress)
{
smartContractRegistration = _defaultContractZeroCodeProvider.DefaultContractZeroRegistration;
if (context.BlockHeight > Constants.GenesisBlockHeight)
{
var executive = await GetExecutiveAsync(smartContractRegistration);
smartContractRegistration =
await GetSmartContractRegistrationFromZeroAsync(executive, context, address);
}
}
else
{
smartContractRegistration = await GetSmartContractRegistrationFromZeroAsync(context, address);
}
smartContractRegistrationCache = new SmartContractRegistrationCache
{
SmartContractRegistration = smartContractRegistration,
BlockHash = context.BlockHash,
BlockHeight = context.BlockHeight,
Address = address
};
_smartContractRegistrationCacheProvider.SetLibCache(address, smartContractRegistrationCache);
return(smartContractRegistrationCache);
}
