Merge pull request #503 from jl777/dPoW

DPoW
2017-12-08 02:07:27 +04:00
parent 0f8433ce45 96fbdd07e3
commit 65cddb38a9
34 changed files with 571 additions and 65 deletions
--- a/src/assetchains
+++ b/src/assetchains
@@ -36,6 +36,7 @@ komodo_asset BET 999999
 komodo_asset CRYPTO 999999
 komodo_asset HODL 9999999
 komodo_asset SHARK 1401
+komodo_asset MSHARK 1400000
 komodo_asset BOTS 999999
 komodo_asset MGW 999999
 #komodo_asset MVP 1000000
--- a/src/assetchains.old
+++ b/src/assetchains.old
@@ -13,6 +13,7 @@ echo $pubkey
 ./komodod -pubkey=$pubkey -ac_name=CRYPTO -ac_supply=999999 -addnode=78.47.196.146 $1 &
 ./komodod -pubkey=$pubkey -ac_name=HODL -ac_supply=9999999 -addnode=78.47.196.146 $1 &
 ./komodod -pubkey=$pubkey -ac_name=SHARK -ac_supply=1401 -addnode=78.47.196.146 $1 &
+./komodod -pubkey=$pubkey -ac_name=MSHARK -ac_supply=1400000 -addnode=78.47.196.146 $1 &
 ./komodod -pubkey=$pubkey -ac_name=BOTS -ac_supply=999999 -addnode=78.47.196.146 $1 &
 ./komodod -pubkey=$pubkey -ac_name=MGW -ac_supply=999999 -addnode=78.47.196.146 $1 &
 #./komodod -pubkey=$pubkey -ac_name=MVP -ac_supply=1000000 -addnode=78.47.196.146 $1 &
--- a/src/bitcoind.cpp
+++ b/src/bitcoind.cpp
@@ -42,7 +42,8 @@
 */

 static bool fDaemon;
-extern char ASSETCHAINS_SYMBOL[16];
+#define KOMODO_ASSETCHAIN_MAXLEN 65
+extern char ASSETCHAINS_SYMBOL[KOMODO_ASSETCHAIN_MAXLEN];
 void komodo_passport_iteration();

 void WaitForShutdown(boost::thread_group* threadGroup)
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -30,7 +30,9 @@ using namespace std;
 * + Contains no strange transactions
 */
 void *chainparams_commandline(void *ptr);
-extern char ASSETCHAINS_SYMBOL[16];
+#include "komodo_defs.h"
+
+extern char ASSETCHAINS_SYMBOL[KOMODO_ASSETCHAIN_MAXLEN];
 extern uint16_t ASSETCHAINS_PORT;
 extern uint32_t ASSETCHAIN_INIT;
 extern uint32_t ASSETCHAINS_MAGIC;
--- a/src/coins.cpp
+++ b/src/coins.cpp
@@ -8,6 +8,7 @@
 #include "random.h"
 #include "version.h"
 #include "policy/fees.h"
+#include "komodo_defs.h"

 #include <assert.h>

@@ -387,7 +388,7 @@ const CScript &CCoinsViewCache::GetSpendFor(const CTxIn& input) const

 //uint64_t komodo_interest(int32_t txheight,uint64_t nValue,uint32_t nLockTime,uint32_t tiptime);
 uint64_t komodo_accrued_interest(int32_t *txheightp,uint32_t *locktimep,uint256 hash,int32_t n,int32_t checkheight,uint64_t checkvalue);
-extern char ASSETCHAINS_SYMBOL[16];
+extern char ASSETCHAINS_SYMBOL[KOMODO_ASSETCHAIN_MAXLEN];

 CAmount CCoinsViewCache::GetValueIn(int32_t nHeight,int64_t *interestp,const CTransaction& tx,uint32_t tiptime) const
 {
--- a/src/dpowassets
+++ b/src/dpowassets
@@ -14,6 +14,7 @@ curl --url "http://127.0.0.1:7776" --data "{\"agent\":\"iguana\",\"method\":\"dp
 curl --url "http://127.0.0.1:7776" --data "{\"agent\":\"iguana\",\"method\":\"dpow\",\"symbol\":\"CRYPTO\",\"pubkey\":\"$pubkey\"}"
 curl --url "http://127.0.0.1:7776" --data "{\"agent\":\"iguana\",\"method\":\"dpow\",\"symbol\":\"HODL\",\"pubkey\":\"$pubkey\"}"
 curl --url "http://127.0.0.1:7776" --data "{\"agent\":\"iguana\",\"method\":\"dpow\",\"symbol\":\"SHARK\",\"pubkey\":\"$pubkey\"}"
+curl --url "http://127.0.0.1:7776" --data "{\"agent\":\"iguana\",\"method\":\"dpow\",\"symbol\":\"MSHARK\",\"pubkey\":\"$pubkey\"}"
 curl --url "http://127.0.0.1:7776" --data "{\"agent\":\"iguana\",\"method\":\"dpow\",\"symbol\":\"BOTS\",\"pubkey\":\"$pubkey\"}"
 curl --url "http://127.0.0.1:7776" --data "{\"agent\":\"iguana\",\"method\":\"dpow\",\"symbol\":\"MGW\",\"pubkey\":\"$pubkey\"}"
 #curl --url "http://127.0.0.1:7776" --data "{\"agent\":\"iguana\",\"method\":\"dpow\",\"symbol\":\"MVP\",\"pubkey\":\"$pubkey\"}"
@@ -23,6 +24,7 @@ curl --url "http://127.0.0.1:7776" --data "{\"agent\":\"iguana\",\"method\":\"dp
 curl --url "http://127.0.0.1:7776" --data "{\"agent\":\"iguana\",\"method\":\"dpow\",\"symbol\":\"CEAL\",\"pubkey\":\"$pubkey\"}"
 curl --url "http://127.0.0.1:7776" --data "{\"agent\":\"iguana\",\"method\":\"dpow\",\"symbol\":\"MESH\",\"pubkey\":\"$pubkey\"}"
 curl --url "http://127.0.0.1:7776" --data "{\"agent\":\"iguana\",\"method\":\"dpow\",\"symbol\":\"MNZ\",\"pubkey\":\"$pubkey\"}"
+curl --url "http://127.0.0.1:7776" --data "{\"agent\":\"iguana\",\"method\":\"dpow\",\"symbol\":\"CHIPS\",\"pubkey\":\"$pubkey\"}"


 #curl --url "http://127.0.0.1:7776" --data "{\"agent\":\"iguana\",\"method\":\"dpow\",\"symbol\":\"USD\",\"pubkey\":\"$pubkey\"}"
--- a/src/fiat-cli
+++ b/src/fiat-cli
@@ -41,6 +41,7 @@ echo bet; fiat/bet $1 $2 $3 $4
 echo crypto; fiat/crypto $1 $2 $3 $4
 echo hodl; fiat/hodl $1 $2 $3 $4
 echo shark; fiat/shark $1 $2 $3 $4
+echo mshark; fiat/mshark $1 $2 $3 $4
 echo bots; fiat/bots $1 $2 $3 $4
 echo mgw; fiat/mgw $1 $2 $3 $4
 #echo mvp; fiat/mvp $1 $2 $3 $4
--- a/src/fiat/mshark
+++ b/src/fiat/mshark
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=MSHARK $1 $2 $3 $4 $5 $6
--- a/src/komodo-tx.cpp
+++ b/src/komodo-tx.cpp
@@ -27,6 +27,7 @@ using namespace std;
 #include "arith_uint256.h"
 #include "komodo_structs.h"
 #include "komodo_globals.h"
+#include "komodo_defs.h"

 #include "komodo_interest.h"

--- a/src/komodo.h
+++ b/src/komodo.h
@@ -15,6 +15,7 @@

 #ifndef H_KOMODO_H
 #define H_KOMODO_H
+#include "komodo_defs.h"

 #ifdef _WIN32
 #define printf(...)
@@ -56,14 +57,14 @@ int32_t komodo_parsestatefile(struct komodo_state *sp,FILE *fp,char *symbol,char

 void komodo_currentheight_set(int32_t height)
 {
-    char symbol[16],dest[16]; struct komodo_state *sp;
+    char symbol[KOMODO_ASSETCHAIN_MAXLEN],dest[KOMODO_ASSETCHAIN_MAXLEN]; struct komodo_state *sp;
    if ( (sp= komodo_stateptr(symbol,dest)) != 0 )
        sp->CURRENT_HEIGHT = height;
 }

 int32_t komodo_currentheight()
 {
-    char symbol[16],dest[16]; struct komodo_state *sp;
+    char symbol[KOMODO_ASSETCHAIN_MAXLEN],dest[KOMODO_ASSETCHAIN_MAXLEN]; struct komodo_state *sp;
    if ( (sp= komodo_stateptr(symbol,dest)) != 0 )
        return(sp->CURRENT_HEIGHT);
    else return(0);
@@ -192,11 +193,143 @@ int32_t komodo_parsestatefile(struct komodo_state *sp,FILE *fp,char *symbol,char
        return(func);
    } else return(-1);
 }
-                    
+
+int32_t memread(void *dest,int32_t size,uint8_t *filedata,long *fposp,long datalen)
+{
+    if ( *fposp+size <= datalen )
+    {
+        memcpy(dest,&filedata[*fposp],size);
+        (*fposp) += size;
+        return(size);
+    }
+    return(-1);
+}
+
+int32_t komodo_parsestatefiledata(struct komodo_state *sp,uint8_t *filedata,long *fposp,long datalen,char *symbol,char *dest)
+{
+    static int32_t errs;
+    int32_t func= -1,ht,notarized_height,num,matched=0; uint256 notarized_hash,notarized_desttxid; uint8_t pubkeys[64][33]; long fpos = *fposp;
+    if ( fpos < datalen )
+    {
+        func = filedata[fpos++];
+        if ( ASSETCHAINS_SYMBOL[0] == 0 && strcmp(symbol,"KMD") == 0 )
+            matched = 1;
+        else matched = (strcmp(symbol,ASSETCHAINS_SYMBOL) == 0);
+        if ( memread(&ht,sizeof(ht),filedata,&fpos,datalen) != sizeof(ht) )
+            errs++;
+        if ( func == 'P' )
+        {
+            if ( (num= filedata[fpos++]) <= 64 )
+            {
+                if ( memread(pubkeys,33*num,filedata,&fpos,datalen) != 33*num )
+                    errs++;
+                else
+                {
+                    //printf("updated %d pubkeys at %s ht.%d\n",num,symbol,ht);
+                    if ( (KOMODO_EXTERNAL_NOTARIES != 0 && matched != 0) || (strcmp(symbol,"KMD") == 0 && KOMODO_EXTERNAL_NOTARIES == 0) )
+                        komodo_eventadd_pubkeys(sp,symbol,ht,num,pubkeys);
+                }
+            } else printf("illegal num.%d\n",num);
+        }
+        else if ( func == 'N' )
+        {
+            if ( memread(&notarized_height,sizeof(notarized_height),filedata,&fpos,datalen) != sizeof(notarized_height) )
+                errs++;
+            if ( memread(&notarized_hash,sizeof(notarized_hash),filedata,&fpos,datalen) != sizeof(notarized_hash) )
+                errs++;
+            if ( memread(&notarized_desttxid,sizeof(notarized_desttxid),filedata,&fpos,datalen) != sizeof(notarized_desttxid) )
+                errs++;
+            if ( 0 && ASSETCHAINS_SYMBOL[0] != 0 && sp != 0 )
+                printf("%s load[%s.%d -> %s] NOTARIZED %d %s\n",ASSETCHAINS_SYMBOL,symbol,sp->NUM_NPOINTS,dest,notarized_height,notarized_hash.ToString().c_str());
+            //if ( matched != 0 ) global independent states -> inside *sp
+            komodo_eventadd_notarized(sp,symbol,ht,dest,notarized_hash,notarized_desttxid,notarized_height);
+        }
+        else if ( func == 'U' ) // deprecated
+        {
+            uint8_t n,nid; uint256 hash; uint64_t mask;
+            n = filedata[fpos++];
+            nid = filedata[fpos++];
+            //printf("U %d %d\n",n,nid);
+            if ( memread(&mask,sizeof(mask),filedata,&fpos,datalen) != sizeof(mask) )
+                errs++;
+            if ( memread(&hash,sizeof(hash),filedata,&fpos,datalen) != sizeof(hash) )
+                errs++;
+        }
+        else if ( func == 'K' )
+        {
+            int32_t kheight;
+            if ( memread(&kheight,sizeof(kheight),filedata,&fpos,datalen) != sizeof(kheight) )
+                errs++;
+             komodo_eventadd_kmdheight(sp,symbol,ht,kheight,0);
+        }
+        else if ( func == 'T' )
+        {
+            int32_t kheight,ktimestamp;
+            if ( memread(&kheight,sizeof(kheight),filedata,&fpos,datalen) != sizeof(kheight) )
+                errs++;
+            if ( memread(&ktimestamp,sizeof(ktimestamp),filedata,&fpos,datalen) != sizeof(ktimestamp) )
+                errs++;
+            //if ( matched != 0 ) global independent states -> inside *sp
+            //printf("%s.%d load[%s] ht.%d t.%u\n",ASSETCHAINS_SYMBOL,ht,symbol,kheight,ktimestamp);
+            komodo_eventadd_kmdheight(sp,symbol,ht,kheight,ktimestamp);
+        }
+        else if ( func == 'R' )
+        {
+            uint16_t olen,v; uint64_t ovalue; uint256 txid; uint8_t opret[16384];
+            if ( memread(&txid,sizeof(txid),filedata,&fpos,datalen) != sizeof(txid) )
+                errs++;
+            if ( memread(&v,sizeof(v),filedata,&fpos,datalen) != sizeof(v) )
+                errs++;
+            if ( memread(&ovalue,sizeof(ovalue),filedata,&fpos,datalen) != sizeof(ovalue) )
+                errs++;
+            if ( memread(&olen,sizeof(olen),filedata,&fpos,datalen) != sizeof(olen) )
+                errs++;
+            if ( olen < sizeof(opret) )
+            {
+                if ( memread(opret,olen,filedata,&fpos,datalen) != olen )
+                    errs++;
+                if ( 0 && ASSETCHAINS_SYMBOL[0] != 0 && matched != 0 )
+                {
+                    int32_t i;  for (i=0; i<olen; i++)
+                        printf("%02x",opret[i]);
+                    printf(" %s.%d load[%s] opret[%c] len.%d %.8f\n",ASSETCHAINS_SYMBOL,ht,symbol,opret[0],olen,(double)ovalue/COIN);
+                }
+                komodo_eventadd_opreturn(sp,symbol,ht,txid,ovalue,v,opret,olen); // global shared state -> global PAX
+            } else
+            {
+                int32_t i;
+                for (i=0; i<olen; i++)
+                    filedata[fpos++];
+                //printf("illegal olen.%u\n",olen);
+            }
+        }
+        else if ( func == 'D' )
+        {
+            printf("unexpected function D[%d]\n",ht);
+        }
+        else if ( func == 'V' )
+        {
+            int32_t numpvals; uint32_t pvals[128];
+            numpvals = filedata[fpos++];
+            if ( numpvals*sizeof(uint32_t) <= sizeof(pvals) && memread(pvals,(int32_t)(sizeof(uint32_t)*numpvals),filedata,&fpos,datalen) == numpvals*sizeof(uint32_t) )
+            {
+                //if ( matched != 0 ) global shared state -> global PVALS
+                //printf("%s load[%s] prices %d\n",ASSETCHAINS_SYMBOL,symbol,ht);
+                komodo_eventadd_pricefeed(sp,symbol,ht,pvals,numpvals);
+                //printf("load pvals ht.%d numpvals.%d\n",ht,numpvals);
+            } else printf("error loading pvals[%d]\n",numpvals);
+        }
+        else printf("[%s] %s illegal func.(%d %c)\n",ASSETCHAINS_SYMBOL,symbol,func,func);
+        *fposp = fpos;
+        return(func);
+    }
+    return(-1);
+}
+
 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 KMDheight,uint32_t KMDtimestamp,uint64_t opretvalue,uint8_t *opretbuf,uint16_t opretlen,uint16_t vout)
 {
    static FILE *fp; static int32_t errs,didinit;
-    struct komodo_state *sp; char fname[512],symbol[16],dest[16]; int32_t ht,func; uint8_t num,pubkeys[64][33];
+    struct komodo_state *sp; char fname[512],symbol[KOMODO_ASSETCHAIN_MAXLEN],dest[KOMODO_ASSETCHAIN_MAXLEN]; int32_t retval,ht,func; uint8_t num,pubkeys[64][33];
    if ( didinit == 0 )
    {
        portable_mutex_init(&KOMODO_KV_mutex);
@@ -214,10 +347,15 @@ void komodo_stateupdate(int32_t height,uint8_t notarypubs[][33],uint8_t numnotar
        komodo_statefname(fname,ASSETCHAINS_SYMBOL,(char *)"komodostate");
        if ( (fp= fopen(fname,"rb+")) != 0 )
        {
-            while ( komodo_parsestatefile(sp,fp,symbol,dest) >= 0 )
-                ;
+            if ( (retval= komodo_faststateinit(sp,fname,symbol,dest)) > 0 )
+                fseek(fp,0,SEEK_END);
+            else
+            {
+                fprintf(stderr,"komodo_faststateinit retval.%d\n",retval);
+                while ( komodo_parsestatefile(sp,fp,symbol,dest) >= 0 )
+                    ;
+            }
        } else fp = fopen(fname,"wb+");
-        printf("fname.(%s) fpos.%ld\n",fname,ftell(fp));
        KOMODO_INITDONE = (uint32_t)time(NULL);
    }
    if ( height <= 0 )
@@ -338,7 +476,7 @@ void komodo_stateupdate(int32_t height,uint8_t notarypubs[][33],uint8_t numnotar
 int32_t komodo_voutupdate(int32_t *isratificationp,int32_t notaryid,uint8_t *scriptbuf,int32_t scriptlen,int32_t height,uint256 txhash,int32_t i,int32_t j,uint64_t *voutmaskp,int32_t *specialtxp,int32_t *notarizedheightp,uint64_t value,int32_t notarized,uint64_t signedmask)
 {
    static uint256 zero; static FILE *signedfp;
-    int32_t opretlen,nid,k,len = 0; uint256 kmdtxid,desttxid; uint8_t crypto777[33]; struct komodo_state *sp; char symbol[16],dest[16];
+    int32_t opretlen,nid,k,len = 0; uint256 kmdtxid,desttxid; uint8_t crypto777[33]; struct komodo_state *sp; char symbol[KOMODO_ASSETCHAIN_MAXLEN],dest[KOMODO_ASSETCHAIN_MAXLEN];
    if ( (sp= komodo_stateptr(symbol,dest)) == 0 )
        return(-1);
    if ( scriptlen == 35 && scriptbuf[0] == 33 && scriptbuf[34] == 0xac )
@@ -407,7 +545,7 @@ int32_t komodo_voutupdate(int32_t *isratificationp,int32_t notaryid,uint8_t *scr
                komodo_stateupdate(height,0,0,0,zero,0,0,0,0,0,0,0,0,0,0);
                len += 4;
                if ( ASSETCHAINS_SYMBOL[0] != 0 )
-                    printf("[%s] ht.%d NOTARIZED.%d %s.%s %sTXID.%s (%s) lens.(%d %d)\n",ASSETCHAINS_SYMBOL,height,*notarizedheightp,ASSETCHAINS_SYMBOL[0]==0?"KMD":ASSETCHAINS_SYMBOL,kmdtxid.ToString().c_str(),ASSETCHAINS_SYMBOL[0]==0?"BTC":"KMD",desttxid.ToString().c_str(),(char *)&scriptbuf[len],opretlen,len);
+                    printf("[%s] ht.%d NOTARIZED.%d %s.%s %sTXID.%s lens.(%d %d)\n",ASSETCHAINS_SYMBOL,height,*notarizedheightp,ASSETCHAINS_SYMBOL[0]==0?"KMD":ASSETCHAINS_SYMBOL,kmdtxid.ToString().c_str(),ASSETCHAINS_SYMBOL[0]==0?"BTC":"KMD",desttxid.ToString().c_str(),opretlen,len);
                if ( ASSETCHAINS_SYMBOL[0] == 0 )
                {
                    if ( signedfp == 0 )
@@ -496,7 +634,7 @@ int32_t komodo_notarycmp(uint8_t *scriptPubKey,int32_t scriptlen,uint8_t pubkeys
 void komodo_connectblock(CBlockIndex *pindex,CBlock& block)
 {
    static int32_t hwmheight;
-    uint64_t signedmask,voutmask; char symbol[16],dest[16]; struct komodo_state *sp;
+    uint64_t signedmask,voutmask; char symbol[KOMODO_ASSETCHAIN_MAXLEN],dest[KOMODO_ASSETCHAIN_MAXLEN]; struct komodo_state *sp;
    uint8_t scriptbuf[4096],pubkeys[64][33],rmd160[20],scriptPubKey[35]; uint256 kmdtxid,zero,btctxid,txhash;
    int32_t i,j,k,numnotaries,notarized,scriptlen,isratification,nid,numvalid,specialtx,notarizedheight,notaryid,len,numvouts,numvins,height,txn_count;
    memset(&zero,0,sizeof(zero));
--- a/src/komodo_bitcoind.h
+++ b/src/komodo_bitcoind.h
@@ -23,6 +23,8 @@
 #include <curl/easy.h>
 #endif

+#include "komodo_defs.h"
+
 //#define issue_curl(cmdstr) bitcoind_RPC(0,(char *)"curl",(char *)"http://127.0.0.1:7776",0,0,(char *)(cmdstr))

 struct MemoryStruct { char *memory; size_t size; };
@@ -559,7 +561,7 @@ uint32_t komodo_txtime(uint256 hash)

 void komodo_disconnect(CBlockIndex *pindex,CBlock& block)
 {
-    char symbol[16],dest[16]; struct komodo_state *sp;
+    char symbol[KOMODO_ASSETCHAIN_MAXLEN],dest[KOMODO_ASSETCHAIN_MAXLEN]; struct komodo_state *sp;
    //fprintf(stderr,"disconnect ht.%d\n",pindex->nHeight);
    komodo_init(pindex->nHeight);
    if ( (sp= komodo_stateptr(symbol,dest)) != 0 )
--- a/src/komodo_defs.h
+++ b/src/komodo_defs.h
@@ -0,0 +1,9 @@
+#ifndef KOMODO_DEFS_H
+#define KOMODO_DEFS_H
+
+#define ASSETCHAINS_MINHEIGHT 128
+#define KOMODO_ELECTION_GAP 2000
+#define ROUNDROBIN_DELAY 61
+#define KOMODO_ASSETCHAIN_MAXLEN 65
+
+#endif
--- a/src/komodo_events.h
+++ b/src/komodo_events.h
@@ -15,6 +15,7 @@

 #ifndef H_KOMODOEVENTS_H
 #define H_KOMODOEVENTS_H
+#include "komodo_defs.h"

 struct komodo_event *komodo_eventadd(struct komodo_state *sp,int32_t height,char *symbol,uint8_t type,uint8_t *data,uint16_t datalen)
 {
--- a/src/komodo_gateway.h
+++ b/src/komodo_gateway.h
@@ -14,6 +14,7 @@
 ******************************************************************************/

 // paxdeposit equivalent in reverse makes opreturn and KMD does the same in reverse
+#include "komodo_defs.h"

 int32_t pax_fiatstatus(uint64_t *available,uint64_t *deposited,uint64_t *issued,uint64_t *withdrawn,uint64_t *approved,uint64_t *redeemed,char *base)
 {
@@ -105,7 +106,7 @@ void komodo_paxdelete(struct pax_transaction *pax)

 void komodo_gateway_deposit(char *coinaddr,uint64_t value,char *symbol,uint64_t fiatoshis,uint8_t *rmd160,uint256 txid,uint16_t vout,uint8_t type,int32_t height,int32_t otherheight,char *source,int32_t approved) // assetchain context
 {
-    struct pax_transaction *pax; uint8_t buf[35]; int32_t addflag = 0; struct komodo_state *sp; char str[16],dest[16],*s;
+    struct pax_transaction *pax; uint8_t buf[35]; int32_t addflag = 0; struct komodo_state *sp; char str[KOMODO_ASSETCHAIN_MAXLEN],dest[KOMODO_ASSETCHAIN_MAXLEN],*s;
    //if ( KOMODO_PAX == 0 )
    //    return;
    //if ( strcmp(symbol,ASSETCHAINS_SYMBOL) != 0 )
@@ -197,7 +198,7 @@ int32_t komodo_rwapproval(int32_t rwflag,uint8_t *opretbuf,struct pax_transactio

 int32_t komodo_issued_opreturn(char *base,uint256 *txids,uint16_t *vouts,int64_t *values,int64_t *srcvalues,int32_t *kmdheights,int32_t *otherheights,int8_t *baseids,uint8_t *rmd160s,uint8_t *opretbuf,int32_t opretlen,int32_t iskomodo)
 {
-    struct pax_transaction p,*pax; int32_t i,n=0,j,len=0,incr,height,otherheight; uint8_t type,rmd160[20]; uint64_t fiatoshis; char symbol[16];
+    struct pax_transaction p,*pax; int32_t i,n=0,j,len=0,incr,height,otherheight; uint8_t type,rmd160[20]; uint64_t fiatoshis; char symbol[KOMODO_ASSETCHAIN_MAXLEN];
    //if ( KOMODO_PAX == 0 )
    //    return(0);
    incr = 34 + (iskomodo * (2*sizeof(fiatoshis) + 2*sizeof(height) + 20 + 4));
@@ -274,7 +275,7 @@ int32_t komodo_paxcmp(char *symbol,int32_t kmdheight,uint64_t value,uint64_t che
            return(0);
        else
        {
-            if ( kmdheight >= 238000 )
+            if ( ASSETCHAINS_SYMBOL[0] != 0 )
                printf("ht.%d ignore mismatched %s value %lld vs checkvalue %lld -> ratio.%d\n",kmdheight,symbol,(long long)value,(long long)checkvalue,ratio);
            return(-1);
        }
@@ -290,7 +291,7 @@ int32_t komodo_paxcmp(char *symbol,int32_t kmdheight,uint64_t value,uint64_t che

 uint64_t komodo_paxtotal()
 {
-    struct pax_transaction *pax,*pax2,*tmp,*tmp2; char symbol[16],dest[16],*str; int32_t i,ht; int64_t checktoshis; uint64_t seed,total = 0; struct komodo_state *basesp;
+    struct pax_transaction *pax,*pax2,*tmp,*tmp2; char symbol[KOMODO_ASSETCHAIN_MAXLEN],dest[KOMODO_ASSETCHAIN_MAXLEN],*str; int32_t i,ht; int64_t checktoshis; uint64_t seed,total = 0; struct komodo_state *basesp;
    if ( KOMODO_PASSPORT_INITDONE == 0 ) //KOMODO_PAX == 0 ||
        return(0);
    if ( komodo_isrealtime(&ht) == 0 )
@@ -464,7 +465,7 @@ int32_t komodo_pending_withdraws(char *opretstr) // todo: enforce deterministic

 int32_t komodo_gateway_deposits(CMutableTransaction *txNew,char *base,int32_t tokomodo)
 {
-    struct pax_transaction *pax,*tmp; char symbol[16],dest[16]; uint8_t *script,opcode,opret[16384],data[16384]; int32_t i,baseid,ht,len=0,opretlen=0,numvouts=1; struct komodo_state *sp; uint64_t available,deposited,issued,withdrawn,approved,redeemed,mask,sum = 0;
+    struct pax_transaction *pax,*tmp; char symbol[KOMODO_ASSETCHAIN_MAXLEN],dest[KOMODO_ASSETCHAIN_MAXLEN]; uint8_t *script,opcode,opret[16384],data[16384]; int32_t i,baseid,ht,len=0,opretlen=0,numvouts=1; struct komodo_state *sp; uint64_t available,deposited,issued,withdrawn,approved,redeemed,mask,sum = 0;
    if ( KOMODO_PASSPORT_INITDONE == 0 )//KOMODO_PAX == 0 ||
        return(0);
    struct komodo_state *kmdsp = komodo_stateptrget((char *)"KMD");
@@ -652,7 +653,7 @@ void komodo_passport_iteration();
 int32_t komodo_check_deposit(int32_t height,const CBlock& block) // verify above block is valid pax pricing
 {
    static uint256 array[64]; static int32_t numbanned,indallvouts;
-    int32_t i,j,k,n,ht,baseid,txn_count,activation,num,opretlen,offset=1,errs=0,matched=0,kmdheights[256],otherheights[256]; uint256 hash,txids[256]; char symbol[16],base[16]; uint16_t vouts[256]; int8_t baseids[256]; uint8_t *script,opcode,rmd160s[256*20]; uint64_t total,available,deposited,issued,withdrawn,approved,redeemed,checktoshis,seed; int64_t values[256],srcvalues[256]; struct pax_transaction *pax; struct komodo_state *sp;
+    int32_t i,j,k,n,ht,baseid,txn_count,activation,num,opretlen,offset=1,errs=0,matched=0,kmdheights[256],otherheights[256]; uint256 hash,txids[256]; char symbol[KOMODO_ASSETCHAIN_MAXLEN],base[KOMODO_ASSETCHAIN_MAXLEN]; uint16_t vouts[256]; int8_t baseids[256]; uint8_t *script,opcode,rmd160s[256*20]; uint64_t total,available,deposited,issued,withdrawn,approved,redeemed,checktoshis,seed; int64_t values[256],srcvalues[256]; struct pax_transaction *pax; struct komodo_state *sp;
    activation = 235300;
    if ( *(int32_t *)&array[0] == 0 )
        numbanned = komodo_bannedset(&indallvouts,array,(int32_t)(sizeof(array)/sizeof(*array)));
@@ -1036,8 +1037,6 @@ const char *komodo_opreturn(int32_t height,uint64_t value,uint8_t *opretbuf,int3
        //printf("komodo_opreturn skip %s\n",ASSETCHAINS_SYMBOL);
        return("assetchain");
    }
-    //else if ( KOMODO_PAX == 0 )
-    //    return("nopax");
    memset(baseids,0xff,sizeof(baseids));
    memset(values,0,sizeof(values));
    memset(srcvalues,0,sizeof(srcvalues));
@@ -1048,8 +1047,11 @@ const char *komodo_opreturn(int32_t height,uint64_t value,uint8_t *opretbuf,int3
    if ( opretbuf[0] == 'K' && opretlen != 40 )
    {
        komodo_kvupdate(opretbuf,opretlen,value);
+        return("kv");
    }
-    else if ( opretbuf[0] == 'D' )
+    else if ( ASSETCHAINS_SYMBOL[0] == 0 && KOMODO_PAX == 0 )
+        return("nopax");
+    if ( opretbuf[0] == 'D' )
    {
        tokomodo = 0;
        if ( opretlen == 38 ) // any KMD tx
@@ -1148,7 +1150,7 @@ const char *komodo_opreturn(int32_t height,uint64_t value,uint8_t *opretbuf,int3
                    if ( baseids[i] < 0 )
                    {
                        static uint32_t counter;
-                        if ( counter++ < 3 )
+                        if ( counter++ < 0 )
                            printf("%d of %d illegal baseid.%d, this can be ignored\n",i,n,baseids[i]);
                        continue;
                    }
@@ -1351,12 +1353,281 @@ const char *komodo_opreturn(int32_t height,uint64_t value,uint8_t *opretbuf,int3
    return(typestr);
 }

+int32_t komodo_parsestatefiledata(struct komodo_state *sp,uint8_t *filedata,long *fposp,long datalen,char *symbol,char *dest);
+
+void komodo_stateind_set(struct komodo_state *sp,uint32_t *inds,int32_t n,uint8_t *filedata,long datalen,char *symbol,char *dest)
+{
+    uint8_t func; long lastK,lastT,lastN,lastV,fpos,lastfpos; int32_t i,count,doissue,iter,numn,numv,numN,numV,numR; uint32_t tmp,prevpos100,offset;
+    count = numR = numN = numV = numn = numv = 0;
+    lastK = lastT = lastN = lastV = -1;
+    for (iter=0; iter<2; iter++)
+    {
+        for (lastfpos=fpos=prevpos100=i=0; i<n; i++)
+        {
+            tmp = inds[i];
+            if ( (i % 100) == 0 )
+                prevpos100 = tmp;
+            else
+            {
+                func = (tmp & 0xff);
+                offset = (tmp >> 8);
+                fpos = prevpos100 + offset;
+                if ( lastfpos >= datalen || (filedata[lastfpos] != func && func != 0) )
+                    printf("i.%d/n.%d lastfpos.%ld >= datalen.%ld or [%d] != func.%d\n",i,n,lastfpos,datalen,filedata[lastfpos],func);
+                else if ( iter == 0 )
+                {
+                    switch ( func )
+                    {
+                        default: case 'P': case 'U': case 'D':
+                            inds[i] &= 0xffffff00;
+                            break;
+                        case 'K':
+                            lastK = lastfpos;
+                            inds[i] &= 0xffffff00;
+                            break;
+                        case 'T':
+                            lastT = lastfpos;
+                            inds[i] &= 0xffffff00;
+                            break;
+                        case 'N':
+                            lastN = lastfpos;
+                            numN++;
+                            break;
+                        case 'V':
+                            lastV = lastfpos;
+                            numV++;
+                            break;
+                        case 'R':
+                            numR++;
+                            break;
+                    }
+                }
+                else
+                {
+                    doissue = 0;
+                    if ( func == 'K' )
+                    {
+                        if ( lastK == lastfpos )
+                            doissue = 1;
+                    }
+                    else if ( func == 'T' )
+                    {
+                        if ( lastT == lastfpos )
+                            doissue = 1;
+                    }
+                    else if ( func == 'N' )
+                    {
+                        if ( numn > numN-128 )
+                            doissue = 1;
+                        numn++;
+                    }
+                    else if ( func == 'V' )
+                    {
+                        if ( KOMODO_PAX != 0 && numv > numV-1440 )
+                            doissue = 1;
+                        numv++;
+                    }
+                    else if ( func == 'R' )
+                        doissue = 1;
+                    if ( doissue != 0 )
+                    {
+                        //printf("issue %c total.%d lastfpos.%ld\n",func,count,lastfpos);
+                        komodo_parsestatefiledata(sp,filedata,&lastfpos,datalen,symbol,dest);
+                        count++;
+                    }
+                }
+            }
+            lastfpos = fpos;
+        }
+    }
+    printf("numR.%d numV.%d numN.%d count.%d\n",numR,numV,numN,count);
+    /*else if ( func == 'K' ) // KMD height: stop after 1st
+    else if ( func == 'T' ) // KMD height+timestamp: stop after 1st
+        
+    else if ( func == 'N' ) // notarization, scan backwards 1440+ blocks;
+    else if ( func == 'V' ) // price feed: can stop after 1440+
+    else if ( func == 'R' ) // opreturn:*/
+}
+
+void *OS_loadfile(char *fname,uint8_t **bufp,long *lenp,long *allocsizep)
+{
+    FILE *fp;
+    long  filesize,buflen = *allocsizep;
+    uint8_t *buf = *bufp;
+    *lenp = 0;
+    if ( (fp= fopen(fname,"rb")) != 0 )
+    {
+        fseek(fp,0,SEEK_END);
+        filesize = ftell(fp);
+        if ( filesize == 0 )
+        {
+            fclose(fp);
+            *lenp = 0;
+            printf("OS_loadfile null size.(%s)\n",fname);
+            return(0);
+        }
+        if ( filesize > buflen )
+        {
+            *allocsizep = filesize;
+            *bufp = buf = (uint8_t *)realloc(buf,(long)*allocsizep+64);
+        }
+        rewind(fp);
+        if ( buf == 0 )
+            printf("Null buf ???\n");
+        else
+        {
+            if ( fread(buf,1,(long)filesize,fp) != (unsigned long)filesize )
+                printf("error reading filesize.%ld\n",(long)filesize);
+            buf[filesize] = 0;
+        }
+        fclose(fp);
+        *lenp = filesize;
+        //printf("loaded.(%s)\n",buf);
+    } //else printf("OS_loadfile couldnt load.(%s)\n",fname);
+    return(buf);
+}
+
+uint8_t *OS_fileptr(long *allocsizep,char *fname)
+{
+    long filesize = 0; uint8_t *buf = 0; void *retptr;
+    *allocsizep = 0;
+    retptr = OS_loadfile(fname,&buf,&filesize,allocsizep);
+    return((uint8_t *)retptr);
+}
+
+long komodo_stateind_validate(struct komodo_state *sp,char *indfname,uint8_t *filedata,long datalen,uint32_t *prevpos100p,uint32_t *indcounterp,char *symbol,char *dest)
+{
+    FILE *fp; long fsize,lastfpos=0,fpos=0; uint8_t *inds,func; int32_t i,n; uint32_t offset,tmp,prevpos100 = 0;
+    *indcounterp = *prevpos100p = 0;
+    if ( (inds= OS_fileptr(&fsize,indfname)) != 0 )
+    {
+        lastfpos = 0;
+        fprintf(stderr,"inds.%p validate %s fsize.%ld datalen.%ld n.%ld lastfpos.%ld\n",inds,indfname,fsize,datalen,fsize / sizeof(uint32_t),lastfpos);
+        if ( (fsize % sizeof(uint32_t)) == 0 )
+        {
+            n = (int32_t)(fsize / sizeof(uint32_t));
+            for (i=0; i<n; i++)
+            {
+                memcpy(&tmp,&inds[i * sizeof(uint32_t)],sizeof(uint32_t));
+                if ( 0 && i > n-10 )
+                    printf("%d: tmp.%08x [%c] prevpos100.%u\n",i,tmp,tmp&0xff,prevpos100);
+                if ( (i % 100) == 0 )
+                    prevpos100 = tmp;
+                else
+                {
+                    func = (tmp & 0xff);
+                    offset = (tmp >> 8);
+                    fpos = prevpos100 + offset;
+                    if ( lastfpos >= datalen || filedata[lastfpos] != func )
+                    {
+                        printf("validate.%d error (%u %d) prev100 %u -> fpos.%ld datalen.%ld [%d] (%c) vs (%c) lastfpos.%ld\n",i,offset,func,prevpos100,fpos,datalen,lastfpos < datalen ? filedata[lastfpos] : -1,func,filedata[lastfpos],lastfpos);
+                        return(-1);
+                    }
+                }
+                lastfpos = fpos;
+            }
+            *indcounterp = n;
+            *prevpos100p = prevpos100;
+            if ( sp != 0 )
+                komodo_stateind_set(sp,(uint32_t *)inds,n,filedata,fpos,symbol,dest);
+            //printf("free inds.%p %s validated[%d] fpos.%ld datalen.%ld, offset %ld vs fsize.%ld\n",inds,indfname,i,fpos,datalen,i * sizeof(uint32_t),fsize);
+            free(inds);
+            return(fpos);
+        } else printf("wrong filesize %s %ld\n",indfname,fsize);
+    }
+    free(inds);
+    fprintf(stderr,"indvalidate return -1\n");
+    return(-1);
+}
+
+long komodo_indfile_update(FILE *indfp,uint32_t *prevpos100p,long lastfpos,long newfpos,uint8_t func,uint32_t *indcounterp)
+{
+    uint32_t tmp;
+    if ( indfp != 0 )
+    {
+        tmp = ((uint32_t)(newfpos - *prevpos100p) << 8) | (func & 0xff);
+        if ( ftell(indfp)/sizeof(uint32_t) != *indcounterp )
+            printf("indfp fpos %ld -> ind.%ld vs counter.%u\n",ftell(indfp),ftell(indfp)/sizeof(uint32_t),*indcounterp);
+        //fprintf(stderr,"ftell.%ld indcounter.%u lastfpos.%ld newfpos.%ld func.%02x\n",ftell(indfp),*indcounterp,lastfpos,newfpos,func);
+        fwrite(&tmp,1,sizeof(tmp),indfp), (*indcounterp)++;
+        if ( (*indcounterp % 100) == 0 )
+        {
+            *prevpos100p = (uint32_t)newfpos;
+            fwrite(prevpos100p,1,sizeof(*prevpos100p),indfp), (*indcounterp)++;
+        }
+    }
+    return(newfpos);
+}
+
+int32_t komodo_faststateinit(struct komodo_state *sp,char *fname,char *symbol,char *dest)
+{
+    FILE *indfp; char indfname[1024]; uint8_t *filedata; long validated=-1,datalen,fpos,lastfpos; uint32_t tmp,prevpos100,indcounter,starttime; int32_t func,finished = 0;
+    starttime = (uint32_t)time(NULL);
+    safecopy(indfname,fname,sizeof(indfname)-4);
+    strcat(indfname,".ind");
+    if ( (filedata= OS_fileptr(&datalen,fname)) != 0 )
+    {
+        if ( 1 )//datalen >= (1LL << 32) || GetArg("-genind",0) != 0 || (validated= komodo_stateind_validate(0,indfname,filedata,datalen,&prevpos100,&indcounter,symbol,dest)) < 0 )
+        {
+            lastfpos = fpos = 0;
+            indcounter = prevpos100 = 0;
+            if ( (indfp= fopen(indfname,"wb")) != 0 )
+                fwrite(&prevpos100,1,sizeof(prevpos100),indfp), indcounter++;
+            fprintf(stderr,"processing %s %ldKB, validated.%ld\n",fname,datalen/1024,validated);
+            while ( (func= komodo_parsestatefiledata(sp,filedata,&fpos,datalen,symbol,dest)) >= 0 )
+            {
+                lastfpos = komodo_indfile_update(indfp,&prevpos100,lastfpos,fpos,func,&indcounter);
+            }
+            if ( indfp != 0 )
+            {
+                fclose(indfp);
+                if ( (fpos= komodo_stateind_validate(0,indfname,filedata,datalen,&prevpos100,&indcounter,symbol,dest)) < 0 )
+                    printf("unexpected komodostate.ind validate failure %s datalen.%ld\n",indfname,datalen);
+                else printf("%s validated fpos.%ld\n",indfname,fpos);
+            }
+            finished = 1;
+            fprintf(stderr,"took %d seconds to process %s %ldKB\n",(int32_t)(time(NULL)-starttime),fname,datalen/1024);
+        }
+        else if ( validated > 0 )
+        {
+            if ( (indfp= fopen(indfname,"rb+")) != 0 )
+            {
+                lastfpos = fpos = validated;
+                fprintf(stderr,"datalen.%ld validated %ld -> indcounter %u, prevpos100 %u offset.%ld\n",datalen,validated,indcounter,prevpos100,indcounter * sizeof(uint32_t));
+                if ( fpos < datalen )
+                {
+                    fseek(indfp,indcounter * sizeof(uint32_t),SEEK_SET);
+                    if ( ftell(indfp) == indcounter * sizeof(uint32_t) )
+                    {
+                        while ( (func= komodo_parsestatefiledata(sp,filedata,&fpos,datalen,symbol,dest)) >= 0 )
+                        {
+                            lastfpos = komodo_indfile_update(indfp,&prevpos100,lastfpos,fpos,func,&indcounter);
+                            if ( lastfpos != fpos )
+                                fprintf(stderr,"unexpected lastfpos.%ld != %ld\n",lastfpos,fpos);
+                        }
+                    }
+                    fclose(indfp);
+                }
+                if ( komodo_stateind_validate(sp,indfname,filedata,datalen,&prevpos100,&indcounter,symbol,dest) < 0 )
+                    printf("unexpected komodostate.ind validate failure %s datalen.%ld\n",indfname,datalen);
+                else
+                {
+                    printf("%s validated updated from validated.%ld to %ld new.[%ld] -> indcounter %u, prevpos100 %u offset.%ld | elapsed %d seconds\n",indfname,validated,fpos,fpos-validated,indcounter,prevpos100,indcounter * sizeof(uint32_t),(int32_t)(time(NULL) - starttime));
+                    finished = 1;
+                }
+            }
+        } else printf("komodo_faststateinit unexpected case\n");
+        free(filedata);
+        return(finished == 1);
+    }
+    return(-1);
+}
+
 void komodo_passport_iteration()
 {
    static long lastpos[34]; static char userpass[33][1024]; static uint32_t lasttime,callcounter;
    int32_t maxseconds = 10;
-    FILE *fp; int32_t baseid,limit,n,ht,isrealtime,expired,refid,blocks,longest; struct komodo_state *sp,*refsp; char *retstr,fname[512],*base,symbol[16],dest[16]; uint32_t buf[3],starttime; cJSON *infoobj,*result; uint64_t RTmask = 0;
-    //printf("PASSPORT.(%s)\n",ASSETCHAINS_SYMBOL);
+    FILE *fp; uint8_t *filedata; long fpos,datalen,lastfpos; int32_t baseid,limit,n,ht,isrealtime,expired,refid,blocks,longest; struct komodo_state *sp,*refsp; char *retstr,fname[512],*base,symbol[KOMODO_ASSETCHAIN_MAXLEN],dest[KOMODO_ASSETCHAIN_MAXLEN]; uint32_t buf[3],starttime; cJSON *infoobj,*result; uint64_t RTmask = 0;
    expired = 0;
    while ( KOMODO_INITDONE == 0 )
    {
@@ -1388,13 +1659,7 @@ void komodo_passport_iteration()
    starttime = (uint32_t)time(NULL);
    if ( callcounter++ < 1 )
        limit = 10000;
-    if ( 0 && starttime == lasttime )
-    {
-        usleep(1000);
-        return;
-    }
    lasttime = starttime;
-    //printf("PASSPORT %s refid.%d\n",ASSETCHAINS_SYMBOL,refid);
    for (baseid=32; baseid>=0; baseid--)
    {
        if ( time(NULL) >= starttime+maxseconds )
@@ -1402,18 +1667,31 @@ void komodo_passport_iteration()
        sp = 0;
        isrealtime = 0;
        base = (char *)CURRENCIES[baseid];
-        if ( baseid+1 != refid )
+        //printf("PASSPORT %s baseid+1 %d refid.%d\n",ASSETCHAINS_SYMBOL,baseid+1,refid);
+        if ( baseid+1 != refid ) // only need to import state from a different coin
        {
-            if ( baseid == 32 || ASSETCHAINS_SYMBOL[0] == 0 )
+            if ( baseid == 32 ) // only care about KMD's state
            {
                refsp->RTmask &= ~(1LL << baseid);
                komodo_statefname(fname,baseid<32?base:(char *)"",(char *)"komodostate");
                komodo_nameset(symbol,dest,base);
                sp = komodo_stateptrget(symbol);
                n = 0;
-                if ( (fp= fopen(fname,"rb")) != 0 && sp != 0 )
+                if ( lastpos[baseid] == 0 && (filedata= OS_fileptr(&datalen,fname)) != 0 )
+                {
+                    fpos = 0;
+                    fprintf(stderr,"%s processing %s %ldKB\n",ASSETCHAINS_SYMBOL,fname,datalen/1024);
+                    while ( komodo_parsestatefiledata(sp,filedata,&fpos,datalen,symbol,dest) >= 0 )
+                        lastfpos = fpos;
+                    fprintf(stderr,"%s took %d seconds to process %s %ldKB\n",ASSETCHAINS_SYMBOL,(int32_t)(time(NULL)-starttime),fname,datalen/1024);
+                    lastpos[baseid] = lastfpos;
+                    free(filedata), filedata = 0;
+                    datalen = 0;
+                }
+                else if ( (fp= fopen(fname,"rb")) != 0 && sp != 0 )
                {
                    fseek(fp,0,SEEK_END);
+                    //fprintf(stderr,"couldnt OS_fileptr(%s), freading %ldKB\n",fname,ftell(fp)/1024);
                    if ( ftell(fp) > lastpos[baseid] )
                    {
                        if ( ASSETCHAINS_SYMBOL[0] != 0 )
@@ -1434,11 +1712,11 @@ void komodo_passport_iteration()
                            n++;
                        }
                        lastpos[baseid] = ftell(fp);
-                        if ( lastpos[baseid] == 0 && strcmp(symbol,"KMD") == 0 )
+                        if ( 0 && lastpos[baseid] == 0 && strcmp(symbol,"KMD") == 0 )
                            printf("from.(%s) lastpos[%s] %ld isrt.%d\n",ASSETCHAINS_SYMBOL,CURRENCIES[baseid],lastpos[baseid],komodo_isrealtime(&ht));
                    } //else fprintf(stderr,"%s.%ld ",CURRENCIES[baseid],ftell(fp));
                    fclose(fp);
-                } //else printf("error.(%s) %p\n",fname,sp);
+                } else fprintf(stderr,"load error.(%s) %p\n",fname,sp);
                komodo_statefname(fname,baseid<32?base:(char *)"",(char *)"realtime");
                if ( (fp= fopen(fname,"rb")) != 0 )
                {
--- a/src/komodo_globals.h
+++ b/src/komodo_globals.h
@@ -13,6 +13,8 @@
 *                                                                            *
 ******************************************************************************/

+#include "komodo_defs.h"
+
 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);
 void komodo_init(int32_t height);
 int32_t komodo_notarizeddata(int32_t nHeight,uint256 *notarized_hashp,uint256 *notarized_desttxidp);
@@ -30,6 +32,7 @@ pthread_mutex_t komodo_mutex;

 #define KOMODO_ELECTION_GAP 2000    //((ASSETCHAINS_SYMBOL[0] == 0) ? 2000 : 100)
 #define IGUANA_MAXSCRIPTSIZE 10001
+#define KOMODO_ASSETCHAIN_MAXLEN 65

 struct pax_transaction *PAX;
 int32_t NUM_PRICES; uint32_t *PVALS;
@@ -41,11 +44,11 @@ struct komodo_state KOMODO_STATES[34];
 int COINBASE_MATURITY = _COINBASE_MATURITY;//100;

 int32_t 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;
-int32_t KOMODO_LASTMINED,prevKOMODO_LASTMINED;
+int32_t KOMODO_LASTMINED,prevKOMODO_LASTMINED,JUMBLR_PAUSE;
 std::string NOTARY_PUBKEY,ASSETCHAINS_NOTARIES;
 uint8_t NOTARY_PUBKEY33[33];

-char ASSETCHAINS_SYMBOL[16];
+char ASSETCHAINS_SYMBOL[KOMODO_ASSETCHAIN_MAXLEN];
 uint16_t ASSETCHAINS_PORT;
 uint32_t ASSETCHAIN_INIT;
 uint32_t ASSETCHAINS_MAGIC = 2387029918;
--- a/src/komodo_interest.h
+++ b/src/komodo_interest.h
@@ -13,12 +13,16 @@
 *                                                                            *
 ******************************************************************************/

+#include "komodo_defs.h"
+
 #define SATOSHIDEN ((uint64_t)100000000L)
 #define dstr(x) ((double)(x) / SATOSHIDEN)

+#define KOMODO_ENDOFERA 7777777
 #define KOMODO_INTEREST ((uint64_t)(0.05 * COIN))   // 5%
 int64_t MAX_MONEY = 200000000 * 100000000LL;

+#ifdef notanymore
 uint64_t komodo_earned_interest(int32_t height,int64_t paidinterest)
 {
    static uint64_t *interests; static int32_t maxheight;
@@ -73,11 +77,12 @@ uint64_t komodo_moneysupply(int32_t height)
        return(0);
    else return(COIN * 100000000 + (height-1) * 3 + komodo_earned_interest(height,-1));
 }
+#endif

 uint64_t _komodo_interestnew(uint64_t nValue,uint32_t nLockTime,uint32_t tiptime)
 {
    int32_t minutes; uint64_t interest = 0;
-    if ( (minutes= (tiptime - nLockTime) / 60) >= 60 )
+    if ( tiptime > nLockTime && (minutes= (tiptime - nLockTime) / 60) >= 60 )
    {
        if ( minutes > 365 * 24 * 60 )
            minutes = 365 * 24 * 60;
@@ -90,7 +95,7 @@ uint64_t _komodo_interestnew(uint64_t nValue,uint32_t nLockTime,uint32_t tiptime
 uint64_t komodo_interestnew(int32_t txheight,uint64_t nValue,uint32_t nLockTime,uint32_t tiptime)
 {
    uint64_t interest = 0;
-    if ( komodo_moneysupply(txheight) < MAX_MONEY && nLockTime >= LOCKTIME_THRESHOLD && tiptime != 0 && nLockTime < tiptime && nValue >= 10*COIN )
+    if ( txheight < KOMODO_ENDOFERA && nLockTime >= LOCKTIME_THRESHOLD && tiptime != 0 && nLockTime < tiptime && nValue >= 10*COIN ) //komodo_moneysupply(txheight) < MAX_MONEY &&
        interest = _komodo_interestnew(nValue,nLockTime,tiptime);
    return(interest);
 }
@@ -101,7 +106,9 @@ uint64_t komodo_interest(int32_t txheight,uint64_t nValue,uint32_t nLockTime,uin
    activation = 1491350400;  // 1491350400 5th April
    if ( ASSETCHAINS_SYMBOL[0] != 0 )
        return(0);
-    if ( komodo_moneysupply(txheight) < MAX_MONEY && nLockTime >= LOCKTIME_THRESHOLD && tiptime != 0 && nLockTime < tiptime && nValue >= 10*COIN )
+    if ( txheight >= KOMODO_ENDOFERA )
+        return(0);
+    if ( nLockTime >= LOCKTIME_THRESHOLD && tiptime != 0 && nLockTime < tiptime && nValue >= 10*COIN ) //komodo_moneysupply(txheight) < MAX_MONEY && 
    {
        if ( (minutes= (tiptime - nLockTime) / 60) >= 60 )
        {
--- a/src/komodo_jumblr.h
+++ b/src/komodo_jumblr.h
@@ -27,6 +27,7 @@
 #ifdef _WIN32
 #include <wincrypt.h>
 #endif
+#include "komodo_defs.h"

 #define JUMBLR_ADDR "RGhxXpXSSBTBm9EvNsXnTQczthMCxHX91t"
 #define JUMBLR_BTCADDR "18RmTJe9qMech8siuhYfMtHo8RtcN1obC6"
@@ -629,6 +630,8 @@ void jumblr_iteration()
 {
    static int32_t lastheight; static uint32_t lasttime;
    char *zaddr,*addr,*retstr,secretaddr[64]; cJSON *array; int32_t i,iter,height,counter,chosen_one,n; uint64_t smallest,medium,biggest,amount=0,total=0; double fee; struct jumblr_item *ptr,*tmp; uint16_t r,s;
+    if ( JUMBLR_PAUSE != 0 )
+        return;
    if ( lasttime == 0 )
    {
        if ( (retstr= jumblr_zlistaddresses()) != 0 )
--- a/src/komodo_kv.h
+++ b/src/komodo_kv.h
@@ -16,6 +16,8 @@
 #ifndef H_KOMODOKV_H
 #define H_KOMODOKV_H

+#include "komodo_defs.h"
+
 int32_t komodo_kvcmp(uint8_t *refvalue,uint16_t refvaluesize,uint8_t *value,uint16_t valuesize)
 {
    if ( refvalue == 0 && value == 0 )
@@ -107,7 +109,7 @@ void komodo_kvupdate(uint8_t *opretbuf,int32_t opretlen,uint64_t value)
    if ( keylen+13 > opretlen )
    {
        static uint32_t counter;
-        if ( counter++ < 3 )
+        if ( ++counter < 1 )
            printf("komodo_kvupdate: keylen.%d + 13 > opretlen.%d, this can be ignored\n",keylen,opretlen);
        return;
    }
--- a/src/komodo_notary.h
+++ b/src/komodo_notary.h
@@ -13,6 +13,8 @@
 *                                                                            *
 ******************************************************************************/

+#include "komodo_defs.h"
+
 #include "komodo_cJSON.h"

 #define KOMODO_MAINNET_START 178999
@@ -307,7 +309,7 @@ void komodo_notarized_update(struct komodo_state *sp,int32_t nHeight,int32_t not
 //struct komodo_state *komodo_stateptr(char *symbol,char *dest);
 int32_t komodo_notarized_height(uint256 *hashp,uint256 *txidp)
 {
-    char symbol[16],dest[16]; struct komodo_state *sp;
+    char symbol[KOMODO_ASSETCHAIN_MAXLEN],dest[KOMODO_ASSETCHAIN_MAXLEN]; struct komodo_state *sp;
    if ( (sp= komodo_stateptr(symbol,dest)) != 0 )
    {
        *hashp = sp->NOTARIZED_HASH;
@@ -324,7 +326,7 @@ int32_t komodo_notarized_height(uint256 *hashp,uint256 *txidp)

 int32_t komodo_notarizeddata(int32_t nHeight,uint256 *notarized_hashp,uint256 *notarized_desttxidp)
 {
-    struct notarized_checkpoint *np = 0; int32_t i=0,flag = 0; char symbol[16],dest[16]; struct komodo_state *sp;
+    struct notarized_checkpoint *np = 0; int32_t i=0,flag = 0; char symbol[KOMODO_ASSETCHAIN_MAXLEN],dest[KOMODO_ASSETCHAIN_MAXLEN]; struct komodo_state *sp;
    if ( (sp= komodo_stateptr(symbol,dest)) != 0 )
    {
        if ( sp->NUM_NPOINTS > 0 )
--- a/src/komodo_pax.h
+++ b/src/komodo_pax.h
@@ -13,6 +13,8 @@
 *                                                                            *
 ******************************************************************************/

+#include "komodo_defs.h"
+
 #define USD 0
 #define EUR 1
 #define JPY 2
--- a/src/komodo_structs.h
+++ b/src/komodo_structs.h
@@ -13,6 +13,8 @@
 *                                                                            *
 ******************************************************************************/

+#include "komodo_defs.h"
+
 #include "uthash.h"
 #include "utlist.h"

@@ -40,6 +42,7 @@
 #define KOMODO_KVPROTECTED 1
 #define KOMODO_KVBINARY 2
 #define KOMODO_KVDURATION 1440
+#define KOMODO_ASSETCHAIN_MAXLEN 65

 union _bits256 { uint8_t bytes[32]; uint16_t ushorts[16]; uint32_t uints[8]; uint64_t ulongs[4]; uint64_t txid; };
 typedef union _bits256 bits256;
@@ -60,7 +63,7 @@ struct komodo_event
    uint16_t len;
    int32_t height;
    uint8_t type,reorged;
-    char symbol[16];
+    char symbol[KOMODO_ASSETCHAIN_MAXLEN];
    uint8_t space[];
 };

@@ -71,7 +74,7 @@ struct pax_transaction
    uint64_t komodoshis,fiatoshis,validated;
    int32_t marked,height,otherheight,approved,didstats,ready;
    uint16_t vout;
-    char symbol[16],source[16],coinaddr[64]; uint8_t rmd160[20],type,buf[35];
+    char symbol[KOMODO_ASSETCHAIN_MAXLEN],source[KOMODO_ASSETCHAIN_MAXLEN],coinaddr[64]; uint8_t rmd160[20],type,buf[35];
 };

 struct knotary_entry { UT_hash_handle hh; uint8_t pubkey[33],notaryid; };
--- a/src/komodo_utils.h
+++ b/src/komodo_utils.h
@@ -12,6 +12,8 @@
 * Removal or modification of this copyright notice is prohibited.            *
 *                                                                            *
 ******************************************************************************/
+#include "komodo_defs.h"
+
 #ifdef _WIN32
 #include <sodium.h>
 #include <boost/date_time/posix_time/posix_time.hpp>
@@ -1402,7 +1404,7 @@ void komodo_configfile(char *symbol,uint16_t port)

 uint16_t komodo_userpass(char *userpass,char *symbol)
 {
-    FILE *fp; uint16_t port = 0; char fname[512],username[512],password[512],confname[16];
+    FILE *fp; uint16_t port = 0; char fname[512],username[512],password[512],confname[KOMODO_ASSETCHAIN_MAXLEN];
    userpass[0] = 0;
    if ( strcmp("KMD",symbol) == 0 )
    {
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1490,8 +1490,8 @@ bool ReadBlockFromDisk(CBlock& block, const CBlockIndex* pindex)
    return true;
 }

-uint64_t komodo_moneysupply(int32_t height);
-extern char ASSETCHAINS_SYMBOL[16];
+//uint64_t komodo_moneysupply(int32_t height);
+extern char ASSETCHAINS_SYMBOL[KOMODO_ASSETCHAIN_MAXLEN];
 extern uint32_t ASSETCHAINS_MAGIC;
 extern uint64_t ASSETCHAINS_SUPPLY;

@@ -1502,7 +1502,7 @@ CAmount GetBlockSubsidy(int nHeight, const Consensus::Params& consensusParams)
    {
        if ( nHeight == 1 )
            return(100000000 * COIN); // ICO allocation
-        else if ( komodo_moneysupply(nHeight) < MAX_MONEY )
+        else if ( nHeight < KOMODO_ENDOFERA ) //komodo_moneysupply(nHeight) < MAX_MONEY )
            return(3 * COIN);
        else return(0);
    }
@@ -2365,8 +2365,8 @@ bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pin
                return false;
            control.Add(vChecks);
        }
-        if ( ASSETCHAINS_SYMBOL[0] == 0 )
-            komodo_earned_interest(pindex->nHeight,sum);
+        //if ( ASSETCHAINS_SYMBOL[0] == 0 )
+        //    komodo_earned_interest(pindex->nHeight,sum);
        CTxUndo undoDummy;
        if (i > 0) {
            blockundo.vtxundo.push_back(CTxUndo());
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -106,11 +106,10 @@ void UpdateTime(CBlockHeader* pblock, const Consensus::Params& consensusParams,
        pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, consensusParams);
 }

-#define ASSETCHAINS_MINHEIGHT 128
-#define KOMODO_ELECTION_GAP 2000
-#define ROUNDROBIN_DELAY 61
+#include "komodo_defs.h"
+
 extern int32_t ASSETCHAINS_SEED,IS_KOMODO_NOTARY,USE_EXTERNAL_PUBKEY,KOMODO_CHOSEN_ONE,ASSETCHAIN_INIT,KOMODO_INITDONE,KOMODO_ON_DEMAND,KOMODO_INITDONE,KOMODO_PASSPORT_INITDONE;
-extern char ASSETCHAINS_SYMBOL[16];
+extern char ASSETCHAINS_SYMBOL[KOMODO_ASSETCHAIN_MAXLEN];
 extern std::string NOTARY_PUBKEY;
 extern uint8_t NOTARY_PUBKEY33[33];
 uint32_t Mining_start,Mining_height;
--- a/src/purge
+++ b/src/purge
@@ -0,0 +1,5 @@
+rm -rf ~/.komodo/$1/chainstate
+rm -rf ~/.komodo/$1/database
+rm -rf ~/.komodo/$1/blocks
+rm -rf ~/.komodo/$1/komodostate
+
--- a/src/rpcblockchain.cpp
+++ b/src/rpcblockchain.cpp
@@ -512,10 +512,12 @@ UniValue gettxoutsetinfo(const UniValue& params, bool fHelp)
    return ret;
 }

+#include "komodo_defs.h"
+
 #define IGUANA_MAXSCRIPTSIZE 10001
 #define KOMODO_KVDURATION 1440
 #define KOMODO_KVBINARY 2
-extern char ASSETCHAINS_SYMBOL[16];
+extern char ASSETCHAINS_SYMBOL[KOMODO_ASSETCHAIN_MAXLEN];
 uint64_t komodo_interest(int32_t txheight,uint64_t nValue,uint32_t nLockTime,uint32_t tiptime);
 uint32_t komodo_txtime(uint256 hash);
 uint64_t komodo_paxprice(uint64_t *seedp,int32_t height,char *base,char *rel,uint64_t basevolume);
--- a/src/rpcmisc.cpp
+++ b/src/rpcmisc.cpp
@@ -47,7 +47,7 @@ uint64_t komodo_interestsum();
 int32_t komodo_longestchain();
 int32_t komodo_notarized_height(uint256 *hashp,uint256 *txidp);
 int32_t komodo_whoami(char *pubkeystr,int32_t height);
-extern int32_t KOMODO_LASTMINED;
+extern int32_t KOMODO_LASTMINED,JUMBLR_PAUSE;
 extern char ASSETCHAINS_SYMBOL[];
 int32_t notarizedtxid_height(char *dest,char *txidstr,int32_t *kmdnotarized_heightp);
 #define KOMODO_VERSION "0.1.1"
@@ -224,6 +224,26 @@ UniValue jumblr_secret(const UniValue& params, bool fHelp)
    return(result);
 }

+UniValue jumblr_pause(const UniValue& params, bool fHelp)
+{
+    int32_t retval; UniValue result(UniValue::VOBJ);
+    if (fHelp )
+        throw runtime_error("jumblr_pause\n");
+    JUMBLR_PAUSE = 1;
+    result.push_back(Pair("result", "paused"));
+    return(result);
+}
+
+UniValue jumblr_resume(const UniValue& params, bool fHelp)
+{
+    int32_t retval; UniValue result(UniValue::VOBJ);
+    if (fHelp )
+        throw runtime_error("jumblr_resume\n");
+    JUMBLR_PAUSE = 0;
+    result.push_back(Pair("result", "resumed"));
+    return(result);
+}
+
 UniValue validateaddress(const UniValue& params, bool fHelp)
 {
    if (fHelp || params.size() != 1)
--- a/src/rpcrawtransaction.cpp
+++ b/src/rpcrawtransaction.cpp
@@ -22,6 +22,8 @@
 #include "wallet/wallet.h"
 #endif

+#include "komodo_defs.h"
+
 #include <stdint.h>

 #include <boost/assign/list_of.hpp>
@@ -144,7 +146,7 @@ void TxToJSON(const CTransaction& tx, const uint256 hashBlock, UniValue& entry)
        out.push_back(Pair("value", ValueFromAmount(txout.nValue)));
        if ( pindex != 0 && tx.nLockTime != 0 && (tipindex= chainActive.Tip()) != 0 )
        {
-            extern char ASSETCHAINS_SYMBOL[16];
+            extern char ASSETCHAINS_SYMBOL[KOMODO_ASSETCHAIN_MAXLEN];
            interest = komodo_interest(pindex->nHeight,txout.nValue,tx.nLockTime,tipindex->nTime);
            if ( 0 && strcmp("REVS",ASSETCHAINS_SYMBOL) == 0 )
                fprintf(stderr,"TxtoJSON interest %llu %.8f (%d %llu %u %u)\n",(long long)interest,(double)interest/COIN,(int32_t)pindex->nHeight,(long long)txout.nValue,(uint32_t)tx.nLockTime,(int32_t)tipindex->nTime);
--- a/src/rpcserver.cpp
+++ b/src/rpcserver.cpp
@@ -338,6 +338,8 @@ static const CRPCCommand vRPCCommands[] =
    { "util",               "z_validateaddress",      &z_validateaddress,      true  }, /* uses wallet if enabled */
    { "util",               "jumblr_deposit",       &jumblr_deposit,       true  },
    { "util",               "jumblr_secret",        &jumblr_secret,       true  },
+    { "util",               "jumblr_pause",        &jumblr_pause,       true  },
+    { "util",               "jumblr_resume",        &jumblr_resume,       true  },

    /* Not shown in help */
    { "hidden",             "invalidateblock",        &invalidateblock,        true  },
--- a/src/rpcserver.h
+++ b/src/rpcserver.h
@@ -248,6 +248,8 @@ extern UniValue zc_sample_joinsplit(const UniValue& params, bool fHelp);

 extern UniValue jumblr_deposit(const UniValue& params, bool fHelp);
 extern UniValue jumblr_secret(const UniValue& params, bool fHelp);
+extern UniValue jumblr_pause(const UniValue& params, bool fHelp);
+extern UniValue jumblr_resume(const UniValue& params, bool fHelp);

 extern UniValue getrawtransaction(const UniValue& params, bool fHelp); // in rcprawtransaction.cpp
 extern UniValue listunspent(const UniValue& params, bool fHelp);
--- a/src/util.cpp
+++ b/src/util.cpp
@@ -15,6 +15,7 @@
 #include "sync.h"
 #include "utilstrencodings.h"
 #include "utiltime.h"
+#include "komodo_defs.h"

 #include <stdarg.h>

@@ -441,13 +442,13 @@ void PrintExceptionContinue(const std::exception* pex, const char* pszThread)
    strMiscWarning = message;
 }

-extern char ASSETCHAINS_SYMBOL[16];
+extern char ASSETCHAINS_SYMBOL[KOMODO_ASSETCHAIN_MAXLEN];
 //int64_t MAX_MONEY = 200000000 * 100000000LL;

 boost::filesystem::path GetDefaultDataDir()
 {
    namespace fs = boost::filesystem;
-    char symbol[16];
+    char symbol[KOMODO_ASSETCHAIN_MAXLEN];
    if ( ASSETCHAINS_SYMBOL[0] != 0 )
        strcpy(symbol,ASSETCHAINS_SYMBOL);
    else symbol[0] = 0;
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -471,6 +471,7 @@ UniValue sendtoaddress(const UniValue& params, bool fHelp)

    return wtx.GetHash().GetHex();
 }
+#include "komodo_defs.h"

 #define KOMODO_KVPROTECTED 1
 #define KOMODO_KVBINARY 2
@@ -479,7 +480,8 @@ UniValue sendtoaddress(const UniValue& params, bool fHelp)
 uint64_t PAX_fiatdest(uint64_t *seedp,int32_t tokomodo,char *destaddr,uint8_t pubkey37[37],char *coinaddr,int32_t height,char *base,int64_t fiatoshis);
 int32_t komodo_opreturnscript(uint8_t *script,uint8_t type,uint8_t *opret,int32_t opretlen);
 #define CRYPTO777_KMDADDR "RXL3YXG2ceaB6C5hfJcN4fvmLH2C34knhA"
-extern char ASSETCHAINS_SYMBOL[16];
+extern char ASSETCHAINS_SYMBOL[KOMODO_ASSETCHAIN_MAXLEN];
+extern int32_t KOMODO_PAX;
 int32_t komodo_is_issuer();
 int32_t iguana_rwnum(int32_t rwflag,uint8_t *serialized,int32_t len,void *endianedp);
 int32_t komodo_isrealtime(int32_t *kmdheightp);
@@ -612,6 +614,10 @@ UniValue paxdeposit(const UniValue& params, bool fHelp)
 {
    uint64_t available,deposited,issued,withdrawn,approved,redeemed,seed,komodoshis = 0; int32_t height; char destaddr[64]; uint8_t i,pubkey37[33];
    bool fSubtractFeeFromAmount = false;
+    if ( KOMODO_PAX == 0 )
+    {
+        throw runtime_error("paxdeposit dispabled without -pax");
+    }
    if ( komodo_is_issuer() != 0 )
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "paxdeposit only from KMD");
    if (!EnsureWalletIsAvailable(fHelp))
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -37,8 +37,10 @@ unsigned int nTxConfirmTarget = DEFAULT_TX_CONFIRM_TARGET;
 bool bSpendZeroConfChange = true;
 bool fSendFreeTransactions = false;
 bool fPayAtLeastCustomFee = true;
+#include "komodo_defs.h"
+
 extern int32_t KOMODO_EXCHANGEWALLET;
-extern char ASSETCHAINS_SYMBOL[16];
+extern char ASSETCHAINS_SYMBOL[KOMODO_ASSETCHAIN_MAXLEN];

 /**
 * Fees smaller than this (in satoshi) are considered zero fee (for transaction creation)
--- a/src/zcash/CreateJoinSplit.cpp
+++ b/src/zcash/CreateJoinSplit.cpp
@@ -6,7 +6,8 @@
 #include "primitives/transaction.h"
 #include "zcash/JoinSplit.hpp"
 #include "libsnark/common/profiling.hpp"
-char ASSETCHAINS_SYMBOL[16];
+#include "komodo_defs.h"
+char ASSETCHAINS_SYMBOL[KOMODO_ASSETCHAIN_MAXLEN];
 int64_t MAX_MONEY = 200000000 * 100000000LL;
 uint16_t BITCOIND_PORT = 7771;