diff --git a/CMakeLists.txt b/CMakeLists.txt index 94b9f07c3..d83f91bf4 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -168,6 +168,7 @@ endif () if (NOT HEADLESS) + add_subdirectory(libnatspec) add_subdirectory(libjsqrc) add_subdirectory(libqwebthree) add_subdirectory(alethzero) diff --git a/alethzero/CMakeLists.txt b/alethzero/CMakeLists.txt index 9aa3c4ddd..b58446935 100644 --- a/alethzero/CMakeLists.txt +++ b/alethzero/CMakeLists.txt @@ -49,6 +49,7 @@ target_link_libraries(${EXECUTABLE} evmcore) target_link_libraries(${EXECUTABLE} devcore) target_link_libraries(${EXECUTABLE} web3jsonrpc) target_link_libraries(${EXECUTABLE} jsqrc) +target_link_libraries(${EXECUTABLE} natspec) # eth_install_executable is defined in cmake/EthExecutableHelper.cmake eth_install_executable(${EXECUTABLE}) diff --git a/alethzero/OurWebThreeStubServer.cpp b/alethzero/OurWebThreeStubServer.cpp index 37d37bce1..02d7236df 100644 --- a/alethzero/OurWebThreeStubServer.cpp +++ b/alethzero/OurWebThreeStubServer.cpp @@ -24,6 +24,7 @@ #include #include #include +#include #include "MainWin.h" @@ -84,36 +85,9 @@ bool OurWebThreeStubServer::authenticate(TransactionSkeleton const& _t) return showAuthenticationPopup("Unverified Pending Transaction", "An undocumented transaction is about to be executed."); - QNatspecExpressionEvaluator evaluator(this, m_main); + NatspecExpressionEvaluator evaluator; userNotice = evaluator.evalExpression(QString::fromStdString(userNotice)).toStdString(); // otherwise it's a transaction to a contract for which we have the natspec return showAuthenticationPopup("Pending Transaction", userNotice); } - -QNatspecExpressionEvaluator::QNatspecExpressionEvaluator(OurWebThreeStubServer* _server, Main* _main) -: m_server(_server), m_main(_main) -{} - -QNatspecExpressionEvaluator::~QNatspecExpressionEvaluator() -{} - -QString QNatspecExpressionEvaluator::evalExpression(QString const& _expression) const -{ - // load natspec.js only when we need it for natspec evaluation - m_main->evalRaw(contentsOfQResource(":/js/natspec.js")); - QVariant result = m_main->evalRaw("evaluateExpression('" + _expression + "')"); - if (result.type() == QVariant::Invalid) - { - cerr << "Could not evaluate natspec expression: \"" << _expression.toStdString() << "\"" << endl; - // return the expression unevaluated - return _expression; - } - return result.toString(); -} - - - - - - diff --git a/alethzero/OurWebThreeStubServer.h b/alethzero/OurWebThreeStubServer.h index 16981f9e1..303b73111 100644 --- a/alethzero/OurWebThreeStubServer.h +++ b/alethzero/OurWebThreeStubServer.h @@ -47,19 +47,3 @@ private: dev::WebThreeDirect* m_web3; Main* m_main; }; - - -class QNatspecExpressionEvaluator: public QObject -{ - Q_OBJECT - -public: - QNatspecExpressionEvaluator(OurWebThreeStubServer* _server, Main* _main); - virtual ~QNatspecExpressionEvaluator(); - - QString evalExpression(QString const& _expression) const; - -private: - OurWebThreeStubServer* m_server; - Main* m_main; -}; diff --git a/libjsqrc/js.qrc b/libjsqrc/js.qrc index 50b5e098c..b23aa144d 100644 --- a/libjsqrc/js.qrc +++ b/libjsqrc/js.qrc @@ -3,6 +3,5 @@ bignumber.min.js setup.js ethereumjs/dist/ethereum.js - natspec.js diff --git a/libnatspec/CMakeLists.txt b/libnatspec/CMakeLists.txt new file mode 100644 index 000000000..b5bd7903e --- /dev/null +++ b/libnatspec/CMakeLists.txt @@ -0,0 +1,35 @@ +cmake_policy(SET CMP0015 NEW) +# let cmake autolink dependencies on windows +cmake_policy(SET CMP0020 NEW) +# this policy was introduced in cmake 3.0 +# remove if, once 3.0 will be used on unix +if (${CMAKE_MAJOR_VERSION} GREATER 2) + # old policy do not use MACOSX_RPATH + cmake_policy(SET CMP0042 OLD) + cmake_policy(SET CMP0043 OLD) +endif() +set(CMAKE_AUTOMOC OFF) + +set(CMAKE_INCLUDE_CURRENT_DIR ON) +aux_source_directory(. SRC_LIST) + +include_directories(..) + +set(EXECUTABLE natspec) + +file(GLOB HEADERS "*.h") + +qt5_add_resources(NATSPECQRC natspec.qrc) + +if (ETH_STATIC) + add_library(${EXECUTABLE} STATIC ${RESOURCE_ADDED} ${SRC_LIST} ${HEADERS} ${NATSPECQRC}) +else() + add_library(${EXECUTABLE} SHARED ${RESOURCE_ADDED} ${SRC_LIST} ${HEADERS} ${NATSPECQRC}) +endif() + +target_link_libraries(${EXECUTABLE} Qt5::Core) +target_link_libraries(${EXECUTABLE} Qt5::Qml) +target_link_libraries(${EXECUTABLE} devcore) + +install( TARGETS ${EXECUTABLE} ARCHIVE DESTINATION lib LIBRARY DESTINATION lib ) +install( FILES ${HEADERS} DESTINATION include/${EXECUTABLE} ) diff --git a/libnatspec/NatspecExpressionEvaluator.cpp b/libnatspec/NatspecExpressionEvaluator.cpp new file mode 100644 index 000000000..fd8369145 --- /dev/null +++ b/libnatspec/NatspecExpressionEvaluator.cpp @@ -0,0 +1,59 @@ +/* + This file is part of cpp-ethereum. + + cpp-ethereum is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + cpp-ethereum is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with cpp-ethereum. If not, see . + */ +/** @file NatspecExpressionEvaluator.cpp + * @author Marek Kotewicz + * @date 2015 + */ + +#include +#include +#include "NatspecExpressionEvaluator.h" + +using namespace std; +using namespace dev; + +static QString contentsOfQResource(string const& _res) +{ + QFile file(QString::fromStdString(_res)); + if (!file.open(QFile::ReadOnly)) + BOOST_THROW_EXCEPTION(FileError()); + QTextStream in(&file); + return in.readAll(); +} + +NatspecExpressionEvaluator::NatspecExpressionEvaluator(QString const& _abi, QString const& _method, QString const& _params) +{ + Q_INIT_RESOURCE(natspec); + QJSValue result = m_engine.evaluate(contentsOfQResource(":/natspec/natspec.js")); + if (result.isError()) + BOOST_THROW_EXCEPTION(FileError()); + + m_engine.evaluate("globals.abi = " + _abi); + m_engine.evaluate("globals.method = " + _method); + m_engine.evaluate("globals.params = " + _params); +} + +QString NatspecExpressionEvaluator::evalExpression(QString const& _expression) +{ + QJSValue result = m_engine.evaluate("evaluateExpression(\"" + _expression + "\")"); + if (result.isError()) + { + cerr << "Could not evaluate expression: \"" << _expression.toStdString() << "\"" << endl; + return _expression; + } + return result.toString(); +} diff --git a/libnatspec/NatspecExpressionEvaluator.h b/libnatspec/NatspecExpressionEvaluator.h new file mode 100644 index 000000000..fc122084e --- /dev/null +++ b/libnatspec/NatspecExpressionEvaluator.h @@ -0,0 +1,49 @@ +/* + This file is part of cpp-ethereum. + + cpp-ethereum is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + cpp-ethereum is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with cpp-ethereum. If not, see . + */ +/** @file NatspecExpressionEvaluator.h + * @author Marek Kotewicz + * @date 2015 + */ + +#include +#include +#include + +/** + * Should be used to evaluate natspec expression. + * @see test/natspec.cpp for natspec expression examples + */ +class NatspecExpressionEvaluator +{ +public: + /// Construct natspec expression evaluator + /// @params abi - contract's abi in json format, passed as string + /// @params method - name of the contract's method for which we evaluate the natspec. + /// If we want to use raw string, it should be passed with quotation marks eg. "\"helloWorld\"" + /// If we pass string "helloWorld", the value of the object with name "helloWorld" will be used + /// @params params - array of method input params, passed as string, objects in array should be + /// javascript valid objects + NatspecExpressionEvaluator(QString const& _abi = "[]", QString const& _method = "", QString const& _params = "[]"); + + /// Should be called to evaluate natspec expression + /// @params expression - natspec expression + /// @returns evaluated natspec expression if it was valid, otherwise original expression + QString evalExpression(QString const& _expression); + +private: + QJSEngine m_engine; +}; diff --git a/libjsqrc/natspec.js b/libnatspec/natspec.js similarity index 65% rename from libjsqrc/natspec.js rename to libnatspec/natspec.js index c8cf07496..ed30b5378 100644 --- a/libjsqrc/natspec.js +++ b/libnatspec/natspec.js @@ -2,13 +2,19 @@ /** * This plugin exposes 'evaluateExpression' method which should be used * to evaluate natspec description - * It should be reloaded each time we want to evaluate set of expressions - * Just because of security reasons - * TODO: make use of sync api (once it's finished) and remove unnecessary - * code from 'getContractMethods' - * TODO: unify method signature creation with abi.js (and make a separate method from it) */ +/// Object which should be used by NatspecExpressionEvaluator +/// abi - abi of the contract that will be used +/// method - name of the method that is called +/// params - input params of the method that will be called +var globals = { + abi: [], + method: "", + params: [] +}; + +/// Helper method /// Should be called to copy values from object to global context var copyToContext = function (obj, context) { var keys = Object.keys(obj); @@ -17,32 +23,38 @@ var copyToContext = function (obj, context) { }); } +/// Helper method +/// Should be called to get method with given name from the abi +/// @param contract's abi +/// @param name of the method that we are looking for +var getMethodWithName = function(abi, name) { + for (var i = 0; i < abi.length; i++) { + if (abi[i].name === name) { + return abi[i]; + } + } + //console.warn('could not find method with name: ' + name); + return undefined; +}; + /// Function called to get all contract's storage values /// @returns hashmap with contract properties which are used +/// TODO: check if this function will be used var getContractProperties = function (address, abi) { return {}; }; /// Function called to get all contract's methods /// @returns hashmap with used contract's methods +/// TODO: check if this function will be used var getContractMethods = function (address, abi) { - return web3.eth.contract(address, abi); -}; - -var getMethodWithName = function(abi, name) { - for (var i = 0; i < abi.length; i++) { - if (abi[i].name === name) { - return abi[i]; - } - } - console.warn('could not find method with name: ' + name); - return undefined; + //return web3.eth.contract(address, abi); // commented out web3 usage + return {}; }; /// Function called to get all contract method input variables /// @returns hashmap with all contract's method input variables -var getContractInputParams = function (abi, methodName, params) { - var method = getMethodWithName(abi, methodName); +var getMethodInputParams = function (method, params) { return method.inputs.reduce(function (acc, current, index) { acc[current.name] = params[index]; return acc; @@ -55,18 +67,15 @@ var getContractInputParams = function (abi, methodName, params) { var evaluateExpression = function (expression) { var self = this; - var abi = web3._currentContractAbi; - var address = web3._currentContractAddress; - var methodName = web3._currentContractMethodName; - var params = web3._currentContractMethodParams; - - var storage = getContractProperties(address, abi); - var methods = getContractMethods(address, abi); - var inputParams = getContractInputParams(abi, methodName, params); - - copyToContext(storage, self); - copyToContext(methods, self); - copyToContext(inputParams, self); + + //var storage = getContractProperties(address, abi); + //var methods = getContractMethods(address, abi); + + var method = getMethodWithName(globals.abi, globals.method); + if (method) { + var input = getMethodInputParams(method, globals.params); + copyToContext(input, self); + } // TODO: test if it is safe var evaluatedExpression = ""; diff --git a/libnatspec/natspec.qrc b/libnatspec/natspec.qrc new file mode 100644 index 000000000..db125974c --- /dev/null +++ b/libnatspec/natspec.qrc @@ -0,0 +1,5 @@ + + + natspec.js + + diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 764bf928e..36876eea6 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -22,6 +22,7 @@ target_link_libraries(testeth ethcore) target_link_libraries(testeth secp256k1) target_link_libraries(testeth solidity) target_link_libraries(testeth webthree) +target_link_libraries(testeth natspec) if (JSONRPC) target_link_libraries(testeth web3jsonrpc) diff --git a/test/natspec.cpp b/test/natspec.cpp new file mode 100644 index 000000000..827f96625 --- /dev/null +++ b/test/natspec.cpp @@ -0,0 +1,112 @@ +/* + This file is part of cpp-ethereum. + + cpp-ethereum is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + cpp-ethereum is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with cpp-ethereum. If not, see . + */ +/** @file natspec.cpp + * @author Marek Kotewicz + * @date 2015 + */ + +#include +#include +#include + +using namespace std; + +BOOST_AUTO_TEST_SUITE(natspec) + +BOOST_AUTO_TEST_CASE(natspec_eval_function_exists) +{ + // given + NatspecExpressionEvaluator e; + // when + string result = e.evalExpression("`typeof evaluateExpression`").toStdString(); + // then + BOOST_CHECK_EQUAL(result, "function"); +} + +BOOST_AUTO_TEST_CASE(natspec_js_eval) +{ + // given + NatspecExpressionEvaluator e; + // when + string result = e.evalExpression("`1 + 2`").toStdString(); + // then + BOOST_CHECK_EQUAL(result, "3"); +} + +BOOST_AUTO_TEST_CASE(natspec_create_custom_function) +{ + // given + NatspecExpressionEvaluator e; + // when + auto x = e.evalExpression("`test = function (x) { return x + 'ok'; }`"); // ommit var, make it global + string result = e.evalExpression("`test(5)`").toStdString(); + string result2 = e.evalExpression("`typeof test`").toStdString(); + // then + BOOST_CHECK_EQUAL(result, "5ok"); + BOOST_CHECK_EQUAL(result2, "function"); +} + +BOOST_AUTO_TEST_CASE(natspec_js_eval_separated_expressions) +{ + // given + NatspecExpressionEvaluator e; + // when + string result = e.evalExpression("`x = 1` + `y = 2` will be equal `x + y`").toStdString(); + // then + BOOST_CHECK_EQUAL(result, "1 + 2 will be equal 3"); +} + +BOOST_AUTO_TEST_CASE(natspec_js_eval_input_params) +{ + // given + char const* abi = R"([ + { + "name": "f", + "constant": false, + "type": "function", + "inputs": [ + { + "name": "a", + "type": "uint256" + } + ], + "outputs": [ + { + "name": "d", + "type": "uint256" + } + ] + } + ])"; + NatspecExpressionEvaluator e(abi, "'f'", "[4]"); + // when + string result = e.evalExpression("Will multiply `a` by 7 and return `a * 7`.").toStdString(); + // then + BOOST_CHECK_EQUAL(result, "Will multiply 4 by 7 and return 28."); +} + +BOOST_AUTO_TEST_CASE(natspec_js_eval_error) +{ + // given + NatspecExpressionEvaluator e; + // when + string result = e.evalExpression("`test(`").toStdString(); + // then + BOOST_CHECK_EQUAL(result, "`test(`"); +} + +BOOST_AUTO_TEST_SUITE_END()