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 static async Task <TransactionResourceInfo> GetTransactionResourceInfoAsync(this IExecutive executive,
IChainContext chainContext, Transaction input)
{
var generatedTxn = new Transaction
{
From = FromAddress,
To = input.To,
MethodName = nameof(ACS2BaseContainer.ACS2BaseStub.GetResourceInfo),
Params = input.ToByteString(),
Signature = ByteString.CopyFromUtf8("SignaturePlaceholder")
};
var txId = input.GetHash();
var trace = new TransactionTrace
{
TransactionId = generatedTxn.GetHash()
};
var transactionContext = new TransactionContext
{
PreviousBlockHash = chainContext.BlockHash,
CurrentBlockTime = TimestampHelper.GetUtcNow(),
Transaction = generatedTxn,
BlockHeight = chainContext.BlockHeight + 1,
Trace = trace,
CallDepth = 0,
StateCache = chainContext.StateCache
};
await executive.ApplyAsync(transactionContext);
if (!trace.IsSuccessful())
{
return(NotParallelizable(txId, executive.ContractHash));
}
try
{
var resourceInfo = ResourceInfo.Parser.ParseFrom(trace.ReturnValue);
return(new TransactionResourceInfo
{
TransactionId = txId,
Paths =
{
resourceInfo.Paths
},
ParallelType = resourceInfo.NonParallelizable
? ParallelType.NonParallelizable
: ParallelType.Parallelizable,
ContractHash = executive.ContractHash
});
}
catch (Exception)
{
return(NotParallelizable(txId, executive.ContractHash));
}
}
private TransactionResult GetTransactionResult(TransactionTrace trace, long blockHeight)
{
if (trace.ExecutionStatus == ExecutionStatus.Undefined)
{
return(null);
}
if (trace.ExecutionStatus == ExecutionStatus.Prefailed)
{
return(new TransactionResult()
{
TransactionId = trace.TransactionId,
Status = TransactionResultStatus.Unexecutable,
Error = trace.StdErr
});
}
if (trace.IsSuccessful())
{
var txRes = new TransactionResult()
{
TransactionId = trace.TransactionId,
Status = TransactionResultStatus.Mined,
ReturnValue = trace.ReturnValue,
ReadableReturnValue = trace.ReadableReturnValue,
BlockNumber = blockHeight,
//StateHash = trace.GetSummarizedStateHash(),
Logs = { trace.FlattenedLogs }
};
txRes.UpdateBloom();
// insert deferred txn to transaction pool and wait for execution
if (trace.DeferredTransaction.Length != 0)
{
var deferredTxn = Transaction.Parser.ParseFrom(trace.DeferredTransaction);
txRes.DeferredTransactions.Add(deferredTxn);
txRes.DeferredTxnId = deferredTxn.GetHash();
}
return(txRes);
}
return(new TransactionResult()
{
TransactionId = trace.TransactionId,
Status = TransactionResultStatus.Failed,
Error = trace.StdErr
});
}
private TransactionResult GetTransactionResult(TransactionTrace trace, long blockHeight)
{
if (trace.ExecutionStatus == ExecutionStatus.Undefined)
{
return(new TransactionResult
{
TransactionId = trace.TransactionId,
Status = TransactionResultStatus.Unexecutable,
Error = ExecutionStatus.Undefined.ToString()
});
}
if (trace.ExecutionStatus == ExecutionStatus.Prefailed)
{
return(new TransactionResult
{
TransactionId = trace.TransactionId,
Status = TransactionResultStatus.Unexecutable,
Error = trace.Error
});
}
if (trace.IsSuccessful())
{
var txRes = new TransactionResult
{
TransactionId = trace.TransactionId,
Status = TransactionResultStatus.Mined,
ReturnValue = trace.ReturnValue,
ReadableReturnValue = trace.ReadableReturnValue,
BlockNumber = blockHeight,
//StateHash = trace.GetSummarizedStateHash(),
Logs = { trace.FlattenedLogs }
};
txRes.UpdateBloom();
return(txRes);
}
return(new TransactionResult
{
TransactionId = trace.TransactionId,
Status = TransactionResultStatus.Failed,
Error = trace.Error
});
}
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 TransactionResult GetTransactionResult(TransactionTrace trace, long blockHeight)
{
var txResult = new TransactionResult
{
TransactionId = trace.TransactionId,
BlockNumber = blockHeight,
};
if (!trace.IsSuccessful())
{
// Is failed.
txResult.Status = TransactionResultStatus.Failed;
if (trace.ExecutionStatus == ExecutionStatus.Undefined)
{
// Cannot find specific contract method.
txResult.Error = ExecutionStatus.Undefined.ToString();
}
else
{
txResult.Error = trace.Error;
if (trace.ExecutionStatus != ExecutionStatus.Prefailed || IsExecutionStoppedByPrePlugin(trace))
{
txResult.Logs.AddRange(trace.GetPluginLogs());
txResult.UpdateBloom();
}
}
}
else
{
// Is successful.
txResult.Status = TransactionResultStatus.Mined;
txResult.ReturnValue = trace.ReturnValue;
txResult.Logs.AddRange(trace.FlattenedLogs);
txResult.UpdateBloom();
}
return(txResult);
}
private static bool TryUpdateStateCache(TransactionTrace trace, TieredStateCache groupStateCache)
{
if (trace == null)
{
return(false);
}
if (!trace.IsSuccessful())
{
var transactionExecutingStateSets = new List <TransactionExecutingStateSet>();
AddToTransactionStateSets(transactionExecutingStateSets, trace.PreTraces);
AddToTransactionStateSets(transactionExecutingStateSets, trace.PostTraces);
groupStateCache.Update(transactionExecutingStateSets);
trace.SurfaceUpError();
}
else
{
groupStateCache.Update(trace.GetStateSets());
}
return(true);
}
private TransactionResult GetTransactionResult(TransactionTrace trace, long blockHeight)
{
if (!trace.IsSuccessful())
{
if (trace.ExecutionStatus == ExecutionStatus.Undefined)
{
// Cannot find specific contract method.
return(new TransactionResult
{
TransactionId = trace.TransactionId,
Status = TransactionResultStatus.Unexecutable,
BlockNumber = blockHeight,
Error = ExecutionStatus.Undefined.ToString()
});
}
// Show log events if pre-txs executed successfully.
var isContainLogEvents = trace.PreTraces.All(pt => pt.ExecutionStatus == ExecutionStatus.Executed);
if (trace.ExecutionStatus == ExecutionStatus.Prefailed)
{
if (isContainLogEvents)
{
// All pre-txs succeeded, but one plugin stopped tx execution.
// Need to add log events to tx result, as well as show the error message in this situation.
var txResult = new TransactionResult
{
TransactionId = trace.TransactionId,
Status = TransactionResultStatus.Failed,
ReturnValue = trace.ReturnValue,
BlockNumber = blockHeight,
Logs = { trace.GetPluginLogs() },
Error = ExecutionStatus.ExecutionStoppedByPrePlugin.ToString()
};
txResult.UpdateBloom();
return(txResult);
}
return(new TransactionResult
{
TransactionId = trace.TransactionId,
Status = TransactionResultStatus.Unexecutable,
BlockNumber = blockHeight,
Error = trace.Error
});
}
// Just failed.
{
var txResult = new TransactionResult
{
TransactionId = trace.TransactionId,
Status = TransactionResultStatus.Failed,
BlockNumber = blockHeight,
Error = trace.Error,
Logs = { trace.GetPluginLogs() }
};
txResult.UpdateBloom();
return(txResult);
}
}
{
// Is successful.
var txResult = new TransactionResult
{
TransactionId = trace.TransactionId,
Status = TransactionResultStatus.Mined,
ReturnValue = trace.ReturnValue,
BlockNumber = blockHeight,
Logs = { trace.FlattenedLogs }
};
txResult.UpdateBloom();
return(txResult);
}
}
public void IsSuccessful_Test(ExecutionStatus executionStatus, bool isSuccess)
{
{
var transactionTrace = new TransactionTrace
{
ExecutionStatus = executionStatus
};
transactionTrace.IsSuccessful().ShouldBe(isSuccess);
}
{
var transactionTrace = new TransactionTrace
{
ExecutionStatus = ExecutionStatus.Executed,
PreTraces =
{
new TransactionTrace
{
ExecutionStatus = ExecutionStatus.Executed
},
new TransactionTrace
{
ExecutionStatus = executionStatus
}
}
};
transactionTrace.IsSuccessful().ShouldBe(isSuccess);
}
{
var transactionTrace = new TransactionTrace
{
ExecutionStatus = ExecutionStatus.Executed,
InlineTraces =
{
new TransactionTrace
{
ExecutionStatus = ExecutionStatus.Executed
},
new TransactionTrace
{
ExecutionStatus = executionStatus
}
}
};
transactionTrace.IsSuccessful().ShouldBe(isSuccess);
}
{
var transactionTrace = new TransactionTrace
{
ExecutionStatus = ExecutionStatus.Executed,
PostTraces =
{
new TransactionTrace
{
ExecutionStatus = ExecutionStatus.Executed
},
new TransactionTrace
{
ExecutionStatus = executionStatus
}
}
};
transactionTrace.IsSuccessful().ShouldBe(isSuccess);
}
}
