src/komodo_globals.h

   1 /******************************************************************************
   2  * Copyright © 2014-2018 The SuperNET Developers.                             *
   3  *                                                                            *
   4  * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
   5  * the top-level directory of this distribution for the individual copyright  *
   6  * holder information and the developer policies on copyright and licensing.  *
   7  *                                                                            *
   8  * Unless otherwise agreed in a custom licensing agreement, no part of the    *
   9  * SuperNET software, including this file may be copied, modified, propagated *
  10  * or distributed except according to the terms contained in the LICENSE file *
  11  *                                                                            *
  12  * Removal or modification of this copyright notice is prohibited.            *
  13  *                                                                            *
  14  ******************************************************************************/
  15
  16 #include "komodo_structs.h"
  17
  18 void komodo_prefetch(FILE *fp);
  19 uint32_t komodo_heightstamp(int32_t height);
  20 void komodo_stateupdate(int32_t height,uint8_t notarypubs[][33],uint8_t numnotaries,uint8_t notaryid,uint256 txhash,uint64_t voutmask,uint8_t numvouts,uint32_t *pvals,uint8_t numpvals,int32_t kheight,uint32_t ktime,uint64_t opretvalue,uint8_t *opretbuf,uint16_t opretlen,uint16_t vout,uint256 MoM,int32_t MoMdepth);
  21 void komodo_init(int32_t height);
  22 int32_t komodo_MoMdata(int32_t *notarized_htp,uint256 *MoMp,uint256 *kmdtxidp,int32_t nHeight,uint256 *MoMoMp,int32_t *MoMoMoffsetp,int32_t *MoMoMdepthp,int32_t *kmdstartip,int32_t *kmdendip);
  23 int32_t komodo_notarizeddata(int32_t nHeight,uint256 *notarized_hashp,uint256 *notarized_desttxidp);
  24 char *komodo_issuemethod(char *userpass,char *method,char *params,uint16_t port);
  25 void komodo_init(int32_t height);
  26 int32_t komodo_chosennotary(int32_t *notaryidp,int32_t height,uint8_t *pubkey33,uint32_t timestamp);
  27 int32_t komodo_isrealtime(int32_t *kmdheightp);
  28 uint64_t komodo_paxtotal();
  29 int32_t komodo_longestchain();
  30 uint64_t komodo_maxallowed(int32_t baseid);
  31 int32_t komodo_bannedset(int32_t *indallvoutsp,uint256 *array,int32_t max);
  32
  33 pthread_mutex_t komodo_mutex;
  34
  35 #define KOMODO_ELECTION_GAP 2000    //((ASSETCHAINS_SYMBOL[0] == 0) ? 2000 : 100)
  36 #define KOMODO_ASSETCHAIN_MAXLEN 65
  37
  38 struct pax_transaction *PAX;
  39 int32_t NUM_PRICES; uint32_t *PVALS;
  40 struct knotaries_entry *Pubkeys;
  41
  42 struct komodo_state KOMODO_STATES[34];
  43
  44 #define _COINBASE_MATURITY 100
  45 int COINBASE_MATURITY = _COINBASE_MATURITY;//100;
  46
  47 int32_t KOMODO_MININGTHREADS = 0,IS_KOMODO_NOTARY,USE_EXTERNAL_PUBKEY,KOMODO_CHOSEN_ONE,ASSETCHAINS_SEED,KOMODO_ON_DEMAND,KOMODO_EXTERNAL_NOTARIES,KOMODO_PASSPORT_INITDONE,KOMODO_PAX,KOMODO_EXCHANGEWALLET,KOMODO_REWIND,KOMODO_CONNECTING = -1;
  48 int32_t KOMODO_INSYNC,KOMODO_LASTMINED,prevKOMODO_LASTMINED,KOMODO_CCACTIVATE,JUMBLR_PAUSE = 1;
  49 std::string VERUS_CHEATCATCHER, NOTARY_PUBKEY,ASSETCHAINS_NOTARIES,ASSETCHAINS_OVERRIDE_PUBKEY,DONATION_PUBKEY;
  50 uint8_t NOTARY_PUBKEY33[33],ASSETCHAINS_OVERRIDE_PUBKEY33[33],ASSETCHAINS_PUBLIC,ASSETCHAINS_PRIVATE;
  51 bool VERUS_MINTBLOCKS;
  52
  53 char ASSETCHAINS_SYMBOL[KOMODO_ASSETCHAIN_MAXLEN], ASSETCHAINS_USERPASS[4096];
  54
  55 bool PBAAS_TESTMODE;
  56 std::string PBAAS_HOST;
  57 int32_t PBAAS_PORT;
  58 std::string PBAAS_USERPASS;
  59 std::string ASSETCHAINS_RPCHOST, ASSETCHAINS_RPCCREDENTIALS;
  60
  61 uint160 ASSETCHAINS_CHAINID;
  62 uint160 VERUS_CHAINID;
  63 std::string VERUS_CHAINNAME;
  64 uint16_t ASSETCHAINS_P2PPORT,ASSETCHAINS_RPCPORT;
  65 uint32_t ASSETCHAIN_INIT,ASSETCHAINS_CC,KOMODO_STOPAT;
  66 uint32_t ASSETCHAINS_MAGIC = 2387029918;
  67 int64_t ASSETCHAINS_GENESISTXVAL = 5000000000;
  68
  69 int64_t MAX_MONEY = 200000000 * 100000000LL;
  70
  71 // consensus variables for coinbase timelock control and timelock transaction support
  72 // time locks are specified enough to enable their use initially to lock specific coinbase transactions for emission control
  73 // to be verifiable, timelocks require additional data that enables them to be validated and their ownership and
  74 // release time determined from the blockchain. to do this, every time locked output according to this
  75 // spec will use an op_return with CLTV at front and anything after |OP_RETURN|PUSH of rest|OPRETTYPE_TIMELOCK|script|
  76 #define _ASSETCHAINS_TIMELOCKOFF 0xffffffffffffffff
  77 uint64_t ASSETCHAINS_TIMELOCKGTE = _ASSETCHAINS_TIMELOCKOFF, ASSETCHAINS_TIMEUNLOCKFROM = 0, ASSETCHAINS_TIMEUNLOCKTO = 0;
  78
  79 uint32_t ASSETCHAINS_LASTERA = 1;
  80 uint64_t ASSETCHAINS_ENDSUBSIDY[ASSETCHAINS_MAX_ERAS],ASSETCHAINS_REWARD[ASSETCHAINS_MAX_ERAS],ASSETCHAINS_HALVING[ASSETCHAINS_MAX_ERAS],ASSETCHAINS_DECAY[ASSETCHAINS_MAX_ERAS];
  81 uint64_t ASSETCHAINS_ERAOPTIONS[ASSETCHAINS_MAX_ERAS];
  82
  83 #define _ASSETCHAINS_EQUIHASH 0
  84 uint32_t ASSETCHAINS_NUMALGOS = 2;
  85 uint32_t ASSETCHAINS_EQUIHASH = _ASSETCHAINS_EQUIHASH;
  86 uint32_t ASSETCHAINS_VERUSHASH = 1;
  87 const char *ASSETCHAINS_ALGORITHMS[] = {"equihash", "verushash"};
  88 uint64_t ASSETCHAINS_NONCEMASK[] = {0xffff,0xfffffff};
  89 uint32_t ASSETCHAINS_NONCESHIFT[] = {32,16};
  90 uint32_t ASSETCHAINS_HASHESPERROUND[] = {1,0x10000};
  91 uint32_t ASSETCHAINS_ALGO = _ASSETCHAINS_EQUIHASH;
  92
  93 // Verus proof of stake controls
  94 int32_t ASSETCHAINS_LWMAPOS = 0;        // percentage of blocks should be PoS
  95 int32_t VERUS_BLOCK_POSUNITS = 1024;    // one block is 1000 units
  96 int32_t VERUS_MIN_STAKEAGE = 150;       // 1/2 this should also be a cap on the POS averaging window, or startup could be too easy
  97 int32_t VERUS_CONSECUTIVE_POS_THRESHOLD = 7;
  98 int32_t VERUS_NOPOS_THRESHHOLD = 150;   // if we have no POS blocks in this many blocks, set to default difficulty
  99 int32_t PBAAS_STARTBLOCK = 0;           // the parent blockchain must be notarized at this value in block 1 for it to be accepted
 100 int32_t PBAAS_ENDBLOCK = 0;             // end of life block for the PBaaS blockchain
 101 uint64_t PBAAS_PRECONVERSION = 0;
 102 uint64_t PBAAS_MINPRECONVERT = 0;
 103 uint64_t PBAAS_MAXPRECONVERT = 0;
 104
 105
 106 int32_t ASSETCHAINS_SAPLING;
 107 int32_t ASSETCHAINS_OVERWINTER;
 108
 109 uint64_t KOMODO_INTERESTSUM,KOMODO_WALLETBALANCE;
 110 uint64_t ASSETCHAINS_COMMISSION,ASSETCHAINS_STAKED,ASSETCHAINS_SUPPLY = 10;
 111
 112 uint32_t KOMODO_INITDONE;
 113 char KMDUSERPASS[8192],BTCUSERPASS[8192]; uint16_t KMD_PORT = 7771,BITCOIND_RPCPORT = 7771;
 114 uint64_t PENDING_KOMODO_TX;
 115 extern int32_t KOMODO_LOADINGBLOCKS;
 116 unsigned int MAX_BLOCK_SIGOPS = 20000;
 117
 118 struct komodo_kv *KOMODO_KV;
 119 pthread_mutex_t KOMODO_KV_mutex,KOMODO_CC_mutex;
 120
 121 #define MAX_CURRENCIES 32
 122 char CURRENCIES[][8] = { "USD", "EUR", "JPY", "GBP", "AUD", "CAD", "CHF", "NZD", // major currencies
 123     "CNY", "RUB", "MXN", "BRL", "INR", "HKD", "TRY", "ZAR", "PLN", "NOK", "SEK", "DKK", "CZK", "HUF", "ILS", "KRW", "MYR", "PHP", "RON", "SGD", "THB", "BGN", "IDR", "HRK",
 124     "KMD" };
 125
 126 int32_t komodo_baseid(char *origbase)
 127 {
 128     int32_t i; char base[64];
 129     for (i=0; origbase[i]!=0&&i<sizeof(base); i++)
 130         base[i] = toupper((int32_t)(origbase[i] & 0xff));
 131     base[i] = 0;
 132     for (i=0; i<=MAX_CURRENCIES; i++)
 133         if ( strcmp(CURRENCIES[i],base) == 0 )
 134             return(i);
 135     //printf("illegal base.(%s) %s\n",origbase,base);
 136     return(-1);
 137 }
 138
 139 #ifndef SATOSHIDEN
 140 #define SATOSHIDEN ((uint64_t)100000000L)
 141 #endif
 142 int64_t komodo_current_supply(uint32_t nHeight)
 143 {
 144     uint64_t cur_money;
 145     int32_t baseid;
 146
 147     if ( (baseid = komodo_baseid(ASSETCHAINS_SYMBOL)) >= 0 && baseid < 32 )
 148         cur_money = ASSETCHAINS_GENESISTXVAL + ASSETCHAINS_SUPPLY + nHeight * ASSETCHAINS_REWARD[0] / SATOSHIDEN;
 149     else
 150     {
 151         // figure out max_money by adding up supply to a maximum of 10,000,000 blocks
 152         cur_money = (ASSETCHAINS_SUPPLY+1) + (ASSETCHAINS_MAGIC & 0xffffff) + ASSETCHAINS_GENESISTXVAL;
 153         if ( ASSETCHAINS_LASTERA == 0 && ASSETCHAINS_REWARD[0] == 0 )
 154         {
 155             cur_money += (nHeight * 10000) / SATOSHIDEN;
 156         }
 157         else
 158         {
 159             for ( int j = 0; j <= ASSETCHAINS_LASTERA; j++ )
 160             {
 161                 // if any condition means we have no more rewards, break
 162                 if (j != 0 && (nHeight <= ASSETCHAINS_ENDSUBSIDY[j - 1] || (ASSETCHAINS_ENDSUBSIDY[j - 1] == 0 &&
 163                     (ASSETCHAINS_REWARD[j] == 0 && (j == ASSETCHAINS_LASTERA || ASSETCHAINS_DECAY[j] != SATOSHIDEN)))))
 164                     break;
 165
 166                 // add rewards from this era, up to nHeight
 167                 int64_t reward = ASSETCHAINS_REWARD[j];
 168                 if ( reward > 0 )
 169                 {
 170                     uint64_t lastEnd = j == 0 ? 0 : ASSETCHAINS_ENDSUBSIDY[j - 1];
 171                     uint64_t curEnd = ASSETCHAINS_ENDSUBSIDY[j] == 0 ? nHeight : nHeight > ASSETCHAINS_ENDSUBSIDY[j] ? ASSETCHAINS_ENDSUBSIDY[j] : nHeight;
 172                     uint64_t period = ASSETCHAINS_HALVING[j];
 173                     if (period == 0)
 174                     {
 175                         period = curEnd - lastEnd;
 176                     }
 177                     uint32_t nSteps = (curEnd - lastEnd) / period;
 178                     uint32_t modulo = (curEnd - lastEnd) % period;
 179                     uint64_t decay = ASSETCHAINS_DECAY[j];
 180
 181                     // if exactly SATOSHIDEN, linear decay to zero or to next era, same as:
 182                     // (next_era_reward + (starting reward - next_era_reward) / 2) * num_blocks
 183                     if ( decay == SATOSHIDEN )
 184                     {
 185                         int64_t lowestSubsidy, subsidyDifference, stepDifference, stepTriangle;
 186                         int64_t denominator, modulo;
 187                         int32_t sign = 1;
 188
 189                         if ( j == ASSETCHAINS_LASTERA )
 190                         {
 191                             subsidyDifference = reward;
 192                             lowestSubsidy = 0;
 193                         }
 194                         else
 195                         {
 196                             // Ex: -ac_eras=3 -ac_reward=0,384,24 -ac_end=1440,260640,0 -ac_halving=1,1440,2103840 -ac_decay 100000000,97750000,0
 197                             subsidyDifference = reward - ASSETCHAINS_REWARD[j + 1];
 198                             if (subsidyDifference < 0)
 199                             {
 200                                 sign = -1;
 201                                 subsidyDifference *= sign;
 202                                 lowestSubsidy = reward;
 203                             }
 204                             else
 205                             {
 206                                 lowestSubsidy = ASSETCHAINS_REWARD[j + 1];
 207                             }
 208                         }
 209
 210                         // if we have not finished the current era, we need to caluclate a total as if we are at the end, with the current
 211                         // subsidy. we will calculate the total of a linear era as follows. Each item represents an area calculation:
 212                         // a) the rectangle from 0 to the lowest reward in the era * the number of blocks
 213                         // b) the rectangle of the remainder of blocks from the lowest point of the era to the highest point of the era if any remainder
 214                         // c) the minor triangle from the start of transition from the lowest point to the start of transition to the highest point
 215                         // d) one halving triangle (half area of one full step)
 216                         //
 217                         // we also need:
 218                         // e) number of steps = (n - erastart) / halving interval
 219                         //
 220                         // the total supply from era start up to height is:
 221                         // a + b + c + (d * e)
 222
 223                         // calculate amount in one step's triangular protrusion over minor triangle's hypotenuse
 224                         denominator = nSteps * period;
 225
 226                         // difference of one step vs. total
 227                         stepDifference = (period * subsidyDifference) / denominator;
 228
 229                         // area == coin holding of one step triangle, protruding from minor triangle's hypotenuse
 230                         stepTriangle = (period * stepDifference) >> 1;
 231
 232                         // sign is negative if slope is positive (start is less than end)
 233                         if (sign < 0)
 234                         {
 235                             // use steps minus one for our calculations, and add the potentially partial rectangle
 236                             // at the end
 237                             cur_money += stepTriangle * (nSteps - 1);
 238                             cur_money += stepTriangle * (nSteps - 1) * (nSteps - 1);
 239
 240                             // difference times number of steps is height of rectangle above lowest subsidy
 241                             cur_money += modulo * stepDifference * nSteps;
 242                         }
 243                         else
 244                         {
 245                             // if negative slope, the minor triangle is the full number of steps, as the highest
 246                             // level step is full. lowest subsidy is just the lowest so far
 247                             lowestSubsidy = reward - (stepDifference * nSteps);
 248
 249                             // add the step triangles, one per step
 250                             cur_money += stepTriangle * nSteps;
 251
 252                             // add the minor triangle
 253                             cur_money += stepTriangle * nSteps * nSteps;
 254                         }
 255
 256                         // add more for the base rectangle if lowest subsidy is not 0
 257                         cur_money += lowestSubsidy * (curEnd - lastEnd);
 258                     }
 259                     else
 260                     {
 261                         if (period == 0)
 262                         {
 263
 264                         }
 265                         else
 266                         {
 267                             /* code */
 268                         }
 269
 270                         for ( int k = lastEnd; k < curEnd; k += period )
 271                         {
 272                             cur_money += period * reward;
 273                             // if zero, we do straight halving
 274                             reward = decay ? (reward * decay) / SATOSHIDEN : reward >> 1;
 275                         }
 276                         cur_money += modulo * reward;
 277                     }
 278                 }
 279             }
 280         }
 281     }
 282     return((int64_t)(cur_money + (cur_money * ASSETCHAINS_COMMISSION) / SATOSHIDEN));
 283 }
 284