public void Call_Contract_Failure()
{
var parameters = new object[] { };
var contractTxData = new ContractTxData(1, 1, (RuntimeObserver.Gas) 1000, uint160.One, "TestMethod", parameters);
StateTransitionResult stateTransitionResult = StateTransitionResult.Fail((RuntimeObserver.Gas) 100, StateTransitionErrorKind.VmError);
var fixture = new ExecutorFixture(contractTxData);
IState snapshot = fixture.State.Object.Snapshot();
fixture.StateProcessor
.Setup(s => s.Apply(snapshot, It.IsAny <ExternalCallMessage>()))
.Returns(stateTransitionResult);
IStateRepository trackedMock = Mock.Of <IStateRepository>();
fixture.ContractStateRoot.Setup(s => s.StartTracking()).Returns(trackedMock);
var sut = new LocalExecutor(
fixture.LoggerFactory,
fixture.CallDataSerializer.Object,
fixture.ContractStateRoot.Object,
fixture.StateFactory.Object,
fixture.StateProcessor.Object,
fixture.ContractPrimitiveSerializer.Object);
ILocalExecutionResult result = sut.Execute(fixture.ContractTransactionContext.BlockHeight,
fixture.ContractTransactionContext.Sender,
fixture.ContractTransactionContext.TxOutValue,
contractTxData);
fixture.StateFactory.Verify(sf => sf
.Create(
trackedMock,
It.IsAny <IBlock>(),
fixture.ContractTransactionContext.TxOutValue,
It.IsAny <uint256>()),
Times.Once);
// We only apply the message to the snapshot.
fixture.StateProcessor.Verify(sm => sm.Apply(snapshot, It.Is <ExternalCallMessage>(m =>
m.Method.Name == contractTxData.MethodName &&
m.Method.Parameters == contractTxData.MethodParameters &&
m.Amount == fixture.ContractTransactionContext.TxOutValue &&
m.From == fixture.ContractTransactionContext.Sender &&
m.To == contractTxData.ContractAddress)), Times.Once);
// Should never transition to the snapshot.
fixture.State.Verify(sm => sm.TransitionTo(snapshot), Times.Never);
// Should never save on the state
fixture.ContractStateRoot.Verify(sr => sr.Commit(), Times.Never);
Assert.Equal(stateTransitionResult.Error.VmError, result.ErrorMessage);
Assert.True(result.Revert);
Assert.Equal <IReadOnlyList <TransferInfo> >(fixture.State.Object.InternalTransfers, result.InternalTransfers);
Assert.Equal(stateTransitionResult.GasConsumed, result.GasConsumed);
Assert.Null(result.Return);
Assert.Equal <IList <Log> >(fixture.State.Object.GetLogs(fixture.ContractPrimitiveSerializer.Object), result.Logs);
}
/// <summary>
/// Executes this task graph.
/// </summary>
/// <param name="executedTasksCount">The total count of the executed tasks (excluding the cached ones).</param>
/// <returns>True if failed, otherwise false.</returns>
public bool Execute(out int executedTasksCount)
{
Log.Verbose("");
Log.Verbose(string.Format("Total {0} tasks", Tasks.Count));
var executor = new LocalExecutor();
executedTasksCount = executor.Execute(Tasks);
var failedCount = 0;
foreach (var task in Tasks)
{
if (task.Failed)
{
failedCount++;
}
}
if (failedCount == 1)
{
Log.Error("1 task failed");
}
else if (failedCount != 0)
{
Log.Error(string.Format("{0} tasks failed", failedCount));
}
else
{
Log.Info("Done!");
}
return(failedCount != 0);
}
private static List <string> GetLocalNetworkIPs()
{
List <string> result = new List <string>();
LocalExecutor executor = new LocalExecutor();
executor.ExecuteCommandWithStreamOutput("arp.exe", "-a",
(reader) =>
{
string line = string.Empty;
while ((line = reader.ReadLine()) != null)
{
if (line.StartsWith(" "))
{
var items = line.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (items.Length == 3)
{
result.Add(items[0]);
}
}
}
return(string.Empty);
});
return(result);
}
public SmartContractsController(IBroadcasterManager broadcasterManager,
IBlockStore blockStore,
ConcurrentChain chain,
IConsensusManager consensus,
IDateTimeProvider dateTimeProvider,
ILoggerFactory loggerFactory,
Network network,
IStateRepositoryRoot stateRoot,
IWalletManager walletManager,
IWalletTransactionHandler walletTransactionHandler,
IAddressGenerator addressGenerator,
ISerializer serializer,
IReceiptRepository receiptRepository,
ICallDataSerializer callDataSerializer,
IMethodParameterStringSerializer methodParameterStringSerializer,
LocalExecutor localExecutor)
{
this.stateRoot = stateRoot;
this.walletTransactionHandler = walletTransactionHandler;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.network = network;
this.coinType = (CoinType)network.Consensus.CoinType;
this.chain = chain;
this.blockStore = blockStore;
this.walletManager = walletManager;
this.broadcasterManager = broadcasterManager;
this.addressGenerator = addressGenerator;
this.serializer = serializer;
this.receiptRepository = receiptRepository;
this.callDataSerializer = callDataSerializer;
this.methodParameterStringSerializer = methodParameterStringSerializer;
this.localExecutor = localExecutor;
}
public void Create_Contract_Failure()
{
var contractTxData = new ContractTxData(1, 1, (Gas)1000, new byte[] { 0xAA, 0xBB, 0xCC });
StateTransitionResult stateTransitionResult = StateTransitionResult.Fail((Gas)100, StateTransitionErrorKind.VmError);
var fixture = new ExecutorFixture(contractTxData);
IState snapshot = fixture.State.Object.Snapshot();
fixture.StateProcessor
.Setup(s => s.Apply(snapshot, It.IsAny <ExternalCreateMessage>()))
.Returns(stateTransitionResult);
IStateRepository trackedMock = Mock.Of <IStateRepository>();
fixture.ContractStateRoot.Setup(s => s.StartTracking()).Returns(trackedMock);
var sut = new LocalExecutor(
fixture.LoggerFactory,
fixture.CallDataSerializer.Object,
fixture.ContractStateRoot.Object,
fixture.StateFactory.Object,
fixture.StateProcessor.Object,
fixture.ContractPrimitiveSerializer.Object);
ILocalExecutionResult result = sut.Execute(fixture.ContractTransactionContext);
fixture.CallDataSerializer.Verify(s => s.Deserialize(fixture.Data), Times.Once);
fixture.StateFactory.Verify(sf => sf
.Create(
trackedMock,
It.IsAny <IBlock>(),
fixture.ContractTransactionContext.TxOutValue,
fixture.ContractTransactionContext.TransactionHash),
Times.Once);
// We only apply the message to the snapshot.
fixture.StateProcessor.Verify(sm => sm.Apply(fixture.State.Object.Snapshot(),
It.Is <ExternalCreateMessage>(m =>
m.Code == contractTxData.ContractExecutionCode &&
m.Parameters == contractTxData.MethodParameters)), Times.Once);
// Should never transition to the snapshot.
fixture.State.Verify(sm => sm.TransitionTo(fixture.State.Object.Snapshot()), Times.Never);
// Should never save on the state
fixture.ContractStateRoot.Verify(sr => sr.Commit(), Times.Never);
Assert.Equal(stateTransitionResult.Error.VmError, result.ErrorMessage);
Assert.True(result.Revert);
Assert.Equal(fixture.State.Object.InternalTransfers, result.InternalTransfers);
Assert.Equal(stateTransitionResult.GasConsumed, result.GasConsumed);
Assert.Null(result.Return);
Assert.Equal(fixture.State.Object.GetLogs(fixture.ContractPrimitiveSerializer.Object), result.Logs);
}
private static string GetMachineName(string ipAddress)
{
LocalExecutor executor = new LocalExecutor();
return(executor.ExecuteCommandWithStreamOutput("nslookup", ipAddress,
(reader) =>
{
string line = string.Empty;
while ((line = reader.ReadLine()) != null)
{
if (line.StartsWith("Name:"))
{
var items = line.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (items.Length == 2)
{
return items[1];
}
}
}
return string.Empty;
}));
}
public void Call_Contract_Success()
{
var parameters = new object[] { };
var contractTxData = new ContractTxData(1, 1, (Gas)1000, uint160.One, "TestMethod", parameters);
VmExecutionResult vmExecutionResult = VmExecutionResult.Ok(new object(), null);
StateTransitionResult stateTransitionResult = StateTransitionResult.Ok((Gas)100, uint160.One, vmExecutionResult.Success.Result);
var fixture = new ExecutorFixture(contractTxData);
IState snapshot = fixture.State.Object.Snapshot();
fixture.StateProcessor
.Setup(s => s.Apply(snapshot, It.IsAny <ExternalCallMessage>()))
.Returns(stateTransitionResult);
IStateRepository trackedMock = Mock.Of <IStateRepository>();
fixture.ContractStateRoot.Setup(s => s.StartTracking()).Returns(trackedMock);
var sut = new LocalExecutor(
fixture.LoggerFactory,
fixture.CallDataSerializer.Object,
fixture.ContractStateRoot.Object,
fixture.StateFactory.Object,
fixture.StateProcessor.Object,
fixture.ContractPrimitiveSerializer.Object);
ILocalExecutionResult result = sut.Execute(fixture.ContractTransactionContext);
fixture.CallDataSerializer.Verify(s => s.Deserialize(fixture.ContractTransactionContext.Data), Times.Once);
// Local executor used a tracked staterepository
fixture.StateFactory.Verify(sf => sf
.Create(
trackedMock,
It.IsAny <IBlock>(),
fixture.ContractTransactionContext.TxOutValue,
fixture.ContractTransactionContext.TransactionHash),
Times.Once);
// We only apply the message to the snapshot.
fixture.StateProcessor.Verify(sm => sm.Apply(snapshot, It.Is <ExternalCallMessage>(m =>
m.Method.Name == contractTxData.MethodName &&
m.Method.Parameters == contractTxData.MethodParameters &&
m.Amount == fixture.ContractTransactionContext.TxOutValue &&
m.From == fixture.ContractTransactionContext.Sender &&
m.To == contractTxData.ContractAddress)), Times.Once);
// Should never transition to the snapshot.
fixture.State.Verify(sm => sm.TransitionTo(snapshot), Times.Never);
// Should never save on the state
fixture.ContractStateRoot.Verify(sr => sr.Commit(), Times.Never);
Assert.Null(result.ErrorMessage);
Assert.False(result.Revert);
Assert.Equal(fixture.State.Object.InternalTransfers, result.InternalTransfers);
Assert.Equal(stateTransitionResult.GasConsumed, result.GasConsumed);
Assert.Equal(stateTransitionResult.Success.ExecutionResult, result.Return);
Assert.Equal(fixture.State.Object.GetLogs(fixture.ContractPrimitiveSerializer.Object), result.Logs);
}