public void ReflectionVirtualMachineFeature_OnInitialize_RulesAdded()
{
Network network = KnownNetworks.StratisRegTest;
var chain = new ConcurrentChain(network);
var contractState = new ContractStateRoot();
var executorFactory = new Mock <ISmartContractExecutorFactory>();
var loggerFactory = new ExtendedLoggerFactory();
var consensusRules = new SmartContractPowConsensusRuleEngine(
chain, new Mock <ICheckpoints>().Object, new Configuration.Settings.ConsensusSettings(),
DateTimeProvider.Default, executorFactory.Object, loggerFactory, network,
new Base.Deployments.NodeDeployments(network, chain), contractState,
new Mock <IReceiptRepository>().Object,
new Mock <ISenderRetriever>().Object,
new Mock <ICoinView>().Object,
new Mock <IChainState>().Object,
new InvalidBlockHashStore(new DateTimeProvider()));
var feature = new ReflectionVirtualMachineFeature(loggerFactory, network);
feature.Initialize();
Assert.Single(network.Consensus.FullValidationRules.Where(r => r.GetType() == typeof(SmartContractFormatRule)));
}
public void SmartContractList_ListHasValueTest()
{
var listName = "testList";
var source = new MemoryDictionarySource();
var root = new ContractStateRoot(source);
IContractState state = root.StartTracking();
IPersistenceStrategy persistenceStrategy = new PersistenceStrategy(state);
var persistentState = new PersistentState(
persistenceStrategy,
this.contractPrimitiveSerializer,
uint160.One);
var list = new SmartContractList <string>(persistentState, listName);
Assert.Equal((uint)0, list.Count);
var testItem = "Test";
list.Add(testItem);
var item1 = list.GetValue(0);
Assert.Equal(testItem, item1);
}
public void SmartContractList_CanAccessValueUsingIndexTest()
{
var listName = "testList";
var source = new MemoryDictionarySource();
var root = new ContractStateRoot(source);
IContractState state = root.StartTracking();
IPersistenceStrategy persistenceStrategy = new PersistenceStrategy(state);
var persistentState = new PersistentState(
persistenceStrategy,
this.contractPrimitiveSerializer,
uint160.One);
var list = new SmartContractList <string>(persistentState, listName);
Assert.Equal((uint)0, list.Count);
// Set a value in the list
list.Add("Test");
list.Add("Test2");
var testItem = list.GetValue(0);
var testItem2 = list.GetValue(1);
var firstItemHash = $"{listName}[0]";
var secondItemHash = $"{listName}[1]";
var item = persistentState.GetString(firstItemHash);
var item2 = persistentState.GetString(secondItemHash);
Assert.Equal(testItem, item);
Assert.Equal(testItem2, item2);
}
public void Repository_CommitAndRollbackTest()
{
ISource <byte[], byte[]> stateDB = new NoDeleteSource <byte[], byte[]>(new MemoryDictionarySource());
ContractStateRoot repository = new ContractStateRoot(stateDB);
IContractState txTrack = repository.StartTracking();
txTrack.CreateAccount(testAddress);
txTrack.SetStorageValue(testAddress, dog, cat);
txTrack.Commit();
repository.Commit();
byte[] root1 = repository.Root;
IContractState txTrack2 = repository.StartTracking();
txTrack2.SetStorageValue(testAddress, dog, fish);
txTrack2.Rollback();
IContractState txTrack3 = repository.StartTracking();
txTrack3.SetStorageValue(testAddress, dodecahedron, bird);
txTrack3.Commit();
repository.Commit();
byte[] upToDateRoot = repository.Root;
Assert.Equal(cat, repository.GetStorageValue(testAddress, dog));
Assert.Equal(bird, repository.GetStorageValue(testAddress, dodecahedron));
IContractState snapshot = repository.GetSnapshotTo(root1);
repository.SyncToRoot(root1);
Assert.Equal(cat, snapshot.GetStorageValue(testAddress, dog));
Assert.Null(snapshot.GetStorageValue(testAddress, dodecahedron));
}
public SmartContractExceptionTests()
{
var context = new ContractExecutorTestContext();
this.network = context.Network;
this.repository = context.State;
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 void Repository_CommitPushesToUnderlyingSource()
{
ISource <byte[], byte[]> stateDB = new NoDeleteSource <byte[], byte[]>(new MemoryDictionarySource());
ContractStateRoot repository = new ContractStateRoot(stateDB);
IContractState txTrack = repository.StartTracking();
txTrack.CreateAccount(testAddress);
txTrack.SetStorageValue(testAddress, dog, cat);
Assert.Null(repository.GetStorageValue(testAddress, dog));
txTrack.Commit();
Assert.Equal(cat, repository.GetStorageValue(testAddress, dog));
}
public void Test20DBreeze()
{
DBreezeEngine engine = new DBreezeEngine(DbreezeTestLocation);
using (DBreeze.Transactions.Transaction t = engine.GetTransaction())
{
t.RemoveAllKeys(DbreezeTestDb, true);
t.Commit();
}
ISource <byte[], byte[]> stateDB = new NoDeleteSource <byte[], byte[]>(new DBreezeByteStore(engine, DbreezeTestDb));
ContractStateRoot repository = new ContractStateRoot(stateDB);
byte[] root = repository.Root;
uint160 cowAddress = new uint160(cow);
uint160 horseAddress = new uint160(horse);
IContractState track2 = repository.StartTracking(); //repository
track2.SetStorageValue(cowAddress, cowKey1, cowVal1);
track2.SetStorageValue(horseAddress, horseKey1, horseVal1);
track2.Commit();
repository.Commit();
byte[] root2 = repository.Root;
track2 = repository.StartTracking(); //repository
track2.SetStorageValue(cowAddress, cowKey2, cowVal0);
track2.SetStorageValue(horseAddress, horseKey2, horseVal0);
track2.Commit();
repository.Commit();
byte[] root3 = repository.Root;
IContractState snapshot = new ContractStateRoot(stateDB, root);
Assert.Null(snapshot.GetStorageValue(cowAddress, cowKey1));
Assert.Null(snapshot.GetStorageValue(cowAddress, cowKey2));
Assert.Null(snapshot.GetStorageValue(horseAddress, horseKey1));
Assert.Null(snapshot.GetStorageValue(horseAddress, horseKey2));
snapshot = new ContractStateRoot(stateDB, root2);
Assert.Equal(cowVal1, snapshot.GetStorageValue(cowAddress, cowKey1));
Assert.Null(snapshot.GetStorageValue(cowAddress, cowKey2));
Assert.Equal(horseVal1, snapshot.GetStorageValue(horseAddress, horseKey1));
Assert.Null(snapshot.GetStorageValue(horseAddress, horseKey2));
snapshot = new ContractStateRoot(stateDB, root3);
Assert.Equal(cowVal1, snapshot.GetStorageValue(cowAddress, cowKey1));
Assert.Equal(cowVal0, snapshot.GetStorageValue(cowAddress, cowKey2));
Assert.Equal(horseVal1, snapshot.GetStorageValue(horseAddress, horseKey1));
Assert.Equal(horseVal0, snapshot.GetStorageValue(horseAddress, horseKey2));
}
public void Test4()
{
MemoryDictionarySource source = new MemoryDictionarySource();
ContractStateRoot root = new ContractStateRoot(source);
IContractState repository = root.StartTracking();
repository.SetStorageValue(new uint160(cow), cowKey, cowValue);
repository.SetStorageValue(new uint160(horse), horseKey, horseValue);
repository.Commit();
Assert.Equal(cowValue, root.GetStorageValue(new uint160(cow), cowKey));
Assert.Equal(horseValue, root.GetStorageValue(new uint160(horse), horseKey));
}
public void Test12()
{
ContractStateRoot repository = new ContractStateRoot(new MemoryDictionarySource());
IContractState track = repository.StartTracking();
track.SetCode(new uint160(cow), cowCode);
track.SetCode(new uint160(horse), horseCode);
Assert.Equal(cowCode, track.GetCode(new uint160(cow)));
Assert.Equal(horseCode, track.GetCode(new uint160(horse)));
track.Rollback();
Assert.Null(repository.GetCode(new uint160(cow)));
Assert.Null(repository.GetCode(new uint160(horse)));
}
public void Test3()
{
ContractStateRoot repository = new ContractStateRoot(new MemoryDictionarySource());
uint160 cow = 100;
uint160 horse = 2000;
byte[] cowCode = "A1A2A3".HexToByteArray();
byte[] horseCode = "B1B2B3".HexToByteArray();
repository.SetCode(cow, cowCode);
repository.SetCode(horse, horseCode);
Assert.Equal(cowCode, repository.GetCode(cow));
Assert.Equal(horseCode, repository.GetCode(horse));
}
public void Test20()
{
ISource <byte[], byte[]> stateDB = new NoDeleteSource <byte[], byte[]>(new MemoryDictionarySource());
ContractStateRoot repository = new ContractStateRoot(stateDB);
byte[] root = repository.Root;
uint160 cowAddress = new uint160(cow);
uint160 horseAddress = new uint160(horse);
IContractState track2 = repository.StartTracking(); //repository
track2.SetStorageValue(cowAddress, cowKey1, cowVal1);
track2.SetStorageValue(horseAddress, horseKey1, horseVal1);
track2.Commit();
repository.Commit();
byte[] root2 = repository.Root;
track2 = repository.StartTracking(); //repository
track2.SetStorageValue(cowAddress, cowKey2, cowVal0);
track2.SetStorageValue(horseAddress, horseKey2, horseVal0);
track2.Commit();
repository.Commit();
byte[] root3 = repository.Root;
IContractState snapshot = new ContractStateRoot(stateDB, root);
Assert.Null(snapshot.GetStorageValue(cowAddress, cowKey1));
Assert.Null(snapshot.GetStorageValue(cowAddress, cowKey2));
Assert.Null(snapshot.GetStorageValue(horseAddress, horseKey1));
Assert.Null(snapshot.GetStorageValue(horseAddress, horseKey2));
snapshot = new ContractStateRoot(stateDB, root2);
Assert.Equal(cowVal1, snapshot.GetStorageValue(cowAddress, cowKey1));
Assert.Null(snapshot.GetStorageValue(cowAddress, cowKey2));
Assert.Equal(horseVal1, snapshot.GetStorageValue(horseAddress, horseKey1));
Assert.Null(snapshot.GetStorageValue(horseAddress, horseKey2));
snapshot = new ContractStateRoot(stateDB, root3);
Assert.Equal(cowVal1, snapshot.GetStorageValue(cowAddress, cowKey1));
Assert.Equal(cowVal0, snapshot.GetStorageValue(cowAddress, cowKey2));
Assert.Equal(horseVal1, snapshot.GetStorageValue(horseAddress, horseKey1));
Assert.Equal(horseVal0, snapshot.GetStorageValue(horseAddress, horseKey2));
}
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 ContractStateRoot(new NoDeleteSource <byte[], byte[]>(new MemoryDictionarySource()));
IContractState track = repository.StartTracking();
var gasMeter = new GasMeter(callData.GasLimit);
var transactionContext = new TransactionContext(
txHash: uint256.One,
blockHeight: 1,
coinbase: TestAddress.ToUint160(this.network),
sender: TestAddress.ToUint160(this.network),
amount: value
);
VmExecutionResult result = this.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 SmartContractList_ListEnumerationTest()
{
var listName = "testList";
var source = new MemoryDictionarySource();
var root = new ContractStateRoot(source);
IContractState state = root.StartTracking();
IPersistenceStrategy persistenceStrategy = new PersistenceStrategy(state);
var persistentState = new PersistentState(
persistenceStrategy,
this.contractPrimitiveSerializer,
uint160.One);
var list = new SmartContractList <string>(persistentState, listName);
Assert.Equal((uint)0, list.Count);
var items = new List <string>
{
"this is a test",
"we should try to find a way",
"to paramaterize our tests"
};
foreach (var item in items)
{
// No AddRange
list.Add(item);
}
Assert.Equal((uint)items.Count, list.Count);
for (var i = 0; i < list.Count; i++)
{
Assert.Equal(items[i], list.GetValue((uint)i));
}
}
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 ContractStateRoot(new NoDeleteSource <byte[], byte[]>(new MemoryDictionarySource()));
IContractState track = repository.StartTracking();
var gasMeter = new GasMeter(callData.GasLimit);
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 = this.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));
}
