Fixed DMN creation system: the collateral can now be included in the …

…proreg

src/qt/pivx/masternodewizarddialog.cpp

@@ -3,6 +3,8 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include "qt/pivx/masternodewizarddialog.h"
+#include "optional.h"
+#include "primitives/transaction.h"
 #include "qt/pivx/forms/ui_masternodewizarddialog.h"
 
 #include "key_io.h"
@@ -425,7 +427,6 @@ bool MasterNodeWizardDialog::createMN()
     }
 
     if (isDeterministic) {
-        // 1) Get or create the owner addr
         auto opOwnerAddrAndKeyId = getOrCreateOwnerAddress(alias);
         if (!opOwnerAddrAndKeyId.getRes()) {
             return errorOut(tr(opOwnerAddrAndKeyId.getError().c_str()));
@@ -462,11 +463,20 @@ bool MasterNodeWizardDialog::createMN()
             votingAddr = ownerKeyId;
         }
 
-        // For now, collateral key is always inside the wallet
+        Optional<COutPoint> collateralOut =  COutPoint(); 
+        bool foundCandidate = false;
+        if(!walletModel->getMNCollateralCandidate(*collateralOut)){
+            collateralOut= nullopt;    
+        }else{
+            //We have to lock the collateral or the system could spend it
+            walletModel->lockCoin(*collateralOut);
+            foundCandidate = true;
+        }
         std::string error_str;
-        walletModel->lockCoin(collateralOut);
+
         auto res = mnModel->createDMN(alias,
                                       collateralOut,
+                                      addressLabel,
                                       ipAddress,
                                       port,
                                       ownerKeyId,
@@ -477,16 +487,18 @@ bool MasterNodeWizardDialog::createMN()
                                       (uint16_t) operatorPercentage * 100, // operator percentage
                                       operatorPayoutKeyId); // operator payout script
         if (!res) {
-            walletModel->unlockCoin(collateralOut);
+            //unlock in case of error
+            if(foundCandidate){
+                walletModel->unlockCoin(*collateralOut);
+            }
             return errorOut(tr(error_str.c_str()));
         }
-
         // If the operator key was created locally, let's get it for the summary
         // future: move "operatorSk" to a constant field
         std::string operatorSk = walletModel->getStrFromTxExtraData(*res.getObjResult(), "operatorSk");
         mnSummary = std::make_unique<MNSummary>(alias,
                                                 ipAddress+":"+port,
-                                                collateralOut,
+                                                collateralOut?*collateralOut:COutPoint(UINT256_ZERO,0), //TODO: the outpoint index is not 0 in general, but it does not matter (just display)
                                                 ownerAddrStr,
                                                 payoutAddrStr,
                                                 operatorSk.empty() ? operatorKey.toStdString() : operatorSk,
@@ -496,7 +508,24 @@ bool MasterNodeWizardDialog::createMN()
 
         returnStr = tr("Deterministic Masternode created! It will appear on your list on the next mined block!");
     } else {
+
         // Legacy
+        // Look for a valid collateral utxo
+        COutPoint collateralOut;
+
+        if (!walletModel->getMNCollateralCandidate(collateralOut)) {
+            // New receive address
+            auto r = walletModel->getNewAddress(alias);
+            if (!r) return errorOut(tr(r.getError().c_str()));
+                if (!mnModel->createDMNExternalCollateral(addressLabel,
+                                     QString::fromStdString(r.getObjResult()->ToString()),
+                                     collateralOut,
+                                     returnStr)) {
+                // error str set internally
+                return false;
+            }
+        }
+
         CKey secret;
         secret.MakeNewKey(false);
         std::string mnKeyString = KeyIO::EncodeSecret(secret);

src/qt/pivx/mnmodel.cpp

@@ -13,6 +13,7 @@
 #include "net.h"        // for validateMasternodeIP
 #include "netbase.h"
 #include "operationresult.h"
+#include "primitives/transaction.h"
 #include "tiertwo/tiertwo_sync_state.h"
 #include "uint256.h"
 #include "qt/bitcoinunits.h"
@@ -24,6 +25,7 @@
 
 #include <QFile>
 #include <QHostAddress>
+#include <cstddef>
 
 uint16_t MasternodeWrapper::getType() const
 {
@@ -311,8 +313,9 @@ std::string translateRejectionError(const std::string& rejection)
     return rejection;
 }
 
-static CallResult<uint256> createDMNInternal(const COutPoint& collateral,
-                                             const CKey& keyCollateral,
+CallResult<uint256> MNModel::createDMNInternal(const Optional<COutPoint>& collateral,
+                                             const Optional<QString>& addr_label,
+                                             const Optional<CKey>& keyCollateral,
                                              const CService& service,
                                              const CKeyID& ownerAddr,
                                              const CBLSPublicKey& operatorPubKey,
@@ -328,7 +331,7 @@ static CallResult<uint256> createDMNInternal(const COutPoint& collateral,
     pl.keyIDOwner = ownerAddr;
     pl.pubKeyOperator = operatorPubKey;
     pl.keyIDVoting = votingAddr ? *votingAddr : pl.keyIDOwner;
-    pl.collateralOutpoint = collateral;
+    pl.collateralOutpoint = (collateral ? *collateral : COutPoint(UINT256_ZERO, 0)); //dummy outpoint if collateral is nullopt
     pl.scriptPayout = GetScriptForDestination(payoutAddr);
     if (operatorPayoutAddr) {
         pl.nOperatorReward = *operatorPercentage;
@@ -337,29 +340,68 @@ static CallResult<uint256> createDMNInternal(const COutPoint& collateral,
     // make sure fee calculation works
     pl.vchSig.resize(CPubKey::COMPACT_SIGNATURE_SIZE);
 
-    CMutableTransaction tx;
-    tx.nVersion = CTransaction::TxVersion::SAPLING;
-    tx.nType = CTransaction::TxType::PROREG;
-
-    auto wallet = vpwallets[0]; // TODO: Move to walletModel
-    auto res = FundSpecialTx(wallet, tx, pl);
-    if (!res) return {res.getError()};
-
-    res = SignSpecialTxPayloadByString(pl, keyCollateral);
-    if (!res) return {res.getError()};
-
     std::map<std::string, std::string> extraValues;
     if (operatorSk) {
         // Only if the operator sk was provided
         extraValues.emplace("operatorSk", bls::EncodeSecret(Params(), *operatorSk));
     }
-    res = SignAndSendSpecialTx(wallet, tx, pl, &extraValues);
-    return res ? CallResult<uint256>(tx.GetHash()) :
+    auto wallet = vpwallets[0]; // TODO: Move to walletModel
+    if(collateral){
+        if(!keyCollateral){
+            return CallResult<uint256>("null key collateral");
+        }
+        CMutableTransaction tx;
+        tx.nVersion = CTransaction::TxVersion::SAPLING;
+        tx.nType = CTransaction::TxType::PROREG;
+        auto res = FundSpecialTx(wallet, tx, pl);
+        if (!res) return {res.getError()};
+
+        res = SignSpecialTxPayloadByString(pl, *keyCollateral);
+        if (!res) return {res.getError()};
+        res = SignAndSendSpecialTx(wallet, tx, pl, &extraValues);
+        return res ? CallResult<uint256>(tx.GetHash()) :
+            CallResult<uint256>(translateRejectionError(res.getError()));
+    }else{
+        if(!addr_label){
+            return  CallResult<uint256>("Null address label");
+        }
+         std::string alias = addr_label->toStdString();
+         CTransactionRef ret_tx;
+         auto r = walletModel->getNewAddress(alias);
+         QString returnStr;
+
+         //CmutTx used only to compute the size of payload
+         CMutableTransaction tx_test;
+         tx_test.nVersion= CTransaction::TxVersion::SAPLING;
+         tx_test.nType = CTransaction::TxType::PROREG;
+         SetTxPayload(tx_test, pl);
+         const int nExtraSize = int(GetSerializeSize(tx_test.extraPayload)+GetSerializeSize(tx_test.sapData));
+
+         COutPoint collateral_outpoint;
+         if (!r) return  CallResult<uint256>(translateRejectionError(r.getError()));
+            if (!createDMNInternalCollateral(*addr_label,
+                                    QString::fromStdString(r.getObjResult()->ToString()),
+                                    ret_tx,
+                                    collateral_outpoint,
+                                    returnStr,nExtraSize)) {
+                 //error str set internally
+                return  CallResult<uint256>(returnStr.toStdString());
+            }
+        pl.collateralOutpoint = collateral_outpoint;
+        CMutableTransaction tx = CMutableTransaction(*ret_tx);
+        tx.nVersion = CTransaction::TxVersion::SAPLING;
+        tx.nType = CTransaction::TxType::PROREG;
+        pl.vchSig.clear();
+        UpdateSpecialTxInputsHash(tx, pl);
+        auto res = SignAndSendSpecialTx(wallet, tx, pl, &extraValues);
+        return res ? CallResult<uint256>(tx.GetHash()) :
             CallResult<uint256>(translateRejectionError(res.getError()));
+    }
 }
 
 CallResult<uint256> MNModel::createDMN(const std::string& alias,
-                                       const COutPoint& collateral,
+                                       const Optional<COutPoint>& collateral,
+                                       const Optional<QString>& addr_label,
                                        std::string& serviceAddr,
                                        const std::string& servicePort,
                                        const CKeyID& ownerAddr,
@@ -370,18 +412,16 @@ CallResult<uint256> MNModel::createDMN(const std::string& alias,
                                        const Optional<uint16_t>& operatorPercentage,
                                        const Optional<CKeyID>& operatorPayoutAddr)
 {
-    // Parse and validate inputs
-
     // Different DMN creation types:
     // 1. internal.
     // 2. external.
     // 3. fund.
 
+    //Either one of them must be non null
     auto p_wallet = vpwallets[0]; // TODO: Move to walletModel
     const auto& chainparams = Params();
 
     // 1) Create the simplest DMN, the collateral was generated by this wallet.
-
     CService service;
     if (!serviceAddr.empty()) {
         if (!Lookup(serviceAddr+":"+servicePort, service, chainparams.GetDefaultPort(), false)) {
@@ -391,11 +431,15 @@ CallResult<uint256> MNModel::createDMN(const std::string& alias,
     }
 
     CPubKey pubKeyCollateral;
-    CKey keyCollateral;
-    if (!p_wallet->GetMasternodeVinAndKeys(pubKeyCollateral, keyCollateral, collateral, false, strError)) {
+    Optional<CKey> keyCollateral = nullopt;
+
+    if (collateral){
+        keyCollateral = CKey();
+        if(!p_wallet->GetMasternodeVinAndKeys(pubKeyCollateral, *keyCollateral, *collateral, false, strError)) {
         return {strError};
+        }
     }
-
+  
     // parse operator pubkey or create one
     Optional<CBLSSecretKey> operatorSk{nullopt};
     CBLSPublicKey operatorPk;
@@ -414,6 +458,7 @@ CallResult<uint256> MNModel::createDMN(const std::string& alias,
     }
 
     auto res = createDMNInternal(collateral,
+                                 addr_label,
                                  keyCollateral,
                                  service,
                                  ownerAddr,
@@ -475,8 +520,62 @@ OperationResult MNModel::killDMN(const uint256& collateralHash, unsigned int out
 
     return {true};
 }
+//This functions create a collateral that will be "locked" inside the ProRegTx (so INTERNAL collateral)
+bool MNModel::createDMNInternalCollateral(
+    const QString& alias,
+    const QString& addr,
+    CTransactionRef& ret_tx,
+    COutPoint& ret_outpoint,
+    QString& ret_error,
+    int nExtraSize
+){
+    SendCoinsRecipient sendCoinsRecipient(addr, alias, getMNCollateralRequiredAmount(), "");
+
+    // Send the 10 tx to one of your address
+    QList<SendCoinsRecipient> recipients;
+    recipients.append(sendCoinsRecipient);
+    WalletModelTransaction currentTransaction(recipients);
+    WalletModel::SendCoinsReturn prepareStatus;
+    // no coincontrol, no P2CS delegations
+    prepareStatus = walletModel->prepareTransaction(&currentTransaction, nullptr, false,nExtraSize);
+    ret_tx = currentTransaction.getTransaction();
+
+    QString returnMsg = tr("Unknown error");
+    // process prepareStatus and on error generate message shown to user
+    CClientUIInterface::MessageBoxFlags informType;
+    returnMsg = GuiTransactionsUtils::ProcessSendCoinsReturn(
+            prepareStatus,
+            walletModel,
+            informType, // this flag is not needed
+            BitcoinUnits::formatWithUnit(walletModel->getOptionsModel()->getDisplayUnit(),
+                                         currentTransaction.getTransactionFee()),
+            true
+    );
+
+    if (prepareStatus.status != WalletModel::OK) {
+        ret_error = tr("Prepare master node failed.\n\n%1\n").arg(returnMsg);
+        return false;
+    }
+
+    int indexOut = -1;
+    for (int i=0; i < (int)ret_tx->vout.size(); i++) {
+        const CTxOut& out = ret_tx->vout[i];
+        if (out.nValue == getMNCollateralRequiredAmount()) {
+            indexOut = i;
+            break;
+        }
+    }
+    if (indexOut == -1) {
+        ret_error = tr("Invalid collateral output index");
+        return false;
+    }
+    // save the collateral outpoint
+    ret_outpoint = COutPoint(UINT256_ZERO, indexOut); //generalise to second case
+    return true;
+}
 
-bool MNModel::createMNCollateral(
+//This functions creates and send an EXTERNAL collateral the ProRegTx will just reference it
+bool MNModel::createDMNExternalCollateral(
         const QString& alias,
         const QString& addr,
         COutPoint& ret_outpoint,

src/qt/pivx/mnmodel.h

@@ -10,6 +10,8 @@
 #include "masternodeconfig.h"
 #include "operationresult.h"
 #include "primitives/transaction.h"
+#include "bls/key_io.h"
+#include "wallet/wallet.h" // TODO: Move to walletModel
 
 class CMasternode;
 class DMNView;
@@ -110,7 +112,8 @@ class MNModel : public QAbstractTableModel
 
     // Creates the DMN and return the hash of the proregtx
     CallResult<uint256> createDMN(const std::string& alias,
-                                  const COutPoint& collateral,
+                                  const Optional<COutPoint>& collateral,
+                                  const Optional<QString>& addr_label,
                                   std::string& serviceAddr,
                                   const std::string& servicePort,
                                   const CKeyID& ownerAddr,
@@ -124,8 +127,10 @@ class MNModel : public QAbstractTableModel
     // Completely stops the Masternode spending the collateral
     OperationResult killDMN(const uint256& collateralHash, unsigned int outIndex);
 
+
     // Generates the collateral transaction
-    bool createMNCollateral(const QString& alias, const QString& addr, COutPoint& ret_outpoint, QString& ret_error);
+    bool createDMNExternalCollateral(const QString& alias, const QString& addr, COutPoint& ret_outpoint, QString& ret_error);
+    bool createDMNInternalCollateral(const QString& alias, const QString& addr, CTransactionRef& ret_tx,COutPoint& ret_outpoint, QString& ret_error,int nExtraSize=0);
     // Creates the mnb and broadcast it to the network
     bool startLegacyMN(const CMasternodeConfig::CMasternodeEntry& mne, int chainHeight, std::string& strError);
     void startAllLegacyMNs(bool onlyMissing, int& amountOfMnFailed, int& amountOfMnStarted,
@@ -148,6 +153,17 @@ class MNModel : public QAbstractTableModel
     QMap<std::string, bool> collateralTxAccepted;
 
     const MasternodeWrapper* getMNWrapper(const QString& mnAlias);
+    CallResult<uint256> createDMNInternal(const Optional<COutPoint>& collateral,
+                                             const Optional<QString>& addr_label,
+                                             const Optional<CKey>& keyCollateral,
+                                             const CService& service,
+                                             const CKeyID& ownerAddr,
+                                             const CBLSPublicKey& operatorPubKey,
+                                             const Optional<CKeyID>& votingAddr,
+                                             const CKeyID& payoutAddr,
+                                             const Optional<CBLSSecretKey>& operatorSk,
+                                             const Optional<uint16_t>& operatorPercentage,
+                                             const Optional<CKeyID>& operatorPayoutAddr);
 };
 
 #endif // MNMODEL_H

src/qt/walletmodel.cpp

@@ -452,7 +452,7 @@ bool WalletModel::addKeys(const CKey& key, const CPubKey& pubkey, WalletRescanRe
     return true;
 }
 
-WalletModel::SendCoinsReturn WalletModel::prepareTransaction(WalletModelTransaction* transaction, const CCoinControl* coinControl, bool fIncludeDelegations)
+WalletModel::SendCoinsReturn WalletModel::prepareTransaction(WalletModelTransaction* transaction, const CCoinControl* coinControl, bool fIncludeDelegations, int nExtraSize)
 {
     CAmount total = 0;
     QList<SendCoinsRecipient> recipients = transaction->getRecipients();
@@ -540,7 +540,7 @@ WalletModel::SendCoinsReturn WalletModel::prepareTransaction(WalletModelTransact
                                                   true,
                                                   0,
                                                   fIncludeDelegations,
-                                                  &transaction->fIsStakeDelegationVoided);
+                                                  &transaction->fIsStakeDelegationVoided,nExtraSize);
         transaction->setTransactionFee(nFeeRequired);
 
         if (!fCreated) {

src/qt/walletmodel.h

@@ -214,7 +214,7 @@ class WalletModel : public QObject
     const CWalletTx* getTx(uint256 id);
 
     // prepare transaction for getting txfee before sending coins
-    SendCoinsReturn prepareTransaction(WalletModelTransaction* transaction, const CCoinControl* coinControl = NULL, bool fIncludeDelegations = true);
+    SendCoinsReturn prepareTransaction(WalletModelTransaction* transaction, const CCoinControl* coinControl = NULL, bool fIncludeDelegations = true, int nExtraSize=0);
 
     // Send coins to a list of recipients
     SendCoinsReturn sendCoins(WalletModelTransaction& transaction);