diff --git a/CMakeLists.txt b/CMakeLists.txt index a97a9c960..2e389230f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,5 +1,25 @@ cmake_minimum_required(VERSION 3.0.2 FATAL_ERROR) + +#set(OPENSSL_ROOT_DIR "/opt/homebrew/opt/openssl/") +#set(GSL_ROOT_DIR "/opt/homebrew/opt/gsl/") +if(EMSCRIPTEN) + set(OPENSSL_FOUND "1") + set(OPENSSL_ROOT_DIR "/Users/altox/Desktop/openssl/openssl-1.1.1d/") + set(OPENSSL_INCLUDE_DIR "/Users/altox/Desktop/openssl/openssl-1.1.1d/include/") + set(OPENSSL_CRYPTO_LIBRARY "/Users/altox/Desktop/openssl/openssl-1.1.1d/libcrypto.a") + set(OPENSSL_SSL_LIBRARY "/Users/altox/Desktop/openssl/openssl-1.1.1d/libssl.a") + set(OPENSSL_LIBRARIES "${OPENSSL_SSL_LIBRARY} ${OPENSSL_CRYPTO_LIBRARY}") + + set(ZLIB_LIBRARY /Users/altox/Desktop/zlib/) + set(ZLIB_INCLUDE_DIR /Users/altox/Desktop/zlib/) +else() + set(OPENSSL_ROOT_DIR "/opt/homebrew/opt/openssl/") + set(GSL_ROOT_DIR "/opt/homebrew/opt/gsl/") +endif() + + + project(TON VERSION 0.5 LANGUAGES C CXX) set(CMAKE_POSITION_INDEPENDENT_CODE ON) #set(OPENSSL_USE_STATIC_LIBS TRUE) @@ -80,7 +100,7 @@ else() endif() #BEGIN internal -option(TON_ONLY_TONLIB "Use \"ON\" to build only tonlib." OFF) +option(TON_ONLY_TONLIB "Use \"ON\" to build only tonlib." ON) if (TON_ONLY_TONLIB) set(NOT_TON_ONLY_TONLIB false) else() @@ -204,7 +224,7 @@ find_package(Threads REQUIRED) find_package(ZLIB REQUIRED) if (TON_ARCH AND NOT MSVC) - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=${TON_ARCH}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") endif() if (THREADS_HAVE_PTHREAD_ARG) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread") @@ -245,10 +265,10 @@ elseif (CLANG OR GCC) set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} -fvisibility=hidden -Wl,-dead_strip,-x,-S") else() set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ffunction-sections -fdata-sections") - set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--gc-sections -Wl,--exclude-libs,ALL") +# set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--gc-sections -Wl,--exclude-libs,ALL") set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--gc-sections") if (NOT TON_USE_ASAN AND NOT TON_USE_TSAN AND NOT MEMPROF) - set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--exclude-libs,ALL") +# set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--exclude-libs,ALL") endif() endif() elseif (INTEL) diff --git a/crypto/CMakeLists.txt b/crypto/CMakeLists.txt index 79406ffca..d14f0b443 100644 --- a/crypto/CMakeLists.txt +++ b/crypto/CMakeLists.txt @@ -307,6 +307,42 @@ if (WINGETOPT_FOUND) target_link_libraries_system(tlbc wingetopt) endif() +add_executable(vm-exec vm-exec/vm-exec.cpp vm-exec/StringLog.h vm-exec/common.cpp vm-exec/common.h) +target_include_directories(vm-exec PUBLIC $) +target_link_libraries(vm-exec PUBLIC ton_crypto terminal) +if(EMSCRIPTEN) + target_link_options(vm-exec PRIVATE -sEXPORTED_RUNTIME_METHODS=free,allocate,intArrayFromString,ALLOC_NORMAL,UTF8ToString) + target_link_options(vm-exec PRIVATE -sEXPORTED_FUNCTIONS=_vm_exec,_free) + target_link_options(vm-exec PRIVATE -sERROR_ON_UNDEFINED_SYMBOLS=0) + target_link_options(vm-exec PRIVATE -sFILESYSTEM=0) + target_link_options(vm-exec PRIVATE -Oz) + target_link_options(vm-exec PRIVATE -sIGNORE_MISSING_MAIN=1) + target_link_options(vm-exec PRIVATE -sAUTO_NATIVE_LIBRARIES=0) + target_link_options(vm-exec PRIVATE -sMODULARIZE=1) + target_compile_options(vm-exec PRIVATE -sNO_DISABLE_EXCEPTION_CATCHING) +endif() +if (WINGETOPT_FOUND) + target_link_libraries_system(func wingetop ton_crypto tdutils ton_crypto fift-lib) +endif() + +add_library(vm-exec-lib SHARED vm-exec/vm-exec-lib.cpp vm-exec/StringLog.h vm-exec/common.cpp vm-exec/common.h) +target_link_libraries(vm-exec-lib PUBLIC ton_crypto terminal) +if(EMSCRIPTEN) + target_link_options(vm-exec-lib PRIVATE -sEXPORTED_RUNTIME_METHODS=ccall,cwrap,allocate,intArrayFromString,ALLOC_NORMAL,UTF8ToString) + target_link_options(vm-exec-lib PRIVATE -sMAIN_MODULE) + target_link_options(vm-exec-lib PRIVATE -sERROR_ON_UNDEFINED_SYMBOLS=0) + target_link_options(vm-exec-lib PRIVATE -sNO_DISABLE_EXCEPTION_CATCHING) + target_compile_options(vm-exec-lib PRIVATE -sNO_DISABLE_EXCEPTION_CATCHING) +endif() +set_target_properties(vm-exec-lib PROPERTIES LINK_FLAGS "-Wl,-exported_symbols_list,${CMAKE_CURRENT_SOURCE_DIR}/vm-exec/vm-exec-lib_export_list") + +add_executable(wallet_gen wallet_gen/wallet_gen.cpp) +target_include_directories(wallet_gen PUBLIC $) +target_link_libraries(wallet_gen PUBLIC ton_crypto tonlib terminal) +if (WINGETOPT_FOUND) + target_link_libraries_system(func wingetop ton_crypto tdutils ton_crypto fift-lib) +endif() + add_library(pow-miner-lib util/Miner.cpp util/Miner.h) target_include_directories(pow-miner-lib PUBLIC $) target_link_libraries(pow-miner-lib PUBLIC ton_crypto ton_block) @@ -407,7 +443,7 @@ target_include_directories(create-state PUBLIC $ + + +class StringLog : public td::LogInterface { + public: + StringLog() { + } + + void append(td::CSlice new_slice, int log_level) override { + lock.lock(); + this->str.append(new_slice.str()); + lock.unlock(); + } + + void rotate() override { + } + + void clear() { + this->str.clear(); + } + + std::string get_string() const { + return this->str; + } + + private: + std::string str; + std::mutex lock; +}; + +#endif //TON_STRINGLOG_H diff --git a/crypto/vm-exec/common.cpp b/crypto/vm-exec/common.cpp new file mode 100644 index 000000000..c3c89184f --- /dev/null +++ b/crypto/vm-exec/common.cpp @@ -0,0 +1,265 @@ +// +// Created by Narek Abovyan on 23.02.2022. +// + +#include "common.h" + +std::string escape_json(const std::string &s) { + std::ostringstream o; + for (auto c = s.cbegin(); c != s.cend(); c++) { + switch (*c) { + case '"': o << "\\\""; break; + case '\\': o << "\\\\"; break; + case '\b': o << "\\b"; break; + case '\f': o << "\\f"; break; + case '\n': o << "\\n"; break; + case '\r': o << "\\r"; break; + case '\t': o << "\\t"; break; + default: + if ('\x00' <= *c && *c <= '\x1f') { + o << "\\u" + << std::hex << std::setw(4) << std::setfill('0') << static_cast(*c); + } else { + o << *c; + } + } + } + return o.str(); +} + +td::Ref prepare_vm_c7(ton::UnixTime now) { + // auto now = static_cast(td::Time::now()); + td::BitArray<256> rand_seed; + td::RefInt256 rand_seed_int{true}; + td::Random::secure_bytes(rand_seed.as_slice()); + if (!rand_seed_int.unique_write().import_bits(rand_seed.cbits(), 256, false)) { + return {}; + } + auto balance = block::CurrencyCollection{1000, {}}.as_vm_tuple(); + auto tuple = vm::make_tuple_ref(td::make_refint(0x076ef1ea), // [ magic:0x076ef1ea + td::make_refint(0), // actions:Integer + td::make_refint(0), // msgs_sent:Integer + td::make_refint(now), // unixtime:Integer + td::make_refint(now), // block_lt:Integer + td::make_refint(now), // trans_lt:Integer + std::move(rand_seed_int), // rand_seed:Integer + balance // balance_remaining:[Integer (Maybe Cell)] + // my_addr, // myself:MsgAddressInt + // vm::StackEntry() // global_config:(Maybe Cell) ] = SmartContractInfo; + ); + LOG(DEBUG) << "SmartContractInfo initialized with " << vm::StackEntry(tuple).to_string(); + return vm::make_tuple_ref(std::move(tuple)); +} + +td::Result json_to_stack_entry(td::JsonObject &obj) { + TRY_RESULT(type, get_json_object_string_field(obj, "type")); + + if (type == "int") { + TRY_RESULT(data, get_json_object_string_field(obj, "value")); + return vm::StackEntry(td::dec_string_to_int256(data)); + } + if (type == "cell") { + TRY_RESULT(data, get_json_object_string_field(obj, "value")); + TRY_RESULT(data_bytes, td::base64_decode(data)); + TRY_RESULT(boc, vm::std_boc_deserialize(data_bytes)); + TRY_RESULT(data_cell, boc->load_cell()); + return vm::StackEntry(data_cell.data_cell); + } + if (type == "cell_slice") { + TRY_RESULT(data, get_json_object_string_field(obj, "value")); + TRY_RESULT(data_bytes, td::base64_decode(data)); + TRY_RESULT(boc, vm::std_boc_deserialize(data_bytes)); + TRY_RESULT(data_cell, boc->load_cell()); + return vm::StackEntry(td::make_ref(vm::CellSlice(data_cell))); + } + if (type == "null") { + return vm::StackEntry(); + } + if (type == "tuple") { + TRY_RESULT(data, td::get_json_object_field(obj, "value", td::JsonValue::Type::Array, false)); + auto &data_arr = data.get_array(); + + std::vector tuple_components; + + for (auto &x : data_arr) { + TRY_RESULT(item, json_to_stack_entry(x.get_object())); + tuple_components.push_back(item); + } + + return vm::StackEntry(tuple_components); + } + + return vm::StackEntry(); +} + +td::Result> json_to_stack(td::JsonArray &array) { + auto stack = td::make_ref(); + + for (auto &x : array) { + if (x.type() != td::JsonValue::Type::Object) { + return td::Status::Error(PSLICE() << "Stack item must be object"); + } + auto &obj = x.get_object(); + TRY_RESULT(entry, json_to_stack_entry(obj)); + stack.write().push(entry); + } + + return stack; +} + +td::Result stack_entry_to_json(vm::StackEntry se) { + if (se.is_int()) { + return R"({ "type": "int", "value": ")" + td::dec_string(se.as_int()) + R"("})"; + } + if (se.is_cell()) { + TRY_RESULT(boc, vm::std_boc_serialize(se.as_cell())); + auto value = td::base64_encode(boc); + return R"({ "type": "cell", "value": ")" + value + R"("})"; + } + if (se.type() == vm::StackEntry::Type::t_slice) { + vm::CellBuilder b; + b.append_cellslice(se.as_slice()); + TRY_RESULT(boc, vm::std_boc_serialize(b.finalize())); + auto value = td::base64_encode(boc); + return R"({ "type": "cell_slice", "value": ")" + value + R"("})"; + } + if (se.is_null()) { + return R"({ "type": "null" })"; + } + if (se.is_tuple()) { + std::string res = R"({ "type": "tuple", "value": [)"; + + auto tuple = se.as_tuple(); + + for (auto &x : *tuple) { + TRY_RESULT(item, stack_entry_to_json(x)); + res.append(item); + res.append(","); + } + res = res.substr(0, res.length() - 1); + res += "] }"; + + return res; + } + + return R"({ "type": "unknown" })"; +} + +td::Result stack2json(vm::Ref stack) { + if (stack->is_empty()) { + return "[]"; + } + std::string out = "["; + for (const auto &x : stack->as_span()) { + TRY_RESULT(item, stack_entry_to_json(x)); + out.append(item); + out.append(","); + } + out = out.substr(0, out.length() - 1); + out.append("]"); + return out; +} + +td::Result run_vm(td::Ref code, td::Ref data, td::JsonArray &stack_array, + td::JsonObject &c7_register, int function_selector, + std::function getLogs) { + vm::init_op_cp0(true); + + TRY_RESULT(stack, json_to_stack(stack_array)); + TRY_RESULT(c7_data, json_to_stack_entry(c7_register)); + + td::int64 method_id = function_selector; + stack.write().push_smallint(method_id); + + long long gas_limit = vm::GasLimits::infty; + vm::GasLimits gas{gas_limit}; + LOG(DEBUG) << "creating VM"; + vm::VmState vm{std::move(code), std::move(stack), gas, 1, data, vm::VmLog()}; + + vm.set_c7(c7_data.as_tuple()); + + LOG(DEBUG) << "SmartContractInfo initialized with " << vm::StackEntry(vm.get_c7()).to_string(); + LOG(INFO) << "starting VM to run method `" << function_selector << "` of smart contract"; + + int exit_code; + bool errored = false; + try { + exit_code = ~vm.run(); + } catch (vm::VmVirtError &err) { + LOG(ERROR) << "virtualization error while running VM: " << err.get_msg(); + errored = true; + } catch (vm::VmError &err) { + LOG(ERROR) << "error while running VM: " << err.get_msg(); + errored = true; + } + + if (errored || exit_code != 0) { + auto serialized_logs = td::base64_encode(getLogs()); + + std::string result; + result += "{"; + result += R"("ok": false,)"; + result += R"("exit_code":)" + std::to_string(exit_code) + ","; + result += R"("logs": ")" + serialized_logs + R"(")"; + result += "}"; + + return result; + } + + stack = vm.get_stack_ref(); + + std::string result; + + auto committed_state = vm.get_committed_state(); + + TRY_RESULT(data_cell_boc, vm::std_boc_serialize(committed_state.c4)); + auto serialized_data_cell = td::base64_encode(data_cell_boc); + TRY_RESULT(action_list_boc, vm::std_boc_serialize(committed_state.c5)); + auto serialized_action_list_cell = td::base64_encode(action_list_boc); + auto serialized_logs = td::base64_encode(getLogs()); + TRY_RESULT(stack_str, stack2json(stack)); + + result += "{"; + result += R"("ok": true,)"; + result += R"("exit_code":)" + std::to_string(exit_code) + ","; + result += R"("stack":)" + stack_str + ","; + result += R"("data_cell": ")" + serialized_data_cell + R"(",)"; + result += R"("gas_consumed": )" + std::to_string(vm.gas_consumed()) + R"(,)"; + result += R"("action_list_cell": ")" + serialized_action_list_cell + R"(",)"; + result += R"("logs": ")" + serialized_logs + R"(")"; + result += "}"; + + return result; +} + +td::Result vm_exec_from_config(std::string config, std::function getLogs) { + TRY_RESULT(input_json, td::json_decode(config)) + auto &obj = input_json.get_object(); + + TRY_RESULT(debug, td::get_json_object_bool_field(obj, "debug", false)); + + if (debug) { + SET_VERBOSITY_LEVEL(verbosity_DEBUG); + } else { + SET_VERBOSITY_LEVEL(verbosity_ERROR); + } + + TRY_RESULT(code, td::get_json_object_string_field(obj, "code", false)); + TRY_RESULT(data, td::get_json_object_string_field(obj, "data", false)); + TRY_RESULT(function_selector, td::get_json_object_int_field(obj, "function_selector", false)); + TRY_RESULT(initial_stack, td::get_json_object_field(obj, "init_stack", td::JsonValue::Type::Array, false)); + TRY_RESULT(c7_register, td::get_json_object_field(obj, "c7_register", td::JsonValue::Type::Object, false)); + + auto &initial_stack_array = initial_stack.get_array(); + + TRY_RESULT(data_bytes, td::base64_decode(data)); + TRY_RESULT(boc, vm::std_boc_deserialize(data_bytes)); + TRY_RESULT(data_cell, boc->load_cell()); + + TRY_RESULT(decoded_code, td::base64_decode(code)); + TRY_RESULT(code_boc, vm::std_boc_deserialize(decoded_code)); + TRY_RESULT(code_cell, code_boc->load_cell()); + + return run_vm(code_cell.data_cell, data_cell.data_cell, initial_stack_array, c7_register.get_object(), + function_selector, getLogs); +} \ No newline at end of file diff --git a/crypto/vm-exec/common.h b/crypto/vm-exec/common.h new file mode 100644 index 000000000..b2097354a --- /dev/null +++ b/crypto/vm-exec/common.h @@ -0,0 +1,43 @@ +// +// Created by Narek Abovyan on 23.02.2022. +// + +#ifndef TON_COMMON_H +#define TON_COMMON_H + +#include "vm/vm.h" +#include "vm/cp0.h" +#include "vm/boc.h" +#include "vm/stack.hpp" +#include "crypto/block/block.h" +#include "td/utils/base64.h" +#include "td/utils/ScopeGuard.h" +#include "terminal/terminal.h" +#include "td/utils/Random.h" +#include "td/utils/filesystem.h" +#include "td/utils/JsonBuilder.h" +#include "td/utils/OptionParser.h" +#include "td/utils/logging.h" +#include "StringLog.h" +#include +#include + + +std::string escape_json(const std::string &s); + +td::Ref prepare_vm_c7(ton::UnixTime now); + +td::Result json_to_stack_entry(td::JsonObject &obj); + +td::Result> json_to_stack(td::JsonArray &array); + +td::Result stack_entry_to_json(vm::StackEntry se); + +td::Result stack2json(vm::Ref stack); + +td::Result run_vm(td::Ref code_cell, td::Ref data, td::JsonArray &stack_array, td::JsonObject &c7_register, + int function_selector, std::function getLogs); + +td::Result vm_exec_from_config(std::string config, std::function getLogs); + +#endif //TON_COMMON_H diff --git a/crypto/vm-exec/vm-exec-lib.cpp b/crypto/vm-exec/vm-exec-lib.cpp new file mode 100644 index 000000000..0296cc5d2 --- /dev/null +++ b/crypto/vm-exec/vm-exec-lib.cpp @@ -0,0 +1,37 @@ +#include "vm/cp0.h" +#include "td/utils/logging.h" +#include "StringLog.h" +#include "common.h" + +using namespace std::literals::string_literals; + +auto memLog = new StringLog(); + +class NoopLog : public td::LogInterface { + public: + void append(td::CSlice slice) override { + } +}; + +extern "C" char *vm_exec(int len, char *_data) { + // Init logging + td::log_interface = memLog; + SET_VERBOSITY_LEVEL(verbosity_DEBUG); + memLog->clear(); + + std::string config(_data, len); + + auto res = vm_exec_from_config(config, []() -> std::string { return memLog->get_string(); }); + + if (res.is_error()) { + std::string result; + result += "{"; + result += R"("ok": false,)"; + result += R"("error": ")" + res.move_as_error().message().str() + R"(")"; + result += "}"; + + return strdup(result.c_str()); + } + + return strdup(res.move_as_ok().c_str()); +} \ No newline at end of file diff --git a/crypto/vm-exec/vm-exec-lib_export_list b/crypto/vm-exec/vm-exec-lib_export_list new file mode 100644 index 000000000..c0f8ddca2 --- /dev/null +++ b/crypto/vm-exec/vm-exec-lib_export_list @@ -0,0 +1 @@ +_vm_exec \ No newline at end of file diff --git a/crypto/vm-exec/vm-exec.cpp b/crypto/vm-exec/vm-exec.cpp new file mode 100644 index 000000000..0740acb54 --- /dev/null +++ b/crypto/vm-exec/vm-exec.cpp @@ -0,0 +1,31 @@ +#include "vm/cp0.h" +#include "td/utils/logging.h" +#include "StringLog.h" +#include "common.h" + +using namespace std::literals::string_literals; + +auto memLog = new StringLog(); + +extern "C" char *vm_exec(int len, char *_data) { + // Init logging + td::log_interface = memLog; + SET_VERBOSITY_LEVEL(verbosity_DEBUG); +// SET_VERBOSITY_LEVEL(verbosity_ERROR); + memLog->clear(); + + std::string config(_data, len); + + auto res = vm_exec_from_config(config, []() -> std::string { return memLog->get_string(); }); + + if (res.is_error()) { + std::string result; + result += "{"; + result += R"("ok": false,)"; + result += R"("error": ")" + escape_json(res.move_as_error().message().str()) + R"(")"; + result += "}"; + + return strdup(result.c_str()); + } + return strdup(res.move_as_ok().c_str()); +} \ No newline at end of file diff --git a/crypto/vm/debugops.cpp b/crypto/vm/debugops.cpp index 0ec205a31..b9558a160 100644 --- a/crypto/vm/debugops.cpp +++ b/crypto/vm/debugops.cpp @@ -75,16 +75,10 @@ int exec_dump_stack(VmState* st) { } Stack& stack = st->get_stack(); int d = stack.depth(); - std::cerr << "#DEBUG#: stack(" << d << " values) : "; - if (d > 255) { - std::cerr << "... "; - d = 255; - } + VM_LOG(st) << "#DEBUG#: stack(" << d << " values) : "; for (int i = d; i > 0; i--) { - stack[i - 1].print_list(std::cerr); - std::cerr << ' '; + VM_LOG(st) << "s" << i-1 << " = " << stack[i - 1].to_lisp_string(); } - std::cerr << std::endl; return 0; } @@ -96,11 +90,9 @@ int exec_dump_value(VmState* st, unsigned arg) { } Stack& stack = st->get_stack(); if ((int)arg < stack.depth()) { - std::cerr << "#DEBUG#: s" << arg << " = "; - stack[arg].print_list(std::cerr); - std::cerr << std::endl; + VM_LOG(st) << "#DEBUG#: s" << arg << " = " << stack[arg].to_lisp_string(); } else { - std::cerr << "#DEBUG#: s" << arg << " is absent" << std::endl; + VM_LOG(st) << "#DEBUG#: s" << arg << " is absent"; } return 0; } diff --git a/crypto/wallet_gen/wallet_gen.cpp b/crypto/wallet_gen/wallet_gen.cpp new file mode 100644 index 000000000..de9027f11 --- /dev/null +++ b/crypto/wallet_gen/wallet_gen.cpp @@ -0,0 +1,30 @@ +#include +#include +#include "tonlib/keys/Mnemonic.h" + +using namespace tonlib; + +int main(int argc, char *argv[]) { + auto out = td::TerminalIO::out(); + + auto bip_words = Mnemonic::normalize_and_split(td::SecureString(bip39_english())); + + for (int i = 0; i <= 1000; i++ ){ + std::vector words; + for (int i = 0; i < 24; i++) { + words.push_back(bip_words[std::rand() % bip_words.size()].copy()); + } + + td::SecureString pass; + auto m = Mnemonic::create(std::move(words), pass.copy()).move_as_ok(); + +// Mnemonic::Options options; +// auto c = Mnemonic::create_new(std::move(options)).move_as_ok(); + td::Timer timer; + auto private_key = m.to_private_key().as_octet_string(); + LOG(INFO) << "Mnemonic generation debug stats: " << timer; + LOG(INFO) << private_key; +// out << "\n"; + } + +} \ No newline at end of file diff --git a/tdutils/td/utils/port/config.h b/tdutils/td/utils/port/config.h index 2bd671b01..383576d29 100644 --- a/tdutils/td/utils/port/config.h +++ b/tdutils/td/utils/port/config.h @@ -62,4 +62,11 @@ #define TD_HAS_MMSG 1 #endif + +#if TD_EMSCRIPTEN + #define TD_POLL_EPOLL 1 + #define TD_EVENTFD_UNSUPPORTED 0 + #define TD_THREAD_PTHREAD 1 + #define TD_EVENTFD_LINUX 1 +#endif // clang-format on diff --git a/tonlib/CMakeLists.txt b/tonlib/CMakeLists.txt index 5b6530a67..b52f13cf2 100644 --- a/tonlib/CMakeLists.txt +++ b/tonlib/CMakeLists.txt @@ -149,11 +149,11 @@ endif() install(FILES ${TONLIB_JSON_HEADERS} ${CMAKE_CURRENT_BINARY_DIR}/tonlib/tonlibjson_export.h DESTINATION include/tonlib/) -install(EXPORT Tonlib - FILE TonlibTargets.cmake - NAMESPACE Tonlib:: - DESTINATION lib/cmake/Tonlib -) +#install(EXPORT Tonlib +# FILE TonlibTargets.cmake +# NAMESPACE Tonlib:: +# DESTINATION lib/cmake/Tonlib +#) include(CMakePackageConfigHelpers) write_basic_package_version_file("TonlibConfigVersion.cmake" VERSION ${TON_VERSION}