- Catch events for each incoming transaction.

mix/ClientModel.cpp

@@ -30,6 +30,7 @@
 #include <jsonrpccpp/server.h>
 #include <libethcore/CommonJS.h>
 #include <libethereum/Transaction.h>
+#include <libdevcore/FixedHash.h>
 #include "DebuggingStateWrapper.h"
 #include "Exceptions.h"
 #include "QContractDefinition.h"
@@ -668,7 +669,7 @@ RecordLogEntry* ClientModel::lastBlock() const
 	strGas << blockInfo.gasUsed;
 	stringstream strNumber;
 	strNumber << blockInfo.number;
-    RecordLogEntry* record =  new RecordLogEntry(0, QString::fromStdString(strNumber.str()), tr(" - Block - "), tr("Hash: ") + QString(QString::fromStdString(dev::toHex(blockInfo.hash().ref()))), QString(), QString(), QString(), false, RecordLogEntry::RecordType::Block, QString::fromStdString(strGas.str()), QString(), tr("Block"), QVariantMap());
+	RecordLogEntry* record =  new RecordLogEntry(0, QString::fromStdString(strNumber.str()), tr(" - Block - "), tr("Hash: ") + QString(QString::fromStdString(dev::toHex(blockInfo.hash().ref()))), QString(), QString(), QString(), false, RecordLogEntry::RecordType::Block, QString::fromStdString(strGas.str()), QString(), tr("Block"), QVariantMap(), QVariantList());
 	QQmlEngine::setObjectOwnership(record, QQmlEngine::JavaScriptOwnership);
 	return record;
 }
@@ -728,8 +729,10 @@ void ClientModel::onNewTransaction()
 	Address contractAddress = (bool)tr.address ? tr.address : tr.contractAddress;
 	auto contractAddressIter = m_contractNames.find(contractAddress);
 	QVariantMap inputParameters;
+	QVariantList logs;
 	if (contractAddressIter != m_contractNames.end())
 	{
+		ContractCallDataEncoder encoder;
 		CompiledContract const& compilerRes = m_codeModel->contract(contractAddressIter->second);
 		const QContractDefinition* def = compilerRes.contract();
 		contract = def->name();
@@ -739,7 +742,6 @@ void ClientModel::onNewTransaction()
 			if (funcDef)
 			{
 				function = funcDef->name();
-				ContractCallDataEncoder encoder;
 				QStringList returnValues = encoder.decode(funcDef->returnParameters(), tr.result.output);
 				returned += "(";
 				returned += returnValues.join(", ");
@@ -751,13 +753,53 @@ void ClientModel::onNewTransaction()
 					inputParameters.insert(funcDef->parametersList().at(k)->name(), parameters.at(k));
 			}
 		}
-	}
 
-    LocalisedLogEntries logs = m_client->logs();
+		// Fill generated logs and decode parameters
+		for (auto const& log: tr.logs)
+		{
+			QVariantMap l;
+			l.insert("address",  QString::fromStdString(log.address.hex()));
+			auto const& sign = log.topics.front(); // first hash supposed to be the event signature. To check
+			auto dataIterator = log.data.begin();
+			int topicDataIndex = 1;
+			for (auto const& event: def->eventsList())
+			{
+				if (sign == event->fullHash())
+				{
+					QVariantList paramsList;
+					l.insert("name", event->name());
+					for (auto const& e: event->parametersList())
+					{
+						bytes data;
+						QString param;
+						if (!e->isIndexed())
+						{
+							data = bytes(dataIterator, dataIterator + 32);
+							dataIterator = dataIterator + 32;
+						}
+						else
+						{
+							data = log.topics.at(topicDataIndex).asBytes();
+							topicDataIndex++;
+						}
+						param = encoder.decode(e, data);
+						QVariantMap p;
+						p.insert("indexed", e->isIndexed());
+						p.insert("value", param);
+						p.insert("name", e->name());
+						paramsList.push_back(p);
+					}
+					l.insert("param", paramsList);
+					break;
+				}
+			}
+			logs.push_back(l);
+		}
+	}
 	QString sender = QString::fromStdString(dev::toHex(tr.sender.ref()));
 	QString label = contract + "." + function + "()";
 	RecordLogEntry* log = new RecordLogEntry(recordIndex, transactionIndex, contract, function, value, address, returned, tr.isCall(), RecordLogEntry::RecordType::Transaction,
-                                             gasUsed, sender, label, inputParameters);
+											 gasUsed, sender, label, inputParameters, logs);
 	QQmlEngine::setObjectOwnership(log, QQmlEngine::JavaScriptOwnership);
 	emit newRecord(log);
 }

mix/ClientModel.h

@@ -115,6 +115,8 @@ class RecordLogEntry: public QObject
     Q_PROPERTY(QString label MEMBER m_label CONSTANT)
     /// input parameters
     Q_PROPERTY(QVariantMap parameters MEMBER m_inputParameters CONSTANT)
+    /// logs
+    Q_PROPERTY(QVariantList logs MEMBER m_logs CONSTANT)
 
 public:
 	enum RecordType
@@ -126,9 +128,9 @@ public:
 	RecordLogEntry():
 		m_recordIndex(0), m_call(false), m_type(RecordType::Transaction) {}
     RecordLogEntry(unsigned _recordIndex, QString _transactionIndex, QString _contract, QString _function, QString _value, QString _address, QString _returned, bool _call, RecordType _type, QString _gasUsed,
-                   QString _sender, QString _label, QVariantMap _inputParameters):
+                   QString _sender, QString _label, QVariantMap _inputParameters, QVariantList _logs):
         m_recordIndex(_recordIndex), m_transactionIndex(_transactionIndex), m_contract(_contract), m_function(_function), m_value(_value), m_address(_address), m_returned(_returned), m_call(_call), m_type(_type), m_gasUsed(_gasUsed),
-        m_sender(_sender), m_label(_label), m_inputParameters(_inputParameters) {}
+        m_sender(_sender), m_label(_label), m_inputParameters(_inputParameters), m_logs(_logs) {}
 
 private:
 	unsigned m_recordIndex;
@@ -144,6 +146,7 @@ private:
     QString m_sender;
     QString m_label;
     QVariantMap m_inputParameters;
+    QVariantList m_logs;
 };
 
 /**

mix/ContractCallDataEncoder.cpp

@@ -228,16 +228,10 @@ QVariant ContractCallDataEncoder::decode(SolidityType const& _type, bytes const&
 		BOOST_THROW_EXCEPTION(Exception() << errinfo_comment("Parameter declaration not found"));
 }
 
-QStringList ContractCallDataEncoder::decode(QList<QVariableDeclaration*> const& _returnParameters, vector<bytes> _value)
+QString ContractCallDataEncoder::decode(QVariableDeclaration* const& _param, bytes _value)
 {
-    QStringList r;
+	SolidityType const& type = _param->type()->type();
-    for (int k = 0; k <_returnParameters.length(); k++)
+	return decode(type, _value).toString();
-    {
-        QVariableDeclaration* dec = static_cast<QVariableDeclaration*>(_returnParameters.at(k));
-        SolidityType const& type = dec->type()->type();
-        r.append(decode(type, _value.at(k)).toString());
-    }
-    return r;
 }
 
 QStringList ContractCallDataEncoder::decode(QList<QVariableDeclaration*> const& _returnParameters, bytes _value)

mix/ContractCallDataEncoder.h

@@ -48,8 +48,8 @@ public:
 	void encode(QVariant const& _data, SolidityType const& _type);
 	/// Decode variable in order to be sent to QML view.
 	QStringList decode(QList<QVariableDeclaration*> const& _dec, bytes _value);
-    /// Decode @param _parameters
+	/// Decode @param _parameter
-    QStringList decode(QList<QVariableDeclaration*> const& _parameters, std::vector<bytes> _value);
+	QString decode(QVariableDeclaration* const& _param, bytes _value);
     /// Decode single variable
 	QVariant decode(SolidityType const& _type, bytes const& _value);
 	/// Get all encoded data encoded by encode function.

mix/MachineStates.h

@@ -84,6 +84,7 @@ namespace mix
 		unsigned transactionIndex;
 		unsigned executonIndex = 0;
         bytes inputParameters;
+        eth::LocalisedLogEntries logs;
 
 		bool isCall() const { return transactionIndex == std::numeric_limits<unsigned>::max(); }
 		bool isConstructor() const { return !isCall() && !address; }

mix/MixClient.cpp

@@ -89,9 +89,9 @@ void MixClient::resetState(std::unordered_map<Address, Account> const& _accounts
     Guard fl(x_filtersWatches);
     m_filters.clear();
     m_watches.clear();
-    LogFilter filter;
+    //LogFilter filter;
-    m_filters.insert(std::make_pair(filter.sha3(), filter));
+    //m_filters.insert(std::make_pair(filter.sha3(), filter));
-    m_watches.insert(std::make_pair(0, ClientWatch(filter.sha3(), Reaping::Automatic)));
+    //m_watches.insert(std::make_pair(0, ClientWatch(filter.sha3(), Reaping::Automatic)));
 
     m_stateDB = OverlayDB();
     SecureTrieDB<Address, MemoryDB> accountState(&m_stateDB);
@@ -249,8 +249,22 @@ void MixClient::executeTransaction(Transaction const& _t, State& _state, bool _c
         // collect watches
         h256Set changed;
         Guard l(x_filtersWatches);
-		for (std::pair<h256 const, eth::InstalledFilter>& i: m_filters)
+        LocalisedLogEntries logs;
-			if ((unsigned)i.second.filter.latest() > bc().number())
+        //for (unsigned i = 0; i < _state.pending().size(); ++i)
+        //{
+        TransactionReceipt const& tr = _state.receipt(_state.pending().size() - 1);
+
+        auto trHash = _state.pending().at(_state.pending().size() - 1).sha3();
+        //for (std::pair<h256 const, eth::InstalledFilter>& installedFilter: m_filters)
+        //{
+        LogEntries le = tr.log(); // installedFilter.second.filter.matches(tr);
+        if (le.size())
+            for (unsigned j = 0; j < le.size(); ++j)
+                logs.insert(logs.begin(), LocalisedLogEntry(le[j], bc().number() + 1, trHash));
+        //}
+        //}
+
+        /*if ((unsigned)i.second.filter.latest() > bc().number())
             {
                 // acceptable number.
                 auto m = i.second.filter.matches(_state.receipt(_state.pending().size() - 1));
@@ -261,9 +275,10 @@ void MixClient::executeTransaction(Transaction const& _t, State& _state, bool _c
                         i.second.changes.push_back(LocalisedLogEntry(l, bc().number() + 1));
                     changed.insert(i.first);
                 }
-			}
+            }*/
         changed.insert(dev::eth::PendingChangedFilter);
-		noteChanged(changed);
+        d.logs =  logs;
+        //noteChanged(changed);
     }
     WriteGuard l(x_executions);
     m_executions.emplace_back(std::move(d));
@@ -278,7 +293,7 @@ void MixClient::mine()
     m_state.sync(bc());
     m_startState = m_state;
     h256Set changed { dev::eth::PendingChangedFilter, dev::eth::ChainChangedFilter };
-	noteChanged(changed);
+    //noteChanged(changed);
 }
 
 ExecutionResult MixClient::lastExecution() const
@@ -365,7 +380,7 @@ dev::eth::ExecutionResult MixClient::create(Address const& _from, u256 _value, b
     return lastExecution().result;
 }
 
-void MixClient::noteChanged(h256Set const& _filters)
+/*void MixClient::noteChanged(h256Set const& _filters)
 {
     for (auto& i: m_watches)
         if (_filters.count(i.second.id))
@@ -377,7 +392,7 @@ void MixClient::noteChanged(h256Set const& _filters)
         }
     for (auto& i: m_filters)
         i.second.changes.clear();
-}
+}*/
 
 eth::BlockInfo MixClient::blockInfo() const
 {

mix/MixClient.h

@@ -91,7 +91,7 @@ protected:
 
 private:
 	void executeTransaction(dev::eth::Transaction const& _t, eth::State& _state, bool _call, bool _gasAuto, dev::Secret const& _secret = dev::Secret());
-	void noteChanged(h256Set const& _filters);
+    //void noteChanged(h256Set const& _filters);
 	dev::eth::Transaction replaceGas(dev::eth::Transaction const& _t, dev::u256 const& _gas, dev::Secret const& _secret = dev::Secret());
 
     eth::State m_state;

mix/QContractDefinition.cpp

@@ -39,10 +39,25 @@ QContractDefinition::QContractDefinition(QObject* _parent, dev::solidity::Contra
 	else
 		m_constructor = new QFunctionDefinition(parent);
 
+	std::vector<std::string> found;
+	for (auto const& f: _contract->getDefinedFunctions())
+	{
+		m_functions.append(new QFunctionDefinition(parent, f));
+		found.push_back(f->getName());
+	}
+
 	for (auto const& it: _contract->getInterfaceFunctions())
+	{
+		if (std::find(found.begin(), found.end(), it.second->getDeclaration().getName()) == found.end())
 			m_functions.append(new QFunctionDefinition(parent, it.second));
 	}
 
+
+    for (auto const& it: _contract->getEvents())
+		m_events.append(new QFunctionDefinition(parent, it));
+
+}
+
 QFunctionDefinition const* QContractDefinition::getFunction(dev::FixedHash<4> _hash) const
 {
 	for (auto const& f: m_functions)

mix/QContractDefinition.h

@@ -37,6 +37,7 @@ class QContractDefinition: public QBasicNodeDefinition
 	Q_OBJECT
 	Q_PROPERTY(QQmlListProperty<dev::mix::QFunctionDefinition> functions READ functions CONSTANT)
 	Q_PROPERTY(dev::mix::QFunctionDefinition* constructor READ constructor CONSTANT)
+	Q_PROPERTY(QQmlListProperty<dev::mix::QFunctionDefinition> events READ events CONSTANT)
 
 public:
 	QContractDefinition(QObject* _parent, solidity::ContractDefinition const* _contract);
@@ -44,12 +45,19 @@ public:
 	QQmlListProperty<QFunctionDefinition> functions() const { return QQmlListProperty<QFunctionDefinition>(const_cast<QContractDefinition*>(this), const_cast<QContractDefinition*>(this)->m_functions); }
 	/// Get the constructor of the contract.
 	QFunctionDefinition* constructor() const { return m_constructor; }
+	/// Get all the functions of the contract.
 	QList<QFunctionDefinition*> const& functionsList() const { return m_functions; }
 	/// Find function by hash, returns nullptr if not found
 	QFunctionDefinition const* getFunction(dev::FixedHash<4> _hash) const;
+	/// Get events
+	QQmlListProperty<QFunctionDefinition> events() const { return QQmlListProperty<QFunctionDefinition>(const_cast<QContractDefinition*>(this), const_cast<QContractDefinition*>(this)->m_events); }
+	/// Get events
+	QList<QFunctionDefinition*> const& eventsList() const { return m_events; }
+
 private:
 	QList<QFunctionDefinition*> m_functions;
 	QFunctionDefinition* m_constructor;
+	QList<QFunctionDefinition*> m_events;
 };
 
 }

mix/QFunctionDefinition.cpp

@@ -28,15 +28,41 @@
 using namespace dev::solidity;
 using namespace dev::mix;
 
-QFunctionDefinition::QFunctionDefinition(QObject* _parent, dev::solidity::FunctionTypePointer const& _f): QBasicNodeDefinition(_parent, &_f->getDeclaration()), m_hash(dev::sha3(_f->externalSignature()))
+QFunctionDefinition::QFunctionDefinition(QObject* _parent, dev::solidity::FunctionTypePointer const& _f): QBasicNodeDefinition(_parent, &_f->getDeclaration()), m_hash(dev::sha3(_f->externalSignature())),
+	m_fullHash(dev::sha3(_f->externalSignature()))
+{
+	init(_f);
+}
+
+QFunctionDefinition::QFunctionDefinition(QObject* _parent, ASTPointer<FunctionDefinition> const& _f): QBasicNodeDefinition(_parent, _f.get()), m_hash(dev::sha3(_f->externalSignature())),
+	m_fullHash(dev::sha3(_f->externalSignature()))
+{
+
+	for (unsigned i = 0; i < _f->getParameters().size(); ++i)
+		m_parameters.append(new QVariableDeclaration(parent(), _f->getParameters().at(i)));
+
+	for (unsigned i = 0; i < _f->getReturnParameters().size(); ++i)
+		m_returnParameters.append(new QVariableDeclaration(parent(), _f->getReturnParameters().at(i)));
+}
+
+QFunctionDefinition::QFunctionDefinition(QObject* _parent, ASTPointer<dev::solidity::EventDefinition> const& _e): QBasicNodeDefinition(_parent, _e.get())
+{
+	for (unsigned i = 0; i < _e->getParameters().size(); ++i)
+		m_parameters.append(new QVariableDeclaration(parent(), _e->getParameters().at(i)));
+	FunctionTypePointer _f = std::make_shared<FunctionType>(*_e);
+	m_hash = (FixedHash<4>)dev::sha3(_f->externalSignature(_e->getName()));
+	m_fullHash = dev::sha3(_f->externalSignature(_e->getName()));
+}
+
+void QFunctionDefinition::init(dev::solidity::FunctionTypePointer _f)
 {
 	auto paramNames = _f->getParameterNames();
 	auto paramTypes = _f->getParameterTypes();
 	auto returnNames = _f->getReturnParameterNames();
 	auto returnTypes = _f->getReturnParameterTypes();
 	for (unsigned i = 0; i < paramNames.size(); ++i)
-		m_parameters.append(new QVariableDeclaration(_parent, paramNames[i], paramTypes[i].get()));
+		m_parameters.append(new QVariableDeclaration(parent(), paramNames[i], paramTypes[i].get()));
 
 	for (unsigned i = 0; i < returnNames.size(); ++i)
-		m_returnParameters.append(new QVariableDeclaration(_parent, returnNames[i], returnTypes[i].get()));
+		m_returnParameters.append(new QVariableDeclaration(parent(), returnNames[i], returnTypes[i].get()));
 }

mix/QFunctionDefinition.h

@@ -41,6 +41,10 @@ public:
 	QFunctionDefinition(){}
 	QFunctionDefinition(QObject* _parent): QBasicNodeDefinition(_parent) {}
 	QFunctionDefinition(QObject* _parent, solidity::FunctionTypePointer const& _f);
+	QFunctionDefinition(QObject* _parent, solidity::ASTPointer<solidity::EventDefinition> const& _f);
+	QFunctionDefinition(QObject* _parent, solidity::ASTPointer<solidity::FunctionDefinition> const& _f);
+	/// Init members
+	void init(dev::solidity::FunctionTypePointer _f);
 	/// Get all input parameters of this function.
 	QList<QVariableDeclaration*> const& parametersList() const { return m_parameters; }
 	/// Get all input parameters of this function as QML property.
@@ -49,10 +53,13 @@ public:
 	QList<QVariableDeclaration*> returnParameters() const { return m_returnParameters; }
 	/// Get the hash of this function declaration on the contract ABI.
 	FixedHash<4> hash() const { return m_hash; }
+	/// Get the full hash of this function declaration on the contract ABI.
+	FixedHash<32> fullHash() const { return m_fullHash; }
 
 private:
 	int m_index;
 	FixedHash<4> m_hash;
+	FixedHash<32> m_fullHash;
 	QList<QVariableDeclaration*> m_parameters;
 	QList<QVariableDeclaration*> m_returnParameters;
 	void initQParameters();

mix/QVariableDeclaration.cpp

@@ -24,27 +24,32 @@
 #include <libsolidity/AST.h>
 #include "CodeModel.h"
 
+using namespace solidity;
+
 namespace dev
 {
 namespace mix
 {
 
-QVariableDeclaration::QVariableDeclaration(QObject* _parent, solidity::VariableDeclaration const* _v):
+QVariableDeclaration::QVariableDeclaration(QObject* _parent, ASTPointer<VariableDeclaration> const _v):
-	QBasicNodeDefinition(_parent, _v),
+	QBasicNodeDefinition(_parent, _v.get()),
 	m_type(new QSolidityType(this, CodeModel::nodeType(_v->getType().get())))
 {
+	m_isIndexed = _v->isIndexed();
 }
 
-QVariableDeclaration::QVariableDeclaration(QObject* _parent, std::string const& _name,  SolidityType const& _type):
+QVariableDeclaration::QVariableDeclaration(QObject* _parent, std::string const& _name,  SolidityType const& _type, bool _isIndexed):
 	QBasicNodeDefinition(_parent, _name),
 	m_type(new QSolidityType(_parent, _type))
 {
+	m_isIndexed = _isIndexed;
 }
 
-QVariableDeclaration::QVariableDeclaration(QObject* _parent, std::string const& _name,  solidity::Type const* _type):
+QVariableDeclaration::QVariableDeclaration(QObject* _parent, std::string const& _name,  solidity::Type const* _type, bool _isIndexed):
 	QBasicNodeDefinition(_parent, _name),
 	m_type(new QSolidityType(this, CodeModel::nodeType(_type)))
 {
+	m_isIndexed = _isIndexed;
 }
 
 QSolidityType::QSolidityType(QObject* _parent, SolidityType const& _type):

mix/QVariableDeclaration.h

@@ -21,6 +21,7 @@
 
 #include <QDebug>
 #include <QVariantList>
+#include <libsolidity/AST.h>
 #include "QBasicNodeDefinition.h"
 #include "SolidityType.h"
 
@@ -82,14 +83,16 @@ class QVariableDeclaration: public QBasicNodeDefinition
 
 public:
 	QVariableDeclaration() {}
-	QVariableDeclaration(QObject* _parent, solidity::VariableDeclaration const* _v);
+	QVariableDeclaration(QObject* _parent, solidity::ASTPointer<solidity::VariableDeclaration> const _v);
-	QVariableDeclaration(QObject* _parent, std::string const& _name,  SolidityType const& _type);
+	QVariableDeclaration(QObject* _parent, std::string const& _name,  SolidityType const& _type, bool _isIndexed = false);
-	QVariableDeclaration(QObject* _parent, std::string const& _name,  solidity::Type const* _type);
+	QVariableDeclaration(QObject* _parent, std::string const& _name,  solidity::Type const* _type, bool _isIndexed = false);
 	QSolidityType* type() const { return m_type; }
 	void setType(QSolidityType* _type) { m_type = _type; }
+	bool isIndexed() { return m_isIndexed; }
 
 private:
 	QSolidityType* m_type;
+	bool m_isIndexed;
 };
 
 

mix/qml/Block.qml

@@ -121,22 +121,36 @@ ColumnLayout
                         clip: true
                     }
 
+                    Label
+                    {
+                        id: logs
+                        width: logsWidth
+                        text: {
+                            if (index >= 0 && transactions.get(index).logs)
+                            {
+                                for (var k in transactions.get(index).logs)
+                                {
+                                    console.log("_________________________")
+                                    console.log(JSON.stringify(transactions.get(index).logs[k]))
+                                    console.log("_________________________")
+                                }
+                                return transactions.get(index).logs.length
+                            }
+                            else
+                                return 0
+                        }
+                    }
+
                     Button
                     {
                         id: debug
-                        width: logsWidth
+                        width: debugActionWidth
                         text: "debug"
                         onClicked:
                         {
                             clientModel.debugRecord(transactions.get(index).recordIndex);
                         }
                     }
-
-                    Label
-                    {
-                        id: logs
-                        width: logsWidth
-                    }
                 }
             }
         }

mix/qml/BlockChain.qml

@@ -30,8 +30,9 @@ Column {
     property int statusWidth: 50
     property int fromWidth: 100
     property int toWidth: 250
-    property int valueWidth: 100
+    property int valueWidth: 50
     property int logsWidth: 50
+    property int debugActionWidth: 50
 
     Row
     {
@@ -62,6 +63,11 @@ Column {
             text: "Logs"
             width: logsWidth
         }
+        Label
+        {
+            text: "Action"
+            width: debugActionWidth
+        }
     }
 
     Rectangle
@@ -253,6 +259,8 @@ Column {
                         blockModel.getTransaction(blockIndex, trIndex).returned = _r.returned;
                         tr.recordIndex = _r.recordIndex;
                         blockModel.getTransaction(blockIndex, trIndex).recordIndex = _r.recordIndex;
+                        tr.logs = _r.logs;
+                        blockModel.getTransaction(blockIndex, trIndex).logs = _r.logs;
                         return;
                     }
                 }
@@ -270,6 +278,7 @@ Column {
                 itemTr.value = QEtherHelper.createEther(_r.value, QEther.Wei)
                 itemTr.sender = _r.sender
                 itemTr.recordIndex = _r.recordIndex
+                itemTr.logs = _r.logs
 
                 model.blocks[model.blocks.length - 1].transactions.push(itemTr)
                 blockModel.appendTransaction(itemTr)