/// <summary>
/// This node will be configured with the reflection contract executor.
/// <para>
/// Should we require another executor, we will need to create a separate daemon and network.
/// </para>
/// </summary>
public static IFullNodeBuilder UseReflectionExecutor(this IFullNodeBuilder fullNodeBuilder)
{
fullNodeBuilder.ConfigureFeature(features =>
{
features
.AddFeature <ReflectionVirtualMachineFeature>()
.FeatureServices(services =>
{
// Validator
ISmartContractValidator validator = new SmartContractValidator(new List <ISmartContractValidator>
{
new SmartContractFormatValidator(ReferencedAssemblyResolver.AllowedAssemblies),
new SmartContractDeterminismValidator()
});
services.AddSingleton(validator);
// Executor et al.
services.AddSingleton <ISmartContractResultRefundProcessor, SmartContractResultRefundProcessor>();
services.AddSingleton <ISmartContractResultTransferProcessor, SmartContractResultTransferProcessor>();
services.AddSingleton <IKeyEncodingStrategy, BasicKeyEncodingStrategy>();
services.AddSingleton <ISmartContractExecutorFactory, ReflectionSmartContractExecutorFactory>();
services.AddSingleton <IMethodParameterSerializer, MethodParameterSerializer>();
// Controllers
services.AddSingleton <SmartContractsController>();
});
});
return(fullNodeBuilder);
}
public void SmartContractValidator_Should_Not_Allow_Nesting_With_Methods()
{
// This test checks that the NestedTypeValidator fails for multiple levels of nesting
const string source = @"using System;
using Stratis.SmartContracts;
public class Test : SmartContract
{
public struct A
{
public void B() {}
}
public Test(ISmartContractState state)
: base(state) { }
}";
var decompilation = CompileToModuleDef(source);
var result = new SmartContractValidator().Validate(decompilation);
Assert.False(result.IsValid);
Assert.Single(result.Errors);
Assert.IsType <TypeHasMethodsValidator.TypeHasMethodsValidationResult>(result.Errors.Single());
}
public void SmartContractValidator_Should_Not_Allow_Two_Levels_Of_Nesting()
{
// This test checks that the NestedTypeValidator fails for multiple levels of nesting
const string source = @"using System;
using Stratis.SmartContracts;
public class Test : SmartContract
{
public struct A
{
public struct B {
}
}
public Test(ISmartContractState state)
: base(state) { }
}";
IContractModuleDefinition decompilation = CompileToModuleDef(source);
SmartContractValidationResult result = new SmartContractValidator().Validate(decompilation.ModuleDefinition);
Assert.False(result.IsValid);
Assert.Single(result.Errors);
Assert.IsType <TypeHasNestedTypesValidator.TypeHasNestedTypesValidationResult>(result.Errors.Single());
Assert.Equal("Test/A", result.Errors.Single().SubjectName);
}
public void SmartContractValidator_Should_Not_Allow_Three_Levels_Of_Nesting()
{
// This test checks that the NestedTypeValidator fails for multiple levels of nesting
const string source = @"using System;
using Stratis.SmartContracts;
public class Test : SmartContract
{
public struct A
{
public struct B {
public struct C {
}
}
}
public Test(ISmartContractState state)
: base(state) { }
}";
var decompilation = CompileToModuleDef(source);
var result = new SmartContractValidator().Validate(decompilation);
Assert.False(result.IsValid);
Assert.Contains(result.Errors, e => e is TypeHasNestedTypesValidator.TypeHasNestedTypesValidationResult);
Assert.Contains(result.Errors, e => e.SubjectName == "Test/A");
Assert.Contains(result.Errors, e => e.SubjectName == "Test/A/B");
}
public void SmartContractValidator_Dont_Allow_MultipleContracts_MultipleDeploy()
{
const string source = @"using System;
using Stratis.SmartContracts;
[Deploy]
public class Test : SmartContract
{
public Test(ISmartContractState state)
: base(state) { }
}
[Deploy]
public class Test2 : SmartContract
{
public Test2(ISmartContractState state)
: base(state) { }
}";
IContractModuleDefinition decompilation = CompileToModuleDef(source);
SmartContractValidationResult result = new SmartContractValidator().Validate(decompilation.ModuleDefinition);
Assert.False(result.IsValid);
Assert.Single(result.Errors);
Assert.IsType <ContractToDeployValidator.ContractToDeployValidationResult>(result.Errors.Single());
}
public void SmartContractValidator_StandardContract_Token()
{
// Validate a standard auction contract
IContractModuleDefinition decompilation = CompileFileToModuleDef(new FileInfo("Contracts/Token.cs"));
SmartContractValidationResult result = new SmartContractValidator().Validate(decompilation.ModuleDefinition);
Assert.True(result.IsValid);
}
public void SmartContractValidator_StandardContract_Auction()
{
// Validate a standard auction contract
var decompilation = CompileFileToModuleDef(new FileInfo("Contracts/Auction.cs"));
var result = new SmartContractValidator().Validate(decompilation);
Assert.True(result.IsValid);
}
public SmartContractExceptionTests()
{
this.repository = new ContractStateRepositoryRoot(new NoDeleteSource <byte[], byte[]>(new MemoryDictionarySource()));
this.keyEncodingStrategy = BasicKeyEncodingStrategy.Default;
this.loggerFactory = new ExtendedLoggerFactory();
this.loggerFactory.AddConsoleWithFilters();
this.network = new SmartContractsRegTest();
this.validator = new SmartContractValidator(new List <ISmartContractValidator>());
}
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 ReflectionVirtualMachineTests()
{
this.network = new SmartContractsRegTest();
this.keyEncodingStrategy = BasicKeyEncodingStrategy.Default;
this.loggerFactory = new ExtendedLoggerFactory();
this.loggerFactory.AddConsoleWithFilters();
this.gasLimit = (Gas)10000;
this.gasMeter = new GasMeter(this.gasLimit);
this.state = new ContractStateRepositoryRoot(new NoDeleteSource<byte[], byte[]>(new MemoryDictionarySource()));
var persistenceStrategy = new MeteredPersistenceStrategy(this.state, this.gasMeter, this.keyEncodingStrategy);
this.persistentState = new PersistentState(persistenceStrategy, TestAddress.ToUint160(this.network), this.network);
this.validator = new SmartContractValidator(new List<ISmartContractValidator>());
}
public ReflectionSmartContractExecutorFactory(
IKeyEncodingStrategy keyEncodingStrategy,
ILoggerFactory loggerFactory,
Network network,
ISmartContractResultRefundProcessor refundProcessor,
ISmartContractResultTransferProcessor transferProcessor,
SmartContractValidator validator,
ISmartContractVirtualMachine vm)
{
this.keyEncodingStrategy = keyEncodingStrategy;
this.loggerFactory = loggerFactory;
this.network = network;
this.refundProcessor = refundProcessor;
this.transferProcessor = transferProcessor;
this.validator = validator;
this.vm = vm;
}
public void SmartContractValidator_Should_Allow_Consts()
{
const string source = @"using System;
using Stratis.SmartContracts;
public class Test : SmartContract
{
public const string Item = ""Test"";
public Test(ISmartContractState state)
: base(state) { var abc = Item.Length; }
}";
IContractModuleDefinition decompilation = CompileToModuleDef(source);
SmartContractValidationResult result = new SmartContractValidator().Validate(decompilation.ModuleDefinition);
Assert.True(result.IsValid);
}
public void SmartContractValidator_Allow_SingleContract()
{
const string source = @"using System;
using Stratis.SmartContracts;
public class Test : SmartContract
{
public Test(ISmartContractState state)
: base(state) { }
}";
IContractModuleDefinition decompilation = CompileToModuleDef(source);
SmartContractValidationResult result = new SmartContractValidator().Validate(decompilation.ModuleDefinition);
Assert.True(result.IsValid);
Assert.Empty(result.Errors);
}
public void SmartContractValidator_Should_Validate_Internal_Types()
{
var adjustedSource = @"
using System;
using Stratis.SmartContracts;
[Deploy]
public class Test : SmartContract
{
public Test(ISmartContractState state): base(state)
{
Create<Test2>();
}
}
public class Test2 : SmartContract {
public Test2(ISmartContractState state): base(state) {
PersistentState.SetString(""dt"", DateTime.Now.ToString());
}
}
";
ContractCompilationResult compilationResult = ContractCompiler.Compile(adjustedSource);
Assert.True(compilationResult.Success);
byte[] assemblyBytes = compilationResult.Compilation;
IContractModuleDefinition decompilation = ContractDecompiler.GetModuleDefinition(assemblyBytes).Value;
var moduleDefinition = decompilation.ModuleDefinition;
var moduleType = moduleDefinition.GetType("<Module>");
moduleDefinition.Types.Remove(moduleType);
var internalType = moduleDefinition.GetType("Test2");
internalType.Name = "<Module>";
SmartContractValidationResult result = new SmartContractValidator().Validate(moduleDefinition);
Assert.False(result.IsValid);
Assert.NotEmpty(result.Errors);
Assert.True(result.Errors.All(e => e is WhitelistValidator.WhitelistValidationResult));
}
public void SmartContractValidator_Should_Not_Allow_New_NestedReferenceType()
{
const string source = @"using System;
using Stratis.SmartContracts;
public class Test : SmartContract
{
public class A {}
public Test(ISmartContractState state)
: base(state) { }
}";
IContractModuleDefinition decompilation = CompileToModuleDef(source);
SmartContractValidationResult result = new SmartContractValidator().Validate(decompilation.ModuleDefinition);
Assert.Contains(result.Errors, e => e is NestedTypeIsValueTypeValidator.NestedTypeIsValueTypeValidationResult);
}
public CreateSmartContract(IKeyEncodingStrategy keyEncodingStrategy,
ILoggerFactory loggerFactory,
Network network,
IContractStateRepository stateSnapshot,
SmartContractValidator validator,
ISmartContractResultRefundProcessor refundProcessor,
ISmartContractResultTransferProcessor transferProcessor,
ISmartContractVirtualMachine vm)
{
this.logger = loggerFactory.CreateLogger(this.GetType());
this.loggerFactory = loggerFactory;
this.stateSnapshot = stateSnapshot;
this.validator = validator;
this.network = network;
this.keyEncodingStrategy = keyEncodingStrategy;
this.refundProcessor = refundProcessor;
this.transferProcessor = transferProcessor;
this.vm = vm;
}
public void SmartContractValidator_Should_Not_Allow_Static_Constructors()
{
const string source = @"using System;
using Stratis.SmartContracts;
public class Test : SmartContract
{
static Test() {}
public Test(ISmartContractState state)
: base(state) { }
}";
IContractModuleDefinition decompilation = CompileToModuleDef(source);
SmartContractValidationResult result = new SmartContractValidator().Validate(decompilation.ModuleDefinition);
Assert.False(result.IsValid);
Assert.Contains(result.Errors, e => e is StaticConstructorValidator.StaticConstructorValidationResult);
}
public void SmartContractValidator_Should_Allow_Enum()
{
const string source = @"
using System;
using Stratis.SmartContracts;
public class Test : SmartContract
{
public enum A { X, Y, Z }
public Test(ISmartContractState state)
: base(state) { }
}";
var decompilation = CompileToModuleDef(source);
var result = new SmartContractValidator().Validate(decompilation.ModuleDefinition);
Assert.Empty(result.Errors);
}
public void SmartContractValidator_Should_Allow_New_NestedType()
{
const string source = @"using System;
using Stratis.SmartContracts;
public class Test : SmartContract
{
public struct A {}
public Test(ISmartContractState state)
: base(state) { }
public void B() { var test = new A(); }
}";
IContractModuleDefinition decompilation = CompileToModuleDef(source);
SmartContractValidationResult result = new SmartContractValidator().Validate(decompilation.ModuleDefinition);
Assert.Empty(result.Errors);
}
public void SmartContractValidator_Should_Allow_New_TransferFundsToContract()
{
const string source = @"using System;
using Stratis.SmartContracts;
public class Test : SmartContract
{
public struct A {}
public Test(ISmartContractState state)
: base(state) { }
public void B() { var test = new TransferFundsToContract(); }
}";
var decompilation = CompileToModuleDef(source);
var result = new SmartContractValidator().Validate(decompilation);
Assert.Empty(result.Errors);
}
public void SmartContractValidator_Should_Not_Allow_Finalizer_Method()
{
const string source = @"using System;
using Stratis.SmartContracts;
public class Test : SmartContract
{
public Test(ISmartContractState state)
: base(state) { }
void Finalize() {}
}";
IContractModuleDefinition decompilation = CompileToModuleDef(source);
SmartContractValidationResult result = new SmartContractValidator().Validate(decompilation.ModuleDefinition);
Assert.False(result.IsValid);
Assert.Single(result.Errors);
Assert.IsType <FinalizerValidator.FinalizerValidationResult>(result.Errors.Single());
}
public void SmartContractValidator_Should_Not_Allow_Finalizer()
{
const string source = @"using System;
using Stratis.SmartContracts;
public class Test : SmartContract
{
public Test(ISmartContractState state)
: base(state) { }
~Test() {}
}";
IContractModuleDefinition decompilation = CompileToModuleDef(source);
SmartContractValidationResult result = new SmartContractValidator().Validate(decompilation.ModuleDefinition);
// Use of finalizer override triggers multiple errors because of the way that it's compiled
Assert.False(result.IsValid);
Assert.Contains(result.Errors, e => e is FinalizerValidator.FinalizerValidationResult);
}
public void SmartContractValidator_Should_Not_Allow_GetType()
{
const string source = @"using System;
using Stratis.SmartContracts;
public class Test : SmartContract
{
public void A()
{
var z = this.GetType();
}
public Test(ISmartContractState state)
: base(state) { }
}";
IContractModuleDefinition decompilation = CompileToModuleDef(source);
SmartContractValidationResult result = new SmartContractValidator().Validate(decompilation.ModuleDefinition);
Assert.Contains(result.Errors, e => e is WhitelistValidator.WhitelistValidationResult);
}
public void SmartContractValidator_Should_Not_Allow_Optional_Params()
{
const string source = @"
using System;
using Stratis.SmartContracts;
public class Test : SmartContract
{
public Test(ISmartContractState state)
: base(state) { }
public void Optional(int optionalParam = 1) {
}
}";
IContractModuleDefinition decompilation = CompileToModuleDef(source);
SmartContractValidationResult result = new SmartContractValidator().Validate(decompilation.ModuleDefinition);
Assert.False(result.IsValid);
Assert.Contains(result.Errors, e => e is MethodParamValidator.MethodParamValidationResult);
}
public void SmartContractValidator_Should_Allow_One_Level_Of_Nesting()
{
// This test checks that the NestedTypeValidator fails for multiple levels of nesting
const string source = @"using System;
using Stratis.SmartContracts;
public class Test : SmartContract
{
public struct A
{
}
public Test(ISmartContractState state)
: base(state) { }
}";
IContractModuleDefinition decompilation = CompileToModuleDef(source);
SmartContractValidationResult result = new SmartContractValidator().Validate(decompilation.ModuleDefinition);
Assert.True(result.IsValid);
}
public void SmartContractValidator_Should_Not_Allow_Try_Catch_All()
{
const string source = @"using System;
using Stratis.SmartContracts;
public class Test : SmartContract
{
public void A()
{
try {} catch (Exception) {}
}
public Test(ISmartContractState state)
: base(state) { }
}";
IContractModuleDefinition decompilation = CompileToModuleDef(source);
SmartContractValidationResult result = new SmartContractValidator().Validate(decompilation.ModuleDefinition);
Assert.Single(result.Errors);
Assert.IsType <TryCatchValidator.TryCatchValidationResult>(result.Errors.Single());
}
public void SmartContractValidator_Should_Not_Allow_New()
{
const string source = @"using System;
using Stratis.SmartContracts;
public class Test : SmartContract
{
public Test(ISmartContractState state)
: base(state) { }
public void B() {
var s = new string('c', 1);
var t = new System.Runtime.CompilerServices.TaskAwaiter();
}
}";
IContractModuleDefinition decompilation = CompileToModuleDef(source);
SmartContractValidationResult result = new SmartContractValidator().Validate(decompilation.ModuleDefinition);
Assert.Contains(result.Errors, e => e is WhitelistValidator.WhitelistValidationResult);
}
public void SmartContractValidator_Should_Not_Allow_Fields()
{
const string source = @"using System;
using Stratis.SmartContracts;
public class Test : SmartContract
{
public string A;
private int B;
private int C = 123;
public Test(ISmartContractState state)
: base(state) { }
}";
IContractModuleDefinition decompilation = CompileToModuleDef(source);
SmartContractValidationResult result = new SmartContractValidator().Validate(decompilation.ModuleDefinition);
Assert.False(result.IsValid);
Assert.Equal(3, result.Errors.Count());
Assert.True(result.Errors.All(e => e is FieldDefinitionValidator.FieldDefinitionValidationResult));
}
public void SmartContractValidator_Should_Not_Allow_Try_Catch_Filtered()
{
const string source = @"using System;
using Stratis.SmartContracts;
public class Test : SmartContract
{
public void A()
{
var abc = ""Test"";
try { } catch (Exception) when (abc == ""Test"") { }
}
public Test(ISmartContractState state)
: base(state) { }
}";
IContractModuleDefinition decompilation = CompileToModuleDef(source);
SmartContractValidationResult result = new SmartContractValidator().Validate(decompilation.ModuleDefinition);
Assert.Contains(result.Errors, e => e is TryCatchValidator.TryCatchValidationResult);
}
public void SmartContractValidator_Dont_Allow_No_Contracts()
{
var adjustedSource = @"
using System;
using Stratis.SmartContracts;
public class Test
{
public Test(ISmartContractState state) {}
}
";
ContractCompilationResult compilationResult = ContractCompiler.Compile(adjustedSource);
Assert.True(compilationResult.Success);
byte[] assemblyBytes = compilationResult.Compilation;
IContractModuleDefinition decompilation = ContractDecompiler.GetModuleDefinition(assemblyBytes).Value;
SmartContractValidationResult result = new SmartContractValidator().Validate(decompilation.ModuleDefinition);
Assert.False(result.IsValid);
Assert.IsType <ContractToDeployValidator.ContractToDeployValidationResult>(result.Errors.Single());
}
