Merge pull request miketout#304 from VerusCoin/dev

0.7.2

Author: Asherda

src/core_write.cpp

@@ -536,8 +536,8 @@ UniValue CCoinbaseCurrencyState::ToUniValue() const
     {
         rowNames.push_back(EncodeDestination(CIdentityID(currencies[i])));
     }
-    std::vector<std::string> columnNames({"reservein", "nativein", "reserveout", "lastconversionprice", "fees", "conversionfees"});
-    std::vector<const std::vector<CAmount> *> data = {&reserveIn, &nativeIn, &reserveOut, &conversionPrice, &fees, &conversionFees};
+    std::vector<std::string> columnNames({"reservein", "nativein", "reserveout", "lastconversionprice", "viaconversionprice", "fees", "conversionfees"});
+    std::vector<const std::vector<CAmount> *> data = {&reserveIn, &nativeIn, &reserveOut, &conversionPrice, &viaConversionPrice, &fees, &conversionFees};
 
     ret.push_back(Pair("currencies", ValueVectorsToUniValue(rowNames, columnNames, data, true)));
     ret.push_back(Pair("nativefees", nativeFees));

src/komodo_utils.h

@@ -1435,10 +1435,10 @@ void komodo_configfile(char *symbol, uint16_t rpcport)
                     // add Verus Coin Foundation sponsored testnet nodes
                     if (PBAAS_TESTMODE)
                     {
-                        fprintf(fp,"addnode=%s\n", "168.119.27.242:18538");
-                        fprintf(fp,"addnode=%s\n", "5.9.224.250:18538");
-                        fprintf(fp,"addnode=%s\n", "95.216.104.210:18538");
-                        fprintf(fp,"addnode=%s\n", "135.181.68.2:18538");
+                        fprintf(fp,"addnode=%s\n", "168.119.27.242:17683");
+                        fprintf(fp,"addnode=%s\n", "5.9.224.250:17683");
+                        fprintf(fp,"addnode=%s\n", "95.216.104.210:17683");
+                        fprintf(fp,"addnode=%s\n", "135.181.68.2:17683");
                     }
                 }
                 else
@@ -1833,7 +1833,7 @@ void komodo_args(char *argv0)
         mapArgs["-ac_supply"] = "5000000000000000";
         mapArgs["-ac_eras"] = "1";
         mapArgs["-ac_reward"] = "2400000000";
-        std::string halving = GetArg("-ac_halving", "287474"); // this assignment is required for an ARM compiler workaround
+        std::string halving = GetArg("-ac_halving", "301111"); // this assignment is required for an ARM compiler workaround
         mapArgs["-ac_halving"] = halving;    // allow testing easily with different values here
         mapArgs["-ac_decay"] = "0";
         mapArgs["-ac_options"] = "72";       // OPTION_ID_REFERRALS + OPTION_CANBERESERVE

src/pbaas/pbaas.cpp

@@ -1039,7 +1039,8 @@ CCoinbaseCurrencyState CConnectedChains::AddPrelaunchConversions(CCurrencyDefini
     // currency state to be up to just before the start block
     std::multimap<uint160, std::pair<CInputDescriptor, CReserveTransfer>> unspentTransfers;
     std::map<uint160, int32_t> currencyIndexes = currencyState.GetReserveMap();
-    int32_t nativeIdx = -1;
+    int32_t nativeIdx = currencyIndexes.count(curDef.systemID) ? currencyIndexes[curDef.systemID] : -1;
+
     if (GetChainTransfers(unspentTransfers, curDef.GetID(), fromHeight, height < curDef.startBlock ? height : curDef.startBlock - 1))
     {
         currencyState.ClearForNextBlock();
@@ -1067,11 +1068,10 @@ CCoinbaseCurrencyState CConnectedChains::AddPrelaunchConversions(CCurrencyDefini
                 {
                     currencyState.nativeConversionFees += conversionFee;
                     currencyState.nativeFees += conversionFee;
-                    nativeIdx = curIdx;
                 }
-
                 currencyState.fees[curIdx] += conversionFee;
                 currencyState.nativeFees +=  transfer.second.second.CalculateTransferFee(transfer.second.second.destination);
+                currencyState.fees[nativeIdx] +=  transfer.second.second.CalculateTransferFee(transfer.second.second.destination);
                 currencyState.conversionFees[curIdx] += conversionFee;
             }
         }
@@ -1081,41 +1081,31 @@ CCoinbaseCurrencyState CConnectedChains::AddPrelaunchConversions(CCurrencyDefini
     {
         // convert all non-native fees to native and update the price as a result
         bool isFeeConversion = false;
-        std::vector<int64_t> reservesToConvert;
-        std::vector<int64_t> fractionalToConvert;
-        std::vector<std::vector<int64_t>> crossConversions = std::vector<std::vector<int64_t>>(curDef.currencies.size(), std::vector<int64_t>(curDef.currencies.size()));
+        int numCurrencies = curDef.currencies.size();
+        std::vector<int64_t> reservesToConvert(numCurrencies, 0);
+        std::vector<int64_t> fractionalToConvert(numCurrencies, 0);
+        CAmount newSupply =  currencyState.supply;
 
-        for (int i = 0; i < curDef.currencies.size(); i++)
+        for (int i = 0; i < numCurrencies; i++)
         {
-            currencyState.conversionPrice[i] = currencyState.PriceInReserve(i, true);
+            curDef.conversions[i] = currencyState.conversionPrice[i] = currencyState.PriceInReserve(i, true);
 
             // all currencies except the native currency of the system will be converted to the native currency
             if (currencyState.fees[i] && curDef.currencies[i] != curDef.systemID)
             {
-                reservesToConvert.push_back(currencyState.fees[i] + currencyState.reserves[i]);
-                fractionalToConvert.push_back(currencyState.ReserveToNative(currencyState.reserves[i], i));
-                if (nativeIdx != -1)
-                {
-                    crossConversions[i][nativeIdx] = currencyState.fees[i];
-                    isFeeConversion = true;
-                }
-            }
-            else
-            {
-                reservesToConvert.push_back(0);
-                fractionalToConvert.push_back(0);
+                fractionalToConvert[nativeIdx] += currencyState.ReserveToNativeRaw(currencyState.fees[i], currencyState.conversionPrice[i]);
+                newSupply += fractionalToConvert[i];
+                isFeeConversion = true;
             }
         }
+        currencyState.supply = newSupply;
 
         // convert all non-native fee currencies to native and adjust prices
         if (isFeeConversion)
         {
             CCurrencyState converterState = static_cast<CCurrencyState>(currencyState);
-            curDef.conversions = currencyState.conversionPrice = converterState.ConvertAmounts(reservesToConvert, fractionalToConvert, currencyState, &crossConversions);
-        }
-        else
-        {
-            curDef.conversions = currencyState.PricesInReserve();
+            currencyState.viaConversionPrice = 
+                converterState.ConvertAmounts(reservesToConvert, fractionalToConvert, currencyState);
         }
     }
 
@@ -1136,19 +1126,35 @@ CCoinbaseCurrencyState CConnectedChains::AddPrelaunchConversions(CCurrencyDefini
         {            
             // get a ratio and reduce all prices by that ratio
             static arith_uint256 bigSatoshi(SATOSHIDEN);
-            arith_uint256 newRatio((calculatedSupply * bigSatoshi) / currencyState.supply);
+            arith_uint256 bigMultipliedSupply(calculatedSupply * bigSatoshi);
+            arith_uint256 newRatio(bigMultipliedSupply / curDef.initialFractionalSupply);
+            // truncate up, not down, to prevent any overflow at all
+            if (newRatio * curDef.initialFractionalSupply < bigMultipliedSupply)
+            {
+                newRatio++;
+            }
             for (auto &rate : currencyState.conversionPrice)
             {
                 arith_uint256 numerator = rate * newRatio;
                 rate = (numerator / bigSatoshi).GetLow64();
-                // truncate up, not down, to prevent any overflow at all
-                if (((numerator / bigSatoshi) >> 1) > 0)
+                if ((numerator - (bigSatoshi * rate)) > 0)
                 {
                     rate++;
                 }
             }
         }
 
+        calculatedSupply = 0;
+        for (auto &transfer : unspentTransfers)
+        {
+            if (transfer.second.second.IsPreConversion())
+            {
+                CAmount toConvert = transfer.second.second.nValue - CReserveTransactionDescriptor::CalculateConversionFee(transfer.second.second.nValue);
+                calculatedSupply += CCurrencyState::ReserveToNativeRaw(toConvert, currencyState.conversionPrice[currencyIndexes[transfer.second.second.currencyID]]);
+            }
+        }
+        printf("Calculated supply %s\n", ValueFromAmount(calculatedSupply).write().c_str());
+
         // now, remove carveout percentage from each weight & reserve
         // for currency state
         int32_t preLaunchCarveOutTotal = 0;