Rename IXLOCK to ISLOCK and InstantX to InstantSend

codablock · codablock · commit 2299ee283601 · 2019-03-07T21:15:09.000+01:00
diff --git a/src/llmq/quorums_chainlocks.cpp b/src/llmq/quorums_chainlocks.cpp
@@ -307,7 +307,7 @@ void CChainLocksHandler::TrySignChainTip()
                     }
                 }
 
-                if (txAge < WAIT_FOR_IXLOCK_TIMEOUT && !quorumInstantSendManager->IsLocked(txid)) {
+                if (txAge < WAIT_FOR_ISLOCK_TIMEOUT && !quorumInstantSendManager->IsLocked(txid)) {
                     LogPrintf("CChainLocksHandler::%s -- not signing block %s due to TX %s not being ixlocked and not old enough. age=%d\n", __func__,
                               pindexWalk->GetBlockHash().ToString(), txid.ToString(), txAge);
                     return;
@@ -396,7 +396,7 @@ bool CChainLocksHandler::IsTxSafeForMining(const uint256& txid)
         }
     }
 
-    if (txAge < WAIT_FOR_IXLOCK_TIMEOUT && !quorumInstantSendManager->IsLocked(txid)) {
+    if (txAge < WAIT_FOR_ISLOCK_TIMEOUT && !quorumInstantSendManager->IsLocked(txid)) {
         return false;
     }
     return true;
diff --git a/src/llmq/quorums_chainlocks.h b/src/llmq/quorums_chainlocks.h
@@ -47,7 +47,7 @@ class CChainLocksHandler : public CRecoveredSigsListener
     static const int64_t CLEANUP_SEEN_TIMEOUT = 24 * 60 * 60 * 1000;
 
     // how long to wait for ixlocks until we consider a block with non-ixlocked TXs to be safe to sign
-    static const int64_t WAIT_FOR_IXLOCK_TIMEOUT = 10 * 60;
+    static const int64_t WAIT_FOR_ISLOCK_TIMEOUT = 10 * 60;
 
 private:
     CScheduler* scheduler;
diff --git a/src/llmq/quorums_instantsend.cpp b/src/llmq/quorums_instantsend.cpp
diff --git a/src/llmq/quorums_instantsend.h b/src/llmq/quorums_instantsend.h
@@ -2,8 +2,8 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#ifndef DASH_QUORUMS_INSTANTX_H
-#define DASH_QUORUMS_INSTANTX_H
+#ifndef DASH_QUORUMS_INSTANTSEND_H
+#define DASH_QUORUMS_INSTANTSEND_H
 
 #include "quorums_signing.h"
 
@@ -18,7 +18,7 @@ class CScheduler;
 namespace llmq
 {
 
-class CInstantXLock
+class CInstantSendLock
 {
 public:
     std::vector<COutPoint> inputs;
@@ -39,14 +39,14 @@ class CInstantXLock
     uint256 GetRequestId() const;
 };
 
-class CInstantXLockInfo
+class CInstantSendLockInfo
 {
 public:
-    // might be nullptr when ixlock is received before the TX itself
+    // might be nullptr when islock is received before the TX itself
     CTransactionRef tx;
-    CInstantXLock ixlock;
+    CInstantSendLock islock;
     // only valid when recovered sig was received
-    uint256 ixlockHash;
+    uint256 islockHash;
     // time when it was created/received
     int64_t time;
 
@@ -68,27 +68,27 @@ class CInstantSendManager : public CRecoveredSigsListener
     std::unordered_map<uint256, uint256, StaticSaltedHasher> inputVotes;
 
     /**
-     * These are the ixlocks that are currently in the middle of being created. Entries are created when we observed
-     * recovered signatures for all inputs of a TX. At the same time, we initiate signing of our sigshare for the ixlock.
-     * When the recovered sig for the ixlock later arrives, we can finish the ixlock and propagate it.
+     * These are the islocks that are currently in the middle of being created. Entries are created when we observed
+     * recovered signatures for all inputs of a TX. At the same time, we initiate signing of our sigshare for the islock.
+     * When the recovered sig for the islock later arrives, we can finish the islock and propagate it.
      */
-    std::unordered_map<uint256, CInstantXLockInfo, StaticSaltedHasher> creatingInstantXLocks;
-    // maps from txid to the in-progress ixlock
-    std::unordered_map<uint256, CInstantXLockInfo*, StaticSaltedHasher> txToCreatingInstantXLocks;
+    std::unordered_map<uint256, CInstantSendLockInfo, StaticSaltedHasher> creatingInstantSendLocks;
+    // maps from txid to the in-progress islock
+    std::unordered_map<uint256, CInstantSendLockInfo*, StaticSaltedHasher> txToCreatingInstantSendLocks;
 
     /**
-     * These are the final ixlocks, indexed by their own hash. The other maps are used to get from TXs, inputs and blocks
-     * to ixlocks.
+     * These are the final islocks, indexed by their own hash. The other maps are used to get from TXs, inputs and blocks
+     * to islocks.
      */
-    std::unordered_map<uint256, CInstantXLockInfo, StaticSaltedHasher> finalInstantXLocks;
-    std::unordered_map<uint256, CInstantXLockInfo*, StaticSaltedHasher> txToInstantXLock;
-    std::unordered_map<COutPoint, CInstantXLockInfo*, SaltedOutpointHasher> inputToInstantXLock;
-    std::unordered_multimap<uint256, CInstantXLockInfo*, StaticSaltedHasher> blockToInstantXLocks;
+    std::unordered_map<uint256, CInstantSendLockInfo, StaticSaltedHasher> finalInstantSendLocks;
+    std::unordered_map<uint256, CInstantSendLockInfo*, StaticSaltedHasher> txToInstantSendLock;
+    std::unordered_map<COutPoint, CInstantSendLockInfo*, SaltedOutpointHasher> inputToInstantSendLock;
+    std::unordered_multimap<uint256, CInstantSendLockInfo*, StaticSaltedHasher> blockToInstantSendLocks;
 
     const CBlockIndex* pindexLastChainLock{nullptr};
 
     // Incoming and not verified yet
-    std::unordered_map<uint256, std::pair<NodeId, CInstantXLock>> pendingInstantXLocks;
+    std::unordered_map<uint256, std::pair<NodeId, CInstantSendLock>> pendingInstantSendLocks;
     bool hasScheduledProcessPending{false};
 
 public:
@@ -108,27 +108,27 @@ class CInstantSendManager : public CRecoveredSigsListener
 
     virtual void HandleNewRecoveredSig(const CRecoveredSig& recoveredSig);
     void HandleNewInputLockRecoveredSig(const CRecoveredSig& recoveredSig, const uint256& txid);
-    void HandleNewInstantXLockRecoveredSig(const CRecoveredSig& recoveredSig);
+    void HandleNewInstantSendLockRecoveredSig(const CRecoveredSig& recoveredSig);
 
-    void TrySignInstantXLock(const CTransaction& tx);
+    void TrySignInstantSendLock(const CTransaction& tx);
 
     void ProcessMessage(CNode* pfrom, const std::string& strCommand, CDataStream& vRecv, CConnman& connman);
-    void ProcessMessageInstantXLock(CNode* pfrom, const CInstantXLock& ixlock, CConnman& connman);
-    bool PreVerifyInstantXLock(NodeId nodeId, const CInstantXLock& ixlock, bool& retBan);
-    void ProcessPendingInstantXLocks();
-    void ProcessInstantXLock(NodeId from, const uint256& hash, const CInstantXLock& ixlock);
+    void ProcessMessageInstantSendLock(CNode* pfrom, const CInstantSendLock& islock, CConnman& connman);
+    bool PreVerifyInstantSendLock(NodeId nodeId, const CInstantSendLock& islock, bool& retBan);
+    void ProcessPendingInstantSendLocks();
+    void ProcessInstantSendLock(NodeId from, const uint256& hash, const CInstantSendLock& islock);
     void UpdateWalletTransaction(const uint256& txid);
 
     void SyncTransaction(const CTransaction &tx, const CBlockIndex *pindex, int posInBlock);
     void NotifyChainLock(const CBlockIndex* pindex);
-    void UpdateIxLockMinedBlock(CInstantXLockInfo* ixlockInfo, const CBlockIndex* pindex);
-    void RemoveFinalIxLock(const uint256& hash);
+    void UpdateISLockMinedBlock(CInstantSendLockInfo* islockInfo, const CBlockIndex* pindex);
+    void RemoveFinalISLock(const uint256& hash);
 
-    void RemoveMempoolConflictsForLock(const uint256& hash, const CInstantXLock& ixlock);
+    void RemoveMempoolConflictsForLock(const uint256& hash, const CInstantSendLock& islock);
     void RetryLockMempoolTxs(const uint256& lockedParentTx);
 
     bool AlreadyHave(const CInv& inv);
-    bool GetInstantXLockByHash(const uint256& hash, CInstantXLock& ret);
+    bool GetInstantSendLockByHash(const uint256& hash, CInstantSendLock& ret);
 };
 
 extern CInstantSendManager* quorumInstantSendManager;
@@ -144,4 +144,4 @@ bool IsInstantSendEnabled();
 
 }
 
-#endif//DASH_QUORUMS_INSTANTX_H
+#endif//DASH_QUORUMS_INSTANTSEND_H
diff --git a/src/llmq/quorums_signing.cpp b/src/llmq/quorums_signing.cpp
@@ -543,7 +543,7 @@ void CSigningManager::ProcessRecoveredSig(NodeId nodeId, const CRecoveredSig& re
                 } else {
                     // Looks like we're trying to process a recSig that is already known. This might happen if the same
                     // recSig comes in through regular QRECSIG messages and at the same time through some other message
-                    // which allowed to reconstruct a recSig (e.g. IXLOCK). In this case, just bail out.
+                    // which allowed to reconstruct a recSig (e.g. ISLOCK). In this case, just bail out.
                 }
                 return;
             } else {
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
@@ -977,7 +977,7 @@ bool static AlreadyHave(const CInv& inv) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
         return llmq::quorumSigningManager->AlreadyHave(inv);
     case MSG_CLSIG:
         return llmq::chainLocksHandler->AlreadyHave(inv);
-    case MSG_IXLOCK:
+    case MSG_ISLOCK:
         return llmq::quorumInstantSendManager->AlreadyHave(inv);
     }
 
@@ -1299,10 +1299,10 @@ void static ProcessGetData(CNode* pfrom, const Consensus::Params& consensusParam
                     }
                 }
 
-                if (!push && (inv.type == MSG_IXLOCK)) {
-                    llmq::CInstantXLock o;
-                    if (llmq::quorumInstantSendManager->GetInstantXLockByHash(inv.hash, o)) {
-                        connman.PushMessage(pfrom, msgMaker.Make(NetMsgType::IXLOCK, o));
+                if (!push && (inv.type == MSG_ISLOCK)) {
+                    llmq::CInstantSendLock o;
+                    if (llmq::quorumInstantSendManager->GetInstantSendLockByHash(inv.hash, o)) {
+                        connman.PushMessage(pfrom, msgMaker.Make(NetMsgType::ISLOCK, o));
                         push = true;
                     }
                 }
@@ -1788,7 +1788,7 @@ bool static ProcessMessage(CNode* pfrom, const std::string& strCommand, CDataStr
                             case MSG_CLSIG:
                                 doubleRequestDelay = 5 * 1000000;
                                 break;
-                            case MSG_IXLOCK:
+                            case MSG_ISLOCK:
                                 doubleRequestDelay = 5 * 1000000;
                                 break;
                         }
diff --git a/src/protocol.cpp b/src/protocol.cpp
@@ -71,7 +71,7 @@ const char *QGETSIGSHARES="qgetsigs";
 const char *QBSIGSHARES="qbsigs";
 const char *QSIGREC="qsigrec";
 const char *CLSIG="clsig";
-const char *IXLOCK="ixlock";
+const char *ISLOCK="islock";
 };
 
 static const char* ppszTypeName[] =
@@ -108,7 +108,7 @@ static const char* ppszTypeName[] =
     NetMsgType::QDEBUGSTATUS,
     NetMsgType::QSIGREC,
     NetMsgType::CLSIG,
-    NetMsgType::IXLOCK,
+    NetMsgType::ISLOCK,
 };
 
 /** All known message types. Keep this in the same order as the list of
@@ -174,7 +174,7 @@ const static std::string allNetMessageTypes[] = {
     NetMsgType::QBSIGSHARES,
     NetMsgType::QSIGREC,
     NetMsgType::CLSIG,
-    NetMsgType::IXLOCK,
+    NetMsgType::ISLOCK,
 };
 const static std::vector<std::string> allNetMessageTypesVec(allNetMessageTypes, allNetMessageTypes+ARRAYLEN(allNetMessageTypes));
 
diff --git a/src/protocol.h b/src/protocol.h
@@ -277,7 +277,7 @@ extern const char *QGETSIGSHARES;
 extern const char *QBSIGSHARES;
 extern const char *QSIGREC;
 extern const char *CLSIG;
-extern const char *IXLOCK;
+extern const char *ISLOCK;
 };
 
 /* Get a vector of all valid message types (see above) */
@@ -380,7 +380,7 @@ enum GetDataMsg {
     MSG_QUORUM_DEBUG_STATUS = 27,
     MSG_QUORUM_RECOVERED_SIG = 28,
     MSG_CLSIG = 29,
-    MSG_IXLOCK = 30,
+    MSG_ISLOCK = 30,
 };
 
 /** inv message data */
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
@@ -3346,7 +3346,7 @@ bool CWallet::CreateTransaction(const std::vector<CRecipient>& vecSend, CWalletT
                                 int& nChangePosInOut, std::string& strFailReason, const CCoinControl* coinControl, bool sign, AvailableCoinsType nCoinType, bool fUseInstantSend, int nExtraPayloadSize)
 {
     if (!llmq::IsOldInstantSendEnabled()) {
-        // The new system does not require special handling for InstantSend as this is all done in CInstantXManager.
+        // The new system does not require special handling for InstantSend as this is all done in CInstantSendManager.
         // There is also no need for an extra fee anymore.
         fUseInstantSend = false;
     }

Original file line number	Diff line number	Diff line change
`@@ -307,7 +307,7 @@ void CChainLocksHandler::TrySignChainTip()`
`307`	`307`	`}`
`308`	`308`	`}`
`309`	`309`
`310`		`- if (txAge < WAIT_FOR_IXLOCK_TIMEOUT && !quorumInstantSendManager->IsLocked(txid)) {`
	`310`	`+ if (txAge < WAIT_FOR_ISLOCK_TIMEOUT && !quorumInstantSendManager->IsLocked(txid)) {`
`311`	`311`	`LogPrintf("CChainLocksHandler::%s -- not signing block %s due to TX %s not being ixlocked and not old enough. age=%d\n", __func__,`
`312`	`312`	`pindexWalk->GetBlockHash().ToString(), txid.ToString(), txAge);`
`313`	`313`	`return;`
`@@ -396,7 +396,7 @@ bool CChainLocksHandler::IsTxSafeForMining(const uint256& txid)`
`396`	`396`	`}`
`397`	`397`	`}`
`398`	`398`
`399`		`- if (txAge < WAIT_FOR_IXLOCK_TIMEOUT && !quorumInstantSendManager->IsLocked(txid)) {`
	`399`	`+ if (txAge < WAIT_FOR_ISLOCK_TIMEOUT && !quorumInstantSendManager->IsLocked(txid)) {`
`400`	`400`	`return false;`
`401`	`401`	`}`
`402`	`402`	`return true;`
Original file line number	Diff line number	Diff line change
`@@ -543,7 +543,7 @@ void CSigningManager::ProcessRecoveredSig(NodeId nodeId, const CRecoveredSig& re`
`543`	`543`	`} else {`
`544`	`544`	`// Looks like we're trying to process a recSig that is already known. This might happen if the same`
`545`	`545`	`// recSig comes in through regular QRECSIG messages and at the same time through some other message`
`546`		`- // which allowed to reconstruct a recSig (e.g. IXLOCK). In this case, just bail out.`
	`546`	`+ // which allowed to reconstruct a recSig (e.g. ISLOCK). In this case, just bail out.`
`547`	`547`	`}`
`548`	`548`	`return;`
`549`	`549`	`} else {`
Original file line number	Diff line number	Diff line change
`@@ -977,7 +977,7 @@ bool static AlreadyHave(const CInv& inv) EXCLUSIVE_LOCKS_REQUIRED(cs_main)`
`977`	`977`	`return llmq::quorumSigningManager->AlreadyHave(inv);`
`978`	`978`	`case MSG_CLSIG:`
`979`	`979`	`return llmq::chainLocksHandler->AlreadyHave(inv);`
`980`		`- case MSG_IXLOCK:`
	`980`	`+ case MSG_ISLOCK:`
`981`	`981`	`return llmq::quorumInstantSendManager->AlreadyHave(inv);`
`982`	`982`	`}`
`983`	`983`
`@@ -1299,10 +1299,10 @@ void static ProcessGetData(CNode* pfrom, const Consensus::Params& consensusParam`
`1299`	`1299`	`}`
`1300`	`1300`	`}`
`1301`	`1301`
`1302`		`- if (!push && (inv.type == MSG_IXLOCK)) {`
`1303`		`- llmq::CInstantXLock o;`
`1304`		`- if (llmq::quorumInstantSendManager->GetInstantXLockByHash(inv.hash, o)) {`
`1305`		`- connman.PushMessage(pfrom, msgMaker.Make(NetMsgType::IXLOCK, o));`
	`1302`	`+ if (!push && (inv.type == MSG_ISLOCK)) {`
	`1303`	`+ llmq::CInstantSendLock o;`
	`1304`	`+ if (llmq::quorumInstantSendManager->GetInstantSendLockByHash(inv.hash, o)) {`
	`1305`	`+ connman.PushMessage(pfrom, msgMaker.Make(NetMsgType::ISLOCK, o));`
`1306`	`1306`	`push = true;`
`1307`	`1307`	`}`
`1308`	`1308`	`}`
`@@ -1788,7 +1788,7 @@ bool static ProcessMessage(CNode* pfrom, const std::string& strCommand, CDataStr`
`1788`	`1788`	`case MSG_CLSIG:`
`1789`	`1789`	`doubleRequestDelay = 5 * 1000000;`
`1790`	`1790`	`break;`
`1791`		`- case MSG_IXLOCK:`
	`1791`	`+ case MSG_ISLOCK:`
`1792`	`1792`	`doubleRequestDelay = 5 * 1000000;`
`1793`	`1793`	`break;`
`1794`	`1794`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3346,7 +3346,7 @@ bool CWallet::CreateTransaction(const std::vector<CRecipient>& vecSend, CWalletT`
`3346`	`3346`	`int& nChangePosInOut, std::string& strFailReason, const CCoinControl* coinControl, bool sign, AvailableCoinsType nCoinType, bool fUseInstantSend, int nExtraPayloadSize)`
`3347`	`3347`	`{`
`3348`	`3348`	`if (!llmq::IsOldInstantSendEnabled()) {`
`3349`		`- // The new system does not require special handling for InstantSend as this is all done in CInstantXManager.`
	`3349`	`+ // The new system does not require special handling for InstantSend as this is all done in CInstantSendManager.`
`3350`	`3350`	`// There is also no need for an extra fee anymore.`
`3351`	`3351`	`fUseInstantSend = false;`
`3352`	`3352`	`}`