2017-02-21 19:38:18 +02:00
|
|
|
// Copyright (c) 2014-2017, The Monero Project
|
2016-02-15 20:04:00 +02:00
|
|
|
//
|
|
|
|
// All rights reserved.
|
|
|
|
//
|
|
|
|
// Redistribution and use in source and binary forms, with or without modification, are
|
|
|
|
// permitted provided that the following conditions are met:
|
|
|
|
//
|
|
|
|
// 1. Redistributions of source code must retain the above copyright notice, this list of
|
|
|
|
// conditions and the following disclaimer.
|
|
|
|
//
|
|
|
|
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
|
|
|
|
// of conditions and the following disclaimer in the documentation and/or other
|
|
|
|
// materials provided with the distribution.
|
|
|
|
//
|
|
|
|
// 3. Neither the name of the copyright holder nor the names of its contributors may be
|
|
|
|
// used to endorse or promote products derived from this software without specific
|
|
|
|
// prior written permission.
|
|
|
|
//
|
|
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
|
|
|
|
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
|
|
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
|
|
|
|
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
|
|
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
|
|
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|
|
|
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
|
|
|
|
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
//
|
|
|
|
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
|
|
|
|
|
|
|
#include <string>
|
2016-04-19 12:25:03 +03:00
|
|
|
#include <vector>
|
2017-02-19 04:42:10 +02:00
|
|
|
#include <set>
|
2016-04-20 13:01:00 +03:00
|
|
|
#include <ctime>
|
2016-12-12 01:42:46 +02:00
|
|
|
#include <iostream>
|
2016-02-15 20:04:00 +02:00
|
|
|
|
|
|
|
// Public interface for libwallet library
|
2016-12-13 17:21:38 +02:00
|
|
|
namespace Monero {
|
2016-02-15 20:04:00 +02:00
|
|
|
|
2016-04-26 13:46:20 +03:00
|
|
|
namespace Utils {
|
|
|
|
bool isAddressLocal(const std::string &hostaddr);
|
2017-12-18 08:09:51 +02:00
|
|
|
void onStartup();
|
2016-04-26 13:46:20 +03:00
|
|
|
}
|
2016-11-09 14:19:22 +02:00
|
|
|
|
|
|
|
template<typename T>
|
|
|
|
class optional {
|
|
|
|
public:
|
|
|
|
optional(): set(false) {}
|
|
|
|
optional(const T &t): t(t), set(true) {}
|
|
|
|
const T &operator*() const { return t; }
|
|
|
|
T &operator*() { return t; }
|
|
|
|
operator bool() const { return set; }
|
|
|
|
private:
|
|
|
|
T t;
|
|
|
|
bool set;
|
|
|
|
};
|
|
|
|
|
2016-04-03 14:34:38 +03:00
|
|
|
/**
|
2016-04-19 12:25:03 +03:00
|
|
|
* @brief Transaction-like interface for sending money
|
2016-04-03 14:34:38 +03:00
|
|
|
*/
|
2016-04-05 15:24:44 +03:00
|
|
|
struct PendingTransaction
|
2016-04-03 14:34:38 +03:00
|
|
|
{
|
|
|
|
enum Status {
|
|
|
|
Status_Ok,
|
2016-12-12 22:39:29 +02:00
|
|
|
Status_Error,
|
|
|
|
Status_Critical
|
2016-04-03 14:34:38 +03:00
|
|
|
};
|
2016-06-27 14:55:13 +03:00
|
|
|
|
|
|
|
enum Priority {
|
|
|
|
Priority_Low = 1,
|
|
|
|
Priority_Medium = 2,
|
|
|
|
Priority_High = 3,
|
|
|
|
Priority_Last
|
|
|
|
};
|
|
|
|
|
2016-04-05 15:24:44 +03:00
|
|
|
virtual ~PendingTransaction() = 0;
|
2016-04-03 14:34:38 +03:00
|
|
|
virtual int status() const = 0;
|
|
|
|
virtual std::string errorString() const = 0;
|
2017-01-08 14:17:09 +02:00
|
|
|
// commit transaction or save to file if filename is provided.
|
|
|
|
virtual bool commit(const std::string &filename = "", bool overwrite = false) = 0;
|
2016-04-05 15:24:44 +03:00
|
|
|
virtual uint64_t amount() const = 0;
|
|
|
|
virtual uint64_t dust() const = 0;
|
|
|
|
virtual uint64_t fee() const = 0;
|
2016-11-05 22:53:45 +02:00
|
|
|
virtual std::vector<std::string> txid() const = 0;
|
2016-11-07 23:05:19 +02:00
|
|
|
/*!
|
|
|
|
* \brief txCount - number of transactions current transaction will be splitted to
|
|
|
|
* \return
|
|
|
|
*/
|
|
|
|
virtual uint64_t txCount() const = 0;
|
2017-02-19 04:42:10 +02:00
|
|
|
virtual std::vector<uint32_t> subaddrAccount() const = 0;
|
|
|
|
virtual std::vector<std::set<uint32_t>> subaddrIndices() const = 0;
|
2016-04-03 14:34:38 +03:00
|
|
|
};
|
2016-02-15 20:04:00 +02:00
|
|
|
|
2017-01-08 14:17:09 +02:00
|
|
|
/**
|
|
|
|
* @brief Transaction-like interface for sending money
|
|
|
|
*/
|
|
|
|
struct UnsignedTransaction
|
|
|
|
{
|
|
|
|
enum Status {
|
|
|
|
Status_Ok,
|
|
|
|
Status_Error,
|
|
|
|
Status_Critical
|
|
|
|
};
|
|
|
|
|
|
|
|
enum Priority {
|
|
|
|
Priority_Low = 1,
|
|
|
|
Priority_Medium = 2,
|
|
|
|
Priority_High = 3,
|
|
|
|
Priority_Last
|
|
|
|
};
|
|
|
|
|
|
|
|
virtual ~UnsignedTransaction() = 0;
|
|
|
|
virtual int status() const = 0;
|
|
|
|
virtual std::string errorString() const = 0;
|
|
|
|
virtual std::vector<uint64_t> amount() const = 0;
|
|
|
|
virtual std::vector<uint64_t> fee() const = 0;
|
|
|
|
virtual std::vector<uint64_t> mixin() const = 0;
|
|
|
|
// returns a string with information about all transactions.
|
|
|
|
virtual std::string confirmationMessage() const = 0;
|
|
|
|
virtual std::vector<std::string> paymentId() const = 0;
|
|
|
|
virtual std::vector<std::string> recipientAddress() const = 0;
|
|
|
|
virtual uint64_t minMixinCount() const = 0;
|
|
|
|
/*!
|
|
|
|
* \brief txCount - number of transactions current transaction will be splitted to
|
|
|
|
* \return
|
|
|
|
*/
|
|
|
|
virtual uint64_t txCount() const = 0;
|
|
|
|
/*!
|
|
|
|
* @brief sign - Sign txs and saves to file
|
|
|
|
* @param signedFileName
|
|
|
|
* return - true on success
|
|
|
|
*/
|
|
|
|
virtual bool sign(const std::string &signedFileName) = 0;
|
|
|
|
};
|
|
|
|
|
2016-04-19 12:25:03 +03:00
|
|
|
/**
|
|
|
|
* @brief The TransactionInfo - interface for displaying transaction information
|
|
|
|
*/
|
|
|
|
struct TransactionInfo
|
|
|
|
{
|
|
|
|
enum Direction {
|
|
|
|
Direction_In,
|
|
|
|
Direction_Out
|
|
|
|
};
|
2016-04-29 16:26:14 +03:00
|
|
|
|
|
|
|
struct Transfer {
|
|
|
|
Transfer(uint64_t _amount, const std::string &address);
|
|
|
|
const uint64_t amount;
|
|
|
|
const std::string address;
|
|
|
|
};
|
|
|
|
|
2016-04-22 13:21:08 +03:00
|
|
|
virtual ~TransactionInfo() = 0;
|
2016-04-20 13:01:00 +03:00
|
|
|
virtual int direction() const = 0;
|
2016-04-29 16:26:14 +03:00
|
|
|
virtual bool isPending() const = 0;
|
2016-04-19 12:25:03 +03:00
|
|
|
virtual bool isFailed() const = 0;
|
|
|
|
virtual uint64_t amount() const = 0;
|
|
|
|
virtual uint64_t fee() const = 0;
|
2016-04-22 13:21:08 +03:00
|
|
|
virtual uint64_t blockHeight() const = 0;
|
2017-02-19 04:42:10 +02:00
|
|
|
virtual std::set<uint32_t> subaddrIndex() const = 0;
|
|
|
|
virtual uint32_t subaddrAccount() const = 0;
|
|
|
|
virtual std::string label() const = 0;
|
2017-01-12 19:23:23 +02:00
|
|
|
virtual uint64_t confirmations() const = 0;
|
2017-08-03 22:37:45 +03:00
|
|
|
virtual uint64_t unlockTime() const = 0;
|
2016-04-29 16:26:14 +03:00
|
|
|
//! transaction_id
|
2016-04-22 13:21:08 +03:00
|
|
|
virtual std::string hash() const = 0;
|
2016-04-20 13:01:00 +03:00
|
|
|
virtual std::time_t timestamp() const = 0;
|
|
|
|
virtual std::string paymentId() const = 0;
|
2016-04-29 16:26:14 +03:00
|
|
|
//! only applicable for output transactions
|
|
|
|
virtual const std::vector<Transfer> & transfers() const = 0;
|
2016-04-19 12:25:03 +03:00
|
|
|
};
|
2016-04-22 13:21:08 +03:00
|
|
|
/**
|
|
|
|
* @brief The TransactionHistory - interface for displaying transaction history
|
|
|
|
*/
|
|
|
|
struct TransactionHistory
|
|
|
|
{
|
|
|
|
virtual ~TransactionHistory() = 0;
|
|
|
|
virtual int count() const = 0;
|
|
|
|
virtual TransactionInfo * transaction(int index) const = 0;
|
|
|
|
virtual TransactionInfo * transaction(const std::string &id) const = 0;
|
|
|
|
virtual std::vector<TransactionInfo*> getAll() const = 0;
|
|
|
|
virtual void refresh() = 0;
|
|
|
|
};
|
|
|
|
|
2016-12-12 01:42:46 +02:00
|
|
|
/**
|
|
|
|
* @brief AddressBookRow - provides functions to manage address book
|
|
|
|
*/
|
|
|
|
struct AddressBookRow {
|
|
|
|
public:
|
2016-12-14 23:37:49 +02:00
|
|
|
AddressBookRow(std::size_t _rowId, const std::string &_address, const std::string &_paymentId, const std::string &_description):
|
2016-12-12 01:42:46 +02:00
|
|
|
m_rowId(_rowId),
|
|
|
|
m_address(_address),
|
|
|
|
m_paymentId(_paymentId),
|
|
|
|
m_description(_description) {}
|
|
|
|
|
|
|
|
private:
|
2016-12-14 23:37:49 +02:00
|
|
|
std::size_t m_rowId;
|
2016-12-12 01:42:46 +02:00
|
|
|
std::string m_address;
|
|
|
|
std::string m_paymentId;
|
|
|
|
std::string m_description;
|
|
|
|
public:
|
|
|
|
std::string extra;
|
|
|
|
std::string getAddress() const {return m_address;}
|
|
|
|
std::string getDescription() const {return m_description;}
|
|
|
|
std::string getPaymentId() const {return m_paymentId;}
|
2016-12-14 23:37:49 +02:00
|
|
|
std::size_t getRowId() const {return m_rowId;}
|
2016-12-12 01:42:46 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief The AddressBook - interface for
|
|
|
|
Book
|
|
|
|
*/
|
|
|
|
struct AddressBook
|
|
|
|
{
|
|
|
|
enum ErrorCode {
|
|
|
|
Status_Ok,
|
|
|
|
General_Error,
|
|
|
|
Invalid_Address,
|
|
|
|
Invalid_Payment_Id
|
|
|
|
};
|
|
|
|
virtual ~AddressBook() = 0;
|
|
|
|
virtual std::vector<AddressBookRow*> getAll() const = 0;
|
|
|
|
virtual bool addRow(const std::string &dst_addr , const std::string &payment_id, const std::string &description) = 0;
|
2016-12-14 23:37:49 +02:00
|
|
|
virtual bool deleteRow(std::size_t rowId) = 0;
|
2016-12-12 01:42:46 +02:00
|
|
|
virtual void refresh() = 0;
|
|
|
|
virtual std::string errorString() const = 0;
|
|
|
|
virtual int errorCode() const = 0;
|
2017-01-01 18:06:34 +02:00
|
|
|
virtual int lookupPaymentID(const std::string &payment_id) const = 0;
|
2016-12-12 01:42:46 +02:00
|
|
|
};
|
2016-04-22 13:21:08 +03:00
|
|
|
|
2017-02-19 04:42:10 +02:00
|
|
|
struct SubaddressRow {
|
|
|
|
public:
|
|
|
|
SubaddressRow(std::size_t _rowId, const std::string &_address, const std::string &_label):
|
|
|
|
m_rowId(_rowId),
|
|
|
|
m_address(_address),
|
|
|
|
m_label(_label) {}
|
|
|
|
|
|
|
|
private:
|
|
|
|
std::size_t m_rowId;
|
|
|
|
std::string m_address;
|
|
|
|
std::string m_label;
|
|
|
|
public:
|
|
|
|
std::string extra;
|
|
|
|
std::string getAddress() const {return m_address;}
|
|
|
|
std::string getLabel() const {return m_label;}
|
|
|
|
std::size_t getRowId() const {return m_rowId;}
|
|
|
|
};
|
|
|
|
|
|
|
|
struct Subaddress
|
|
|
|
{
|
|
|
|
virtual ~Subaddress() = 0;
|
|
|
|
virtual std::vector<SubaddressRow*> getAll() const = 0;
|
|
|
|
virtual void addRow(uint32_t accountIndex, const std::string &label) = 0;
|
|
|
|
virtual void setLabel(uint32_t accountIndex, uint32_t addressIndex, const std::string &label) = 0;
|
|
|
|
virtual void refresh(uint32_t accountIndex) = 0;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct SubaddressAccountRow {
|
|
|
|
public:
|
|
|
|
SubaddressAccountRow(std::size_t _rowId, const std::string &_address, const std::string &_label, const std::string &_balance, const std::string &_unlockedBalance):
|
|
|
|
m_rowId(_rowId),
|
|
|
|
m_address(_address),
|
|
|
|
m_label(_label),
|
|
|
|
m_balance(_balance),
|
|
|
|
m_unlockedBalance(_unlockedBalance) {}
|
|
|
|
|
|
|
|
private:
|
|
|
|
std::size_t m_rowId;
|
|
|
|
std::string m_address;
|
|
|
|
std::string m_label;
|
|
|
|
std::string m_balance;
|
|
|
|
std::string m_unlockedBalance;
|
|
|
|
public:
|
|
|
|
std::string extra;
|
|
|
|
std::string getAddress() const {return m_address;}
|
|
|
|
std::string getLabel() const {return m_label;}
|
|
|
|
std::string getBalance() const {return m_balance;}
|
|
|
|
std::string getUnlockedBalance() const {return m_unlockedBalance;}
|
|
|
|
std::size_t getRowId() const {return m_rowId;}
|
|
|
|
};
|
|
|
|
|
|
|
|
struct SubaddressAccount
|
|
|
|
{
|
|
|
|
virtual ~SubaddressAccount() = 0;
|
|
|
|
virtual std::vector<SubaddressAccountRow*> getAll() const = 0;
|
|
|
|
virtual void addRow(const std::string &label) = 0;
|
|
|
|
virtual void setLabel(uint32_t accountIndex, const std::string &label) = 0;
|
|
|
|
virtual void refresh() = 0;
|
|
|
|
};
|
|
|
|
|
2016-05-05 22:24:00 +03:00
|
|
|
struct WalletListener
|
|
|
|
{
|
|
|
|
virtual ~WalletListener() = 0;
|
2016-09-23 22:36:37 +03:00
|
|
|
/**
|
|
|
|
* @brief moneySpent - called when money spent
|
|
|
|
* @param txId - transaction id
|
|
|
|
* @param amount - amount
|
|
|
|
*/
|
2016-05-16 13:11:44 +03:00
|
|
|
virtual void moneySpent(const std::string &txId, uint64_t amount) = 0;
|
2016-09-23 22:36:37 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief moneyReceived - called when money received
|
|
|
|
* @param txId - transaction id
|
|
|
|
* @param amount - amount
|
|
|
|
*/
|
2016-05-16 13:11:44 +03:00
|
|
|
virtual void moneyReceived(const std::string &txId, uint64_t amount) = 0;
|
2017-01-12 19:23:23 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief unconfirmedMoneyReceived - called when payment arrived in tx pool
|
|
|
|
* @param txId - transaction id
|
|
|
|
* @param amount - amount
|
|
|
|
*/
|
|
|
|
virtual void unconfirmedMoneyReceived(const std::string &txId, uint64_t amount) = 0;
|
2016-09-23 22:36:37 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief newBlock - called when new block received
|
|
|
|
* @param height - block height
|
|
|
|
*/
|
|
|
|
virtual void newBlock(uint64_t height) = 0;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief updated - generic callback, called when any event (sent/received/block reveived/etc) happened with the wallet;
|
|
|
|
*/
|
2016-07-10 17:17:23 +03:00
|
|
|
virtual void updated() = 0;
|
2016-09-23 22:36:37 +03:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief refreshed - called when wallet refreshed by background thread or explicitly refreshed by calling "refresh" synchronously
|
|
|
|
*/
|
2016-07-10 17:17:23 +03:00
|
|
|
virtual void refreshed() = 0;
|
2016-05-05 22:24:00 +03:00
|
|
|
};
|
|
|
|
|
2016-04-19 12:25:03 +03:00
|
|
|
|
2016-02-15 20:04:00 +02:00
|
|
|
/**
|
|
|
|
* @brief Interface for wallet operations.
|
|
|
|
* TODO: check if /include/IWallet.h is still actual
|
|
|
|
*/
|
|
|
|
struct Wallet
|
|
|
|
{
|
2016-03-10 18:43:10 +02:00
|
|
|
|
|
|
|
enum Status {
|
|
|
|
Status_Ok,
|
2016-12-12 22:39:29 +02:00
|
|
|
Status_Error,
|
|
|
|
Status_Critical
|
2016-03-10 18:43:10 +02:00
|
|
|
};
|
|
|
|
|
2016-11-07 14:00:29 +02:00
|
|
|
enum ConnectionStatus {
|
|
|
|
ConnectionStatus_Disconnected,
|
|
|
|
ConnectionStatus_Connected,
|
|
|
|
ConnectionStatus_WrongVersion
|
|
|
|
};
|
|
|
|
|
2016-02-21 20:18:16 +02:00
|
|
|
virtual ~Wallet() = 0;
|
|
|
|
virtual std::string seed() const = 0;
|
|
|
|
virtual std::string getSeedLanguage() const = 0;
|
|
|
|
virtual void setSeedLanguage(const std::string &arg) = 0;
|
2016-03-10 18:43:10 +02:00
|
|
|
//! returns wallet status (Status_Ok | Status_Error)
|
|
|
|
virtual int status() const = 0;
|
|
|
|
//! in case error status, returns error string
|
|
|
|
virtual std::string errorString() const = 0;
|
2016-03-11 16:05:36 +02:00
|
|
|
virtual bool setPassword(const std::string &password) = 0;
|
2017-10-22 16:13:35 +03:00
|
|
|
virtual std::string address(uint32_t accountIndex = 0, uint32_t addressIndex = 0) const = 0;
|
2017-02-19 04:42:10 +02:00
|
|
|
std::string mainAddress() const { return address(0, 0); }
|
2016-11-26 16:19:57 +02:00
|
|
|
virtual std::string path() const = 0;
|
2017-01-23 00:02:01 +02:00
|
|
|
virtual bool testnet() const = 0;
|
2017-03-24 10:59:26 +02:00
|
|
|
//! returns current hard fork info
|
|
|
|
virtual void hardForkInfo(uint8_t &version, uint64_t &earliest_height) const = 0;
|
|
|
|
//! check if hard fork rules should be used
|
|
|
|
virtual bool useForkRules(uint8_t version, int64_t early_blocks) const = 0;
|
2016-06-23 14:38:22 +03:00
|
|
|
/*!
|
|
|
|
* \brief integratedAddress - returns integrated address for current wallet address and given payment_id.
|
|
|
|
* if passed "payment_id" param is an empty string or not-valid payment id string
|
|
|
|
* (16 characters hexadecimal string) - random payment_id will be generated
|
|
|
|
*
|
|
|
|
* \param payment_id - 16 characters hexadecimal string or empty string if new random payment id needs to be
|
|
|
|
* generated
|
|
|
|
* \return - 106 characters string representing integrated address
|
|
|
|
*/
|
|
|
|
virtual std::string integratedAddress(const std::string &payment_id) const = 0;
|
2016-06-23 16:23:09 +03:00
|
|
|
|
2017-01-10 23:34:15 +02:00
|
|
|
/*!
|
2017-05-02 17:48:38 +03:00
|
|
|
* \brief secretViewKey - returns secret view key
|
|
|
|
* \return - secret view key
|
2017-01-10 23:34:15 +02:00
|
|
|
*/
|
2017-05-02 17:48:38 +03:00
|
|
|
virtual std::string secretViewKey() const = 0;
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* \brief publicViewKey - returns public view key
|
|
|
|
* \return - public view key
|
|
|
|
*/
|
|
|
|
virtual std::string publicViewKey() const = 0;
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* \brief secretSpendKey - returns secret spend key
|
|
|
|
* \return - secret spend key
|
|
|
|
*/
|
|
|
|
virtual std::string secretSpendKey() const = 0;
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* \brief publicSpendKey - returns public spend key
|
|
|
|
* \return - public spend key
|
|
|
|
*/
|
|
|
|
virtual std::string publicSpendKey() const = 0;
|
2017-01-10 23:34:15 +02:00
|
|
|
|
2016-06-10 12:51:09 +03:00
|
|
|
/*!
|
|
|
|
* \brief store - stores wallet to file.
|
|
|
|
* \param path - main filename to store wallet to. additionally stores address file and keys file.
|
|
|
|
* to store to the same file - just pass empty string;
|
|
|
|
* \return
|
|
|
|
*/
|
2016-03-15 22:11:38 +02:00
|
|
|
virtual bool store(const std::string &path) = 0;
|
2016-06-10 12:51:09 +03:00
|
|
|
/*!
|
|
|
|
* \brief filename - returns wallet filename
|
|
|
|
* \return
|
|
|
|
*/
|
|
|
|
virtual std::string filename() const = 0;
|
|
|
|
/*!
|
|
|
|
* \brief keysFilename - returns keys filename. usually this formed as "wallet_filename".keys
|
|
|
|
* \return
|
|
|
|
*/
|
|
|
|
virtual std::string keysFilename() const = 0;
|
2016-07-14 12:47:01 +03:00
|
|
|
/*!
|
2017-01-30 12:59:19 +02:00
|
|
|
* \brief init - initializes wallet with daemon connection params.
|
|
|
|
* if daemon_address is local address, "trusted daemon" will be set to true forcibly
|
|
|
|
* startRefresh() should be called when wallet is initialized.
|
2016-07-14 12:47:01 +03:00
|
|
|
*
|
|
|
|
* \param daemon_address - daemon address in "hostname:port" format
|
|
|
|
* \param upper_transaction_size_limit
|
2017-08-05 00:28:38 +03:00
|
|
|
* \param daemon_username
|
|
|
|
* \param daemon_password
|
|
|
|
* \param lightWallet - start wallet in light mode, connect to a openmonero compatible server.
|
2017-01-30 12:59:19 +02:00
|
|
|
* \return - true on success
|
2016-07-14 12:47:01 +03:00
|
|
|
*/
|
2017-08-05 00:28:38 +03:00
|
|
|
virtual bool init(const std::string &daemon_address, uint64_t upper_transaction_size_limit = 0, const std::string &daemon_username = "", const std::string &daemon_password = "", bool use_ssl = false, bool lightWallet = false) = 0;
|
2016-07-14 12:47:01 +03:00
|
|
|
|
2017-01-10 23:34:15 +02:00
|
|
|
/*!
|
|
|
|
* \brief createWatchOnly - Creates a watch only wallet
|
|
|
|
* \param path - where to store the wallet
|
|
|
|
* \param password
|
|
|
|
* \param language
|
|
|
|
* \return - true if created successfully
|
|
|
|
*/
|
|
|
|
virtual bool createWatchOnly(const std::string &path, const std::string &password, const std::string &language) const = 0;
|
|
|
|
|
2016-10-08 01:57:09 +03:00
|
|
|
/*!
|
|
|
|
* \brief setRefreshFromBlockHeight - start refresh from block height on recover
|
|
|
|
*
|
|
|
|
* \param refresh_from_block_height - blockchain start height
|
|
|
|
*/
|
|
|
|
virtual void setRefreshFromBlockHeight(uint64_t refresh_from_block_height) = 0;
|
|
|
|
|
2017-08-05 01:09:06 +03:00
|
|
|
/*!
|
|
|
|
* \brief getRestoreHeight - get wallet creation height
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
virtual uint64_t getRefreshFromBlockHeight() const = 0;
|
|
|
|
|
2016-10-10 20:34:25 +03:00
|
|
|
/*!
|
|
|
|
* \brief setRecoveringFromSeed - set state recover form seed
|
|
|
|
*
|
|
|
|
* \param recoveringFromSeed - true/false
|
|
|
|
*/
|
|
|
|
virtual void setRecoveringFromSeed(bool recoveringFromSeed) = 0;
|
|
|
|
|
2016-07-14 12:47:01 +03:00
|
|
|
/**
|
|
|
|
* @brief connectToDaemon - connects to the daemon. TODO: check if it can be removed
|
|
|
|
* @return
|
|
|
|
*/
|
2016-03-25 16:06:30 +02:00
|
|
|
virtual bool connectToDaemon() = 0;
|
2016-07-14 12:47:01 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief connected - checks if the wallet connected to the daemon
|
|
|
|
* @return - true if connected
|
|
|
|
*/
|
2016-11-07 14:00:29 +02:00
|
|
|
virtual ConnectionStatus connected() const = 0;
|
2016-04-26 13:46:20 +03:00
|
|
|
virtual void setTrustedDaemon(bool arg) = 0;
|
|
|
|
virtual bool trustedDaemon() const = 0;
|
2017-10-22 16:13:35 +03:00
|
|
|
virtual uint64_t balance(uint32_t accountIndex = 0) const = 0;
|
2017-02-19 04:42:10 +02:00
|
|
|
uint64_t balanceAll() const {
|
|
|
|
uint64_t result = 0;
|
|
|
|
for (uint32_t i = 0; i < numSubaddressAccounts(); ++i)
|
|
|
|
result += balance(i);
|
|
|
|
return result;
|
|
|
|
}
|
2017-10-22 16:13:35 +03:00
|
|
|
virtual uint64_t unlockedBalance(uint32_t accountIndex = 0) const = 0;
|
2017-02-19 04:42:10 +02:00
|
|
|
uint64_t unlockedBalanceAll() const {
|
|
|
|
uint64_t result = 0;
|
|
|
|
for (uint32_t i = 0; i < numSubaddressAccounts(); ++i)
|
|
|
|
result += unlockedBalance(i);
|
|
|
|
return result;
|
|
|
|
}
|
2016-06-20 22:56:30 +03:00
|
|
|
|
2017-01-10 23:34:15 +02:00
|
|
|
/**
|
|
|
|
* @brief watchOnly - checks if wallet is watch only
|
|
|
|
* @return - true if watch only
|
|
|
|
*/
|
|
|
|
virtual bool watchOnly() const = 0;
|
|
|
|
|
2016-09-23 22:36:37 +03:00
|
|
|
/**
|
2016-09-26 21:35:00 +03:00
|
|
|
* @brief blockChainHeight - returns current blockchain height
|
2016-09-23 22:36:37 +03:00
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
virtual uint64_t blockChainHeight() const = 0;
|
2016-11-10 16:36:16 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief approximateBlockChainHeight - returns approximate blockchain height calculated from date/time
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
virtual uint64_t approximateBlockChainHeight() const = 0;
|
2016-09-23 22:36:37 +03:00
|
|
|
|
2016-09-26 21:35:00 +03:00
|
|
|
/**
|
|
|
|
* @brief daemonBlockChainHeight - returns daemon blockchain height
|
|
|
|
* @return 0 - in case error communicating with the daemon.
|
|
|
|
* status() will return Status_Error and errorString() will return verbose error description
|
|
|
|
*/
|
|
|
|
virtual uint64_t daemonBlockChainHeight() const = 0;
|
|
|
|
|
2016-10-03 21:47:41 +03:00
|
|
|
/**
|
|
|
|
* @brief daemonBlockChainTargetHeight - returns daemon blockchain target height
|
|
|
|
* @return 0 - in case error communicating with the daemon.
|
|
|
|
* status() will return Status_Error and errorString() will return verbose error description
|
|
|
|
*/
|
|
|
|
virtual uint64_t daemonBlockChainTargetHeight() const = 0;
|
2016-09-26 21:35:00 +03:00
|
|
|
|
2016-10-07 00:29:13 +03:00
|
|
|
/**
|
|
|
|
* @brief synchronized - checks if wallet was ever synchronized
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
virtual bool synchronized() const = 0;
|
|
|
|
|
2016-04-05 15:24:44 +03:00
|
|
|
static std::string displayAmount(uint64_t amount);
|
2016-06-16 16:42:33 +03:00
|
|
|
static uint64_t amountFromString(const std::string &amount);
|
|
|
|
static uint64_t amountFromDouble(double amount);
|
2016-06-23 14:38:22 +03:00
|
|
|
static std::string genPaymentId();
|
2016-06-24 16:17:06 +03:00
|
|
|
static bool paymentIdValid(const std::string &paiment_id);
|
2016-10-16 18:52:45 +03:00
|
|
|
static bool addressValid(const std::string &str, bool testnet);
|
2017-01-26 22:33:36 +02:00
|
|
|
static bool keyValid(const std::string &secret_key_string, const std::string &address_string, bool isViewKey, bool testnet, std::string &error);
|
2016-10-16 18:52:45 +03:00
|
|
|
static std::string paymentIdFromAddress(const std::string &str, bool testnet);
|
2016-08-23 12:35:01 +03:00
|
|
|
static uint64_t maximumAllowedAmount();
|
2017-02-05 21:12:01 +02:00
|
|
|
// Easylogger wrapper
|
2017-02-18 22:44:23 +02:00
|
|
|
static void init(const char *argv0, const char *default_log_base_name);
|
2017-02-05 21:12:01 +02:00
|
|
|
static void debug(const std::string &str);
|
2016-06-20 22:56:30 +03:00
|
|
|
|
2016-12-14 13:18:52 +02:00
|
|
|
/**
|
|
|
|
* @brief StartRefresh - Start/resume refresh thread (refresh every 10 seconds)
|
|
|
|
*/
|
|
|
|
virtual void startRefresh() = 0;
|
|
|
|
/**
|
|
|
|
* @brief pauseRefresh - pause refresh thread
|
|
|
|
*/
|
|
|
|
virtual void pauseRefresh() = 0;
|
|
|
|
|
2016-07-13 13:13:10 +03:00
|
|
|
/**
|
|
|
|
* @brief refresh - refreshes the wallet, updating transactions from daemon
|
|
|
|
* @return - true if refreshed successfully;
|
|
|
|
*/
|
2016-03-31 16:38:57 +03:00
|
|
|
virtual bool refresh() = 0;
|
2016-09-20 20:40:58 +03:00
|
|
|
|
2016-07-13 13:13:10 +03:00
|
|
|
/**
|
|
|
|
* @brief refreshAsync - refreshes wallet asynchronously.
|
|
|
|
*/
|
2016-07-10 17:17:23 +03:00
|
|
|
virtual void refreshAsync() = 0;
|
2016-09-20 20:40:58 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief setAutoRefreshInterval - setup interval for automatic refresh.
|
2016-09-26 22:50:10 +03:00
|
|
|
* @param seconds - interval in millis. if zero or less than zero - automatic refresh disabled;
|
2016-09-20 20:40:58 +03:00
|
|
|
*/
|
2016-09-26 22:50:10 +03:00
|
|
|
virtual void setAutoRefreshInterval(int millis) = 0;
|
2016-09-20 20:40:58 +03:00
|
|
|
|
|
|
|
/**
|
2016-09-26 22:50:10 +03:00
|
|
|
* @brief autoRefreshInterval - returns automatic refresh interval in millis
|
2016-09-20 20:40:58 +03:00
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
virtual int autoRefreshInterval() const = 0;
|
|
|
|
|
2017-02-19 04:42:10 +02:00
|
|
|
/**
|
|
|
|
* @brief addSubaddressAccount - appends a new subaddress account at the end of the last major index of existing subaddress accounts
|
|
|
|
* @param label - the label for the new account (which is the as the label of the primary address (accountIndex,0))
|
|
|
|
*/
|
|
|
|
virtual void addSubaddressAccount(const std::string& label) = 0;
|
|
|
|
/**
|
|
|
|
* @brief numSubaddressAccounts - returns the number of existing subaddress accounts
|
|
|
|
*/
|
|
|
|
virtual size_t numSubaddressAccounts() const = 0;
|
|
|
|
/**
|
|
|
|
* @brief numSubaddresses - returns the number of existing subaddresses associated with the specified subaddress account
|
|
|
|
* @param accountIndex - the major index specifying the subaddress account
|
|
|
|
*/
|
|
|
|
virtual size_t numSubaddresses(uint32_t accountIndex) const = 0;
|
|
|
|
/**
|
|
|
|
* @brief addSubaddress - appends a new subaddress at the end of the last minor index of the specified subaddress account
|
|
|
|
* @param accountIndex - the major index specifying the subaddress account
|
|
|
|
* @param label - the label for the new subaddress
|
|
|
|
*/
|
|
|
|
virtual void addSubaddress(uint32_t accountIndex, const std::string& label) = 0;
|
|
|
|
/**
|
|
|
|
* @brief getSubaddressLabel - gets the label of the specified subaddress
|
|
|
|
* @param accountIndex - the major index specifying the subaddress account
|
|
|
|
* @param addressIndex - the minor index specifying the subaddress
|
|
|
|
*/
|
|
|
|
virtual std::string getSubaddressLabel(uint32_t accountIndex, uint32_t addressIndex) const = 0;
|
|
|
|
/**
|
|
|
|
* @brief setSubaddressLabel - sets the label of the specified subaddress
|
|
|
|
* @param accountIndex - the major index specifying the subaddress account
|
|
|
|
* @param addressIndex - the minor index specifying the subaddress
|
|
|
|
* @param label - the new label for the specified subaddress
|
|
|
|
*/
|
|
|
|
virtual void setSubaddressLabel(uint32_t accountIndex, uint32_t addressIndex, const std::string &label) = 0;
|
2016-09-20 20:40:58 +03:00
|
|
|
|
2016-06-20 22:56:30 +03:00
|
|
|
/*!
|
2016-06-23 14:38:22 +03:00
|
|
|
* \brief createTransaction creates transaction. if dst_addr is an integrated address, payment_id is ignored
|
2016-06-20 22:56:30 +03:00
|
|
|
* \param dst_addr destination address as string
|
2016-06-23 14:38:22 +03:00
|
|
|
* \param payment_id optional payment_id, can be empty string
|
2016-06-20 22:56:30 +03:00
|
|
|
* \param amount amount
|
|
|
|
* \param mixin_count mixin count. if 0 passed, wallet will use default value
|
2017-02-19 04:42:10 +02:00
|
|
|
* \param subaddr_account subaddress account from which the input funds are taken
|
|
|
|
* \param subaddr_indices set of subaddress indices to use for transfer or sweeping. if set empty, all are chosen when sweeping, and one or more are automatically chosen when transferring. after execution, returns the set of actually used indices
|
2016-06-27 14:55:13 +03:00
|
|
|
* \param priority
|
2016-06-20 22:56:30 +03:00
|
|
|
* \return PendingTransaction object. caller is responsible to check PendingTransaction::status()
|
|
|
|
* after object returned
|
|
|
|
*/
|
2016-06-23 16:23:09 +03:00
|
|
|
|
2016-06-23 14:38:22 +03:00
|
|
|
virtual PendingTransaction * createTransaction(const std::string &dst_addr, const std::string &payment_id,
|
2016-11-09 14:19:22 +02:00
|
|
|
optional<uint64_t> amount, uint32_t mixin_count,
|
2017-10-22 16:13:35 +03:00
|
|
|
PendingTransaction::Priority = PendingTransaction::Priority_Low,
|
|
|
|
uint32_t subaddr_account = 0,
|
|
|
|
std::set<uint32_t> subaddr_indices = {}) = 0;
|
2016-06-23 16:23:09 +03:00
|
|
|
|
2016-11-08 22:03:07 +02:00
|
|
|
/*!
|
|
|
|
* \brief createSweepUnmixableTransaction creates transaction with unmixable outputs.
|
|
|
|
* \return PendingTransaction object. caller is responsible to check PendingTransaction::status()
|
|
|
|
* after object returned
|
|
|
|
*/
|
|
|
|
|
|
|
|
virtual PendingTransaction * createSweepUnmixableTransaction() = 0;
|
2017-01-08 14:17:09 +02:00
|
|
|
|
|
|
|
/*!
|
|
|
|
* \brief loadUnsignedTx - creates transaction from unsigned tx file
|
|
|
|
* \return - UnsignedTransaction object. caller is responsible to check UnsignedTransaction::status()
|
|
|
|
* after object returned
|
|
|
|
*/
|
|
|
|
virtual UnsignedTransaction * loadUnsignedTx(const std::string &unsigned_filename) = 0;
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* \brief submitTransaction - submits transaction in signed tx file
|
|
|
|
* \return - true on success
|
|
|
|
*/
|
|
|
|
virtual bool submitTransaction(const std::string &fileName) = 0;
|
|
|
|
|
2016-11-08 22:03:07 +02:00
|
|
|
|
2016-06-27 14:55:13 +03:00
|
|
|
/*!
|
|
|
|
* \brief disposeTransaction - destroys transaction object
|
|
|
|
* \param t - pointer to the "PendingTransaction" object. Pointer is not valid after function returned;
|
|
|
|
*/
|
2016-04-05 15:24:44 +03:00
|
|
|
virtual void disposeTransaction(PendingTransaction * t) = 0;
|
2017-01-08 14:17:09 +02:00
|
|
|
|
2017-01-14 00:00:03 +02:00
|
|
|
/*!
|
|
|
|
* \brief exportKeyImages - exports key images to file
|
|
|
|
* \param filename
|
|
|
|
* \return - true on success
|
|
|
|
*/
|
|
|
|
virtual bool exportKeyImages(const std::string &filename) = 0;
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* \brief importKeyImages - imports key images from file
|
|
|
|
* \param filename
|
|
|
|
* \return - true on success
|
|
|
|
*/
|
|
|
|
virtual bool importKeyImages(const std::string &filename) = 0;
|
|
|
|
|
|
|
|
|
2017-02-19 04:42:10 +02:00
|
|
|
virtual TransactionHistory * history() = 0;
|
|
|
|
virtual AddressBook * addressBook() = 0;
|
|
|
|
virtual Subaddress * subaddress() = 0;
|
|
|
|
virtual SubaddressAccount * subaddressAccount() = 0;
|
2016-05-05 22:24:00 +03:00
|
|
|
virtual void setListener(WalletListener *) = 0;
|
2016-06-10 13:52:10 +03:00
|
|
|
/*!
|
|
|
|
* \brief defaultMixin - returns number of mixins used in transactions
|
|
|
|
* \return
|
|
|
|
*/
|
|
|
|
virtual uint32_t defaultMixin() const = 0;
|
|
|
|
/*!
|
|
|
|
* \brief setDefaultMixin - setum number of mixins to be used for new transactions
|
|
|
|
* \param arg
|
|
|
|
*/
|
|
|
|
virtual void setDefaultMixin(uint32_t arg) = 0;
|
2016-11-05 22:53:45 +02:00
|
|
|
|
|
|
|
/*!
|
|
|
|
* \brief setUserNote - attach an arbitrary string note to a txid
|
|
|
|
* \param txid - the transaction id to attach the note to
|
|
|
|
* \param note - the note
|
|
|
|
* \return true if succesful, false otherwise
|
|
|
|
*/
|
|
|
|
virtual bool setUserNote(const std::string &txid, const std::string ¬e) = 0;
|
|
|
|
/*!
|
|
|
|
* \brief getUserNote - return an arbitrary string note attached to a txid
|
|
|
|
* \param txid - the transaction id to attach the note to
|
|
|
|
* \return the attached note, or empty string if there is none
|
|
|
|
*/
|
|
|
|
virtual std::string getUserNote(const std::string &txid) const = 0;
|
2016-11-06 20:04:59 +02:00
|
|
|
virtual std::string getTxKey(const std::string &txid) const = 0;
|
2017-09-12 04:05:41 +03:00
|
|
|
virtual bool checkTxKey(const std::string &txid, std::string tx_key, const std::string &address, uint64_t &received, bool &in_pool, uint64_t &confirmations) = 0;
|
2017-11-20 11:10:58 +02:00
|
|
|
virtual std::string getTxProof(const std::string &txid, const std::string &address, const std::string &message) const = 0;
|
2017-09-12 04:05:41 +03:00
|
|
|
virtual bool checkTxProof(const std::string &txid, const std::string &address, const std::string &message, const std::string &signature, bool &good, uint64_t &received, bool &in_pool, uint64_t &confirmations) = 0;
|
2017-08-28 18:34:17 +03:00
|
|
|
virtual std::string getSpendProof(const std::string &txid, const std::string &message) const = 0;
|
|
|
|
virtual bool checkSpendProof(const std::string &txid, const std::string &message, const std::string &signature, bool &good) const = 0;
|
2016-11-08 11:58:46 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* \brief signMessage - sign a message with the spend private key
|
|
|
|
* \param message - the message to sign (arbitrary byte data)
|
|
|
|
* \return the signature
|
|
|
|
*/
|
|
|
|
virtual std::string signMessage(const std::string &message) = 0;
|
|
|
|
/*!
|
|
|
|
* \brief verifySignedMessage - verify a signature matches a given message
|
|
|
|
* \param message - the message (arbitrary byte data)
|
|
|
|
* \param address - the address the signature claims to be made with
|
|
|
|
* \param signature - the signature
|
|
|
|
* \return true if the signature verified, false otherwise
|
|
|
|
*/
|
|
|
|
virtual bool verifySignedMessage(const std::string &message, const std::string &addres, const std::string &signature) const = 0;
|
2017-01-09 00:53:24 +02:00
|
|
|
|
|
|
|
virtual bool parse_uri(const std::string &uri, std::string &address, std::string &payment_id, uint64_t &amount, std::string &tx_description, std::string &recipient_name, std::vector<std::string> &unknown_parameters, std::string &error) = 0;
|
2017-08-09 13:38:29 +03:00
|
|
|
|
|
|
|
virtual std::string getDefaultDataDir() const = 0;
|
|
|
|
|
2017-01-12 23:10:38 +02:00
|
|
|
/*
|
|
|
|
* \brief rescanSpent - Rescan spent outputs - Can only be used with trusted daemon
|
|
|
|
* \return true on success
|
|
|
|
*/
|
|
|
|
virtual bool rescanSpent() = 0;
|
2017-08-05 00:31:33 +03:00
|
|
|
|
|
|
|
//! Light wallet authenticate and login
|
|
|
|
virtual bool lightWalletLogin(bool &isNewWallet) const = 0;
|
|
|
|
|
|
|
|
//! Initiates a light wallet import wallet request
|
|
|
|
virtual bool lightWalletImportWalletRequest(std::string &payment_id, uint64_t &fee, bool &new_request, bool &request_fulfilled, std::string &payment_address, std::string &status) = 0;
|
2016-02-15 20:04:00 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief WalletManager - provides functions to manage wallets
|
|
|
|
*/
|
|
|
|
struct WalletManager
|
|
|
|
{
|
2016-03-11 16:05:36 +02:00
|
|
|
|
|
|
|
/*!
|
|
|
|
* \brief Creates new wallet
|
|
|
|
* \param path Name of wallet file
|
|
|
|
* \param password Password of wallet file
|
|
|
|
* \param language Language to be used to generate electrum seed memo
|
|
|
|
* \return Wallet instance (Wallet::status() needs to be called to check if created successfully)
|
|
|
|
*/
|
2016-03-31 12:48:41 +03:00
|
|
|
virtual Wallet * createWallet(const std::string &path, const std::string &password, const std::string &language, bool testnet = false) = 0;
|
2016-03-10 18:43:10 +02:00
|
|
|
|
2016-03-11 16:05:36 +02:00
|
|
|
/*!
|
|
|
|
* \brief Opens existing wallet
|
|
|
|
* \param path Name of wallet file
|
|
|
|
* \param password Password of wallet file
|
|
|
|
* \return Wallet instance (Wallet::status() needs to be called to check if opened successfully)
|
|
|
|
*/
|
2016-03-31 12:48:41 +03:00
|
|
|
virtual Wallet * openWallet(const std::string &path, const std::string &password, bool testnet = false) = 0;
|
2016-02-15 20:04:00 +02:00
|
|
|
|
2016-03-11 16:05:36 +02:00
|
|
|
/*!
|
|
|
|
* \brief recovers existing wallet using memo (electrum seed)
|
|
|
|
* \param path Name of wallet file to be created
|
|
|
|
* \param memo memo (25 words electrum seed)
|
2016-10-08 01:57:09 +03:00
|
|
|
* \param testnet testnet
|
|
|
|
* \param restoreHeight restore from start height
|
2016-03-11 16:05:36 +02:00
|
|
|
* \return Wallet instance (Wallet::status() needs to be called to check if recovered successfully)
|
|
|
|
*/
|
2016-10-08 01:57:09 +03:00
|
|
|
virtual Wallet * recoveryWallet(const std::string &path, const std::string &memo, bool testnet = false, uint64_t restoreHeight = 0) = 0;
|
2016-03-11 16:05:36 +02:00
|
|
|
|
2017-01-26 22:33:36 +02:00
|
|
|
/*!
|
|
|
|
* \brief recovers existing wallet using keys. Creates a view only wallet if spend key is omitted
|
|
|
|
* \param path Name of wallet file to be created
|
|
|
|
* \param language language
|
|
|
|
* \param testnet testnet
|
|
|
|
* \param restoreHeight restore from start height
|
|
|
|
* \param addressString public address
|
|
|
|
* \param viewKeyString view key
|
|
|
|
* \param spendKeyString spend key (optional)
|
|
|
|
* \return Wallet instance (Wallet::status() needs to be called to check if recovered successfully)
|
|
|
|
*/
|
|
|
|
virtual Wallet * createWalletFromKeys(const std::string &path,
|
|
|
|
const std::string &language,
|
|
|
|
bool testnet,
|
|
|
|
uint64_t restoreHeight,
|
|
|
|
const std::string &addressString,
|
|
|
|
const std::string &viewKeyString,
|
|
|
|
const std::string &spendKeyString = "") = 0;
|
|
|
|
|
2016-03-11 16:05:36 +02:00
|
|
|
/*!
|
|
|
|
* \brief Closes wallet. In case operation succeded, wallet object deleted. in case operation failed, wallet object not deleted
|
|
|
|
* \param wallet previously opened / created wallet instance
|
|
|
|
* \return None
|
|
|
|
*/
|
2017-09-23 01:52:09 +03:00
|
|
|
virtual bool closeWallet(Wallet *wallet, bool store = true) = 0;
|
2016-03-10 18:43:10 +02:00
|
|
|
|
2016-06-03 14:52:58 +03:00
|
|
|
/*
|
|
|
|
* ! checks if wallet with the given name already exists
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* @brief TODO: delme walletExists - check if the given filename is the wallet
|
|
|
|
* @param path - filename
|
2017-08-02 01:41:05 +03:00
|
|
|
* @return - true if wallet exists
|
2016-06-03 14:52:58 +03:00
|
|
|
*/
|
2016-02-20 18:04:56 +02:00
|
|
|
virtual bool walletExists(const std::string &path) = 0;
|
2016-02-15 20:04:00 +02:00
|
|
|
|
2017-08-02 01:41:05 +03:00
|
|
|
/*!
|
|
|
|
* @brief verifyWalletPassword - check if the given filename is the wallet
|
|
|
|
* @param keys_file_name - location of keys file
|
|
|
|
* @param password - password to verify
|
Add N/N multisig tx generation and signing
Scheme by luigi1111:
Multisig for RingCT on Monero
2 of 2
User A (coordinator):
Spendkey b,B
Viewkey a,A (shared)
User B:
Spendkey c,C
Viewkey a,A (shared)
Public Address: C+B, A
Both have their own watch only wallet via C+B, a
A will coordinate spending process (though B could easily as well, coordinator is more needed for more participants)
A and B watch for incoming outputs
B creates "half" key images for discovered output D:
I2_D = (Hs(aR)+c) * Hp(D)
B also creates 1.5 random keypairs (one scalar and 2 pubkeys; one on base G and one on base Hp(D)) for each output, storing the scalar(k) (linked to D),
and sending the pubkeys with I2_D.
A also creates "half" key images:
I1_D = (Hs(aR)+b) * Hp(D)
Then I_D = I1_D + I2_D
Having I_D allows A to check spent status of course, but more importantly allows A to actually build a transaction prefix (and thus transaction).
A builds the transaction until most of the way through MLSAG_Gen, adding the 2 pubkeys (per input) provided with I2_D
to his own generated ones where they are needed (secret row L, R).
At this point, A has a mostly completed transaction (but with an invalid/incomplete signature). A sends over the tx and includes r,
which allows B (with the recipient's address) to verify the destination and amount (by reconstructing the stealth address and decoding ecdhInfo).
B then finishes the signature by computing ss[secret_index][0] = ss[secret_index][0] + k - cc[secret_index]*c (secret indices need to be passed as well).
B can then broadcast the tx, or send it back to A for broadcasting. Once B has completed the signing (and verified the tx to be valid), he can add the full I_D
to his cache, allowing him to verify spent status as well.
NOTE:
A and B *must* present key A and B to each other with a valid signature proving they know a and b respectively.
Otherwise, trickery like the following becomes possible:
A creates viewkey a,A, spendkey b,B, and sends a,A,B to B.
B creates a fake key C = zG - B. B sends C back to A.
The combined spendkey C+B then equals zG, allowing B to spend funds at any time!
The signature fixes this, because B does not know a c corresponding to C (and thus can't produce a signature).
2 of 3
User A (coordinator)
Shared viewkey a,A
"spendkey" j,J
User B
"spendkey" k,K
User C
"spendkey" m,M
A collects K and M from B and C
B collects J and M from A and C
C collects J and K from A and B
A computes N = nG, n = Hs(jK)
A computes O = oG, o = Hs(jM)
B anc C compute P = pG, p = Hs(kM) || Hs(mK)
B and C can also compute N and O respectively if they wish to be able to coordinate
Address: N+O+P, A
The rest follows as above. The coordinator possesses 2 of 3 needed keys; he can get the other
needed part of the signature/key images from either of the other two.
Alternatively, if secure communication exists between parties:
A gives j to B
B gives k to C
C gives m to A
Address: J+K+M, A
3 of 3
Identical to 2 of 2, except the coordinator must collect the key images from both of the others.
The transaction must also be passed an additional hop: A -> B -> C (or A -> C -> B), who can then broadcast it
or send it back to A.
N-1 of N
Generally the same as 2 of 3, except participants need to be arranged in a ring to pass their keys around
(using either the secure or insecure method).
For example (ignoring viewkey so letters line up):
[4 of 5]
User: spendkey
A: a
B: b
C: c
D: d
E: e
a -> B, b -> C, c -> D, d -> E, e -> A
Order of signing does not matter, it just must reach n-1 users. A "remaining keys" list must be passed around with
the transaction so the signers know if they should use 1 or both keys.
Collecting key image parts becomes a little messy, but basically every wallet sends over both of their parts with a tag for each.
Thia way the coordinating wallet can keep track of which images have been added and which wallet they come from. Reasoning:
1. The key images must be added only once (coordinator will get key images for key a from both A and B, he must add only one to get the proper key actual key image)
2. The coordinator must keep track of which helper pubkeys came from which wallet (discussed in 2 of 2 section). The coordinator
must choose only one set to use, then include his choice in the "remaining keys" list so the other wallets know which of their keys to use.
You can generalize it further to N-2 of N or even M of N, but I'm not sure there's legitimate demand to justify the complexity. It might
also be straightforward enough to support with minimal changes from N-1 format.
You basically just give each user additional keys for each additional "-1" you desire. N-2 would be 3 keys per user, N-3 4 keys, etc.
The process is somewhat cumbersome:
To create a N/N multisig wallet:
- each participant creates a normal wallet
- each participant runs "prepare_multisig", and sends the resulting string to every other participant
- each participant runs "make_multisig N A B C D...", with N being the threshold and A B C D... being the strings received from other participants (the threshold must currently equal N)
As txes are received, participants' wallets will need to synchronize so that those new outputs may be spent:
- each participant runs "export_multisig FILENAME", and sends the FILENAME file to every other participant
- each participant runs "import_multisig A B C D...", with A B C D... being the filenames received from other participants
Then, a transaction may be initiated:
- one of the participants runs "transfer ADDRESS AMOUNT"
- this partly signed transaction will be written to the "multisig_monero_tx" file
- the initiator sends this file to another participant
- that other participant runs "sign_multisig multisig_monero_tx"
- the resulting transaction is written to the "multisig_monero_tx" file again
- if the threshold was not reached, the file must be sent to another participant, until enough have signed
- the last participant to sign runs "submit_multisig multisig_monero_tx" to relay the transaction to the Monero network
2017-06-04 00:34:26 +03:00
|
|
|
* @param no_spend_key - verify only view keys?
|
2017-08-02 01:41:05 +03:00
|
|
|
* @return - true if password is correct
|
|
|
|
*/
|
Add N/N multisig tx generation and signing
Scheme by luigi1111:
Multisig for RingCT on Monero
2 of 2
User A (coordinator):
Spendkey b,B
Viewkey a,A (shared)
User B:
Spendkey c,C
Viewkey a,A (shared)
Public Address: C+B, A
Both have their own watch only wallet via C+B, a
A will coordinate spending process (though B could easily as well, coordinator is more needed for more participants)
A and B watch for incoming outputs
B creates "half" key images for discovered output D:
I2_D = (Hs(aR)+c) * Hp(D)
B also creates 1.5 random keypairs (one scalar and 2 pubkeys; one on base G and one on base Hp(D)) for each output, storing the scalar(k) (linked to D),
and sending the pubkeys with I2_D.
A also creates "half" key images:
I1_D = (Hs(aR)+b) * Hp(D)
Then I_D = I1_D + I2_D
Having I_D allows A to check spent status of course, but more importantly allows A to actually build a transaction prefix (and thus transaction).
A builds the transaction until most of the way through MLSAG_Gen, adding the 2 pubkeys (per input) provided with I2_D
to his own generated ones where they are needed (secret row L, R).
At this point, A has a mostly completed transaction (but with an invalid/incomplete signature). A sends over the tx and includes r,
which allows B (with the recipient's address) to verify the destination and amount (by reconstructing the stealth address and decoding ecdhInfo).
B then finishes the signature by computing ss[secret_index][0] = ss[secret_index][0] + k - cc[secret_index]*c (secret indices need to be passed as well).
B can then broadcast the tx, or send it back to A for broadcasting. Once B has completed the signing (and verified the tx to be valid), he can add the full I_D
to his cache, allowing him to verify spent status as well.
NOTE:
A and B *must* present key A and B to each other with a valid signature proving they know a and b respectively.
Otherwise, trickery like the following becomes possible:
A creates viewkey a,A, spendkey b,B, and sends a,A,B to B.
B creates a fake key C = zG - B. B sends C back to A.
The combined spendkey C+B then equals zG, allowing B to spend funds at any time!
The signature fixes this, because B does not know a c corresponding to C (and thus can't produce a signature).
2 of 3
User A (coordinator)
Shared viewkey a,A
"spendkey" j,J
User B
"spendkey" k,K
User C
"spendkey" m,M
A collects K and M from B and C
B collects J and M from A and C
C collects J and K from A and B
A computes N = nG, n = Hs(jK)
A computes O = oG, o = Hs(jM)
B anc C compute P = pG, p = Hs(kM) || Hs(mK)
B and C can also compute N and O respectively if they wish to be able to coordinate
Address: N+O+P, A
The rest follows as above. The coordinator possesses 2 of 3 needed keys; he can get the other
needed part of the signature/key images from either of the other two.
Alternatively, if secure communication exists between parties:
A gives j to B
B gives k to C
C gives m to A
Address: J+K+M, A
3 of 3
Identical to 2 of 2, except the coordinator must collect the key images from both of the others.
The transaction must also be passed an additional hop: A -> B -> C (or A -> C -> B), who can then broadcast it
or send it back to A.
N-1 of N
Generally the same as 2 of 3, except participants need to be arranged in a ring to pass their keys around
(using either the secure or insecure method).
For example (ignoring viewkey so letters line up):
[4 of 5]
User: spendkey
A: a
B: b
C: c
D: d
E: e
a -> B, b -> C, c -> D, d -> E, e -> A
Order of signing does not matter, it just must reach n-1 users. A "remaining keys" list must be passed around with
the transaction so the signers know if they should use 1 or both keys.
Collecting key image parts becomes a little messy, but basically every wallet sends over both of their parts with a tag for each.
Thia way the coordinating wallet can keep track of which images have been added and which wallet they come from. Reasoning:
1. The key images must be added only once (coordinator will get key images for key a from both A and B, he must add only one to get the proper key actual key image)
2. The coordinator must keep track of which helper pubkeys came from which wallet (discussed in 2 of 2 section). The coordinator
must choose only one set to use, then include his choice in the "remaining keys" list so the other wallets know which of their keys to use.
You can generalize it further to N-2 of N or even M of N, but I'm not sure there's legitimate demand to justify the complexity. It might
also be straightforward enough to support with minimal changes from N-1 format.
You basically just give each user additional keys for each additional "-1" you desire. N-2 would be 3 keys per user, N-3 4 keys, etc.
The process is somewhat cumbersome:
To create a N/N multisig wallet:
- each participant creates a normal wallet
- each participant runs "prepare_multisig", and sends the resulting string to every other participant
- each participant runs "make_multisig N A B C D...", with N being the threshold and A B C D... being the strings received from other participants (the threshold must currently equal N)
As txes are received, participants' wallets will need to synchronize so that those new outputs may be spent:
- each participant runs "export_multisig FILENAME", and sends the FILENAME file to every other participant
- each participant runs "import_multisig A B C D...", with A B C D... being the filenames received from other participants
Then, a transaction may be initiated:
- one of the participants runs "transfer ADDRESS AMOUNT"
- this partly signed transaction will be written to the "multisig_monero_tx" file
- the initiator sends this file to another participant
- that other participant runs "sign_multisig multisig_monero_tx"
- the resulting transaction is written to the "multisig_monero_tx" file again
- if the threshold was not reached, the file must be sent to another participant, until enough have signed
- the last participant to sign runs "submit_multisig multisig_monero_tx" to relay the transaction to the Monero network
2017-06-04 00:34:26 +03:00
|
|
|
virtual bool verifyWalletPassword(const std::string &keys_file_name, const std::string &password, bool no_spend_key) const = 0;
|
2017-08-02 01:41:05 +03:00
|
|
|
|
2016-06-03 14:52:58 +03:00
|
|
|
/*!
|
|
|
|
* \brief findWallets - searches for the wallet files by given path name recursively
|
|
|
|
* \param path - starting point to search
|
|
|
|
* \return - list of strings with found wallets (absolute paths);
|
|
|
|
*/
|
|
|
|
virtual std::vector<std::string> findWallets(const std::string &path) = 0;
|
|
|
|
|
|
|
|
//! returns verbose error string regarding last error;
|
2016-03-10 18:43:10 +02:00
|
|
|
virtual std::string errorString() const = 0;
|
2016-06-03 14:52:58 +03:00
|
|
|
|
2016-11-29 12:54:38 +02:00
|
|
|
//! set the daemon address (hostname and port)
|
|
|
|
virtual void setDaemonAddress(const std::string &address) = 0;
|
|
|
|
|
|
|
|
//! returns whether the daemon can be reached, and its version number
|
|
|
|
virtual bool connected(uint32_t *version = NULL) const = 0;
|
|
|
|
|
|
|
|
//! returns current blockchain height
|
|
|
|
virtual uint64_t blockchainHeight() const = 0;
|
|
|
|
|
|
|
|
//! returns current blockchain target height
|
|
|
|
virtual uint64_t blockchainTargetHeight() const = 0;
|
|
|
|
|
|
|
|
//! returns current network difficulty
|
|
|
|
virtual uint64_t networkDifficulty() const = 0;
|
|
|
|
|
|
|
|
//! returns current mining hash rate (0 if not mining)
|
|
|
|
virtual double miningHashRate() const = 0;
|
2016-12-17 14:48:22 +02:00
|
|
|
|
2016-12-25 14:31:50 +02:00
|
|
|
//! returns current block target
|
|
|
|
virtual uint64_t blockTarget() const = 0;
|
|
|
|
|
2016-12-29 15:16:21 +02:00
|
|
|
//! returns true iff mining
|
|
|
|
virtual bool isMining() const = 0;
|
|
|
|
|
|
|
|
//! starts mining with the set number of threads
|
2017-03-02 15:09:04 +02:00
|
|
|
virtual bool startMining(const std::string &address, uint32_t threads = 1, bool background_mining = false, bool ignore_battery = true) = 0;
|
2016-12-29 15:16:21 +02:00
|
|
|
|
|
|
|
//! stops mining
|
|
|
|
virtual bool stopMining() = 0;
|
|
|
|
|
2016-12-17 14:48:22 +02:00
|
|
|
//! resolves an OpenAlias address to a monero address
|
|
|
|
virtual std::string resolveOpenAlias(const std::string &address, bool &dnssec_valid) const = 0;
|
2017-02-19 12:35:15 +02:00
|
|
|
|
|
|
|
//! checks for an update and returns version, hash and url
|
2017-10-22 13:56:01 +03:00
|
|
|
static std::tuple<bool, std::string, std::string, std::string, std::string> checkUpdates(const std::string &software, std::string subdir);
|
2016-02-15 20:04:00 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
struct WalletManagerFactory
|
|
|
|
{
|
2016-07-14 12:47:01 +03:00
|
|
|
// logging levels for underlying library
|
|
|
|
enum LogLevel {
|
|
|
|
LogLevel_Silent = -1,
|
|
|
|
LogLevel_0 = 0,
|
|
|
|
LogLevel_1 = 1,
|
|
|
|
LogLevel_2 = 2,
|
|
|
|
LogLevel_3 = 3,
|
|
|
|
LogLevel_4 = 4,
|
|
|
|
LogLevel_Min = LogLevel_Silent,
|
|
|
|
LogLevel_Max = LogLevel_4
|
|
|
|
};
|
|
|
|
|
2016-02-15 20:04:00 +02:00
|
|
|
static WalletManager * getWalletManager();
|
2016-07-14 12:47:01 +03:00
|
|
|
static void setLogLevel(int level);
|
2017-01-16 23:11:03 +02:00
|
|
|
static void setLogCategories(const std::string &categories);
|
2016-02-15 20:04:00 +02:00
|
|
|
};
|
|
|
|
|
2016-07-14 12:47:01 +03:00
|
|
|
|
2016-02-15 20:04:00 +02:00
|
|
|
}
|
|
|
|
|
2016-12-13 17:21:38 +02:00
|
|
|
namespace Bitmonero = Monero;
|
|
|
|
|