private (ExecutionReturnSet, Transaction) GetFakePairs(Address destination, int[] expectedKeys,
int[] actualKeys = null)
{
var tri = new TransactionResourceInfo
{
Paths =
{
expectedKeys.Select(GetPath)
}
};
var txn = new Transaction
{
From = SampleAddress.AddressList[7],
To = destination,
MethodName = "Dummy",
Params = tri.ToByteString(),
Signature = ByteString.CopyFromUtf8("SignaturePlaceholder")
};
var rs = new ExecutionReturnSet {
TransactionId = txn.GetHash()
};
actualKeys = actualKeys ?? expectedKeys;
foreach (var key in actualKeys.Select(GetPath).Select(p => p.ToStateKey()))
{
rs.StateAccesses[key] = true;
}
return(rs, txn);
}
private async Task <List <ExecutionReturnSet> > ProcessTransactionsWithoutContract(List <Transaction> transactions,
BlockHeader blockHeader)
{
var transactionResults = new List <TransactionResult>();
var returnSets = new List <ExecutionReturnSet>();
foreach (var transaction in transactions)
{
var result = new TransactionResult
{
TransactionId = transaction.GetHash(),
Status = TransactionResultStatus.Failed,
Error = "Invalid contract address."
};
Logger.LogError(result.Error);
transactionResults.Add(result);
var returnSet = new ExecutionReturnSet
{
TransactionId = result.TransactionId,
Status = result.Status,
Bloom = result.Bloom
};
returnSets.Add(returnSet);
}
await _transactionResultService.AddTransactionResultsAsync(transactionResults, blockHeader);
return(returnSets);
}
private List <ExecutionReturnSet> ProcessTransactionsWithoutContract(List <Transaction> transactions)
{
var returnSets = new List <ExecutionReturnSet>();
foreach (var transaction in transactions)
{
var result = new TransactionResult
{
TransactionId = transaction.GetHash(),
Status = TransactionResultStatus.Failed,
Error = "Invalid contract address."
};
Logger.LogDebug(result.Error);
var returnSet = new ExecutionReturnSet
{
TransactionId = result.TransactionId,
Status = result.Status,
Bloom = result.Bloom,
TransactionResult = result
};
returnSets.Add(returnSet);
}
return(returnSets);
}
private ExecutionReturnSet GetReturnSet(TransactionTrace trace, TransactionResult result)
{
var returnSet = new ExecutionReturnSet
{
TransactionId = result.TransactionId,
Status = result.Status,
Bloom = result.Bloom
};
if (trace.IsSuccessful())
{
foreach (var s in trace.GetFlattenedWrites())
{
returnSet.StateChanges[s.Key] = s.Value;
}
returnSet.ReturnValue = trace.ReturnValue;
}
foreach (var s in trace.GetFlattenedReads())
{
returnSet.StateAccesses[s.Key] = s.Value;
}
return(returnSet);
}
private ExecutionReturnSet GetReturnSet(TransactionTrace trace, TransactionResult result)
{
var returnSet = new ExecutionReturnSet()
{
TransactionId = result.TransactionId,
Status = result.Status,
Bloom = result.Bloom
};
foreach (var tx in result.DeferredTransactions)
{
returnSet.DeferredTransactions.Add(tx);
}
if (trace.IsSuccessful())
{
foreach (var s in trace.GetFlattenedWrite())
{
returnSet.StateChanges[s.Key] = s.Value;
}
returnSet.ReturnValue = trace.ReturnValue;
}
return(returnSet);
}
public override void ConfigureServices(ServiceConfigurationContext context)
{
var services = context.Services;
services.AddTransient(p =>
{
var mockService = new Mock <ITransactionExecutingService>();
mockService.Setup(m => m.ExecuteAsync(It.IsAny <TransactionExecutingDto>(),
It.IsAny <CancellationToken>()))
.Returns <TransactionExecutingDto, CancellationToken>(
(transactionExecutingDto, cancellationToken) =>
{
var returnSets = new List <ExecutionReturnSet>();
var count = 0;
foreach (var tx in transactionExecutingDto.Transactions)
{
if (cancellationToken.IsCancellationRequested && count >= 3)
{
break;
}
var returnSet = new ExecutionReturnSet
{
TransactionId = tx.GetHash()
};
returnSet.StateChanges.Add(tx.GetHash().ToHex(), tx.ToByteString());
returnSets.Add(returnSet);
count++;
}
return(Task.FromResult(returnSets));
});
return(mockService.Object);
});
services.AddTransient(p =>
{
var mockService = new Mock <IBlockExecutingService>();
mockService.Setup(m =>
m.ExecuteBlockAsync(It.IsAny <BlockHeader>(), It.IsAny <List <Transaction> >()))
.Returns <BlockHeader, IEnumerable <Transaction> >((blockHeader, transactions) =>
{
var block = new Block
{
Header = blockHeader,
Body = new BlockBody()
};
block.Body.AddTransactions(transactions.Select(x => x.GetHash()));
return(Task.FromResult(new BlockExecutedSet()
{
Block = block
}));
});
return(mockService.Object);
});
}
private ExecutionReturnSet GetReturnSet(TransactionTrace trace, TransactionResult result)
{
var returnSet = new ExecutionReturnSet
{
TransactionId = result.TransactionId,
Status = result.Status,
Bloom = result.Bloom,
TransactionResult = result
};
if (trace.IsSuccessful())
{
var transactionExecutingStateSets = trace.GetStateSets();
returnSet = GetReturnSet(returnSet, transactionExecutingStateSets);
returnSet.ReturnValue = trace.ReturnValue;
}
else
{
var transactionExecutingStateSets = new List <TransactionExecutingStateSet>();
foreach (var preTrace in trace.PreTraces)
{
if (preTrace.IsSuccessful())
{
transactionExecutingStateSets.AddRange(preTrace.GetStateSets());
}
}
foreach (var postTrace in trace.PostTraces)
{
if (postTrace.IsSuccessful())
{
transactionExecutingStateSets.AddRange(postTrace.GetStateSets());
}
}
returnSet = GetReturnSet(returnSet, transactionExecutingStateSets);
}
var reads = trace.GetFlattenedReads();
foreach (var read in reads)
{
returnSet.StateAccesses[read.Key] = read.Value;
}
return(returnSet);
}
private ExecutionReturnSet GetReturnSet(ExecutionReturnSet returnSet,
IEnumerable <TransactionExecutingStateSet> transactionExecutingStateSets)
{
foreach (var transactionExecutingStateSet in transactionExecutingStateSets)
{
foreach (var write in transactionExecutingStateSet.Writes)
{
returnSet.StateChanges[write.Key] = write.Value;
returnSet.StateDeletes.Remove(write.Key);
}
foreach (var delete in transactionExecutingStateSet.Deletes)
{
returnSet.StateDeletes[delete.Key] = delete.Value;
returnSet.StateChanges.Remove(delete.Key);
}
}
return(returnSet);
}
private (ExecutionReturnSet, Transaction) GetFakePairs(Address destination, int[] expectedKeys,
int[] actualKeys = null, int[] readExpectedKeys = null, int[] readOnlyActualKeys = null)
{
var tri = new TransactionResourceInfo
{
WritePaths =
{
expectedKeys.Select(GetPath)
}
};
if (readExpectedKeys != null)
{
tri.ReadPaths.AddRange(readExpectedKeys.Select(GetPath));
}
var txn = new Transaction
{
From = SampleAddress.AddressList[7],
To = destination,
MethodName = "Dummy",
Params = tri.ToByteString(),
Signature = ByteString.CopyFromUtf8(KernelConstants.SignaturePlaceholder)
};
var rs = new ExecutionReturnSet {
TransactionId = txn.GetHash()
};
actualKeys ??= expectedKeys;
var readOnlyStateKeys = readOnlyActualKeys?.Select(GetPath).Select(p => p.ToStateKey()).ToList();
foreach (var key in actualKeys.Select(GetPath).Select(p => p.ToStateKey()))
{
rs.StateAccesses[key] = true;
if (readOnlyActualKeys != null && readOnlyStateKeys.Contains(key))
{
continue;
}
rs.StateChanges[key] = ByteString.Empty;
}
return(rs, txn);
}
private List <ExecutionReturnSet> GetExecutionReturnSets()
{
var firstKey = "firstKey";
var secondKey = "secondKey";
var executionReturnSets = new List <ExecutionReturnSet>();
var minedTransactionId = HashHelper.ComputeFrom("minedTxId");
var minedExecutionReturnSet = new ExecutionReturnSet
{
TransactionId = minedTransactionId,
Status = TransactionResultStatus.Mined,
StateChanges = { { "firstKey", ByteString.Empty } },
StateDeletes = { { "secondKey", true } }
};
executionReturnSets.Add(minedExecutionReturnSet);
var failedTransactionId = HashHelper.ComputeFrom("failedTxId");
var failedExecutionReturnSet = new ExecutionReturnSet
{
TransactionId = failedTransactionId,
Status = TransactionResultStatus.Failed,
StateChanges = { { "secondKey", ByteString.Empty } },
StateDeletes = { { "firstKey", true } }
};
executionReturnSets.Add(failedExecutionReturnSet);
var conflictTransactionId = HashHelper.ComputeFrom("conflictTxId");
var conflictExecutionReturnSet = new ExecutionReturnSet
{
TransactionId = conflictTransactionId,
Status = TransactionResultStatus.Conflict
};
executionReturnSets.Add(conflictExecutionReturnSet);
return(executionReturnSets);
}
private HashSet <string> GetKeys(ExecutionReturnSet returnSet)
{
return(new HashSet <string>(returnSet.StateAccesses.Keys));
}
