Line data    Source code

       1             : // Copyright (c) 2017-2019 The PIVX Core developers
       2             : // Distributed under the MIT software license, see the accompanying
       3             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       4             : 
       5             : #include "Denominations.h"
       6             : #include "amount.h"
       7             : 
       8             : namespace libzerocoin {
       9             : // All denomination values should only exist in these routines for consistency.
      10             : // For serialization/unserialization enums are converted to int (denoted enumvalue in function name)
      11             : 
      12         320 : CoinDenomination IntToZerocoinDenomination(int64_t amount)
      13             : {
      14         320 :     CoinDenomination denomination;
      15         320 :     switch (amount) {
      16             :     case 1:        denomination = CoinDenomination::ZQ_ONE; break;
      17          40 :     case 5:    denomination = CoinDenomination::ZQ_FIVE; break;
      18          40 :     case 10:    denomination = CoinDenomination::ZQ_TEN; break;
      19          40 :     case 50:    denomination = CoinDenomination::ZQ_FIFTY; break;
      20          40 :     case 100: denomination = CoinDenomination::ZQ_ONE_HUNDRED; break;
      21          40 :     case 500: denomination = CoinDenomination::ZQ_FIVE_HUNDRED; break;
      22          40 :     case 1000: denomination = CoinDenomination::ZQ_ONE_THOUSAND; break;
      23          40 :     case 5000: denomination = CoinDenomination::ZQ_FIVE_THOUSAND; break;
      24           0 :     default:
      25             :         //not a valid denomination
      26           0 :         denomination = CoinDenomination::ZQ_ERROR; break;
      27             :     }
      28             : 
      29         320 :     return denomination;
      30             : }
      31             : 
      32         699 : int64_t ZerocoinDenominationToInt(const CoinDenomination& denomination)
      33             : {
      34         699 :     int64_t Value = 0;
      35         699 :     switch (denomination) {
      36             :     case CoinDenomination::ZQ_ONE: Value = 1; break;
      37          40 :     case CoinDenomination::ZQ_FIVE: Value = 5; break;
      38          40 :     case CoinDenomination::ZQ_TEN: Value = 10; break;
      39          40 :     case CoinDenomination::ZQ_FIFTY : Value = 50; break;
      40          40 :     case CoinDenomination::ZQ_ONE_HUNDRED: Value = 100; break;
      41          40 :     case CoinDenomination::ZQ_FIVE_HUNDRED: Value = 500; break;
      42          40 :     case CoinDenomination::ZQ_ONE_THOUSAND: Value = 1000; break;
      43          40 :     case CoinDenomination::ZQ_FIVE_THOUSAND: Value = 5000; break;
      44         379 :     default:
      45             :         // Error Case
      46         379 :         Value = 0; break;
      47             :     }
      48         699 :     return Value;
      49             : }
      50             : 
      51           0 : CoinDenomination AmountToZerocoinDenomination(CAmount amount)
      52             : {
      53             :     // Check to make sure amount is an exact integer number of COINS
      54           0 :     CAmount residual_amount = amount - COIN * (amount / COIN);
      55           0 :     if (residual_amount == 0) {
      56           0 :         return IntToZerocoinDenomination(amount/COIN);
      57             :     } else {
      58             :         return CoinDenomination::ZQ_ERROR;
      59             :     }
      60             : }
      61             : 
      62             : // return the highest denomination that is less than or equal to the amount given
      63             : // use case: converting PIV to zPIV without user worrying about denomination math themselves
      64           0 : CoinDenomination AmountToClosestDenomination(CAmount nAmount, CAmount& nRemaining)
      65             : {
      66           0 :     if (nAmount < 1 * COIN)
      67             :         return ZQ_ERROR;
      68             : 
      69           0 :     CAmount nConvert = nAmount / COIN;
      70           0 :     CoinDenomination denomination = ZQ_ERROR;
      71           0 :     for (unsigned int i = 0; i < zerocoinDenomList.size(); i++) {
      72           0 :         denomination = zerocoinDenomList[i];
      73             : 
      74             :         //exact match
      75           0 :         if (nConvert == denomination) {
      76           0 :             nRemaining = 0;
      77           0 :             return denomination;
      78             :         }
      79             : 
      80             :         //we are beyond the value, use previous denomination
      81           0 :         if (denomination > nConvert && i) {
      82           0 :             CoinDenomination d = zerocoinDenomList[i - 1];
      83           0 :             nRemaining = nConvert - d;
      84           0 :             return d;
      85             :         }
      86             :     }
      87             :     //last denomination, the highest value possible
      88           0 :     nRemaining = nConvert - denomination;
      89           0 :     return denomination;
      90             : }
      91             : 
      92           0 : CAmount ZerocoinDenominationToAmount(const CoinDenomination& denomination)
      93             : {
      94           0 :     CAmount nValue = COIN * ZerocoinDenominationToInt(denomination);
      95           0 :     return nValue;
      96             : }
      97             : 
      98             : 
      99           0 : CoinDenomination get_denomination(std::string denomAmount) {
     100           0 :     int64_t val = std::stoi(denomAmount);
     101           0 :     return IntToZerocoinDenomination(val);
     102             : }
     103             : 
     104             : 
     105           0 : int64_t get_amount(std::string denomAmount) {
     106           0 :     int64_t nAmount = 0;
     107           0 :     CoinDenomination denom = get_denomination(denomAmount);
     108           0 :     if (denom == ZQ_ERROR) {
     109             :         // SHOULD WE THROW EXCEPTION or Something?
     110             :         nAmount = 0;
     111             :     } else {
     112           0 :         nAmount = ZerocoinDenominationToAmount(denom);
     113             :     }
     114           0 :     return nAmount;
     115             : }
     116             : 
     117             : } /* namespace libzerocoin */