/// <summary>
/// Get the current status of a transaction
/// </summary>
/// <param name="transactionId">transaction id</param>
/// <returns></returns>
public async Task <TransactionResultDto> GetTransactionResultAsync(string transactionId)
{
Hash transactionIdHash;
try
{
transactionIdHash = HashHelper.HexStringToHash(transactionId);
}
catch
{
throw new UserFriendlyException(Error.Message[Error.InvalidTransactionId],
Error.InvalidTransactionId.ToString());
}
var transactionResult = await GetTransactionResultAsync(transactionIdHash);
var transaction = await _transactionManager.GetTransactionAsync(transactionResult.TransactionId);
var output = JsonConvert.DeserializeObject <TransactionResultDto>(transactionResult.ToString());
if (transactionResult.Status == TransactionResultStatus.Mined)
{
var block = await _blockchainService.GetBlockAtHeightAsync(transactionResult.BlockNumber);
output.BlockHash = block.GetHash().ToHex();
output.ReturnValue = transactionResult.ReturnValue.ToHex();
}
if (transactionResult.Status == TransactionResultStatus.Failed)
{
output.Error = transactionResult.Error;
}
if (transactionResult.Status == TransactionResultStatus.NotExisted)
{
output.Status = transactionResult.Status.ToString();
return(output);
}
output.Transaction = JsonConvert.DeserializeObject <TransactionDto>(transaction.ToString());
var methodDescriptor = await ContractMethodDescriptorHelper.GetContractMethodDescriptorAsync(
_blockchainService, _transactionReadOnlyExecutionService, transaction.To, transaction.MethodName);
if (methodDescriptor != null)
{
output.Transaction.Params = JsonFormatter.ToDiagnosticString(
methodDescriptor.InputType.Parser.ParseFrom(transaction.Params));
}
return(output);
}
private async Task <TransactionResultDto> GetTransactionResultDto(Hash transactionId, Hash realBlockHash, Hash blockHash)
{
var transactionResult = await GetTransactionResultAsync(transactionId, realBlockHash);
var transactionResultDto =
JsonConvert.DeserializeObject <TransactionResultDto>(transactionResult.ToString());
var transaction = await _transactionManager.GetTransactionAsync(transactionResult.TransactionId);
transactionResultDto.BlockHash = blockHash.ToHex();
transactionResultDto.ReturnValue = transactionResult.ReturnValue.ToHex();
if (transactionResult.Status == TransactionResultStatus.Failed)
{
transactionResultDto.Error = transactionResult.Error;
}
transactionResultDto.Transaction =
JsonConvert.DeserializeObject <TransactionDto>(transaction.ToString());
var methodDescriptor =
await ContractMethodDescriptorHelper.GetContractMethodDescriptorAsync(_blockchainService,
_transactionReadOnlyExecutionService, transaction.To, transaction.MethodName,
new ChainContext
{ BlockHash = blockHash, BlockHeight = transactionResult.BlockNumber }, false);
if (methodDescriptor != null)
{
var parameters = methodDescriptor.InputType.Parser.ParseFrom(transaction.Params);
if (!IsValidMessage(parameters))
{
throw new UserFriendlyException(Error.Message[Error.InvalidParams], Error.InvalidParams.ToString());
}
transactionResultDto.Transaction.Params = JsonFormatter.ToDiagnosticString(parameters);
}
transactionResultDto.Status = transactionResult.Status.ToString();
transactionResultDto.TransactionFee = transactionResult.TransactionFee == null
? new TransactionFeeDto()
: JsonConvert.DeserializeObject <TransactionFeeDto>(transactionResult.TransactionFee.ToString());
return(transactionResultDto);
}
private async Task <MethodDescriptor> GetContractMethodDescriptorAsync(Address contractAddress,
string methodName)
{
return(await ContractMethodDescriptorHelper.GetContractMethodDescriptorAsync(_blockchainService,
_transactionReadOnlyExecutionService, contractAddress, methodName));
}
/// <summary>
/// Get multiple transaction results.
/// </summary>
/// <param name="blockHash">block hash</param>
/// <param name="offset">offset</param>
/// <param name="limit">limit</param>
/// <returns></returns>
/// <exception cref="UserFriendlyException"></exception>
public async Task <List <TransactionResultDto> > GetTransactionResultsAsync(string blockHash, int offset = 0,
int limit = 10)
{
if (offset < 0)
{
throw new UserFriendlyException(Error.Message[Error.InvalidOffset], Error.InvalidOffset.ToString());
}
if (limit <= 0 || limit > 100)
{
throw new UserFriendlyException(Error.Message[Error.InvalidLimit], Error.InvalidLimit.ToString());
}
Hash realBlockHash;
try
{
realBlockHash = HashHelper.HexStringToHash(blockHash);
}
catch
{
throw new UserFriendlyException(Error.Message[Error.InvalidBlockHash],
Error.InvalidBlockHash.ToString());
}
var block = await _blockchainService.GetBlockAsync(realBlockHash);
if (block == null)
{
throw new UserFriendlyException(Error.Message[Error.NotFound], Error.NotFound.ToString());
}
var output = new List <TransactionResultDto>();
if (offset <= block.Body.TransactionIds.Count - 1)
{
limit = Math.Min(limit, block.Body.TransactionIds.Count - offset);
var transactionIds = block.Body.TransactionIds.ToList().GetRange(offset, limit);
foreach (var hash in transactionIds)
{
var transactionResult = await GetTransactionResultAsync(hash);
var transactionResultDto =
JsonConvert.DeserializeObject <TransactionResultDto>(transactionResult.ToString());
var transaction = await _transactionManager.GetTransaction(transactionResult.TransactionId);
transactionResultDto.BlockHash = block.GetHash().ToHex();
if (transactionResult.Status == TransactionResultStatus.Failed)
{
transactionResultDto.Error = transactionResult.Error;
}
transactionResultDto.Transaction =
JsonConvert.DeserializeObject <TransactionDto>(transaction.ToString());
var methodDescriptor =
await ContractMethodDescriptorHelper.GetContractMethodDescriptorAsync(_blockchainService,
_transactionReadOnlyExecutionService, transaction.To, transaction.MethodName);
transactionResultDto.Transaction.Params = JsonFormatter.ToDiagnosticString(
methodDescriptor.InputType.Parser.ParseFrom(transaction.Params));
transactionResultDto.Status = transactionResult.Status.ToString();
output.Add(transactionResultDto);
}
}
return(output);
}
/// <summary>
/// Get the current status of a transaction
/// </summary>
/// <param name="transactionId">transaction id</param>
/// <returns></returns>
public async Task <TransactionResultDto> GetTransactionResultAsync(string transactionId)
{
Hash transactionIdHash;
try
{
transactionIdHash = HashHelper.HexStringToHash(transactionId);
}
catch
{
throw new UserFriendlyException(Error.Message[Error.InvalidTransactionId],
Error.InvalidTransactionId.ToString());
}
var transactionResult = await GetTransactionResultAsync(transactionIdHash);
var transaction = await _transactionManager.GetTransactionAsync(transactionResult.TransactionId);
var output = JsonConvert.DeserializeObject <TransactionResultDto>(transactionResult.ToString());
if (transactionResult.Status == TransactionResultStatus.NotExisted)
{
output.Status = transactionResult.Status.ToString();
return(output);
}
ChainContext chainContext = null;
if (transactionResult.BlockNumber > 0)
{
var block = await _blockchainService.GetBlockAtHeightAsync(transactionResult.BlockNumber);
output.BlockHash = block.GetHash().ToHex();
chainContext = new ChainContext
{
BlockHash = block.GetHash(),
BlockHeight = block.Height
};
}
output.Transaction = JsonConvert.DeserializeObject <TransactionDto>(transaction.ToString());
var methodDescriptor = await ContractMethodDescriptorHelper.GetContractMethodDescriptorAsync(
_blockchainService, _transactionReadOnlyExecutionService, transaction.To, transaction.MethodName,
chainContext, false);
if (methodDescriptor != null)
{
var parameters = methodDescriptor.InputType.Parser.ParseFrom(transaction.Params);
if (!IsValidMessage(parameters))
{
throw new UserFriendlyException(Error.Message[Error.InvalidParams], Error.InvalidParams.ToString());
}
output.Transaction.Params = JsonFormatter.ToDiagnosticString(parameters);
}
if (transactionResult.Status == TransactionResultStatus.Pending)
{
return(output);
}
if (transactionResult.Status == TransactionResultStatus.Mined)
{
output.ReturnValue = transactionResult.ReturnValue.ToHex();
var bloom = transactionResult.Bloom;
output.Bloom = bloom.Length == 0 ? ByteString.CopyFrom(new byte[256]).ToBase64() : bloom.ToBase64();
}
if (transactionResult.Status == TransactionResultStatus.Failed)
{
output.Error = transactionResult.Error;
}
output.TransactionFee = transactionResult.TransactionFee == null
? new TransactionFeeDto()
: JsonConvert.DeserializeObject <TransactionFeeDto>(transactionResult.TransactionFee.ToString());
return(output);
}
