Replaced uses of "uint" with "unsigned int" as the former needs additional header includes.

denavila · denavila · commit 2d53c14dda1e · 2023-05-30T09:46:25.000-07:00
diff --git a/src/interfaces/wallet.h b/src/interfaces/wallet.h
@@ -152,8 +152,8 @@ class Wallet
         WalletOrderForm order_form) = 0;
 
     virtual util::Result<CTransactionRef> createDeniabilizationTransaction(const std::set<COutPoint>& inputs,
-                                                                           uint confirm_target,
-                                                                           uint deniabilization_cycles,
+                                                                           unsigned int confirm_target,
+                                                                           unsigned int deniabilization_cycles,
                                                                            bool sign,
                                                                            bool& insufficient_amount,
                                                                            CAmount& fee) = 0;
@@ -186,7 +186,7 @@ class Wallet
 
     //! Create a fee bump transaction for a deniabilization transaction
     virtual util::Result<CTransactionRef> createBumpDeniabilizationTransaction(const uint256& txid,
-                                                                               uint confirm_target,
+                                                                               unsigned int confirm_target,
                                                                                bool sign,
                                                                                CAmount& old_fee,
                                                                                CAmount& new_fee) = 0;
@@ -263,7 +263,7 @@ class Wallet
         FeeReason* reason) = 0;
 
     //! Get the fee rate for deniabilization
-    virtual CFeeRate getDeniabilizationFeeRate(uint confirm_target) = 0;
+    virtual CFeeRate getDeniabilizationFeeRate(unsigned int confirm_target) = 0;
 
     //! Get tx confirm target.
     virtual unsigned int getConfirmTarget() = 0;
diff --git a/src/wallet/feebumper.cpp b/src/wallet/feebumper.cpp
@@ -365,7 +365,7 @@ Result CommitTransaction(CWallet& wallet, const uint256& txid, CMutableTransacti
     return Result::OK;
 }
 
-Result CreateRateBumpDeniabilizationTransaction(CWallet& wallet, const uint256& txid, uint confirm_target, bool sign, bilingual_str& error, CAmount& old_fee, CAmount& new_fee, CTransactionRef& new_tx)
+Result CreateRateBumpDeniabilizationTransaction(CWallet& wallet, const uint256& txid, unsigned int confirm_target, bool sign, bilingual_str& error, CAmount& old_fee, CAmount& new_fee, CTransactionRef& new_tx)
 {
     CCoinControl coin_control = SetupDeniabilizationCoinControl(confirm_target);
     coin_control.m_feerate = CalculateDeniabilizationFeeRate(wallet, confirm_target);
diff --git a/src/wallet/feebumper.h b/src/wallet/feebumper.h
@@ -71,7 +71,7 @@ Result CommitTransaction(CWallet& wallet,
 
 Result CreateRateBumpDeniabilizationTransaction(CWallet& wallet,
                                                 const uint256& txid,
-                                                uint confirm_target,
+                                                unsigned int confirm_target,
                                                 bool sign,
                                                 bilingual_str& error,
                                                 CAmount& old_fee,
diff --git a/src/wallet/interfaces.cpp b/src/wallet/interfaces.cpp
@@ -296,8 +296,8 @@ class WalletImpl : public Wallet
         m_wallet->CommitTransaction(std::move(tx), std::move(value_map), std::move(order_form));
     }
     util::Result<CTransactionRef> createDeniabilizationTransaction(const std::set<COutPoint>& inputs,
-                                                                   uint confirm_target,
-                                                                   uint deniabilization_cycles,
+                                                                   unsigned int confirm_target,
+                                                                   unsigned int deniabilization_cycles,
                                                                    bool sign,
                                                                    bool& insufficient_amount,
                                                                    CAmount& fee) override
@@ -341,7 +341,7 @@ class WalletImpl : public Wallet
                feebumper::Result::OK;
     }
     util::Result<CTransactionRef> createBumpDeniabilizationTransaction(const uint256& txid,
-                                                                       uint confirm_target,
+                                                                       unsigned int confirm_target,
                                                                        bool sign,
                                                                        CAmount& old_fee,
                                                                        CAmount& new_fee) override
@@ -536,7 +536,7 @@ class WalletImpl : public Wallet
         if (reason) *reason = fee_calc.reason;
         return result;
     }
-    CFeeRate getDeniabilizationFeeRate(uint confirm_target) override
+    CFeeRate getDeniabilizationFeeRate(unsigned int confirm_target) override
     {
         return CalculateDeniabilizationFeeRate(*m_wallet, confirm_target);
     }
diff --git a/src/wallet/spend.cpp b/src/wallet/spend.cpp
@@ -1251,27 +1251,27 @@ bool FundTransaction(CWallet& wallet, CMutableTransaction& tx, CAmount& nFeeRet,
 
 constexpr int NUM_DENIABILIZATION_OUTPUTS = 2;
 
-static uint CalculateDeniabilizationTxSize(const CTxDestination& address, CAmount value, uint numTxIn)
+static unsigned int CalculateDeniabilizationTxSize(const CTxDestination& address, CAmount value, unsigned int numTxIn)
 {
     // Calculation based on the comments and code in GetDustThreshold and CreateTransactionInternal
     CScript script = GetScriptForDestination(address);
-    uint txOutSize = (uint)GetSerializeSize(CTxOut(value, script), PROTOCOL_VERSION);
+    unsigned int txOutSize = (unsigned int)GetSerializeSize(CTxOut(value, script), PROTOCOL_VERSION);
 
     const size_t txOutCount = NUM_DENIABILIZATION_OUTPUTS;
-    uint txSize = 10 + GetSizeOfCompactSize(txOutCount); // bytes for output count
+    unsigned int txSize = 10 + GetSizeOfCompactSize(txOutCount); // bytes for output count
     txSize += txOutSize * txOutCount;
 
     int witnessversion = 0;
     std::vector<unsigned char> witnessprogram;
     if (script.IsWitnessProgram(witnessversion, witnessprogram)) {
-        txSize += (uint)(numTxIn * 67.75f + 0.5f);
+        txSize += (unsigned int)(numTxIn * 67.75f + 0.5f);
     } else {
         txSize += numTxIn * 148;
     }
     return txSize;
 }
 
-float CalculateDeniabilizationProbability(uint deniabilization_cycles)
+float CalculateDeniabilizationProbability(unsigned int deniabilization_cycles)
 {
     // 100%, 50%, 25%, 13%, 6%, 3%, 2%, 1%
     return powf(0.5f, deniabilization_cycles);
@@ -1283,7 +1283,7 @@ bool IsDeniabilizationWorthwhile(CAmount total_value, CAmount fee_estimate)
     return total_value > fee_estimate * value_to_fee_ratio;
 }
 
-CCoinControl SetupDeniabilizationCoinControl(uint confirm_target)
+CCoinControl SetupDeniabilizationCoinControl(unsigned int confirm_target)
 {
     CCoinControl coin_control;
     coin_control.m_avoid_address_reuse = true;
@@ -1296,7 +1296,7 @@ CCoinControl SetupDeniabilizationCoinControl(uint confirm_target)
     return coin_control;
 }
 
-CFeeRate CalculateDeniabilizationFeeRate(const CWallet& wallet, uint confirm_target)
+CFeeRate CalculateDeniabilizationFeeRate(const CWallet& wallet, unsigned int confirm_target)
 {
     CCoinControl coin_control = SetupDeniabilizationCoinControl(confirm_target);
 
@@ -1308,18 +1308,18 @@ CFeeRate CalculateDeniabilizationFeeRate(const CWallet& wallet, uint confirm_tar
     return minFeeRate;
 }
 
-static CAmount CalculateDeniabilizationTxFee(const CTxDestination& shared_destination, CAmount total_value, uint num_utxos, const CFeeRate& fee_rate)
+static CAmount CalculateDeniabilizationTxFee(const CTxDestination& shared_destination, CAmount total_value, unsigned int num_utxos, const CFeeRate& fee_rate)
 {
     Assert(num_utxos > 0);
-    uint deniabilization_tx_size = CalculateDeniabilizationTxSize(shared_destination, total_value, num_utxos);
+    unsigned int deniabilization_tx_size = CalculateDeniabilizationTxSize(shared_destination, total_value, num_utxos);
     return fee_rate.GetFee(deniabilization_tx_size);
 }
 
-CAmount CalculateDeniabilizationFeeEstimate(const CTxDestination& shared_destination, CAmount total_value, uint num_utxos, uint deniabilization_cycles, const CFeeRate& fee_rate)
+CAmount CalculateDeniabilizationFeeEstimate(const CTxDestination& shared_destination, CAmount total_value, unsigned int num_utxos, unsigned int deniabilization_cycles, const CFeeRate& fee_rate)
 {
     float deniabilizationProbability = CalculateDeniabilizationProbability(deniabilization_cycles);
     // convert to integer percent to truncate and check for zero probability
-    uint deniabilizationProbabilityPercent = deniabilizationProbability * 100;
+    unsigned int deniabilizationProbabilityPercent = deniabilizationProbability * 100;
     if (deniabilizationProbabilityPercent == 0) {
         return 0;
     }
@@ -1340,8 +1340,8 @@ CAmount CalculateDeniabilizationFeeEstimate(const CTxDestination& shared_destina
 util::Result<CreatedTransactionResult> CreateDeniabilizationTransaction(
     CWallet& wallet,
     const std::set<COutPoint>& inputs,
-    uint confirm_target,
-    uint deniabilization_cycles,
+    unsigned int confirm_target,
+    unsigned int deniabilization_cycles,
     bool sign,
     bool& insufficient_amount)
 {
diff --git a/src/wallet/spend.h b/src/wallet/spend.h
@@ -227,7 +227,7 @@ bool FundTransaction(CWallet& wallet, CMutableTransaction& tx, CAmount& nFeeRet,
 /**
  * Calculate the probability for a deniabilization transaction given the number of deniabilization cycles already performed
  */
-float CalculateDeniabilizationProbability(uint deniabilization_cycles);
+float CalculateDeniabilizationProbability(unsigned int deniabilization_cycles);
 
 /**
  * Determine if it's worth performing deniabilization given a coin amount and fee estimate (see CalculateDeniabilizationFeeEstimate)
@@ -237,24 +237,24 @@ bool IsDeniabilizationWorthwhile(CAmount total_value, CAmount fee_estimate);
 /**
  * Setup a coin control to be used in deniabilization transactions
  */
-CCoinControl SetupDeniabilizationCoinControl(uint confirm_target);
+CCoinControl SetupDeniabilizationCoinControl(unsigned int confirm_target);
 
 /**
  * Estimate the total deniabilization transaction fees for a given set of UTXOs that share an input destination
  */
-CAmount CalculateDeniabilizationFeeEstimate(const CTxDestination& shared_destination, CAmount total_value, uint num_utxos, uint deniabilization_cycles, const CFeeRate& fee_rate);
+CAmount CalculateDeniabilizationFeeEstimate(const CTxDestination& shared_destination, CAmount total_value, unsigned int num_utxos, unsigned int deniabilization_cycles, const CFeeRate& fee_rate);
 
 /**
  * Calculate the fee rate for a deniabilization transaction
  */
-CFeeRate CalculateDeniabilizationFeeRate(const CWallet& wallet, uint confirm_target);
+CFeeRate CalculateDeniabilizationFeeRate(const CWallet& wallet, unsigned int confirm_target);
 
 /**
  * Create a deniabilization transaction with the provided set of inputs (must share the same destination)
  * confirm_target is the confirmation target for the deniabilization transaction
  * deniabilization_cycles is the number of deniabilization cycles these inputs have already had
  */
-util::Result<CreatedTransactionResult> CreateDeniabilizationTransaction(CWallet& wallet, const std::set<COutPoint>& inputs, uint confirm_target, uint deniabilization_cycles, bool sign, bool& insufficient_amount);
+util::Result<CreatedTransactionResult> CreateDeniabilizationTransaction(CWallet& wallet, const std::set<COutPoint>& inputs, unsigned int confirm_target, unsigned int deniabilization_cycles, bool sign, bool& insufficient_amount);
 } // namespace wallet
 
 #endif // BITCOIN_WALLET_SPEND_H

Original file line number	Diff line number	Diff line change
`@@ -365,7 +365,7 @@ Result CommitTransaction(CWallet& wallet, const uint256& txid, CMutableTransacti`
`365`	`365`	`return Result::OK;`
`366`	`366`	`}`
`367`	`367`
`368`		`-Result CreateRateBumpDeniabilizationTransaction(CWallet& wallet, const uint256& txid, uint confirm_target, bool sign, bilingual_str& error, CAmount& old_fee, CAmount& new_fee, CTransactionRef& new_tx)`
	`368`	`+Result CreateRateBumpDeniabilizationTransaction(CWallet& wallet, const uint256& txid, unsigned int confirm_target, bool sign, bilingual_str& error, CAmount& old_fee, CAmount& new_fee, CTransactionRef& new_tx)`
`369`	`369`	`{`
`370`	`370`	`CCoinControl coin_control = SetupDeniabilizationCoinControl(confirm_target);`
`371`	`371`	`coin_control.m_feerate = CalculateDeniabilizationFeeRate(wallet, confirm_target);`
Original file line number	Diff line number	Diff line change
`@@ -296,8 +296,8 @@ class WalletImpl : public Wallet`
`296`	`296`	`m_wallet->CommitTransaction(std::move(tx), std::move(value_map), std::move(order_form));`
`297`	`297`	`}`
`298`	`298`	`util::Result<CTransactionRef> createDeniabilizationTransaction(const std::set<COutPoint>& inputs,`
`299`		`- uint confirm_target,`
`300`		`- uint deniabilization_cycles,`
	`299`	`+ unsigned int confirm_target,`
	`300`	`+ unsigned int deniabilization_cycles,`
`301`	`301`	`bool sign,`
`302`	`302`	`bool& insufficient_amount,`
`303`	`303`	`CAmount& fee) override`
`@@ -341,7 +341,7 @@ class WalletImpl : public Wallet`
`341`	`341`	`feebumper::Result::OK;`
`342`	`342`	`}`
`343`	`343`	`util::Result<CTransactionRef> createBumpDeniabilizationTransaction(const uint256& txid,`
`344`		`- uint confirm_target,`
	`344`	`+ unsigned int confirm_target,`
`345`	`345`	`bool sign,`
`346`	`346`	`CAmount& old_fee,`
`347`	`347`	`CAmount& new_fee) override`
`@@ -536,7 +536,7 @@ class WalletImpl : public Wallet`
`536`	`536`	`if (reason) *reason = fee_calc.reason;`
`537`	`537`	`return result;`
`538`	`538`	`}`
`539`		`- CFeeRate getDeniabilizationFeeRate(uint confirm_target) override`
	`539`	`+ CFeeRate getDeniabilizationFeeRate(unsigned int confirm_target) override`
`540`	`540`	`{`
`541`	`541`	`return CalculateDeniabilizationFeeRate(*m_wallet, confirm_target);`
`542`	`542`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1251,27 +1251,27 @@ bool FundTransaction(CWallet& wallet, CMutableTransaction& tx, CAmount& nFeeRet,`
`1251`	`1251`
`1252`	`1252`	`constexpr int NUM_DENIABILIZATION_OUTPUTS = 2;`
`1253`	`1253`
`1254`		`-static uint CalculateDeniabilizationTxSize(const CTxDestination& address, CAmount value, uint numTxIn)`
	`1254`	`+static unsigned int CalculateDeniabilizationTxSize(const CTxDestination& address, CAmount value, unsigned int numTxIn)`
`1255`	`1255`	`{`
`1256`	`1256`	`// Calculation based on the comments and code in GetDustThreshold and CreateTransactionInternal`
`1257`	`1257`	`CScript script = GetScriptForDestination(address);`
`1258`		`- uint txOutSize = (uint)GetSerializeSize(CTxOut(value, script), PROTOCOL_VERSION);`
	`1258`	`+ unsigned int txOutSize = (unsigned int)GetSerializeSize(CTxOut(value, script), PROTOCOL_VERSION);`
`1259`	`1259`
`1260`	`1260`	`const size_t txOutCount = NUM_DENIABILIZATION_OUTPUTS;`
`1261`		`- uint txSize = 10 + GetSizeOfCompactSize(txOutCount); // bytes for output count`
	`1261`	`+ unsigned int txSize = 10 + GetSizeOfCompactSize(txOutCount); // bytes for output count`
`1262`	`1262`	`txSize += txOutSize * txOutCount;`
`1263`	`1263`
`1264`	`1264`	`int witnessversion = 0;`
`1265`	`1265`	`std::vector<unsigned char> witnessprogram;`
`1266`	`1266`	`if (script.IsWitnessProgram(witnessversion, witnessprogram)) {`
`1267`		`- txSize += (uint)(numTxIn * 67.75f + 0.5f);`
	`1267`	`+ txSize += (unsigned int)(numTxIn * 67.75f + 0.5f);`
`1268`	`1268`	`} else {`
`1269`	`1269`	`txSize += numTxIn * 148;`
`1270`	`1270`	`}`
`1271`	`1271`	`return txSize;`
`1272`	`1272`	`}`
`1273`	`1273`
`1274`		`-float CalculateDeniabilizationProbability(uint deniabilization_cycles)`
	`1274`	`+float CalculateDeniabilizationProbability(unsigned int deniabilization_cycles)`
`1275`	`1275`	`{`
`1276`	`1276`	`// 100%, 50%, 25%, 13%, 6%, 3%, 2%, 1%`
`1277`	`1277`	`return powf(0.5f, deniabilization_cycles);`
`@@ -1283,7 +1283,7 @@ bool IsDeniabilizationWorthwhile(CAmount total_value, CAmount fee_estimate)`
`1283`	`1283`	`return total_value > fee_estimate * value_to_fee_ratio;`
`1284`	`1284`	`}`
`1285`	`1285`
`1286`		`-CCoinControl SetupDeniabilizationCoinControl(uint confirm_target)`
	`1286`	`+CCoinControl SetupDeniabilizationCoinControl(unsigned int confirm_target)`
`1287`	`1287`	`{`
`1288`	`1288`	`CCoinControl coin_control;`
`1289`	`1289`	`coin_control.m_avoid_address_reuse = true;`
`@@ -1296,7 +1296,7 @@ CCoinControl SetupDeniabilizationCoinControl(uint confirm_target)`
`1296`	`1296`	`return coin_control;`
`1297`	`1297`	`}`
`1298`	`1298`
`1299`		`-CFeeRate CalculateDeniabilizationFeeRate(const CWallet& wallet, uint confirm_target)`
	`1299`	`+CFeeRate CalculateDeniabilizationFeeRate(const CWallet& wallet, unsigned int confirm_target)`
`1300`	`1300`	`{`
`1301`	`1301`	`CCoinControl coin_control = SetupDeniabilizationCoinControl(confirm_target);`
`1302`	`1302`
`@@ -1308,18 +1308,18 @@ CFeeRate CalculateDeniabilizationFeeRate(const CWallet& wallet, uint confirm_tar`
`1308`	`1308`	`return minFeeRate;`
`1309`	`1309`	`}`
`1310`	`1310`
`1311`		`-static CAmount CalculateDeniabilizationTxFee(const CTxDestination& shared_destination, CAmount total_value, uint num_utxos, const CFeeRate& fee_rate)`
	`1311`	`+static CAmount CalculateDeniabilizationTxFee(const CTxDestination& shared_destination, CAmount total_value, unsigned int num_utxos, const CFeeRate& fee_rate)`
`1312`	`1312`	`{`
`1313`	`1313`	`Assert(num_utxos > 0);`
`1314`		`- uint deniabilization_tx_size = CalculateDeniabilizationTxSize(shared_destination, total_value, num_utxos);`
	`1314`	`+ unsigned int deniabilization_tx_size = CalculateDeniabilizationTxSize(shared_destination, total_value, num_utxos);`
`1315`	`1315`	`return fee_rate.GetFee(deniabilization_tx_size);`
`1316`	`1316`	`}`
`1317`	`1317`
`1318`		`-CAmount CalculateDeniabilizationFeeEstimate(const CTxDestination& shared_destination, CAmount total_value, uint num_utxos, uint deniabilization_cycles, const CFeeRate& fee_rate)`
	`1318`	`+CAmount CalculateDeniabilizationFeeEstimate(const CTxDestination& shared_destination, CAmount total_value, unsigned int num_utxos, unsigned int deniabilization_cycles, const CFeeRate& fee_rate)`
`1319`	`1319`	`{`
`1320`	`1320`	`float deniabilizationProbability = CalculateDeniabilizationProbability(deniabilization_cycles);`
`1321`	`1321`	`// convert to integer percent to truncate and check for zero probability`
`1322`		`- uint deniabilizationProbabilityPercent = deniabilizationProbability * 100;`
	`1322`	`+ unsigned int deniabilizationProbabilityPercent = deniabilizationProbability * 100;`
`1323`	`1323`	`if (deniabilizationProbabilityPercent == 0) {`
`1324`	`1324`	`return 0;`
`1325`	`1325`	`}`
`@@ -1340,8 +1340,8 @@ CAmount CalculateDeniabilizationFeeEstimate(const CTxDestination& shared_destina`
`1340`	`1340`	`util::Result<CreatedTransactionResult> CreateDeniabilizationTransaction(`
`1341`	`1341`	`CWallet& wallet,`
`1342`	`1342`	`const std::set<COutPoint>& inputs,`
`1343`		`- uint confirm_target,`
`1344`		`- uint deniabilization_cycles,`
	`1343`	`+ unsigned int confirm_target,`
	`1344`	`+ unsigned int deniabilization_cycles,`
`1345`	`1345`	`bool sign,`
`1346`	`1346`	`bool& insufficient_amount)`
`1347`	`1347`	`{`