diff options
Diffstat (limited to 'patches')
| -rw-r--r-- | patches/monero/0021-add-dummy-device-for-Trezor.patch | 596 |
1 files changed, 596 insertions, 0 deletions
diff --git a/patches/monero/0021-add-dummy-device-for-Trezor.patch b/patches/monero/0021-add-dummy-device-for-Trezor.patch new file mode 100644 index 0000000..9205a9f --- /dev/null +++ b/patches/monero/0021-add-dummy-device-for-Trezor.patch @@ -0,0 +1,596 @@ +From 32f25991193d88f07109ed0416ccd1cead078550 Mon Sep 17 00:00:00 2001 +From: Czarek Nakamoto <cyjan@mrcyjanek.net> +Date: Wed, 6 May 2026 13:45:34 -0400 +Subject: [PATCH] add dummy device for Trezor + +--- + src/device/device_io_dummy.cpp | 6 +- + src/device/device_io_dummy.hpp | 2 +- + src/device_trezor/trezor/transport.cpp | 178 ++++++++++++++++++++++++- + src/device_trezor/trezor/transport.hpp | 51 +++++++ + src/wallet/api/wallet.cpp | 127 ++++++++++++++---- + src/wallet/api/wallet.h | 14 +- + src/wallet/api/wallet2_api.h | 21 ++- + 7 files changed, 351 insertions(+), 48 deletions(-) + +diff --git a/src/device/device_io_dummy.cpp b/src/device/device_io_dummy.cpp +index 74742150d..6365bb427 100644 +--- a/src/device/device_io_dummy.cpp ++++ b/src/device/device_io_dummy.cpp +@@ -138,9 +138,9 @@ namespace hw { + MDEBUG("release()"); + } + +- void device_io_dummy::setLedgerCallback(void (*sendToLedgerDevice)(unsigned char *command, unsigned int cmd_len)) { +- MDEBUG("setLedgerCallback()"); +- sendToLedgerDeviceCallback = sendToLedgerDevice; ++ void device_io_dummy::setDeviceCallback(void (*sendToDeviceCallback)(unsigned char *command, unsigned int cmd_len)) { ++ MDEBUG("setDeviceCallback()"); ++ sendToLedgerDeviceCallback = sendToDeviceCallback; + } + + void device_io_dummy::setDeviceReceivedData(unsigned char* data, size_t len) { +diff --git a/src/device/device_io_dummy.hpp b/src/device/device_io_dummy.hpp +index 87a5f109f..80b356a0b 100644 +--- a/src/device/device_io_dummy.hpp ++++ b/src/device/device_io_dummy.hpp +@@ -73,7 +73,7 @@ namespace hw { + + int exchange(unsigned char *command, unsigned int cmd_len, unsigned char *response, unsigned int max_resp_len, bool user_input); + +- static void setLedgerCallback(void (*sendToLedgerDevice)(unsigned char *command, unsigned int cmd_len)); ++ static void setDeviceCallback(void (*sendToDeviceCallback)(unsigned char *command, unsigned int cmd_len)); + static void setDeviceReceivedData(unsigned char* data, size_t len); + }; + }; +diff --git a/src/device_trezor/trezor/transport.cpp b/src/device_trezor/trezor/transport.cpp +index 10dd82c53..5cf7e1cb8 100644 +--- a/src/device_trezor/trezor/transport.cpp ++++ b/src/device_trezor/trezor/transport.cpp +@@ -27,6 +27,7 @@ + // THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + // + ++#include "exceptions.hpp" + #ifdef WITH_DEVICE_TREZOR_WEBUSB + #include <libusb.h> + #endif +@@ -1166,8 +1167,177 @@ namespace trezor{ + return o << ">"; + }; + +-#endif // WITH_DEVICE_TREZOR_WEBUSB ++#endif // WITH_DEVICE_TREZOR_WEBUSB + ++ ++std::condition_variable hw::trezor::DummyTransport::cv_send; ++std::condition_variable hw::trezor::DummyTransport::cv_receive; ++bool hw::trezor::DummyTransport::stateIsConnected = false; ++unsigned char* hw::trezor::DummyTransport::sendToDevice = {}; ++size_t hw::trezor::DummyTransport::sendToDeviceLength = 0; ++unsigned char* hw::trezor::DummyTransport::receivedFromDevice = {}; ++size_t hw::trezor::DummyTransport::receivedFromDeviceLength = 0; ++bool hw::trezor::DummyTransport::waitsForDeviceSend = false; ++bool hw::trezor::DummyTransport::waitsForDeviceReceive = false; ++void (*hw::trezor::DummyTransport::sendToTrezorDeviceCallback)(unsigned char *command, unsigned int cmd_len) = nullptr; ++std::mutex hw::trezor::DummyTransport::mutex; ++ ++const char * DummyTransport::PATH_PREFIX = "dummy:"; ++ ++DummyTransport::DummyTransport( ++ boost::optional<std::shared_ptr<Protocol>> proto ++) ++{ ++ m_proto = proto ? proto.get() : std::make_shared<ProtocolV1>(); ++} ++ ++DummyTransport::~DummyTransport(){ ++ close(); ++} ++ ++std::shared_ptr<Transport> DummyTransport::find_debug() { ++ return nullptr; ++} ++ ++void DummyTransport::require_device() const{ ++ if (!stateIsConnected){ ++ throw std::runtime_error("stateIsConnected is false"); ++ } ++} ++ ++void DummyTransport::require_connected() const{ ++ require_device(); ++} ++ ++void DummyTransport::enumerate(t_transport_vect & res) { ++ auto t = std::make_shared<DummyTransport>(); ++ res.push_back(t); ++} ++ ++std::string DummyTransport::get_path() const { ++ std::stringstream ss; ++ ss << DummyTransport::PATH_PREFIX << "dummy"; ++ return ss.str(); ++}; ++ ++void DummyTransport::open() { ++ if (sendToTrezorDeviceCallback == nullptr) { ++ throw exc::TrezorException("sendToTrezorDeviceCallback is null"); ++ } ++ stateIsConnected = true; ++ m_proto->session_begin(*this); ++} ++ ++void DummyTransport::close() { ++ stateIsConnected = false; ++}; ++ ++int DummyTransport::get_interface() const{ ++ const int INTERFACE_NORMAL = 0; ++#ifdef WITH_TREZOR_DEBUGGING ++ const int INTERFACE_DEBUG = 1; ++ return m_debug_mode ? INTERFACE_DEBUG : INTERFACE_NORMAL; ++#else ++ return INTERFACE_NORMAL; ++#endif ++} ++ ++unsigned char DummyTransport::get_endpoint() const{ ++ const unsigned char ENDPOINT_NORMAL = 1; ++#ifdef WITH_TREZOR_DEBUGGING ++ const unsigned char ENDPOINT_DEBUG = 2; ++ return m_debug_mode ? ENDPOINT_DEBUG : ENDPOINT_NORMAL; ++#else ++ return ENDPOINT_NORMAL; ++#endif ++} ++ ++void DummyTransport::write(const google::protobuf::Message &req) { ++ m_proto->write(*this, req); ++}; ++ ++void DummyTransport::read(std::shared_ptr<google::protobuf::Message> & msg, messages::MessageType * msg_type) { ++ m_proto->read(*this, msg, msg_type); ++}; ++ ++void DummyTransport::write_chunk(const void * buff, size_t size) { ++ require_connected(); ++ if (size != REPLEN){ ++ throw exc::CommunicationException("Invalid chunk size: "); ++ } ++ ++ MDEBUG("write_chunk(): locking mutex"); ++ std::unique_lock<std::mutex> lock(mutex); ++ ++ sendToDevice = const_cast<unsigned char*>(static_cast<const unsigned char*>(buff)); ++ sendToDeviceLength = size; ++ waitsForDeviceSend = true; ++ waitsForDeviceReceive = true; ++ ++ if (sendToTrezorDeviceCallback != nullptr) { ++ MDEBUG("write_chunk(): calling sendToTrezorDeviceCallback"); ++ sendToTrezorDeviceCallback( ++ const_cast<unsigned char*>(static_cast<const unsigned char*>(buff)), ++ static_cast<unsigned int>(size) ++ ); ++ } ++ ++ while (waitsForDeviceSend) { ++ cv_send.wait(lock); ++ MDEBUG("write_chunk(): waitsForDeviceSend notified"); ++ } ++} ++ ++size_t DummyTransport::read_chunk(void * buff, size_t size) { ++ require_connected(); ++ MDEBUG("read_chunk(): locking mutex"); ++ std::unique_lock<std::mutex> lock(mutex); ++ ++ while (waitsForDeviceReceive) { ++ cv_receive.wait(lock); ++ MDEBUG("read_chunk(): waitsForDeviceReceive notified"); ++ } ++ ++ if (receivedFromDeviceLength > size) { ++ MDEBUG("read_chunk(): receivedFromDeviceLength (" ++ << receivedFromDeviceLength << ") > buffer size (" << size << ")"); ++ throw exc::CommunicationException("Response chunk too large for buffer"); ++ } ++ ++ memset(buff, 0, size); ++ memcpy(buff, receivedFromDevice, receivedFromDeviceLength); ++ ++ waitsForDeviceReceive = true; ++ ++ return receivedFromDeviceLength; ++} ++ ++std::ostream& DummyTransport::dump(std::ostream& o) const { ++ o << "DummyTransport<path=" << get_path(); ++ return o << ">"; ++}; ++ ++ ++void DummyTransport::setDeviceCallback(void (*sendToDeviceCallback)(unsigned char *command, unsigned int cmd_len)) { ++ MDEBUG("setDeviceCallback()"); ++ sendToTrezorDeviceCallback = sendToDeviceCallback; ++} ++ ++void DummyTransport::setDeviceReceivedData(unsigned char* data, size_t len) { ++ MDEBUG("setDeviceReceivedData(len: " << len << ")"); ++ std::unique_lock<std::mutex> lock(mutex); ++ ++ receivedFromDevice = static_cast<unsigned char *>(malloc(len)); ++ receivedFromDeviceLength = len; ++ memset(receivedFromDevice, 0, len); ++ memcpy(receivedFromDevice, data, len); ++ waitsForDeviceReceive = false; ++ waitsForDeviceSend = false; ++ cv_send.notify_all(); ++ cv_receive.notify_all(); ++} ++ ++ + void enumerate(t_transport_vect & res){ + BridgeTransport bt; + try{ +@@ -1193,6 +1363,12 @@ namespace trezor{ + MERROR("UdpTransport enumeration failed:" << e.what()); + } + #endif ++ hw::trezor::DummyTransport dt; ++ try{ ++ dt.enumerate(res); ++ } catch (const std::exception & e){ ++ MERROR("DummyTransport enumeration failed:" << e.what()); ++ } + } + + void sort_transports_by_env(t_transport_vect & res){ +diff --git a/src/device_trezor/trezor/transport.hpp b/src/device_trezor/trezor/transport.hpp +index 827b189fd..f1036383b 100644 +--- a/src/device_trezor/trezor/transport.hpp ++++ b/src/device_trezor/trezor/transport.hpp +@@ -302,6 +302,57 @@ namespace trezor { + + #endif + ++class DummyTransport : public Transport { ++public: ++ ++ explicit DummyTransport( ++ boost::optional<std::shared_ptr<Protocol>> proto = boost::none ++ ); ++ ++ virtual ~DummyTransport(); ++ ++ static const char * PATH_PREFIX; ++ ++ std::string get_path() const override; ++ void enumerate(t_transport_vect & res) override; ++ ++ void open() override; ++ void close() override; ++ std::shared_ptr<Transport> find_debug() override; ++ ++ void write(const google::protobuf::Message &req) override; ++ void read(std::shared_ptr<google::protobuf::Message> & msg, messages::MessageType * msg_type=nullptr) override; ++ ++ void write_chunk(const void * buff, size_t size) override; ++ size_t read_chunk(void * buff, size_t size) override; ++ ++ std::ostream& dump(std::ostream& o) const override; ++ static std::mutex mutex; ++ static void setDeviceReceivedData(unsigned char* data, size_t len); ++ static void setDeviceCallback(void (*sendToDeviceCallback)(unsigned char *command, unsigned int cmd_len)); ++ static std::condition_variable cv_send; ++ static std::condition_variable cv_receive; ++ static bool stateIsConnected; ++ static unsigned char* sendToDevice; ++ static size_t sendToDeviceLength; ++ static unsigned char* receivedFromDevice; ++ static size_t receivedFromDeviceLength; ++ static bool waitsForDeviceSend; ++ static bool waitsForDeviceReceive; ++ static void (*sendToTrezorDeviceCallback)(unsigned char *command, unsigned int cmd_len); ++private: ++ void require_device() const; ++ void require_connected() const; ++ int get_interface() const; ++ unsigned char get_endpoint() const; ++ ++ std::shared_ptr<Protocol> m_proto; ++ ++#ifdef WITH_TREZOR_DEBUGGING ++ bool m_debug_mode; ++#endif ++}; ++ + // + // General helpers + // +diff --git a/src/wallet/api/wallet.cpp b/src/wallet/api/wallet.cpp +index c24b4a97d..4cb37a4a6 100644 +--- a/src/wallet/api/wallet.cpp ++++ b/src/wallet/api/wallet.cpp +@@ -42,6 +42,7 @@ + + #include "mnemonics/electrum-words.h" + #include "mnemonics/english.h" ++#include "wallet2_api.h" + #include <boost/format.hpp> + #include <sstream> + #include <unordered_map> +@@ -53,6 +54,7 @@ + #include "bc-ur/src/bc-ur.hpp" + #if defined(HIDAPI_DUMMY) && !defined(HAVE_HIDAPI) + #include "device/device_io_dummy.hpp" ++#include "device_trezor/trezor/transport.hpp" + #endif + + using namespace std; +@@ -3379,98 +3381,173 @@ uint64_t WalletImpl::getBytesSent() + + + // HIDAPI_DUMMY +-bool Wallet::getStateIsConnected() { ++bool Wallet::getStateIsConnected(Device device) { + #if !(defined(HIDAPI_DUMMY) && !defined(HAVE_HIDAPI)) + MERROR("MONERO compiled with #if !(defined(HIDAPI_DUMMY) && !defined(HAVE_HIDAPI))"); + return false; + #else +- return hw::io::device_io_dummy::stateIsConnected; ++ switch (device) { ++ case Monero::Wallet::Device_Ledger: ++ return hw::io::device_io_dummy::stateIsConnected; ++ case Monero::Wallet::Device_Trezor: ++ return hw::trezor::DummyTransport::stateIsConnected; ++ default: ++ throw std::runtime_error("unknown device type"); ++ } + #endif + } + +-unsigned char* Wallet::getSendToDevice() { ++unsigned char* Wallet::getSendToDevice(Device device) { + #if !(defined(HIDAPI_DUMMY) && !defined(HAVE_HIDAPI)) + MERROR("MONERO compiled with #if !(defined(HIDAPI_DUMMY) && !defined(HAVE_HIDAPI))"); + return {}; + #else +- return hw::io::device_io_dummy::sendToDevice; ++ switch (device) { ++ case Monero::Wallet::Device_Ledger: ++ return hw::io::device_io_dummy::sendToDevice; ++ case Monero::Wallet::Device_Trezor: ++ return hw::trezor::DummyTransport::sendToDevice; ++ default: ++ throw std::runtime_error("unknown device type"); ++ } + #endif + } + +-size_t Wallet::getSendToDeviceLength() { ++size_t Wallet::getSendToDeviceLength(Device device) { + #if !(defined(HIDAPI_DUMMY) && !defined(HAVE_HIDAPI)) + MERROR("MONERO compiled with #if !(defined(HIDAPI_DUMMY) && !defined(HAVE_HIDAPI))"); + return -1; + #else +- return hw::io::device_io_dummy::sendToDeviceLength; ++ switch (device) { ++ case Monero::Wallet::Device_Ledger: ++ return hw::io::device_io_dummy::sendToDeviceLength; ++ case Monero::Wallet::Device_Trezor: ++ return hw::trezor::DummyTransport::sendToDeviceLength; ++ default: ++ throw std::runtime_error("unknown device type"); ++ } + #endif + } + +-unsigned char* Wallet::getReceivedFromDevice() { ++unsigned char* Wallet::getReceivedFromDevice(Device device) { + #if !(defined(HIDAPI_DUMMY) && !defined(HAVE_HIDAPI)) + MERROR("MONERO compiled with #if !(defined(HIDAPI_DUMMY) && !defined(HAVE_HIDAPI))"); + return {}; + #else +- return hw::io::device_io_dummy::receivedFromDevice; ++ switch (device) { ++ case Monero::Wallet::Device_Ledger: ++ return hw::io::device_io_dummy::receivedFromDevice; ++ case Monero::Wallet::Device_Trezor: ++ return hw::trezor::DummyTransport::receivedFromDevice; ++ default: ++ throw std::runtime_error("unknown device type"); ++ } + #endif + } + +-size_t Wallet::getReceivedFromDeviceLength() { ++size_t Wallet::getReceivedFromDeviceLength(Device device) { + #if !(defined(HIDAPI_DUMMY) && !defined(HAVE_HIDAPI)) + MERROR("MONERO compiled with #if !(defined(HIDAPI_DUMMY) && !defined(HAVE_HIDAPI))"); + return -1; + #else +- return hw::io::device_io_dummy::receivedFromDeviceLength; ++ switch (device) { ++ case Monero::Wallet::Device_Ledger: ++ return hw::io::device_io_dummy::receivedFromDeviceLength; ++ case Monero::Wallet::Device_Trezor: ++ return hw::trezor::DummyTransport::receivedFromDeviceLength; ++ default: ++ throw std::runtime_error("unknown device type"); ++ } + #endif + } + +-bool Wallet::getWaitsForDeviceSend() { ++bool Wallet::getWaitsForDeviceSend(Device device) { + #if !(defined(HIDAPI_DUMMY) && !defined(HAVE_HIDAPI)) + MERROR("MONERO compiled with #if !(defined(HIDAPI_DUMMY) && !defined(HAVE_HIDAPI))"); + return false; + #else +- return hw::io::device_io_dummy::waitsForDeviceSend; ++ switch (device) { ++ case Monero::Wallet::Device_Ledger: ++ return hw::io::device_io_dummy::waitsForDeviceSend; ++ case Monero::Wallet::Device_Trezor: ++ return hw::trezor::DummyTransport::waitsForDeviceSend; ++ default: ++ throw std::runtime_error("unknown device type"); ++ } + #endif + } + +-bool Wallet::getWaitsForDeviceReceive() { ++bool Wallet::getWaitsForDeviceReceive(Device device) { + #if !(defined(HIDAPI_DUMMY) && !defined(HAVE_HIDAPI)) + MERROR("MONERO compiled with #if !(defined(HIDAPI_DUMMY) && !defined(HAVE_HIDAPI))"); + return false; + #else +- return hw::io::device_io_dummy::waitsForDeviceReceive; ++ switch (device) { ++ case Monero::Wallet::Device_Ledger: ++ return hw::io::device_io_dummy::waitsForDeviceReceive; ++ case Monero::Wallet::Device_Trezor: ++ return hw::trezor::DummyTransport::waitsForDeviceReceive; ++ default: ++ throw std::runtime_error("unknown device type"); ++ } + #endif + } + +-void Wallet::setDeviceReceivedData(unsigned char* data, size_t len) { ++void Wallet::setDeviceReceivedData(Device device, unsigned char* data, size_t len) { + #if !(defined(HIDAPI_DUMMY) && !defined(HAVE_HIDAPI)) + MERROR("MONERO compiled with #if !(defined(HIDAPI_DUMMY) && !defined(HAVE_HIDAPI))"); + return; + #else +- hw::io::device_io_dummy::setDeviceReceivedData(data, len); ++ switch (device) { ++ case Monero::Wallet::Device_Ledger: ++ hw::io::device_io_dummy::setDeviceReceivedData(data, len); ++ case Monero::Wallet::Device_Trezor: ++ hw::trezor::DummyTransport::setDeviceReceivedData(data, len); ++ default: ++ throw std::runtime_error("unknown device type"); ++ } + #endif + } + +-void Wallet::setDeviceSendData(unsigned char* data, size_t len) { ++void Wallet::setDeviceSendData(Device device, unsigned char* data, size_t len) { + #if !(defined(HIDAPI_DUMMY) && !defined(HAVE_HIDAPI)) + MERROR("MONERO compiled with #if !(defined(HIDAPI_DUMMY) && !defined(HAVE_HIDAPI))"); + return; + #else +- hw::io::device_io_dummy::sendToDevice = static_cast<unsigned char *>(malloc(len)); +- hw::io::device_io_dummy::sendToDeviceLength = len; +- memset(hw::io::device_io_dummy::sendToDevice, 0, len); +- memcpy(hw::io::device_io_dummy::sendToDevice, data, len); +- hw::io::device_io_dummy::waitsForDeviceSend = false; +- hw::io::device_io_dummy::cv_send.notify_all(); ++ switch (device) { ++ case Monero::Wallet::Device_Ledger: ++ hw::io::device_io_dummy::sendToDevice = static_cast<unsigned char *>(malloc(len)); ++ hw::io::device_io_dummy::sendToDeviceLength = len; ++ memset(hw::io::device_io_dummy::sendToDevice, 0, len); ++ memcpy(hw::io::device_io_dummy::sendToDevice, data, len); ++ hw::io::device_io_dummy::waitsForDeviceSend = false; ++ hw::io::device_io_dummy::cv_send.notify_all(); ++ case Monero::Wallet::Device_Trezor: ++ hw::trezor::DummyTransport::sendToDevice = static_cast<unsigned char *>(malloc(len)); ++ hw::trezor::DummyTransport::sendToDeviceLength = len; ++ memset(hw::trezor::DummyTransport::sendToDevice, 0, len); ++ memcpy(hw::trezor::DummyTransport::sendToDevice, data, len); ++ hw::trezor::DummyTransport::waitsForDeviceSend = false; ++ hw::trezor::DummyTransport::cv_send.notify_all(); ++ default: ++ throw std::runtime_error("unknown device type"); ++ } + #endif + } + +-void Wallet::setLedgerCallback(void (*sendToLedgerDevice)(unsigned char *command, unsigned int cmd_len)) { ++void Wallet::setDeviceCallback(Monero::Wallet::Device device, void (*sendToDevice)(unsigned char *command, unsigned int cmd_len)) { + #if !(defined(HIDAPI_DUMMY) && !defined(HAVE_HIDAPI)) + MERROR("MONERO compiled with #if !(defined(HIDAPI_DUMMY) && !defined(HAVE_HIDAPI))"); + return; + #else +- hw::io::device_io_dummy::setLedgerCallback(sendToLedgerDevice); ++ switch (device) { ++ case Monero::Wallet::Device_Ledger: ++ hw::io::device_io_dummy::setDeviceCallback(sendToDevice); ++ case Monero::Wallet::Device_Trezor: ++ hw::trezor::DummyTransport::setDeviceCallback(sendToDevice); ++ default: ++ throw std::runtime_error("unknown device type"); ++ } + #endif + } + +diff --git a/src/wallet/api/wallet.h b/src/wallet/api/wallet.h +index 98c03b9c1..2a29c07b3 100644 +--- a/src/wallet/api/wallet.h ++++ b/src/wallet/api/wallet.h +@@ -322,19 +322,19 @@ private: + mutable std::atomic<bool> m_is_connected; + boost::optional<epee::net_utils::http::login> m_daemon_login{}; + +- bool getStateIsConnected(); ++ bool getStateIsConnected(Device device); + +- unsigned char *getSendToDevice(); ++ unsigned char *getSendToDevice(Device device); + +- size_t getSendToDeviceLength(); ++ size_t getSendToDeviceLength(Device device); + +- unsigned char *getReceivedFromDevice(); ++ unsigned char *getReceivedFromDevice(Device device); + +- size_t getReceivedFromDeviceLength(); ++ size_t getReceivedFromDeviceLength(Device device); + +- bool getWaitsForDeviceSend(); ++ bool getWaitsForDeviceSend(Device device); + +- bool getWaitsForDeviceReceive(); ++ bool getWaitsForDeviceReceive(Device device); + + virtual std::string serializeCacheToJson() const override; + }; +diff --git a/src/wallet/api/wallet2_api.h b/src/wallet/api/wallet2_api.h +index 3d11929f9..61756a127 100644 +--- a/src/wallet/api/wallet2_api.h ++++ b/src/wallet/api/wallet2_api.h +@@ -1206,17 +1206,16 @@ struct Wallet + virtual uint64_t getBytesSent() = 0; + + // HIDAPI_DUMMY +- static bool getStateIsConnected(); +- static unsigned char* getSendToDevice(); +- static size_t getSendToDeviceLength(); +- static unsigned char* getReceivedFromDevice(); +- static size_t getReceivedFromDeviceLength(); +- static bool getWaitsForDeviceSend(); +- static bool getWaitsForDeviceReceive(); +- +- static void setDeviceReceivedData(unsigned char* data, size_t len); +- static void setDeviceSendData(unsigned char* data, size_t len); +- static void setLedgerCallback(void (*sendToLedgerDevice)(unsigned char *command, unsigned int cmd_len)); ++ static bool getStateIsConnected(Device device); ++ static unsigned char* getSendToDevice(Device device); ++ static size_t getSendToDeviceLength(Device device); ++ static unsigned char* getReceivedFromDevice(Device device); ++ static size_t getReceivedFromDeviceLength(Device device); ++ static bool getWaitsForDeviceSend(Device device); ++ static bool getWaitsForDeviceReceive(Device device); ++ static void setDeviceReceivedData(Device device, unsigned char* data, size_t len); ++ static void setDeviceSendData(Device device, unsigned char* data, size_t len); ++ static void setDeviceCallback(Device device, void (*sendToDevice)(unsigned char *command, unsigned int cmd_len)); + + //! serialize wallet cache to JSON + virtual std::string serializeCacheToJson() const = 0; +-- +2.50.1 (Apple Git-155) + |