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));
ContractStateRepositoryRoot repository = new ContractStateRepositoryRoot(stateDB);
byte[] root = repository.Root;
uint160 cowAddress = new uint160(cow);
uint160 horseAddress = new uint160(horse);
IContractStateRepository 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;
IContractStateRepository snapshot = new ContractStateRepositoryRoot(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 ContractStateRepositoryRoot(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 ContractStateRepositoryRoot(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 Repository_CommitAndRollbackTest()
{
ISource <byte[], byte[]> stateDB = new NoDeleteSource <byte[], byte[]>(new MemoryDictionarySource());
ContractStateRepositoryRoot repository = new ContractStateRepositoryRoot(stateDB);
IContractStateRepository txTrack = repository.StartTracking();
txTrack.CreateAccount(testAddress);
txTrack.SetStorageValue(testAddress, dog, cat);
txTrack.Commit();
repository.Commit();
byte[] root1 = repository.Root;
IContractStateRepository txTrack2 = repository.StartTracking();
txTrack2.SetStorageValue(testAddress, dog, fish);
txTrack2.Rollback();
IContractStateRepository 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));
IContractStateRepository snapshot = repository.GetSnapshotTo(root1);
repository.SyncToRoot(root1);
Assert.Equal(cat, snapshot.GetStorageValue(testAddress, dog));
Assert.Null(snapshot.GetStorageValue(testAddress, dodecahedron));
}
///<inheritdoc />
public ICreateResult Create <T>(ISmartContractState smartContractState,
ulong amountToTransfer,
object[] parameters,
ulong gasLimit = 0)
{
// TODO: Expend any neccessary costs.
ulong gasBudget = (gasLimit != 0) ? gasLimit : DefaultGasLimit;
// Ensure we have enough gas left to be able to fund the new GasMeter.
if (smartContractState.GasMeter.GasAvailable < gasBudget)
{
throw new InsufficientGasException();
}
var nestedGasMeter = new GasMeter((Gas)gasBudget);
// Check balance.
EnsureContractHasEnoughBalance(smartContractState, amountToTransfer);
// Build objects for VM
byte[] contractCode = this.contractStateRepository.GetCode(smartContractState.Message.ContractAddress.ToUint160(this.network)); // TODO: Fix this when calling from constructor.
var context = new TransactionContext(
this.transactionContext.TransactionHash,
this.transactionContext.BlockHeight,
this.transactionContext.Coinbase,
smartContractState.Message.ContractAddress.ToUint160(this.network),
amountToTransfer,
this.transactionContext.GetNonceAndIncrement());
IContractStateRepository track = this.contractStateRepository.StartTracking();
var createData = new CreateData(nestedGasMeter.GasLimit, contractCode, parameters);
// Do create in vm
VmExecutionResult result = this.vm.Create(nestedGasMeter, track, createData, context, typeof(T).Name);
// Update parent gas meter.
smartContractState.GasMeter.Spend(nestedGasMeter.GasConsumed);
var revert = result.ExecutionException != null;
if (revert)
{
this.logger.LogTrace("(-)[CONTRACT_EXECUTION_FAILED]");
track.Rollback();
return(CreateResult.Failed());
}
this.logger.LogTrace("(-)[CONTRACT_EXECUTION_SUCCEEDED]");
track.Commit();
// TODO: Add internaltransfer update here
this.contractLogHolder.AddRawLogs(result.RawLogs);
return(CreateResult.Succeeded(result.NewContractAddress.ToAddress(this.network)));
}
public void Test20()
{
ISource <byte[], byte[]> stateDB = new NoDeleteSource <byte[], byte[]>(new MemoryDictionarySource());
ContractStateRepositoryRoot repository = new ContractStateRepositoryRoot(stateDB);
byte[] root = repository.Root;
uint160 cowAddress = new uint160(cow);
uint160 horseAddress = new uint160(horse);
IContractStateRepository 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;
IContractStateRepository snapshot = new ContractStateRepositoryRoot(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 ContractStateRepositoryRoot(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 ContractStateRepositoryRoot(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));
}
/// <summary>
/// If the address to where the funds will be tranferred to is a contract, instantiate and execute it.
/// </summary>
private ITransferResult ExecuteTransferFundsToContract(byte[] contractCode, ISmartContractState smartContractState, Address addressTo, ulong amountToTransfer, TransferFundsToContract contractDetails)
{
this.logger.LogTrace("({0}:{1},{2}:{3})", nameof(addressTo), addressTo, nameof(amountToTransfer), amountToTransfer);
ulong gasBudget = contractDetails.GasBudget == 0 ? DefaultGasLimit : contractDetails.GasBudget;
// Ensure we have enough gas left to be able to fund the new GasMeter.
if (smartContractState.GasMeter.GasAvailable < gasBudget)
{
throw new InsufficientGasException();
}
var nestedGasMeter = new GasMeter((Gas)gasBudget);
IContractStateRepository track = this.contractStateRepository.StartTracking();
var callData = new CallData(smartContractState.GasMeter.GasLimit, addressTo.ToUint160(this.network), contractDetails.ContractMethodName, contractDetails.MethodParameters);
var context = new TransactionContext(
this.transactionContext.TransactionHash,
this.transactionContext.BlockHeight,
this.transactionContext.Coinbase,
smartContractState.Message.ContractAddress.ToUint160(this.network),
amountToTransfer,
this.transactionContext.GetNonceAndIncrement());
VmExecutionResult result = this.vm.ExecuteMethod(nestedGasMeter,
track,
callData,
context);
// Update parent gas meter.
smartContractState.GasMeter.Spend(nestedGasMeter.GasConsumed);
var revert = result.ExecutionException != null;
if (revert)
{
track.Rollback();
return(TransferResult.Failed(result.ExecutionException));
}
track.Commit();
this.internalTransferList.Add(new TransferInfo
{
From = smartContractState.Message.ContractAddress.ToUint160(this.network),
To = addressTo.ToUint160(this.network),
Value = amountToTransfer
});
this.logger.LogTrace("(-)");
return(TransferResult.Transferred(result.Result));
}
public void Repository_CommitPushesToUnderlyingSource()
{
ISource <byte[], byte[]> stateDB = new NoDeleteSource <byte[], byte[]>(new MemoryDictionarySource());
ContractStateRepositoryRoot repository = new ContractStateRepositoryRoot(stateDB);
IContractStateRepository 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 Test4()
{
MemoryDictionarySource source = new MemoryDictionarySource();
ContractStateRepositoryRoot root = new ContractStateRepositoryRoot(source);
IContractStateRepository 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 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")));
}
/// <summary>
/// If the address to where the funds will be tranferred to is a contract, instantiate and execute it.
/// </summary>
private ITransferResult ExecuteTransferFundsToContract(byte[] contractCode, ISmartContractState smartContractState, Address addressTo, ulong amountToTransfer, TransferFundsToContract contractDetails)
{
this.logger.LogTrace("({0}:{1},{2}:{3})", nameof(addressTo), addressTo, nameof(amountToTransfer), amountToTransfer);
IContractStateRepository track = this.contractStateRepository.StartTracking();
IPersistenceStrategy persistenceStrategy = new MeteredPersistenceStrategy(track, smartContractState.GasMeter, this.keyEncodingStrategy);
IPersistentState newPersistentState = new PersistentState(persistenceStrategy, addressTo.ToUint160(this.network), this.network);
var newMessage = new Message(addressTo, smartContractState.Message.ContractAddress, amountToTransfer, (Gas)(smartContractState.Message.GasLimit - smartContractState.GasMeter.GasConsumed));
ISmartContractExecutionContext newContext = new SmartContractExecutionContext(smartContractState.Block, newMessage, addressTo.ToUint160(this.network), 0, contractDetails.MethodParameters);
ISmartContractVirtualMachine vm = new ReflectionVirtualMachine(new InternalTransactionExecutorFactory(this.keyEncodingStrategy, this.loggerFactory, this.network), this.loggerFactory);
var result = vm.ExecuteMethod(
contractCode,
contractDetails.ContractMethodName,
newContext,
smartContractState.GasMeter,
newPersistentState,
track);
var revert = result.ExecutionException != null;
if (revert)
{
track.Rollback();
return(TransferResult.Failed(result.ExecutionException));
}
track.Commit();
this.internalTransferList.Add(new TransferInfo
{
From = smartContractState.Message.ContractAddress.ToUint160(this.network),
To = addressTo.ToUint160(this.network),
Value = amountToTransfer
});
this.logger.LogTrace("(-)");
return(TransferResult.Transferred(result.Result));
}
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));
}
/// <summary>
/// If the address to where the funds will be tranferred to is a contract, instantiate and execute it.
/// </summary>
private ITransferResult ExecuteTransferFundsToContract(byte[] contractCode, ISmartContractState smartContractState, Address addressTo, ulong amountToTransfer, TransferFundsToContract contractDetails)
{
this.logger.LogTrace("({0}:{1},{2}:{3})", nameof(addressTo), addressTo, nameof(amountToTransfer), amountToTransfer);
IContractStateRepository track = this.contractStateRepository.StartTracking();
var callData = new CallData(smartContractState.GasMeter.GasLimit, addressTo.ToUint160(this.network), contractDetails.ContractMethodName, contractDetails.MethodParameters);
var context = new TransactionContext(
this.transactionContext.TransactionHash,
this.transactionContext.BlockHeight,
this.transactionContext.Coinbase,
smartContractState.Message.ContractAddress.ToUint160(this.network),
amountToTransfer);
var result = this.vm.ExecuteMethod(smartContractState.GasMeter,
track,
callData,
context);
var revert = result.ExecutionException != null;
if (revert)
{
track.Rollback();
return(TransferResult.Failed(result.ExecutionException));
}
track.Commit();
this.internalTransferList.Add(new TransferInfo
{
From = smartContractState.Message.ContractAddress.ToUint160(this.network),
To = addressTo.ToUint160(this.network),
Value = amountToTransfer
});
this.logger.LogTrace("(-)");
return(TransferResult.Transferred(result.Result));
}
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;
//-------------------------------------------------------
//Set the calldata for the transaction----------
var callData = new CallData((Gas)5000000, new uint160(1), "StoreData");
Money value = Money.Zero;
//-------------------------------------------------------
var repository = new ContractStateRepositoryRoot(new NoDeleteSource <byte[], byte[]>(new MemoryDictionarySource()));
IContractStateRepository stateRepository = repository.StartTracking();
var gasMeter = new GasMeter(callData.GasLimit);
uint160 address = TestAddress.ToUint160(this.network);
var transactionContext = new TransactionContext(uint256.One, 1, address, address, 0);
repository.SetCode(callData.ContractAddress, contractExecutionCode);
repository.SetContractType(callData.ContractAddress, "StorageTest");
VmExecutionResult result = this.vm.ExecuteMethod(gasMeter,
repository,
callData,
transactionContext);
stateRepository.Commit();
Assert.Equal(Encoding.UTF8.GetBytes("TestValue"), stateRepository.GetStorageValue(callData.ContractAddress, Encoding.UTF8.GetBytes("TestKey")));
Assert.Equal(Encoding.UTF8.GetBytes("TestValue"), repository.GetStorageValue(callData.ContractAddress, Encoding.UTF8.GetBytes("TestKey")));
}
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")));
}