public void TestGasInjector_OutOfGasFails()
{
SmartContractCompilationResult compilationResult = SmartContractCompiler.CompileFile("SmartContracts/OutOfGasTest.cs");
Assert.True(compilationResult.Success);
byte[] originalAssemblyBytes = compilationResult.Compilation;
var gasLimit = (Gas)500000;
var gasMeter = new GasMeter(gasLimit);
var persistenceStrategy = new MeteredPersistenceStrategy(this.repository, gasMeter, this.keyEncodingStrategy);
var persistentState = new PersistentState(persistenceStrategy, TestAddress.ToUint160(this.network), this.network);
var internalTxExecutorFactory =
new InternalTransactionExecutorFactory(this.keyEncodingStrategy, this.loggerFactory, this.network);
var vm = new ReflectionVirtualMachine(internalTxExecutorFactory, this.loggerFactory);
var executionContext = new SmartContractExecutionContext(new Block(0, TestAddress), new Message(TestAddress, TestAddress, 0, (Gas)500000), TestAddress.ToUint160(this.network), 1);
var result = vm.ExecuteMethod(
originalAssemblyBytes,
"UseAllGas",
executionContext,
gasMeter, persistentState, repository);
Assert.NotNull(result.ExecutionException);
Assert.Equal((Gas)0, gasMeter.GasAvailable);
Assert.Equal(gasLimit, result.GasConsumed);
Assert.Equal(gasLimit, gasMeter.GasConsumed);
}
public void VM_Throws_Exception_CanCatch()
{
SmartContractCompilationResult compilationResult = SmartContractCompiler.CompileFile("SmartContracts/ThrowExceptionContract.cs");
Assert.True(compilationResult.Success);
byte[] contractCode = compilationResult.Compilation;
var gasLimit = (Gas)100;
var gasMeter = new GasMeter(gasLimit);
var persistenceStrategy = new MeteredPersistenceStrategy(this.repository, gasMeter, this.keyEncodingStrategy);
var persistentState = new PersistentState(persistenceStrategy,
TestAddress.ToUint160(this.network), this.network);
var internalTxExecutorFactory = new InternalTransactionExecutorFactory(this.keyEncodingStrategy, this.loggerFactory, this.network);
var vm = new ReflectionVirtualMachine(internalTxExecutorFactory, this.loggerFactory);
var context = new SmartContractExecutionContext(
new Block(0, TestAddress),
new Message(TestAddress, TestAddress, 0, gasLimit),
TestAddress.ToUint160(this.network),
1,
new object[] { }
);
var result = vm.ExecuteMethod(
contractCode,
"ThrowException",
context,
gasMeter, persistentState,
this.repository);
Assert.Equal(typeof(Exception), result.ExecutionException.GetType());
}
public void TestGasInjector_OutOfGasFails()
{
SmartContractCompilationResult compilationResult = SmartContractCompiler.CompileFile("SmartContracts/OutOfGasTest.cs");
Assert.True(compilationResult.Success);
byte[] originalAssemblyBytes = compilationResult.Compilation;
var gasLimit = (Gas)500000;
var gasMeter = new GasMeter(gasLimit);
var internalTxExecutorFactory =
new InternalTransactionExecutorFactory(this.keyEncodingStrategy, this.loggerFactory, this.network);
var vm = new ReflectionVirtualMachine(this.validator, internalTxExecutorFactory, this.loggerFactory, this.network);
var address = TestAddress.ToUint160(this.network);
var callData = new CallData(gasLimit, address, "UseAllGas");
var transactionContext = new TransactionContext(uint256.One, 0, address, address, 0);
this.repository.SetCode(callData.ContractAddress, originalAssemblyBytes);
this.repository.SetContractType(callData.ContractAddress, "OutOfGasTest");
var result = vm.ExecuteMethod(gasMeter, this.repository, callData, transactionContext);
Assert.NotNull(result.ExecutionException);
Assert.Equal((Gas)0, gasMeter.GasAvailable);
Assert.Equal(gasLimit, result.GasConsumed);
Assert.Equal(gasLimit, gasMeter.GasConsumed);
}
public void VM_Throws_Exception_CanCatch()
{
SmartContractCompilationResult compilationResult = SmartContractCompiler.CompileFile("SmartContracts/ThrowExceptionContract.cs");
Assert.True(compilationResult.Success);
byte[] contractCode = compilationResult.Compilation;
var gasLimit = (Gas)10000;
var gasMeter = new GasMeter(gasLimit);
var internalTxExecutorFactory = new InternalTransactionExecutorFactory(this.keyEncodingStrategy, this.loggerFactory, this.network);
var vm = new ReflectionVirtualMachine(this.validator, internalTxExecutorFactory, this.loggerFactory, this.network);
var address = TestAddress.ToUint160(this.network);
var callData = new CallData(gasLimit, address, "ThrowException");
this.repository.SetCode(address, contractCode);
this.repository.SetContractType(address, "ThrowExceptionContract");
var transactionContext = new TransactionContext(uint256.One, 0, address, address, 0);
var result = vm.ExecuteMethod(gasMeter,
this.repository,
callData,
transactionContext);
Assert.Equal(typeof(Exception), result.ExecutionException.GetType());
}
public void SmartContracts_GasInjector_MultipleParamConstructorGasInjectedSuccess()
{
SmartContractCompilationResult compilationResult =
SmartContractCompiler.Compile(TestMultipleConstructorSource);
Assert.True(compilationResult.Success);
byte[] originalAssemblyBytes = compilationResult.Compilation;
var gasLimit = (Gas)500000;
var gasMeter = new GasMeter(gasLimit);
var internalTxExecutorFactory = new InternalTransactionExecutorFactory(this.keyEncodingStrategy, this.loggerFactory, this.network);
var vm = new ReflectionVirtualMachine(this.validator, internalTxExecutorFactory, this.loggerFactory, this.network, this.addressGenerator);
var callData = new CreateData(gasLimit, originalAssemblyBytes, new[] { "Test Owner" });
var transactionContext = new TransactionContext(
txHash: uint256.One,
blockHeight: 0,
coinbase: TestAddress.ToUint160(this.network),
sender: TestAddress.ToUint160(this.network),
amount: 0
);
VmExecutionResult result = vm.Create(gasMeter,
this.repository,
callData, transactionContext);
// Constructor: 15
// Property setter: 12
// Storage: 150
Assert.Equal((Gas)177, result.GasConsumed);
}
public void TestGasInjector_ContractMethodWithRecursion_GasInjectionSucceeds()
{
SmartContractCompilationResult compilationResult = SmartContractCompiler.CompileFile("SmartContracts/Recursion.cs");
Assert.True(compilationResult.Success);
byte[] originalAssemblyBytes = compilationResult.Compilation;
var gasLimit = (Gas)500000;
var gasMeter = new GasMeter(gasLimit);
var internalTxExecutorFactory =
new InternalTransactionExecutorFactory(this.keyEncodingStrategy, this.loggerFactory, this.network);
var vm = new ReflectionVirtualMachine(this.validator, internalTxExecutorFactory, this.loggerFactory, this.network, this.addressGenerator);
uint160 address = TestAddress.ToUint160(this.network);
var callData = new CallData(gasLimit, address, nameof(Recursion.DoRecursion));
var transactionContext = new TransactionContext(uint256.One, 0, address, address, 0);
this.repository.SetCode(callData.ContractAddress, originalAssemblyBytes);
this.repository.SetContractType(callData.ContractAddress, nameof(Recursion));
VmExecutionResult result = vm.ExecuteMethod(gasMeter, this.repository, callData, transactionContext);
Assert.Null(result.ExecutionException);
Assert.True(result.GasConsumed > 0);
}
public void SmartContracts_GasInjector_MultipleParamConstructorGasInjectedSuccess()
{
SmartContractCompilationResult compilationResult =
SmartContractCompiler.Compile(TestMultipleConstructorSource);
Assert.True(compilationResult.Success);
byte[] originalAssemblyBytes = compilationResult.Compilation;
var gasLimit = (Gas)500000;
var gasMeter = new GasMeter(gasLimit);
var persistenceStrategy = new MeteredPersistenceStrategy(this.repository, gasMeter, new BasicKeyEncodingStrategy());
var persistentState = new PersistentState(persistenceStrategy, TestAddress.ToUint160(this.network), this.network);
var internalTxExecutorFactory = new InternalTransactionExecutorFactory(this.keyEncodingStrategy, this.loggerFactory, this.network);
var vm = new ReflectionVirtualMachine(internalTxExecutorFactory, this.loggerFactory);
var executionContext = new SmartContractExecutionContext(new Block(0, TestAddress), new Message(TestAddress, TestAddress, 0, (Gas)500000), TestAddress.ToUint160(this.network), 1, new[] { "Tset Owner" });
var result = vm.Create(
originalAssemblyBytes,
executionContext,
gasMeter, persistentState, repository);
// Constructor: 15
// Property setter: 12
// Storage: 150
Assert.Equal((Gas)177, result.GasConsumed);
}
public SmartContractExceptionTests()
{
var context = new ContractExecutorTestContext();
this.network = context.Network;
this.repository = context.State;
this.vm = context.Vm;
}
public ReflectionVirtualMachineTests()
{
// Take what's needed for these tests
var context = new ContractExecutorTestContext();
this.network = context.Network;
this.vm = context.Vm;
}
public GasInjectorTests()
{
// Only take from context what these tests require.
var context = new ContractExecutorTestContext();
this.vm = context.Vm;
this.repository = context.State;
this.network = context.Network;
}
public SmartContractExecutorTests()
{
this.keyEncodingStrategy = BasicKeyEncodingStrategy.Default;
this.loggerFactory = new ExtendedLoggerFactory();
this.loggerFactory.AddConsoleWithFilters();
this.network = new SmartContractsRegTest();
this.refundProcessor = new SmartContractResultRefundProcessor(this.loggerFactory);
this.state = new ContractStateRepositoryRoot(new NoDeleteSource <byte[], byte[]>(new MemoryDictionarySource()));
this.transferProcessor = new SmartContractResultTransferProcessor(this.loggerFactory, this.network);
this.validator = new SmartContractValidator(new ISmartContractValidator[] { });
this.internalTxExecutorFactory = new InternalTransactionExecutorFactory(this.keyEncodingStrategy, loggerFactory, this.network);
this.vm = new ReflectionVirtualMachine(this.internalTxExecutorFactory, loggerFactory);
}
public void TestGasInjector()
{
SmartContractCompilationResult compilationResult = SmartContractCompiler.Compile(TestSource);
Assert.True(compilationResult.Success);
byte[] originalAssemblyBytes = compilationResult.Compilation;
var resolver = new DefaultAssemblyResolver();
resolver.AddSearchDirectory(AppContext.BaseDirectory);
int aimGasAmount;
using (ModuleDefinition moduleDefinition = ModuleDefinition.ReadModule(
new MemoryStream(originalAssemblyBytes),
new ReaderParameters {
AssemblyResolver = resolver
}))
{
TypeDefinition contractType = moduleDefinition.GetType(ContractName);
MethodDefinition testMethod = contractType.Methods.FirstOrDefault(x => x.Name == MethodName);
aimGasAmount =
testMethod?.Body?.Instructions?
.Count ?? 10000000;
}
var gasLimit = (Gas)500000;
var gasMeter = new GasMeter(gasLimit);
var internalTxExecutorFactory =
new InternalTransactionExecutorFactory(this.keyEncodingStrategy, this.loggerFactory, this.network);
var vm = new ReflectionVirtualMachine(this.validator, internalTxExecutorFactory, this.loggerFactory, this.network, this.addressGenerator);
uint160 address = TestAddress.ToUint160(this.network);
var callData = new CallData(gasLimit, address, "TestMethod", new object[] { 1 });
var transactionContext = new TransactionContext(uint256.One, 0, address, address, 0);
this.repository.SetCode(callData.ContractAddress, originalAssemblyBytes);
this.repository.SetContractType(callData.ContractAddress, "Test");
VmExecutionResult result = vm.ExecuteMethod(gasMeter,
this.repository,
callData,
transactionContext);
Assert.Equal((ulong)aimGasAmount, result.GasConsumed);
}
public void TestGasInjector()
{
SmartContractCompilationResult compilationResult = SmartContractCompiler.Compile(TestSource);
Assert.True(compilationResult.Success);
byte[] originalAssemblyBytes = compilationResult.Compilation;
var resolver = new DefaultAssemblyResolver();
resolver.AddSearchDirectory(AppContext.BaseDirectory);
int aimGasAmount;
using (ModuleDefinition moduleDefinition = ModuleDefinition.ReadModule(
new MemoryStream(originalAssemblyBytes),
new ReaderParameters {
AssemblyResolver = resolver
}))
{
TypeDefinition contractType = moduleDefinition.GetType(ContractName);
MethodDefinition testMethod = contractType.Methods.FirstOrDefault(x => x.Name == MethodName);
aimGasAmount =
testMethod?.Body?.Instructions?
.Count ?? 10000000;
}
var gasLimit = (Gas)500000;
var gasMeter = new GasMeter(gasLimit);
var persistenceStrategy = new MeteredPersistenceStrategy(this.repository, gasMeter, this.keyEncodingStrategy);
var persistentState = new PersistentState(persistenceStrategy,
TestAddress.ToUint160(this.network), this.network);
var internalTxExecutorFactory =
new InternalTransactionExecutorFactory(this.keyEncodingStrategy, this.loggerFactory, this.network);
var vm = new ReflectionVirtualMachine(internalTxExecutorFactory, this.loggerFactory);
var executionContext = new SmartContractExecutionContext(
new Block(0, TestAddress),
new Message(TestAddress, TestAddress, 0, (Gas)500000), TestAddress.ToUint160(this.network), 1, new object[] { 1 });
var result = vm.ExecuteMethod(
originalAssemblyBytes,
MethodName,
executionContext,
gasMeter,
persistentState,
this.repository);
Assert.Equal(aimGasAmount, Convert.ToInt32(result.GasConsumed));
}
public ContractExecutorTestContext()
{
this.Network = new SmartContractsRegTest();
this.KeyEncodingStrategy = BasicKeyEncodingStrategy.Default;
this.LoggerFactory = new ExtendedLoggerFactory();
this.LoggerFactory.AddConsoleWithFilters();
this.State = new ContractStateRoot(new NoDeleteSource <byte[], byte[]>(new MemoryDictionarySource()));
this.ContractPrimitiveSerializer = new ContractPrimitiveSerializer(this.Network);
this.AddressGenerator = new AddressGenerator();
this.Validator = new SmartContractValidator();
this.AssemblyLoader = new ContractAssemblyLoader();
this.ModuleDefinitionReader = new ContractModuleDefinitionReader();
this.InternalTxExecutorFactory = new InternalTransactionExecutorFactory(this.KeyEncodingStrategy, this.LoggerFactory, this.Network);
this.Vm = new ReflectionVirtualMachine(this.Validator, this.InternalTxExecutorFactory, this.LoggerFactory, this.Network, this.AddressGenerator, this.AssemblyLoader, this.ModuleDefinitionReader, this.ContractPrimitiveSerializer);
}
public void VM_CreateContract_WithParameters()
{
//Get the contract execution code------------------------
SmartContractCompilationResult compilationResult =
SmartContractCompiler.CompileFile("SmartContracts/Auction.cs");
Assert.True(compilationResult.Success);
byte[] contractExecutionCode = compilationResult.Compilation;
//-------------------------------------------------------
//Set the calldata for the transaction----------
var methodParameters = new object[] { (ulong)5 };
var callData = new CreateData((Gas)5000000, contractExecutionCode, methodParameters);
Money value = Money.Zero;
//-------------------------------------------------------
var repository = new ContractStateRepositoryRoot(new NoDeleteSource <byte[], byte[]>(new MemoryDictionarySource()));
IContractStateRepository track = repository.StartTracking();
var gasMeter = new GasMeter(callData.GasLimit);
var internalTxExecutorFactory =
new InternalTransactionExecutorFactory(this.keyEncodingStrategy, this.loggerFactory, this.network);
var vm = new ReflectionVirtualMachine(this.validator, internalTxExecutorFactory, this.loggerFactory, this.network, this.addressGenerator);
var transactionContext = new TransactionContext(
txHash: uint256.One,
blockHeight: 1,
coinbase: TestAddress.ToUint160(this.network),
sender: TestAddress.ToUint160(this.network),
amount: value
);
VmExecutionResult result = vm.Create(gasMeter,
repository,
callData,
transactionContext);
track.Commit();
var endBlockValue = track.GetStorageValue(result.NewContractAddress,
Encoding.UTF8.GetBytes("EndBlock"));
Assert.Equal(6, BitConverter.ToInt16(endBlockValue, 0));
Assert.Equal(TestAddress.ToUint160(this.network).ToBytes(), track.GetStorageValue(result.NewContractAddress, Encoding.UTF8.GetBytes("Owner")));
}
public void VM_ExecuteContract_WithParameters()
{
//Get the contract execution code------------------------
SmartContractCompilationResult compilationResult = SmartContractCompiler.CompileFile("SmartContracts/StorageTestWithParameters.cs");
Assert.True(compilationResult.Success);
byte[] contractExecutionCode = compilationResult.Compilation;
//-------------------------------------------------------
//Set the calldata for the transaction----------
var methodParameters = new object[] { (short)5 };
var callData = new CallData((Gas)5000000, new uint160(1), "StoreData", methodParameters);
Money value = Money.Zero;
//-------------------------------------------------------
var repository = new ContractStateRepositoryRoot(new NoDeleteSource <byte[], byte[]>(new MemoryDictionarySource()));
IContractStateRepository track = repository.StartTracking();
var gasMeter = new GasMeter(callData.GasLimit);
var internalTxExecutorFactory =
new InternalTransactionExecutorFactory(this.keyEncodingStrategy, this.loggerFactory, this.network);
var vm = new ReflectionVirtualMachine(this.validator, internalTxExecutorFactory, this.loggerFactory, this.network, this.addressGenerator);
uint160 address = TestAddress.ToUint160(this.network);
var transactionContext = new TransactionContext(uint256.One, 1, address, address, value);
repository.SetCode(callData.ContractAddress, contractExecutionCode);
repository.SetContractType(callData.ContractAddress, "StorageTestWithParameters");
VmExecutionResult result = vm.ExecuteMethod(gasMeter,
repository,
callData,
transactionContext);
track.Commit();
Assert.Equal(5, BitConverter.ToInt16(track.GetStorageValue(callData.ContractAddress, Encoding.UTF8.GetBytes("orders")), 0));
Assert.Equal(5, BitConverter.ToInt16(repository.GetStorageValue(callData.ContractAddress, Encoding.UTF8.GetBytes("orders")), 0));
}
public ReflectionVirtualMachineTests()
{
// Take what's needed for these tests
var context = new ContractExecutorTestContext();
this.network = context.Network;
this.vm = context.Vm;
this.state = context.State;
this.contractState = new SmartContractState(
new Block(1, TestAddress),
new Message(TestAddress, TestAddress, 0),
new PersistentState(new PersistenceStrategy(this.state),
context.ContractPrimitiveSerializer, TestAddress.ToUint160(this.network)),
context.ContractPrimitiveSerializer,
new GasMeter((Gas)5000000),
new ContractLogHolder(this.network),
Mock.Of <IInternalTransactionExecutor>(),
new InternalHashHelper(),
() => 1000);
}
public ReflectionVirtualMachineTests()
{
// Take what's needed for these tests
this.context = new ContractExecutorTestContext();
this.network = this.context.Network;
this.TestAddress = "0x0000000000000000000000000000000000000001".HexToAddress();
this.vm = this.context.Vm;
this.state = this.context.State;
this.contractState = new SmartContractState(
new Block(1, this.TestAddress),
new Message(this.TestAddress, this.TestAddress, 0),
new PersistentState(
new TestPersistenceStrategy(this.state),
this.context.Serializer, this.TestAddress.ToUint160()),
this.context.Serializer,
new ContractLogHolder(),
Mock.Of <IInternalTransactionExecutor>(),
new InternalHashHelper(),
() => 1000);
this.gasMeter = new GasMeter((RuntimeObserver.Gas) 50_000);
}
public GasInjectorTests()
{
// Only take from context what these tests require.
var context = new ContractExecutorTestContext();
this.vm = context.Vm;
this.repository = context.State;
this.network = context.Network;
this.moduleReader = new ContractModuleDefinitionReader();
this.assemblyLoader = new ContractAssemblyLoader();
this.gasMeter = new GasMeter((Gas)5000000);
this.state = new SmartContractState(
new Block(1, TestAddress),
new Message(TestAddress, TestAddress, 0),
new PersistentState(new MeteredPersistenceStrategy(this.repository, this.gasMeter, new BasicKeyEncodingStrategy()),
context.ContractPrimitiveSerializer, TestAddress.ToUint160(this.network)),
context.ContractPrimitiveSerializer,
this.gasMeter,
new ContractLogHolder(this.network),
Mock.Of <IInternalTransactionExecutor>(),
new InternalHashHelper(),
() => 1000);
}
public void VM_ExecuteContract_WithoutParameters()
{
//Get the contract execution code------------------------
SmartContractCompilationResult compilationResult = SmartContractCompiler.CompileFile("SmartContracts/StorageTest.cs");
Assert.True(compilationResult.Success);
byte[] contractExecutionCode = compilationResult.Compilation;
//-------------------------------------------------------
//Call smart contract and add to transaction-------------
var carrier = SmartContractCarrier.CallContract(1, new uint160(1), "StoreData", 1, (Gas)500000);
var transactionCall = new Transaction();
transactionCall.AddInput(new TxIn());
TxOut callTxOut = transactionCall.AddOutput(0, new Script(carrier.Serialize()));
//-------------------------------------------------------
//Deserialize the contract from the transaction----------
var deserializedCall = SmartContractCarrier.Deserialize(transactionCall);
//-------------------------------------------------------
var repository = new ContractStateRepositoryRoot(new NoDeleteSource <byte[], byte[]>(new MemoryDictionarySource()));
IContractStateRepository stateRepository = repository.StartTracking();
var gasMeter = new GasMeter(deserializedCall.CallData.GasLimit);
var persistenceStrategy = new MeteredPersistenceStrategy(repository, gasMeter, this.keyEncodingStrategy);
var persistentState = new PersistentState(persistenceStrategy, deserializedCall.CallData.ContractAddress, this.network);
var internalTxExecutorFactory =
new InternalTransactionExecutorFactory(this.keyEncodingStrategy, this.loggerFactory, this.network);
var vm = new ReflectionVirtualMachine(internalTxExecutorFactory, this.loggerFactory);
var sender = deserializedCall.Sender?.ToString() ?? TestAddress.ToString();
var context = new SmartContractExecutionContext(
new Block(1, new Address("2")),
new Message(
new Address(deserializedCall.CallData.ContractAddress.ToString()),
new Address(sender),
deserializedCall.Value,
deserializedCall.CallData.GasLimit
),
TestAddress.ToUint160(this.network),
deserializedCall.CallData.GasPrice
);
var result = vm.ExecuteMethod(
contractExecutionCode,
"StoreData",
context,
gasMeter,
persistentState,
repository);
stateRepository.Commit();
Assert.Equal(Encoding.UTF8.GetBytes("TestValue"), stateRepository.GetStorageValue(deserializedCall.CallData.ContractAddress, Encoding.UTF8.GetBytes("TestKey")));
Assert.Equal(Encoding.UTF8.GetBytes("TestValue"), repository.GetStorageValue(deserializedCall.CallData.ContractAddress, Encoding.UTF8.GetBytes("TestKey")));
}
public void VM_CreateContract_WithParameters()
{
//Get the contract execution code------------------------
SmartContractCompilationResult compilationResult =
SmartContractCompiler.CompileFile("SmartContracts/Auction.cs");
Assert.True(compilationResult.Success);
byte[] contractExecutionCode = compilationResult.Compilation;
//-------------------------------------------------------
// //Call smart contract and add to transaction-------------
string[] methodParameters = new string[]
{
string.Format("{0}#{1}", (int)SmartContractCarrierDataType.ULong, 5),
};
var carrier = SmartContractCarrier.CreateContract(1, contractExecutionCode, 1, (Gas)500000, methodParameters);
var transactionCall = new Transaction();
transactionCall.AddInput(new TxIn());
TxOut callTxOut = transactionCall.AddOutput(0, new Script(carrier.Serialize()));
//-------------------------------------------------------
//Deserialize the contract from the transaction----------
var deserializedCall = SmartContractCarrier.Deserialize(transactionCall);
//-------------------------------------------------------
var repository = new ContractStateRepositoryRoot(new NoDeleteSource <byte[], byte[]>(new MemoryDictionarySource()));
IContractStateRepository track = repository.StartTracking();
var gasMeter = new GasMeter(deserializedCall.CallData.GasLimit);
var persistenceStrategy = new MeteredPersistenceStrategy(repository, gasMeter, new BasicKeyEncodingStrategy());
var persistentState = new PersistentState(persistenceStrategy, TestAddress.ToUint160(this.network), this.network);
var internalTxExecutorFactory =
new InternalTransactionExecutorFactory(this.keyEncodingStrategy, this.loggerFactory, this.network);
var vm = new ReflectionVirtualMachine(internalTxExecutorFactory, this.loggerFactory);
var context = new SmartContractExecutionContext(
new Block(1, TestAddress),
new Message(
TestAddress,
TestAddress,
deserializedCall.Value,
deserializedCall.CallData.GasLimit
),
TestAddress.ToUint160(this.network),
deserializedCall.CallData.GasPrice,
deserializedCall.MethodParameters
);
var result = vm.Create(
contractExecutionCode,
context,
gasMeter,
persistentState,
repository);
track.Commit();
Assert.Equal(6, BitConverter.ToInt16(track.GetStorageValue(context.Message.ContractAddress.ToUint160(this.network), Encoding.UTF8.GetBytes("EndBlock")), 0));
Assert.Equal(TestAddress.ToUint160(this.network).ToBytes(), track.GetStorageValue(context.Message.ContractAddress.ToUint160(this.network), Encoding.UTF8.GetBytes("Owner")));
}
