Merge pull request #75 from blackjok3rtt/paymentsAD

Payments airdrop

src/cc/CCPayments.h

@@ -18,8 +18,10 @@
 #define CC_PAYMENTS_H
 
 #include "CCinclude.h"
+#include <gmp.h>
 
 #define PAYMENTS_TXFEE 10000
+extern std::vector <std::pair<CAmount, CTxDestination>> vAddressSnapshot;
 
 bool PaymentsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx, uint32_t nIn);
 
@@ -28,7 +30,9 @@ UniValue PaymentsRelease(struct CCcontract_info *cp,char *jsonstr);
 UniValue PaymentsFund(struct CCcontract_info *cp,char *jsonstr);
 UniValue PaymentsTxidopret(struct CCcontract_info *cp,char *jsonstr);
 UniValue PaymentsCreate(struct CCcontract_info *cp,char *jsonstr);
+UniValue PaymentsAirdrop(struct CCcontract_info *cp,char *jsonstr);
 UniValue PaymentsInfo(struct CCcontract_info *cp,char *jsonstr);
 UniValue PaymentsList(struct CCcontract_info *cp,char *jsonstr);
 
 #endif
+ 

src/cc/CCutils.cpp

@@ -74,7 +74,7 @@ CScript getCCopret(const CScript &scriptPubKey)
 {
     std::vector<std::vector<unsigned char>> vParams = std::vector<std::vector<unsigned char>>();
     CScript dummy; CScript opret;
-    if ( scriptPubKey.IsPayToCryptoCondition(&dummy, vParams) )
+    if ( scriptPubKey.IsPayToCryptoCondition(&dummy, vParams) && vParams.size() == 1 )
     {
         //fprintf(stderr, "vparams.%s\n", HexStr(vParams[0].begin(), vParams[0].end()).c_str());
         opret = CScript(vParams[0].begin()+6, vParams[0].end());

src/cc/COptCCParams.cpp

@@ -0,0 +1,116 @@
+/*Descriptson and examples of COptCCParams class found in:
+    script/standard.h/cpp 
+    class COptCCParams
+    
+structure of data in vData payload attached to end of CCvout: 
+    param 
+    OP_1 
+    param
+    OP_2 ... etc until OP_16
+    OP_PUSHDATA4 is the last OP code to tell things its at the end. 
+    
+    taken from standard.cpp line 22: COptCCParams::COptCCParams(std::vector<unsigned char> &vch)
+
+EXAMPLE taken from Verus how to create scriptPubKey from COptCCParams class:
+EXAMPLE taken from Verus how to decode scriptPubKey from COptCCParams class:
+*/
+
+bool MakeGuardedOutput(CAmount value, CPubKey &dest, CTransaction &stakeTx, CTxOut &vout)
+{
+    CCcontract_info *cp, C;
+    cp = CCinit(&C,EVAL_STAKEGUARD);
+
+    CPubKey ccAddress = CPubKey(ParseHex(cp->CChexstr));
+
+    // return an output that is bound to the stake transaction and can be spent by presenting either a signed condition by the original 
+    // destination address or a properly signed stake transaction of the same utxo on a fork
+    vout = MakeCC1of2vout(EVAL_STAKEGUARD, value, dest, ccAddress);
+
+    std::vector<CPubKey> vPubKeys = std::vector<CPubKey>();
+    vPubKeys.push_back(dest);
+    vPubKeys.push_back(ccAddress);
+        
+    std::vector<std::vector<unsigned char>> vData = std::vector<std::vector<unsigned char>>();
+
+    CVerusHashWriter hw = CVerusHashWriter(SER_GETHASH, PROTOCOL_VERSION);
+
+    hw << stakeTx.vin[0].prevout.hash;
+    hw << stakeTx.vin[0].prevout.n;
+
+    uint256 utxo = hw.GetHash();
+    vData.push_back(std::vector<unsigned char>(utxo.begin(), utxo.end())); // Can we use any data here to construct vector? 
+
+    CStakeParams p;
+    if (GetStakeParams(stakeTx, p))
+    {
+        // prev block hash and height is here to make validation easy
+        vData.push_back(std::vector<unsigned char>(p.prevHash.begin(), p.prevHash.end()));
+        std::vector<unsigned char> height = std::vector<unsigned char>(4);
+        for (int i = 0; i < 4; i++)
+        {
+            height[i] = (p.blkHeight >> (8 * i)) & 0xff;
+        }
+        vData.push_back(height);
+
+        COptCCParams ccp = COptCCParams(COptCCParams::VERSION, EVAL_STAKEGUARD, 1, 2, vPubKeys, vData);
+
+        vout.scriptPubKey << ccp.AsVector() << OP_DROP;
+        return true;
+    }
+    return false;
+}
+
+bool ValidateMatchingStake(const CTransaction &ccTx, uint32_t voutNum, const CTransaction &stakeTx, bool &cheating)
+{
+    // an invalid or non-matching stake transaction cannot cheat
+    cheating = false;
+
+    //printf("ValidateMatchingStake: ccTx.vin[0].prevout.hash: %s, ccTx.vin[0].prevout.n: %d\n", ccTx.vin[0].prevout.hash.GetHex().c_str(), ccTx.vin[0].prevout.n);
+
+    if (ccTx.IsCoinBase())
+    {
+        CStakeParams p;
+        if (ValidateStakeTransaction(stakeTx, p))
+        {
+            std::vector<std::vector<unsigned char>> vParams = std::vector<std::vector<unsigned char>>();
+            CScript dummy;
+
+            if (ccTx.vout[voutNum].scriptPubKey.IsPayToCryptoCondition(&dummy, vParams) && vParams.size() > 0)
+            {
+                COptCCParams ccp = COptCCParams(vParams[0]);
+                if (ccp.IsValid() & ccp.vData.size() >= 3 && ccp.vData[2].size() <= 4)
+                {
+                    CVerusHashWriter hw = CVerusHashWriter(SER_GETHASH, PROTOCOL_VERSION);
+
+                    hw << stakeTx.vin[0].prevout.hash;
+                    hw << stakeTx.vin[0].prevout.n;
+                    uint256 utxo = hw.GetHash();
+
+                    uint32_t height = 0;
+                    int i, dataLen = ccp.vData[2].size();
+                    for (i = dataLen - 1; i >= 0; i--)
+                    {
+                        height = (height << 8) + ccp.vData[2][i];
+                    }
+                    // for debugging strange issue
+                    // printf("iterator: %d, height: %d, datalen: %d\n", i, height, dataLen);
+
+                    if (utxo == uint256(ccp.vData[0]))
+                    {
+                        if (p.prevHash != uint256(ccp.vData[1]) && p.blkHeight >= height)
+                        {
+                            cheating = true;
+                            return true;
+                        }
+                        // if block height is equal and we are at the else, prevHash must have been equal
+                        else if (p.blkHeight == height)
+                        {
+                            return true;                            
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return false;
+}

src/cc/eval.cpp

@@ -53,6 +53,15 @@ bool RunCCEval(const CC *cond, const CTransaction &tx, unsigned int nIn)
             eval->state.GetRejectReason().data(),
             tx.vin[nIn].prevout.hash.GetHex().data());
     if (eval->state.IsError()) fprintf(stderr, "Culprit: %s\n", EncodeHexTx(tx).data());
+    CTransaction tmp; 
+    if (mempool.lookup(tx.GetHash(), tmp))
+    {
+        // This is to remove a payments airdrop if it gets stuck in the mempool. 
+        // Miner will mine 1 invalid block, but doesnt stop them mining until a restart.
+        // This would almost never happen in normal use.
+        std::list<CTransaction> dummy;
+        mempool.remove(tx,dummy,true);
+    }
     return false;
 }
 

src/cc/hempcoin_notes.txt

@@ -56,7 +56,7 @@ get the payment fund scriptpubkey hex from vout 0: (the split it at OP_CHECKCRYP
     put the second half into an OP_RETURN: (the remaining part of the the above scriptpubkey) eg.
         ./komodo-cli -ac_name=TESTHC opreturn_burn 1 2a0401f00101246a22f046337db779358deaa69b9af053e27d85cb8e8e48b0b13805c084b04f87be6577ee75
             opret_burn takes any burn amount and arbitrary hex string. (RPC works, but may have bugs, likely use this for LABS too with some fixes)
-    this gives a raw hex. Decode it and check the OP_RETURN is right before sending (using this RPC currently adds 3 extra bytes to the front (6a2d2c), which is truncated later on, this should be fixed if possible before making any real chains as its consensus code. Need to try diffrent methods to decode the hex correctly.)
+    this gives a raw hex. Decode it and check the OP_RETURN is right before sending. 
         -earlytxid=810bd62fb8353fad20267ff2050684b8829affa3edf6b366633931530791dfce
     restart the chain with earlytxid param before height 100 on all nodes (if not using -testnode=1) 
     ./komodod -ac_name=TESTHC -ac_supply=1000000 -ac_reward=100000000000 -ac_cc=2 -ac_script=2ea22c8020987fad30df055db6fd922c3a57e55d76601229ed3da3b31340112e773df3d0d28103120c008203000401ccb8 -ac_founders=150 -ac_blocktime=20 -ac_nk=96,5 -earlytxid=810bd62fb8353fad20267ff2050684b8829affa3edf6b366633931530791dfce

src/cc/payments.cpp

@@ -16,6 +16,27 @@
 #include "CCPayments.h"
 
 /* 
+192.168.0.139: RH side screen. 
+    ./komodod -ac_name=TESTDP -ac_supply=10000000 -ac_reward=1000000000 -ac_nk=96,5 -ac_blocktime=20 -ac_cc=2 -addndoe=192.168.0.112
+        - TESTDP.tar saved after distributing funds randomly. approx block 120. 
+LH screen:
+    ./komodod -ac_name=TESTDP -ac_supply=10000000 -ac_reward=1000000000 -ac_nk=96,5 -ac_blocktime=20 -ac_cc=2 -pubkey=0244a96824fa317433f0eaa6d5b1faf68e802b1958df273c24cb82bce1ef8e1aec -gen -genproclimit=1
+
+./komodo-cli -ac_name=TESTDP paymentsairdrop '[10,2000,500,"76a9149758abb81ee168dd3824cb55e94df509b35462d788ac",76a9144cfd873dadbfbb4b9c03e77ecaa6cfb74a484f4888ac"]'
+
+use notarizations DB to scan back from the correct height, then undo ALL blocks back to this notarized height!
+payments airdrop:
+    - extra RPC to merge all payments inputs to a single utxo, this must be called first and be confirmed before payments release, 
+        or tx will be too big, we can check add payments inputs is only 1 input, at RPC and in validation very early on. 
+    - do getsnapshot2 every 1440 blocks and save the result into some global sorted vector.
+        -this allows any address balance to be calculated by only iterating each 1439 blocks maximum. 
+    - calculate scriptpubkey to pay from each address, set allocations from balance of each address. allocation = balance?
+
+payments airdrop paying a token: 
+    - tokenid, top number of tokens to pay, list of pubkeys to exclude as optional param
+    - token airdrop code should be the same as normal snapshot, but call a diffrent snapshot function that only fetches the info for a specific tokenid given.
+        this should be fine to work in validation/rpc level rather than a global saved result, as a single token id doesnt require iterating the whole DB. 
+
  0) txidopret <- allocation, scriptPubKey, opret
  1) create <-  locked_blocks, minrelease, list of txidopret
  
@@ -131,12 +152,53 @@ uint8_t DecodePaymentsOpRet(CScript scriptPubKey,int32_t &lockedblocks,int32_t &
     script = (uint8_t *)vopret.data();
     if ( vopret.size() > 2 && E_UNMARSHAL(vopret,ss >> e; ss >> f; ss >> lockedblocks; ss >> minrelease; ss >> totalallocations; ss >> txidoprets) != 0 )
     {
-        if ( e == EVAL_PAYMENTS && f == 'C' )
+        if ( e == EVAL_PAYMENTS && f == 'C' && txidoprets.size() > 1 )
             return(f);
     }
     return(0);
 }
 
+
+CScript EncodePaymentsSnapsShotOpRet(int32_t lockedblocks,int32_t minrelease,int32_t top,std::vector<std::vector<uint8_t>> excludeScriptPubKeys)
+{
+    CScript opret; uint8_t evalcode = EVAL_PAYMENTS;
+    opret << OP_RETURN << E_MARSHAL(ss << evalcode << 'S' << lockedblocks << minrelease << top << excludeScriptPubKeys);
+    return(opret);
+}
+
+uint8_t DecodePaymentsSnapsShotOpRet(CScript scriptPubKey,int32_t &lockedblocks,int32_t &minrelease,int32_t &top,std::vector<std::vector<uint8_t>> &excludeScriptPubKeys)
+{
+    std::vector<uint8_t> vopret; uint8_t *script,e,f;
+    GetOpReturnData(scriptPubKey, vopret);
+    script = (uint8_t *)vopret.data();
+    if ( vopret.size() > 2 && E_UNMARSHAL(vopret,ss >> e; ss >> f; ss >> lockedblocks; ss >> minrelease; ss >> top; ss >> excludeScriptPubKeys) != 0 )
+    {
+        if ( e == EVAL_PAYMENTS && f == 'S' )
+            return(f);
+    }
+    return(0);
+}
+
+CScript EncodePaymentsTokensOpRet(int32_t lockedblocks,int32_t minrelease,int32_t top,std::vector<std::vector<uint8_t>> excludeScriptPubKeys, uint256 tokenid)
+{
+    CScript opret; uint8_t evalcode = EVAL_PAYMENTS;
+    opret << OP_RETURN << E_MARSHAL(ss << evalcode << 'O' << lockedblocks << minrelease << top << excludeScriptPubKeys << tokenid);
+    return(opret);
+}
+
+uint8_t DecodePaymentsTokensOpRet(CScript scriptPubKey,int32_t &lockedblocks,int32_t &minrelease,int32_t &top,std::vector<std::vector<uint8_t>>  &excludeScriptPubKeys, uint256 &tokenid)
+{
+    std::vector<uint8_t> vopret; uint8_t *script,e,f;
+    GetOpReturnData(scriptPubKey, vopret);
+    script = (uint8_t *)vopret.data();
+    if ( vopret.size() > 2 && E_UNMARSHAL(vopret,ss >> e; ss >> f; ss >> lockedblocks; ss >> minrelease; ss >> top; ss >> excludeScriptPubKeys; ss >> tokenid) != 0 )
+    {
+        if ( e == EVAL_PAYMENTS && f == 'O' )
+            return(f);
+    }
+    return(0);
+} 
+
 int64_t IsPaymentsvout(struct CCcontract_info *cp,const CTransaction& tx,int32_t v,char *cmpaddr)
 {
     char destaddr[64];
@@ -171,8 +233,10 @@ bool PaymentsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &
     //    change is/must be in vout[0]
     // only 'F' or 1of2 txidaddr can be spent
     // all vouts must match exactly
-    char temp[128], coinaddr[64], txidaddr[64]; std::string scriptpubkey; uint256 createtxid, blockhash; CTransaction tmptx; 
+    char temp[128], coinaddr[64], txidaddr[64]; std::string scriptpubkey; uint256 createtxid, blockhash, tokenid; CTransaction plantx; uint8_t funcid = 0;
     int32_t i,lockedblocks,minrelease; int64_t change,totalallocations; std::vector<uint256> txidoprets; bool fHasOpret = false; CPubKey txidpk,Paymentspk;
+    int32_t top; std::vector<std::vector<uint8_t>> excludeScriptPubKeys; 
+    mpz_t mpzTotalAllocations, mpzAllocation;; mpz_init(mpzTotalAllocations);
     // user marker vout to get the createtxid
     if ( tx.vout.size() < 2 )
         return(eval->Invalid("not enough vouts"));
@@ -187,13 +251,15 @@ bool PaymentsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &
     //printf("createtxid.%s\n",createtxid.ToString().c_str());
     
     // use the createtxid to fetch the tx and all of the plans info.
-    if ( myGetTransaction(createtxid,tmptx,blockhash) != 0 )
-    {
-        if ( tmptx.vout.size() > 0 && DecodePaymentsOpRet(tmptx.vout[tmptx.vout.size()-1].scriptPubKey,lockedblocks,minrelease,totalallocations,txidoprets) != 0 )
+    if ( myGetTransaction(createtxid,plantx,blockhash) != 0 && plantx.vout.size() > 0 )
+    {                                                                                                                        
+        if ( ((funcid= DecodePaymentsOpRet(plantx.vout[plantx.vout.size()-1].scriptPubKey,lockedblocks,minrelease,totalallocations,txidoprets)) == 'C' || (funcid= DecodePaymentsSnapsShotOpRet(plantx.vout[plantx.vout.size()-1].scriptPubKey,lockedblocks,minrelease,top,excludeScriptPubKeys)) == 'S' || (funcid= DecodePaymentsTokensOpRet(plantx.vout[plantx.vout.size()-1].scriptPubKey,lockedblocks,minrelease,top,excludeScriptPubKeys,tokenid)) == 'O') )
         {
-            if ( lockedblocks < 0 || minrelease < 0 || totalallocations <= 0 || txidoprets.size() < 2 )
+            if ( lockedblocks < 0 || minrelease < 0 || totalallocations <= 0 )
                 return(eval->Invalid("negative values"));    
             Paymentspk = GetUnspendable(cp,0);
+            txidpk = CCtxidaddr(txidaddr,createtxid);
+            GetCCaddress1of2(cp,coinaddr,Paymentspk,txidpk);
             //fprintf(stderr, "lockedblocks.%i minrelease.%i totalallocations.%i txidopret1.%s txidopret2.%s\n",lockedblocks, minrelease, totalallocations, txidoprets[0].ToString().c_str(), txidoprets[1].ToString().c_str() );
             if ( !CheckTxFee(tx, PAYMENTS_TXFEE+1, chainActive.LastTip()->GetHeight(), chainActive.LastTip()->nTime) )
                 return eval->Invalid("txfee is too high");
@@ -202,65 +268,101 @@ bool PaymentsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &
             std::vector<CScript> scriptPubKeys;
             int64_t checkallocations = 0;
             i = 0;
-            BOOST_FOREACH(const uint256& txidopret, txidoprets)
+            if ( funcid == 'C' )
             {
-                CTransaction tx0; std::vector<uint8_t> scriptPubKey,opret; int64_t allocation;
-                if ( myGetTransaction(txidopret,tx0,blockhash) != 0 && tx0.vout.size() > 1 && DecodePaymentsTxidOpRet(tx0.vout[tx0.vout.size()-1].scriptPubKey,allocation,scriptPubKey,opret) == 'T' )
+                // normal payment
+                for (const uint256& txidopret : txidoprets)
                 {
-                    scriptPubKeys.push_back(CScript(scriptPubKey.begin(), scriptPubKey.end()));
-                    allocations.push_back(allocation);
-                    //fprintf(stderr, "i.%i scriptpubkey.%s allocation.%li\n",i,scriptPubKeys[i].ToString().c_str(),allocation);
-                    checkallocations += allocation;
-                    // if we have an op_return to pay to need to check it exists and is paying the correct opret. 
-                    if ( !opret.empty() )
+                    CTransaction tx0; std::vector<uint8_t> scriptPubKey,opret; int64_t allocation;
+                    if ( myGetTransaction(txidopret,tx0,blockhash) != 0 && tx0.vout.size() > 1 && DecodePaymentsTxidOpRet(tx0.vout[tx0.vout.size()-1].scriptPubKey,allocation,scriptPubKey,opret) == 'T' )
                     {
-                        if ( !fHasOpret )
+                        scriptPubKeys.push_back(CScript(scriptPubKey.begin(), scriptPubKey.end()));
+                        allocations.push_back(allocation);
+                        //fprintf(stderr, "i.%i scriptpubkey.%s allocation.%li\n",i,scriptPubKeys[i].ToString().c_str(),allocation);
+                        checkallocations += allocation;
+                        // if we have an op_return to pay to need to check it exists and is paying the correct opret. 
+                        if ( !opret.empty() )
                         {
-                            fprintf(stderr, "missing opret.%s in payments release.\n",HexStr(opret.begin(), opret.end()).c_str());
-                            return(eval->Invalid("missing opret in payments release"));
+                            if ( !fHasOpret )
+                            {
+                                fprintf(stderr, "missing opret.%s in payments release.\n",HexStr(opret.begin(), opret.end()).c_str());
+                                return(eval->Invalid("missing opret in payments release"));
+                            }
+                            else if ( CScript(opret.begin(),opret.end()) != tx.vout[tx.vout.size()-1].scriptPubKey )
+                            {
+                                fprintf(stderr, "opret.%s vs opret.%s\n",HexStr(opret.begin(), opret.end()).c_str(), HexStr(tx.vout[tx.vout.size()-1].scriptPubKey.begin(), tx.vout[tx.vout.size()-1].scriptPubKey.end()).c_str());
+                                return(eval->Invalid("pays incorrect opret"));
+                            }
                         }
-                        else if ( CScript(opret.begin(),opret.end()) != tx.vout[tx.vout.size()-1].scriptPubKey )
+                    }
+                    i++;
+                }
+                mpz_set_si(mpzTotalAllocations,totalallocations);
+            }
+            else if ( funcid == 'S' )
+            {
+                // need time for TX to me mined before the next snapshot.
+                if ( top > 5000 )
+                    return(eval->Invalid("transaction too big"));
+                for ( auto address : vAddressSnapshot )
+                {
+                    CScript scriptPubKey = GetScriptForDestination(address.second);
+                    for ( auto skipkey : excludeScriptPubKeys )
+                    {
+                        //fprintf(stderr, "scriptpubkey.%s\n skipkey.%s", HexStr(scriptPubKey).c_str(), HexStr(CScript(skipkey.begin(), skipkey.end())).c_str());
+                        if ( scriptPubKey != CScript(skipkey.begin(), skipkey.end()) )
                         {
-                            fprintf(stderr, "opret.%s vs opret.%s\n",HexStr(opret.begin(), opret.end()).c_str(), HexStr(tx.vout[tx.vout.size()-1].scriptPubKey.begin(), tx.vout[tx.vout.size()-1].scriptPubKey.end()).c_str());
-                            return(eval->Invalid("pays incorrect opret"));
+                            mpz_init(mpzAllocation); 
+                            i++;
+                            scriptPubKeys.push_back(scriptPubKey);
+                            allocations.push_back(address.first);
+                            mpz_set_si(mpzAllocation,address.first);
+                            mpz_add(mpzTotalAllocations,mpzTotalAllocations,mpzAllocation); 
+                            mpz_clear(mpzAllocation);
                         }
                     }
+                    if ( i == top ) // we reached top amount to pay, it can be less than this!
+                        break;
                 }
-                i++;
+                if ( i != tx.vout.size()-2 )
+                    return(eval->Invalid("pays wrong amount of recipients"));
+            } 
+            else if ( funcid == 'O' )
+            {
+                // tokens snapshot.
             }
-            
             // sanity check to make sure we got all the required info
+            //fprintf(stderr, " allocations.size().%li scriptPubKeys.size.%li\n",allocations.size(), scriptPubKeys.size());
             if ( allocations.size() == 0 || scriptPubKeys.size() == 0 || allocations.size() != scriptPubKeys.size() )
                 return(eval->Invalid("missing data cannot validate"));
                 
             //fprintf(stderr, "totalallocations.%li checkallocations.%li\n",totalallocations, checkallocations);
-            if ( totalallocations != checkallocations )
+            if ( funcid == 'C' && totalallocations != checkallocations ) // only check for normal payments release. 
                 return(eval->Invalid("allocation missmatch"));
-            
-            txidpk = CCtxidaddr(txidaddr,createtxid);
-            GetCCaddress1of2(cp,coinaddr,Paymentspk,txidpk);
-            //fprintf(stderr, "coinaddr.%s\n", coinaddr);
-            
+
             // make sure change is in vout 0 and is paying to the contract address.
             if ( (change= IsPaymentsvout(cp,tx,0,coinaddr)) == 0 )
                 return(eval->Invalid("change is in wrong vout or is wrong tx type"));
             
             // Check vouts go to the right place and pay the right amounts. 
-            int64_t amount = 0, checkamount; int32_t n = 0;
+            int64_t amount = 0, checkamount; int32_t n = 0; 
             checkamount = tx.GetValueOut() - change - PAYMENTS_TXFEE;
+            mpz_t mpzCheckamount; mpz_init(mpzCheckamount); mpz_set_si(mpzCheckamount,checkamount); 
             for (i = 1; i < (fHasOpret ? tx.vout.size()-2 : tx.vout.size()-1); i++) 
             {
-                std::string destscriptPubKey = HexStr(scriptPubKeys[n].begin(),scriptPubKeys[n].end());
-                std::string voutscriptPubKey = HexStr(tx.vout[i].scriptPubKey.begin(),tx.vout[i].scriptPubKey.end());
-                if ( destscriptPubKey != voutscriptPubKey )
+                if ( scriptPubKeys[n] != tx.vout[i].scriptPubKey )
                 {
-                    fprintf(stderr, "pays wrong destination destscriptPubKey.%s voutscriptPubKey.%s\n", destscriptPubKey.c_str(), voutscriptPubKey.c_str());
+                    fprintf(stderr, "pays wrong destination destscriptPubKey.%s voutscriptPubKey.%s\n", HexStr(scriptPubKeys[n].begin(),scriptPubKeys[n].end()).c_str(), HexStr(tx.vout[i].scriptPubKey.begin(),tx.vout[i].scriptPubKey.end()).c_str());
                     return(eval->Invalid("pays wrong address"));
                 }
-                int64_t test = allocations[n];
-                test *= checkamount;
-                test /= totalallocations;
-                if ( test != tx.vout[i].nValue && test != tx.vout[i].nValue-1 )
+                mpz_init(mpzAllocation); 
+                mpz_set_si(mpzAllocation,allocations[n]);
+                mpz_mul(mpzAllocation,mpzAllocation,mpzCheckamount);
+                mpz_cdiv_q(mpzAllocation,mpzAllocation,mpzTotalAllocations);
+                int64_t test = mpz_get_si(mpzAllocation);
+                mpz_clear(mpzAllocation);
+                // Vairance of 1 sat is allowed, for rounding errors.
+                if ( test >= tx.vout[i].nValue+1 && test <= tx.vout[i].nValue-1 )
                 {
                     fprintf(stderr, "vout.%i test.%li vs nVlaue.%li\n",i, test, tx.vout[i].nValue);
                     return(eval->Invalid("amounts do not match"));
@@ -268,6 +370,7 @@ bool PaymentsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &
                 amount += tx.vout[i].nValue;
                 n++;
             }
+            mpz_clear(mpzTotalAllocations);
             // This is a backup check to make sure there are no extra vouts paying something else!
             if ( checkamount != amount )
                 return(eval->Invalid("amounts do not match"));
@@ -278,6 +381,7 @@ bool PaymentsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &
                 return(eval->Invalid("amount is too small"));
             }
             
+            // Check vins
             i = 0; 
             int32_t ht = chainActive.LastTip()->GetHeight();
             BOOST_FOREACH(const CTxIn& vin, tx.vin)
@@ -290,17 +394,12 @@ bool PaymentsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &
                     Getscriptaddress(destaddr,txin.vout[vin.prevout.n].scriptPubKey);
                     if ( strcmp(destaddr,coinaddr) != 0 )
                     {
+                        // if does not come from address its in the global payments adddress and we need to check the opreturn.
                         CScript opret; uint256 checktxid; int32_t opret_ind;
                         if ( (opret_ind= has_opret(txin, EVAL_PAYMENTS)) == 0 )
-                        {
-                            // get op_return from CCvout, 
-                            opret = getCCopret(txin.vout[vin.prevout.n].scriptPubKey);
-                        }
+                            opret = getCCopret(txin.vout[vin.prevout.n].scriptPubKey); // get op_return from CCvout, 
                         else
-                        {
-                            // get op_return from the op_return 
-                            opret = txin.vout[opret_ind].scriptPubKey;
-                        }
+                            opret = txin.vout[opret_ind].scriptPubKey; 
                         if ( DecodePaymentsFundOpRet(opret,checktxid) != 'F' || checktxid != createtxid )
                         {
                             fprintf(stderr, "vin.%i is not a payments CC vout: txid.%s\n", i, txin.GetHash().ToString().c_str());
@@ -391,6 +490,7 @@ int64_t AddPaymentsInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CP
                     if ( (total > 0 && totalinputs >= total) || (maxinputs > 0 && n >= maxinputs) )
                         break;
                 } //else fprintf(stderr,"nValue %.8f vs threshold %.8f\n",(double)nValue/COIN,(double)threshold/COIN);
+                iter++;
             }
         }
     }
@@ -469,8 +569,10 @@ int32_t payments_parsehexdata(std::vector<uint8_t> &hexdata,cJSON *item,int32_t
 UniValue PaymentsRelease(struct CCcontract_info *cp,char *jsonstr)
 {
     int32_t latestheight,nextheight = komodo_nextheight();
-    CMutableTransaction tmpmtx,mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(),nextheight); UniValue result(UniValue::VOBJ); uint256 createtxid,hashBlock;
-    CTransaction tx,txO; CPubKey mypk,txidpk,Paymentspk; int32_t i,n,m,numoprets=0,lockedblocks,minrelease; int64_t newamount,inputsum,amount,CCchange=0,totalallocations,checkallocations=0,allocation; CTxOut vout; CScript onlyopret; char txidaddr[64],destaddr[64]; std::vector<uint256> txidoprets;
+    CMutableTransaction tmpmtx,mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(),nextheight); UniValue result(UniValue::VOBJ); uint256 createtxid,hashBlock,tokenid;
+    CTransaction tx,txO; CPubKey mypk,txidpk,Paymentspk; int32_t i,n,m,numoprets=0,lockedblocks,minrelease; int64_t newamount,inputsum,amount,CCchange=0,totalallocations=0,checkallocations=0,allocation; CTxOut vout; CScript onlyopret; char txidaddr[64],destaddr[64]; std::vector<uint256> txidoprets;
+    int32_t top; std::vector<std::vector<uint8_t>> excludeScriptPubKeys; int8_t funcid;
+    mpz_t mpzTotalAllocations; mpz_init(mpzTotalAllocations);
     cJSON *params = payments_reparse(&n,jsonstr);
     mypk = pubkey2pk(Mypubkey());
     Paymentspk = GetUnspendable(cp,0);
@@ -478,14 +580,16 @@ UniValue PaymentsRelease(struct CCcontract_info *cp,char *jsonstr)
     {
         createtxid = payments_juint256(jitem(params,0));
         amount = jdouble(jitem(params,1),0) * SATOSHIDEN + 0.0000000049;
-        if ( myGetTransaction(createtxid,tx,hashBlock) != 0 )
+        if ( myGetTransaction(createtxid,tx,hashBlock) != 0 && tx.vout.size() > 0 )
         {
-            if ( tx.vout.size() > 0 && DecodePaymentsOpRet(tx.vout[tx.vout.size()-1].scriptPubKey,lockedblocks,minrelease,totalallocations,txidoprets) != 0 )
+            if ( ((funcid= DecodePaymentsOpRet(tx.vout[tx.vout.size()-1].scriptPubKey,lockedblocks,minrelease,totalallocations,txidoprets)) == 'C' || (funcid= DecodePaymentsSnapsShotOpRet(tx.vout[tx.vout.size()-1].scriptPubKey,lockedblocks,minrelease,top,excludeScriptPubKeys)) == 'S' || (funcid= DecodePaymentsTokensOpRet(tx.vout[tx.vout.size()-1].scriptPubKey,lockedblocks,minrelease,top,excludeScriptPubKeys,tokenid)) == 'O') )
             {
-                if ( lockedblocks < 0 || minrelease < 0 || totalallocations <= 0 || txidoprets.size() < 2 )
+                if ( lockedblocks < 0 || minrelease < 0 || totalallocations <= 0 )
                 {
                     result.push_back(Pair("result","error"));
                     result.push_back(Pair("error","negative parameter"));
+                    if ( params != 0 )
+                        free_json(params);
                     return(result);
                 }
                 latestheight = (nextheight - lockedblocks - 1);
@@ -495,94 +599,163 @@ UniValue PaymentsRelease(struct CCcontract_info *cp,char *jsonstr)
                     result.push_back(Pair("error","amount too smal"));
                     result.push_back(Pair("amount",ValueFromAmount(amount)));
                     result.push_back(Pair("minrelease",ValueFromAmount(minrelease*COIN)));
+                    if ( params != 0 )
+                        free_json(params);
                     return(result);
                 }
                 txidpk = CCtxidaddr(txidaddr,createtxid);
                 mtx.vout.push_back(MakeCC1of2vout(EVAL_PAYMENTS,0,Paymentspk,txidpk));
-                m = txidoprets.size();
-                for (i=0; i<m; i++)
+                if ( funcid = 'C' )
                 {
-                    std::vector<uint8_t> scriptPubKey,opret;
-                    vout.nValue = 0;
-                    if ( myGetTransaction(txidoprets[i],txO,hashBlock) != 0 && txO.vout.size() > 1 && DecodePaymentsTxidOpRet(txO.vout[txO.vout.size()-1].scriptPubKey,allocation,scriptPubKey,opret) == 'T' )
+                    // normal payments
+                    for (i=0; i<m; i++)
                     {
-                        vout.nValue = allocation;
-                        vout.scriptPubKey.resize(scriptPubKey.size());
-                        memcpy(&vout.scriptPubKey[0],&scriptPubKey[0],scriptPubKey.size());
-                        checkallocations += allocation;
-                        if ( opret.size() > 0 )
+                        std::vector<uint8_t> scriptPubKey,opret;
+                        vout.nValue = 0;
+                        if ( myGetTransaction(txidoprets[i],txO,hashBlock) != 0 && txO.vout.size() > 1 && DecodePaymentsTxidOpRet(txO.vout[txO.vout.size()-1].scriptPubKey,allocation,scriptPubKey,opret) == 'T' )
                         {
-                            onlyopret.resize(opret.size());
-                            memcpy(&onlyopret[0],&opret[0],opret.size());
-                            numoprets++;
-                        }
-                    } else break;
-                    mtx.vout.push_back(vout);
-                }
-                result.push_back(Pair("numoprets",(int64_t)numoprets));
-                if ( i != m )
-                {
-                    result.push_back(Pair("result","error"));
-                    result.push_back(Pair("error","invalid txidoprets[i]"));
-                    result.push_back(Pair("txi",(int64_t)i));
-                    if ( params != 0 )
-                        free_json(params);
-                    return(result);
+                            vout.nValue = allocation;
+                            vout.scriptPubKey.resize(scriptPubKey.size());
+                            memcpy(&vout.scriptPubKey[0],&scriptPubKey[0],scriptPubKey.size());
+                            checkallocations += allocation;
+                            if ( opret.size() > 0 )
+                            {
+                                onlyopret.resize(opret.size());
+                                memcpy(&onlyopret[0],&opret[0],opret.size());
+                                numoprets++;
+                            }
+                        } else break;
+                        mtx.vout.push_back(vout);
+                    }
+                    result.push_back(Pair("numoprets",(int64_t)numoprets));
+                    if ( i != m )
+                    {
+                        result.push_back(Pair("result","error"));
+                        result.push_back(Pair("error","invalid txidoprets[i]"));
+                        result.push_back(Pair("txi",(int64_t)i));
+                        if ( params != 0 )
+                            free_json(params);
+                        return(result);
+                    }
+                    else if ( checkallocations != totalallocations )
+                    {
+                        result.push_back(Pair("result","error"));
+                        result.push_back(Pair("error","totalallocations mismatch"));
+                        result.push_back(Pair("checkallocations",(int64_t)checkallocations));
+                        result.push_back(Pair("totalallocations",(int64_t)totalallocations));
+                        if ( params != 0 )
+                            free_json(params);
+                        return(result);
+                    }
+                    else if ( numoprets > 1 )
+                    {
+                        result.push_back(Pair("result","error"));
+                        result.push_back(Pair("error","too many oprets"));
+                        if ( params != 0 )
+                            free_json(params);
+                        return(result);
+                    }
+                    // set totalallocations to a mpz_t bignum, for amounts calculation later. 
+                    mpz_set_si(mpzTotalAllocations,totalallocations);
                 }
-                else if ( checkallocations != totalallocations )
+                else if ( funcid = 'S' )
                 {
-                    result.push_back(Pair("result","error"));
-                    result.push_back(Pair("error","totalallocations mismatch"));
-                    result.push_back(Pair("checkallocations",(int64_t)checkallocations));
-                    result.push_back(Pair("totalallocations",(int64_t)totalallocations));
-                    if ( params != 0 )
-                        free_json(params);
-                    return(result);
+                    // normal snapshot
+                    i = 0;
+                    if ( top > 5000 )
+                    {
+                        // need to test the maximum number, this is an estimate.
+                        result.push_back(Pair("result","error"));
+                        result.push_back(Pair("error","cannot pay more than 5000 addresses"));
+                        if ( params != 0 )
+                            free_json(params);
+                        return(result);
+                    }
+                    for ( auto address : vAddressSnapshot )
+                    {
+                        CScript scriptPubKey = GetScriptForDestination(address.second);
+                        for ( auto skipkey : excludeScriptPubKeys )
+                        {
+                            if ( scriptPubKey != CScript(skipkey.begin(), skipkey.end()) )
+                            {
+                                mpz_t mpzAllocation; mpz_init(mpzAllocation);
+                                i++;
+                                //fprintf(stderr, "address: %s nValue.%li \n", CBitcoinAddress(address.second).ToString().c_str(), address.first);
+                                vout.nValue = address.first;
+                                vout.scriptPubKey = scriptPubKey;
+                                mpz_set_si(mpzAllocation,address.first); 
+                                mpz_add(mpzTotalAllocations,mpzTotalAllocations,mpzAllocation); //totalallocations += address.first;
+                                mtx.vout.push_back(vout);
+                                mpz_clear(mpzAllocation);
+                            } else fprintf(stderr, "SKIPPED::: %s\n", CBitcoinAddress(address.second).ToString().c_str());
+                        }
+                        if ( i == top ) // we reached top amount to pay, it can be less than this!
+                            break;
+                    }
+                    m = i; // this is the amount we got, either top, or all of the address on the chain.
                 }
-                else if ( numoprets > 1 )
+                else if ( funcid = 'O' )
                 {
-                    result.push_back(Pair("result","error"));
-                    result.push_back(Pair("error","too many oprets"));
-                    if ( params != 0 )
-                        free_json(params);
-                    return(result);
+                    // token snapshot
                 }
                 newamount = amount;
+                int64_t totalamountsent = 0;
+                mpz_t mpzAmount; mpz_init(mpzAmount); mpz_set_si(mpzAmount,amount);
                 for (i=0; i<m; i++)
                 {
-                    mtx.vout[i+1].nValue *= amount;
-                    mtx.vout[i+1].nValue /= totalallocations;
+                    mpz_t mpzValue; mpz_init(mpzValue);
+                    mpz_set_si(mpzValue,mtx.vout[i+1].nValue);
+                    mpz_mul(mpzValue,mpzValue,mpzAmount); 
+                    mpz_cdiv_q(mpzValue,mpzValue,mpzTotalAllocations); 
+                    if ( mpz_fits_slong_p(mpzValue) ) 
+                        mtx.vout[i+1].nValue = mpz_get_si(mpzValue);
+                    else
+                    {
+                        result.push_back(Pair("result","error"));
+                        result.push_back(Pair("error","value too big, try releasing a smaller amount"));
+                        if ( params != 0 )
+                            free_json(params);
+                        return(result);
+                    } 
+                    //fprintf(stderr, "nValue.%li \n", mtx.vout[i+1].nValue);
+                    mpz_clear(mpzValue);
                     if ( mtx.vout[i+1].nValue < PAYMENTS_TXFEE )
                     {
                         newamount += (PAYMENTS_TXFEE - mtx.vout[i+1].nValue);
                         mtx.vout[i+1].nValue = PAYMENTS_TXFEE;
                     }
+                    totalamountsent += mtx.vout[i+1].nValue;
                 } 
-                if ( (inputsum= AddPaymentsInputs(cp,mtx,txidpk,newamount+2*PAYMENTS_TXFEE,CC_MAXVINS/2,createtxid,latestheight)) >= newamount+2*PAYMENTS_TXFEE )
-                {
-                    std::string rawtx;
-                    if ( (CCchange= (inputsum - newamount - 2*PAYMENTS_TXFEE)) >= PAYMENTS_TXFEE )
-                        mtx.vout[0].nValue = CCchange;
-                    mtx.vout.push_back(CTxOut(PAYMENTS_TXFEE,CScript() << ParseHex(HexStr(txidpk)) << OP_CHECKSIG));
-                    GetCCaddress1of2(cp,destaddr,Paymentspk,txidpk);
-                    CCaddr1of2set(cp,Paymentspk,txidpk,cp->CCpriv,destaddr);
-                    rawtx = FinalizeCCTx(0,cp,mtx,mypk,PAYMENTS_TXFEE,onlyopret);
-                    if ( params != 0 )
-                        free_json(params);
-                    result.push_back(Pair("amount",ValueFromAmount(amount)));
-                    result.push_back(Pair("newamount",ValueFromAmount(newamount)));
-                    return(payments_rawtxresult(result,rawtx,1));
-                }
-                else
-                {
-                    result.push_back(Pair("result","error"));
-                    result.push_back(Pair("error","couldnt find enough locked funds"));
-                }
+                //fprintf(stderr, "newamount.%li totalamountsent.%li\n", newamount, totalamountsent);
+                mpz_clear(mpzAmount); mpz_clear(mpzTotalAllocations);
             }
             else
             {
                 result.push_back(Pair("result","error"));
                 result.push_back(Pair("error","couldnt decode paymentscreate txid opret"));
+                if ( params != 0 )
+                    free_json(params);
+                return(result);
+            }
+            if ( (inputsum= AddPaymentsInputs(cp,mtx,txidpk,newamount+2*PAYMENTS_TXFEE,CC_MAXVINS/2,createtxid,latestheight)) >= newamount+2*PAYMENTS_TXFEE )
+            {
+                std::string rawtx;
+                if ( (CCchange= (inputsum - newamount - 2*PAYMENTS_TXFEE)) >= PAYMENTS_TXFEE )
+                    mtx.vout[0].nValue = CCchange;
+                mtx.vout.push_back(CTxOut(PAYMENTS_TXFEE,CScript() << ParseHex(HexStr(txidpk)) << OP_CHECKSIG));
+                GetCCaddress1of2(cp,destaddr,Paymentspk,txidpk);
+                CCaddr1of2set(cp,Paymentspk,txidpk,cp->CCpriv,destaddr);
+                rawtx = FinalizeCCTx(0,cp,mtx,mypk,PAYMENTS_TXFEE,onlyopret);
+                if ( params != 0 )
+                    free_json(params);
+                result.push_back(Pair("amount",ValueFromAmount(amount)));
+                result.push_back(Pair("newamount",ValueFromAmount(newamount)));
+                return(payments_rawtxresult(result,rawtx,0));
+            }
+            else
+            {
+                result.push_back(Pair("result","error"));
+                result.push_back(Pair("error","couldnt find enough locked funds"));
             }
         }
         else
@@ -605,6 +778,8 @@ UniValue PaymentsFund(struct CCcontract_info *cp,char *jsonstr)
 {
     CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight()); UniValue result(UniValue::VOBJ);
     CPubKey Paymentspk,mypk,txidpk; uint256 txid,hashBlock; int64_t amount,totalallocations; CScript opret; CTransaction tx; char txidaddr[64]; std::string rawtx; int32_t n,useopret = 0,lockedblocks,minrelease; std::vector<uint256> txidoprets;
+    int32_t top; std::vector<std::vector<uint8_t>> excludeScriptPubKeys; // snapshot 
+    uint256 tokenid;
     cJSON *params = payments_reparse(&n,jsonstr);
     mypk = pubkey2pk(Mypubkey());
     Paymentspk = GetUnspendable(cp,0);
@@ -614,14 +789,14 @@ UniValue PaymentsFund(struct CCcontract_info *cp,char *jsonstr)
         amount = jdouble(jitem(params,1),0) * SATOSHIDEN + 0.0000000049;
         if ( n == 3 )
             useopret = jint(jitem(params,2),0) != 0;
-        if ( myGetTransaction(txid,tx,hashBlock) == 0 || tx.vout.size() == 1 || DecodePaymentsOpRet(tx.vout[tx.vout.size()-1].scriptPubKey,lockedblocks,minrelease,totalallocations,txidoprets) == 0 )
+        if ( myGetTransaction(txid,tx,hashBlock) == 0 || tx.vout.size() == 1 || (DecodePaymentsOpRet(tx.vout[tx.vout.size()-1].scriptPubKey,lockedblocks,minrelease,totalallocations,txidoprets) == 0 && DecodePaymentsSnapsShotOpRet(tx.vout[tx.vout.size()-1].scriptPubKey,lockedblocks,minrelease,top,excludeScriptPubKeys) == 0 && DecodePaymentsTokensOpRet(tx.vout[tx.vout.size()-1].scriptPubKey,lockedblocks,minrelease,top,excludeScriptPubKeys,tokenid) == 0) )
         {
             result.push_back(Pair("result","error"));
             result.push_back(Pair("error","invalid createtxid"));
         }
         else if ( AddNormalinputs(mtx,mypk,amount+PAYMENTS_TXFEE,60) > 0 )
         {
-            if ( lockedblocks < 0 || minrelease < 0 || totalallocations <= 0 || txidoprets.size() < 2 )
+            if ( lockedblocks < 0 || minrelease < 0 || totalallocations <= 0 )
             {
                 result.push_back(Pair("result","error"));
                 result.push_back(Pair("error","negative parameter"));
@@ -637,13 +812,13 @@ UniValue PaymentsFund(struct CCcontract_info *cp,char *jsonstr)
             else
             {
                 mtx.vout.push_back(MakeCC1vout(EVAL_PAYMENTS,amount,Paymentspk));
+                opret = EncodePaymentsFundOpRet(txid);
                 // Use the below one along with other FinalizeCCTx/return, to get the ccvout scriptpubkey
-                /*opret = EncodePaymentsFundOpRet(txid);
-                std::vector<std::vector<unsigned char>> vData = std::vector<std::vector<unsigned char>>();
+                /*std::vector<std::vector<unsigned char>> vData = std::vector<std::vector<unsigned char>>();
                 if ( makeCCopret(opret, vData) )
                     mtx.vout.push_back(MakeCC1vout(EVAL_PAYMENTS,amount,Paymentspk,&vData)); */
             }
-            rawtx = FinalizeCCTx(0,cp,mtx,mypk,PAYMENTS_TXFEE,EncodePaymentsFundOpRet(txid));
+            rawtx = FinalizeCCTx(0,cp,mtx,mypk,PAYMENTS_TXFEE,opret);
             //rawtx = FinalizeCCTx(0,cp,mtx,mypk,PAYMENTS_TXFEE,CScript()); // use this one to get ccvout scriptpubkey.
             if ( params != 0 )
                 free_json(params);
@@ -783,15 +958,17 @@ UniValue PaymentsCreate(struct CCcontract_info *cp,char *jsonstr)
 
 UniValue PaymentsAirdrop(struct CCcontract_info *cp,char *jsonstr)
 {
-    // need to code: exclude list of tokenid, dust threshold, maxpayees, excluded pubkeys[]
     CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
-    UniValue result(UniValue::VOBJ); CTransaction tx; CPubKey Paymentspk,mypk; char markeraddr[64]; std::vector<uint256> txidoprets; uint256 hashBlock; int32_t i,n,numoprets=0,lockedblocks,minrelease; std::string rawtx; int64_t totalallocations = 0;
+    UniValue result(UniValue::VOBJ); 
+    uint256 hashBlock; CTransaction tx; CPubKey Paymentspk,mypk; char markeraddr[64]; std::string rawtx; 
+    int32_t lockedblocks,minrelease,top,n,i; std::vector<std::vector<uint8_t>> excludeScriptPubKeys;
     cJSON *params = payments_reparse(&n,jsonstr);
     if ( params != 0 && n >= 4 )
     {
         lockedblocks = juint(jitem(params,0),0);
         minrelease = juint(jitem(params,1),0);
-        if ( lockedblocks < 0 || minrelease < 0 )
+        top = juint(jitem(params,2),0);
+        if ( lockedblocks < 0 || minrelease < 0 || top < 0 )
         {
             result.push_back(Pair("result","error"));
             result.push_back(Pair("error","negative parameter"));
@@ -799,47 +976,29 @@ UniValue PaymentsAirdrop(struct CCcontract_info *cp,char *jsonstr)
                 free_json(params);
             return(result);
         }
-        for (i=0; i<n-2; i++)
-            txidoprets.push_back(payments_juint256(jitem(params,2+i)));
-        for (i=0; i<txidoprets.size(); i++)
-        {
-            std::vector<uint8_t> scriptPubKey,opret; int64_t allocation;
-            if ( myGetTransaction(txidoprets[i],tx,hashBlock) != 0 && tx.vout.size() > 1 && DecodePaymentsTxidOpRet(tx.vout[tx.vout.size()-1].scriptPubKey,allocation,scriptPubKey,opret) == 'T' )
-            {
-                totalallocations += allocation;
-                if ( opret.size() > 0 )
-                    numoprets++;
-            }
-            else
-            {
-                result.push_back(Pair("result","error"));
-                result.push_back(Pair("error","invalid txidopret"));
-                result.push_back(Pair("txid",txidoprets[i].GetHex()));
-                result.push_back(Pair("txi",(int64_t)i));
-                if ( params != 0 )
-                    free_json(params);
-                return(result);
-            }
-        }
-        if ( numoprets > 1 )
+        for (i=0; i<n-3; i++)
         {
-            result.push_back(Pair("result","error"));
-            result.push_back(Pair("error","too many opreturns"));
-            result.push_back(Pair("numoprets",(int64_t)numoprets));
-            if ( params != 0 )
-                free_json(params);
-            return(result);
+            /* TODO: Change this RPC to take an address. Because a tokens airdrop needs its own RPC anyway.
+            CTxDestination destination = DecodeDestination(name_);
+            CScript scriptPubKey = GetScriptForDestination(destination);
+            */
+            char *inputhex = jstri(params,3+i);
+            std::vector<uint8_t> scriptPubKey;
+            int32_t len = strlen(inputhex)/2;
+            scriptPubKey.resize(len);
+            decode_hex((uint8_t *)scriptPubKey.data(),len,(char *)inputhex);
+            excludeScriptPubKeys.push_back(scriptPubKey);
         }
         mypk = pubkey2pk(Mypubkey());
         Paymentspk = GetUnspendable(cp,0);
         if ( AddNormalinputs(mtx,mypk,2*PAYMENTS_TXFEE,60) > 0 )
         {
             mtx.vout.push_back(MakeCC1of2vout(cp->evalcode,PAYMENTS_TXFEE,Paymentspk,Paymentspk));
-            rawtx = FinalizeCCTx(0,cp,mtx,mypk,PAYMENTS_TXFEE,EncodePaymentsOpRet(lockedblocks,minrelease,totalallocations,txidoprets));
+            rawtx = FinalizeCCTx(0,cp,mtx,mypk,PAYMENTS_TXFEE,EncodePaymentsSnapsShotOpRet(lockedblocks,minrelease,top,excludeScriptPubKeys));
             if ( params != 0 )
                 free_json(params);
-            return(payments_rawtxresult(result,rawtx,1));
-        }
+            return(payments_rawtxresult(result,rawtx,0));
+        } 
         result.push_back(Pair("result","error"));
         result.push_back(Pair("error","not enough normal funds"));
     }
@@ -856,14 +1015,16 @@ UniValue PaymentsAirdrop(struct CCcontract_info *cp,char *jsonstr)
 UniValue PaymentsInfo(struct CCcontract_info *cp,char *jsonstr)
 {
     UniValue result(UniValue::VOBJ),a(UniValue::VARR); CTransaction tx,txO; CPubKey Paymentspk,txidpk; int32_t i,j,n,flag=0,numoprets=0,lockedblocks,minrelease; std::vector<uint256> txidoprets; int64_t funds,fundsopret,totalallocations=0,allocation; char fundsaddr[64],fundsopretaddr[64],txidaddr[64],*outstr; uint256 createtxid,hashBlock;
+    int32_t top; std::vector<std::vector<uint8_t>> excludeScriptPubKeys; // snapshot 
+    uint256 tokenid;
     cJSON *params = payments_reparse(&n,jsonstr);
     if ( params != 0 && n == 1 )
     {
         Paymentspk = GetUnspendable(cp,0);
         createtxid = payments_juint256(jitem(params,0));
-        if ( myGetTransaction(createtxid,tx,hashBlock) != 0 )
+        if ( myGetTransaction(createtxid,tx,hashBlock) != 0 && tx.vout.size() > 0 )
         {
-            if ( tx.vout.size() > 0 && DecodePaymentsOpRet(tx.vout[tx.vout.size()-1].scriptPubKey,lockedblocks,minrelease,totalallocations,txidoprets) != 0 )
+            if ( DecodePaymentsOpRet(tx.vout[tx.vout.size()-1].scriptPubKey,lockedblocks,minrelease,totalallocations,txidoprets) != 0 )
             {
                 if ( lockedblocks < 0 || minrelease < 0 || totalallocations <= 0 || txidoprets.size() < 2 )
                 {
@@ -873,6 +1034,7 @@ UniValue PaymentsInfo(struct CCcontract_info *cp,char *jsonstr)
                         free_json(params);
                     return(result);
                 }
+                result.push_back(Pair("plan_type","payments"));
                 result.push_back(Pair("lockedblocks",(int64_t)lockedblocks));
                 result.push_back(Pair("totalallocations",(int64_t)totalallocations));
                 result.push_back(Pair("minrelease",(int64_t)minrelease));
@@ -901,29 +1063,71 @@ UniValue PaymentsInfo(struct CCcontract_info *cp,char *jsonstr)
                     } else fprintf(stderr,"error decoding voutsize.%d\n",(int32_t)txO.vout.size());
                     a.push_back(obj);
                 }
-                flag++;
                 result.push_back(Pair("numoprets",(int64_t)numoprets));
                 if ( numoprets > 1 )
                 {
+                    flag++;
                     result.push_back(Pair("result","error"));
                     result.push_back(Pair("error","too many opreturns"));
+                } else result.push_back(Pair("txidoprets",a));
+            }
+            else if ( DecodePaymentsSnapsShotOpRet(tx.vout[tx.vout.size()-1].scriptPubKey,lockedblocks,minrelease,top,excludeScriptPubKeys) != 0 )
+            {
+                if ( lockedblocks < 0 || minrelease < 0 || top <= 0 )
+                {
+                    result.push_back(Pair("result","error"));
+                    result.push_back(Pair("error","negative parameter"));
+                    if ( params != 0 )
+                        free_json(params);
+                    return(result);
                 }
-                else
+                result.push_back(Pair("plan_type","snapshot"));
+                result.push_back(Pair("lockedblocks",(int64_t)lockedblocks));
+                result.push_back(Pair("minrelease",(int64_t)minrelease));
+                result.push_back(Pair("top",(int64_t)top));
+                for ( auto scriptPubKey : excludeScriptPubKeys )
+                    a.push_back(HexStr(scriptPubKey.begin(),scriptPubKey.end()));
+                result.push_back(Pair("excludeScriptPubkeys",a));
+            }
+            else if ( DecodePaymentsTokensOpRet(tx.vout[tx.vout.size()-1].scriptPubKey,lockedblocks,minrelease,top,excludeScriptPubKeys,tokenid) != 0 )
+            {
+                if ( lockedblocks < 0 || minrelease < 0 || top <= 0 )
                 {
-                    result.push_back(Pair("txidoprets",a));
-                    txidpk = CCtxidaddr(txidaddr,createtxid);
-                    GetCCaddress1of2(cp,fundsaddr,Paymentspk,txidpk);
-                    funds = CCaddress_balance(fundsaddr,1);
-                    result.push_back(Pair(fundsaddr,ValueFromAmount(funds)));
-                    GetCCaddress(cp,fundsopretaddr,Paymentspk);
-                    fundsopret = CCaddress_balance(fundsopretaddr,1); // Shows balance for ALL payments plans, not just the one asked for!
-                    result.push_back(Pair(fundsopretaddr,ValueFromAmount(fundsopret)));
-                    result.push_back(Pair("totalfunds",ValueFromAmount(funds+fundsopret)));
-                    result.push_back(Pair("result","success"));
+                    result.push_back(Pair("result","error"));
+                    result.push_back(Pair("error","negative parameter"));
+                    if ( params != 0 )
+                        free_json(params);
+                    return(result);
                 }
+                result.push_back(Pair("plan_type","token snapshot"));
+                result.push_back(Pair("lockedblocks",(int64_t)lockedblocks));
+                result.push_back(Pair("minrelease",(int64_t)minrelease));
+                result.push_back(Pair("top",(int64_t)top));
+                result.push_back(Pair("tokenid",tokenid.ToString()));
+                for ( auto scriptPubKey : excludeScriptPubKeys )
+                    a.push_back(HexStr(scriptPubKey.begin(),scriptPubKey.end()));
+                result.push_back(Pair("excludeScriptPubkeys",a));
+            }
+            else
+            {
+                result.push_back(Pair("result","error"));
+                result.push_back(Pair("error","couldnt decode valid payments create txid opreturn"));
+            }
+            if ( flag == 0 )
+            {
+                txidpk = CCtxidaddr(txidaddr,createtxid);
+                GetCCaddress1of2(cp,fundsaddr,Paymentspk,txidpk);
+                funds = CCaddress_balance(fundsaddr,1);
+                result.push_back(Pair(fundsaddr,ValueFromAmount(funds)));
+                GetCCaddress(cp,fundsopretaddr,Paymentspk);
+                // TODO: Shows balance for ALL payments plans, not just the one asked for! Needs to be reworked. 
+                fundsopret = CCaddress_balance(fundsopretaddr,1);
+                result.push_back(Pair(fundsopretaddr,ValueFromAmount(fundsopret)));
+                result.push_back(Pair("totalfunds",ValueFromAmount(funds+fundsopret)));
+                result.push_back(Pair("result","success"));
             }
         }
-        if ( flag == 0 )
+        else 
         {
             result.push_back(Pair("result","error"));
             result.push_back(Pair("error","couldnt find valid payments create txid"));
@@ -941,8 +1145,9 @@ UniValue PaymentsInfo(struct CCcontract_info *cp,char *jsonstr)
 
 UniValue PaymentsList(struct CCcontract_info *cp,char *jsonstr)
 {
-    std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex; uint256 txid,hashBlock;
+    std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex; uint256 txid,hashBlock,tokenid;
     UniValue result(UniValue::VOBJ),a(UniValue::VARR); char markeraddr[64],str[65]; CPubKey Paymentspk; CTransaction tx; int32_t lockedblocks,minrelease; std::vector<uint256> txidoprets; int64_t totalallocations;
+    int32_t top; std::vector<std::vector<uint8_t>> excludeScriptPubKeys;
     Paymentspk = GetUnspendable(cp,0);
     GetCCaddress1of2(cp,markeraddr,Paymentspk,Paymentspk);
     SetCCtxids(addressIndex,markeraddr,true);
@@ -951,7 +1156,7 @@ UniValue PaymentsList(struct CCcontract_info *cp,char *jsonstr)
         txid = it->first.txhash;
         if ( it->first.index == 0 && myGetTransaction(txid,tx,hashBlock) != 0 )
         {
-            if ( tx.vout.size() > 0 && DecodePaymentsOpRet(tx.vout[tx.vout.size()-1].scriptPubKey,lockedblocks,minrelease,totalallocations,txidoprets) == 'C' )
+            if ( tx.vout.size() > 0 && (DecodePaymentsOpRet(tx.vout[tx.vout.size()-1].scriptPubKey,lockedblocks,minrelease,totalallocations,txidoprets) == 'C' || DecodePaymentsSnapsShotOpRet(tx.vout[tx.vout.size()-1].scriptPubKey,lockedblocks,minrelease,top,excludeScriptPubKeys) == 'S' || DecodePaymentsTokensOpRet(tx.vout[tx.vout.size()-1].scriptPubKey,lockedblocks,minrelease,top,excludeScriptPubKeys,tokenid) == 'O') )
             {
                 if ( lockedblocks < 0 || minrelease < 0 || totalallocations <= 0 || txidoprets.size() < 2 )
                 {

src/komodo_defs.h

@@ -20,6 +20,7 @@
 #define ASSETCHAINS_MINHEIGHT 128
 #define ASSETCHAINS_MAX_ERAS 3
 #define KOMODO_ELECTION_GAP 2000
+#define KOMODO_SNAPSHOT_INTERVAL 1440 // 1440 is approx 1 day. Maybe this can be -ac param to allow for diffrent block times etc.?
 #define ROUNDROBIN_DELAY 61
 #define KOMODO_ASSETCHAIN_MAXLEN 65
 #define KOMODO_LIMITED_NETWORKSIZE 4

src/main.cpp

@@ -642,6 +642,102 @@ UniValue komodo_snapshot(int top)
     return(result);
 }
 
+bool komodo_snapshot2(std::map <std::string, CAmount> &addressAmounts)
+{
+    if ( fAddressIndex && pblocktree != 0 ) 
+    {
+		return pblocktree->Snapshot2(addressAmounts, 0);
+    }
+    else return false;
+}
+
+int32_t lastSnapShotHeight = 0;
+std::vector <std::pair<CAmount, CTxDestination>> vAddressSnapshot;
+
+bool komodo_dailysnapshot(int32_t height)
+{
+    int reorglimit = 10; // CHANGE BACK TO 100 AFTER TESTING!
+    uint256 notarized_hash,notarized_desttxid; int32_t prevMoMheight,notarized_height,undo_height,extraoffset;
+    if ( (extraoffset= height % KOMODO_SNAPSHOT_INTERVAL) != 0 )
+    {
+        // we are on chain init, and need to scan all the way back to the correct height, other wise our node will have a diffrent snapshot to online nodes.
+        // use the notarizationsDB to scan back from the consesnus height to get the offset we need.
+        std::string symbol; Notarisation nota;
+        symbol.assign(ASSETCHAINS_SYMBOL);
+        if ( ScanNotarisationsDB(height-extraoffset, symbol, 100, nota) == 0 )
+            undo_height = height-extraoffset-reorglimit; 
+        else undo_height = nota.second.height;
+        //fprintf(stderr, "height.%i-extraoffset.%i = startscanfrom.%i to get undo_height.%i\n", height, extraoffset, height-extraoffset, undo_height);
+    }
+    else 
+    {
+        // we are at the right height in connect block to scan back to last notarized height. 
+        notarized_height = komodo_notarized_height(&prevMoMheight,&notarized_hash,&notarized_desttxid);
+        notarized_height > height-100 ? undo_height = notarized_height : undo_height = height-reorglimit; 
+    }
+    fprintf(stderr, "doing snapshot for height.%i undo_height.%i\n", height, undo_height);
+    // if we already did this height dont bother doing it again, this is just a reorg. The actual snapshot height cannot be reorged.
+    if ( undo_height == lastSnapShotHeight )
+        return true;
+    std::map <std::string, int64_t> addressAmounts;
+    if ( !komodo_snapshot2(addressAmounts) )
+        return false;
+
+    // undo blocks in reverse order
+    for (int32_t n = height; n > undo_height; n--) 
+    {
+        //fprintf(stderr, "undoing block.%i\n",n);
+        CBlockIndex *pindex; CBlock block;
+        if ( (pindex= komodo_chainactive(n)) == 0 || komodo_blockload(block, pindex) != 0 ) 
+            return false;
+        // undo transactions in reverse order
+        for (int32_t i = block.vtx.size() - 1; i >= 0; i--) 
+        {
+            const CTransaction &tx = block.vtx[i];
+            CTxDestination vDest; 
+            // loop vouts reverse order, remove value recieved.
+            for (unsigned int k = tx.vout.size(); k-- > 0;) 
+            {
+                const CTxOut &out = tx.vout[k];
+                if ( ExtractDestination(out.scriptPubKey, vDest) )
+                {
+                    addressAmounts[CBitcoinAddress(vDest).ToString()] -= out.nValue;
+                    if ( addressAmounts[CBitcoinAddress(vDest).ToString()] < 1 )
+                        addressAmounts.erase(CBitcoinAddress(vDest).ToString());
+                    //fprintf(stderr, "VOUT: address.%s remove_coins.%li\n",CBitcoinAddress(vDest).ToString().c_str(), out.nValue);
+                } 
+            }
+            // loop vins in reverse order, get prevout and return the sent balance.
+            for (unsigned int j = tx.vin.size(); j-- > 0;) 
+            {
+                uint256 blockhash; CTransaction txin;
+                if ( !tx.IsCoinImport() && !tx.IsCoinBase() && myGetTransaction(tx.vin[j].prevout.hash,txin,blockhash) ) 
+                {
+                    int vout = tx.vin[j].prevout.n;
+                    if ( ExtractDestination(txin.vout[vout].scriptPubKey, vDest) )
+                    {
+                        //fprintf(stderr, "VIN: address.%s add_coins.%li\n",CBitcoinAddress(vDest).ToString().c_str(), txin.vout[vout].nValue);
+                        addressAmounts[CBitcoinAddress(vDest).ToString()] += txin.vout[vout].nValue;
+                    }
+                }
+            }
+        }
+    }
+    vAddressSnapshot.clear(); // clear existing snapshot
+    // convert address string to destination for easier conversion to what ever is required, eg, scriptPubKey. 
+    for ( auto element : addressAmounts)
+        vAddressSnapshot.push_back(make_pair(element.second, DecodeDestination(element.first)));
+    // sort the vector by amount, highest at top.
+    std::sort(vAddressSnapshot.rbegin(), vAddressSnapshot.rend());
+    //for (int j = 0; j < 50; j++) 
+    //    fprintf(stderr, "j.%i address.%s nValue.%li\n",j, CBitcoinAddress(vAddressSnapshot[j].second).ToString().c_str(), vAddressSnapshot[j].first );
+    // include only top 5000 address.
+    if ( vAddressSnapshot.size() > 5000 ) vAddressSnapshot.resize(5000);
+    lastSnapShotHeight = undo_height; 
+    fprintf(stderr, "vAddressSnapshot.size.%li\n", vAddressSnapshot.size());
+    return true;
+}
+
 //////////////////////////////////////////////////////////////////////////////
 //
 // mapOrphanTransactions
@@ -3096,7 +3192,6 @@ bool DisconnectBlock(CBlock& block, CValidationState& state, CBlockIndex* pindex
                             uint160 addrHash = addr.size() == 20 ? uint160(addr) : Hash160(addr);
                             // undo spending activity
                             addressIndex.push_back(make_pair(CAddressIndexKey(keyType, addrHash, pindex->GetHeight(), i, hash, j, true), prevout.nValue * -1));
-
                             // restore unspent index
                             addressUnspentIndex.push_back(make_pair(CAddressUnspentKey(keyType, addrHash, input.prevout.hash, input.prevout.n), CAddressUnspentValue(prevout.nValue, prevout.scriptPubKey, undo.nHeight)));
                         }
@@ -4156,6 +4251,13 @@ bool static ConnectTip(CValidationState &state, CBlockIndex *pindexNew, CBlock *
         komodo_pricesupdate(pindexNew->GetHeight(),pblock);
     if ( ASSETCHAINS_SAPLING <= 0 && pindexNew->nTime > KOMODO_SAPLING_ACTIVATION - 24*3600 )
         komodo_activate_sapling(pindexNew);
+    if ( ASSETCHAINS_CC != 0 && (pindexNew->GetHeight() % KOMODO_SNAPSHOT_INTERVAL) == 0 )
+    {
+        uint64_t start = time(NULL);
+        if ( !komodo_dailysnapshot(pindexNew->GetHeight()) )
+            fprintf(stderr, "daily snapshot failed, please reindex your chain\n"); // maybe force shutdown here?
+        fprintf(stderr, "snapshot completed in: %lu seconds\n", time(NULL)-start);
+    }
     return true;
 }
 
@@ -6095,7 +6197,13 @@ bool CVerifyDB::VerifyDB(CCoinsView *coinsview, int nCheckLevel, int nCheckDepth
     }
 
     LogPrintf("No coin database inconsistencies in last %i blocks (%i transactions)\n", chainActive.Height() - pindexState->GetHeight(), nGoodTransactions);
-
+    
+    if ( ASSETCHAINS_CC != 0 && chainActive.Height() > KOMODO_SNAPSHOT_INTERVAL )
+    {
+        if ( !komodo_dailysnapshot(chainActive.Height()) )
+            fprintf(stderr, "daily snapshot failed, please reindex your chain\n"); // maybe force shutdown here?
+    }
+    
     return true;
 }
 

src/rpc/server.cpp

@@ -480,12 +480,13 @@ static const CRPCCommand vRPCCommands[] =
     { "marmara",       "marmaralock",   &marmara_lock,      true },
 
     // Payments
-    { "payments",       "paymentsaddress",   &paymentsaddress,      true },
-    { "payments",       "paymentstxidopret", &payments_txidopret,      true },
-    { "payments",       "paymentscreate",    &payments_create,      true },
-    { "payments",       "paymentslist",      &payments_list,      true },
-    { "payments",       "paymentsinfo",      &payments_info,      true },
-    { "payments",       "paymentsfund",      &payments_fund,      true },
+    { "payments",       "paymentsaddress",   &paymentsaddress,       true },
+    { "payments",       "paymentstxidopret", &payments_txidopret,    true },
+    { "payments",       "paymentscreate",    &payments_create,       true },
+    { "payments",       "paymentsairdrop",   &payments_airdrop,      true },
+    { "payments",       "paymentslist",      &payments_list,         true },
+    { "payments",       "paymentsinfo",      &payments_info,         true },
+    { "payments",       "paymentsfund",      &payments_fund,         true },
     { "payments",       "paymentsrelease",   &payments_release,      true },
 
     { "CClib",       "cclibaddress",   &cclibaddress,      true },

src/rpc/server.h

@@ -287,6 +287,7 @@ extern UniValue payments_release(const UniValue& params, bool fHelp);
 extern UniValue payments_fund(const UniValue& params, bool fHelp);
 extern UniValue payments_txidopret(const UniValue& params, bool fHelp);
 extern UniValue payments_create(const UniValue& params, bool fHelp);
+extern UniValue payments_airdrop(const UniValue& params, bool fHelp);
 extern UniValue payments_info(const UniValue& params, bool fHelp);
 extern UniValue payments_list(const UniValue& params, bool fHelp);
 

src/txdb.cpp

@@ -458,13 +458,13 @@ uint32_t komodo_segid32(char *coinaddr);
     {"RD6GgnrMpPaTSMn8vai6yiGA7mN4QGPVMY", 1} \
 };
 
-int32_t CBlockTreeDB::Snapshot2(int64_t dustthreshold, int32_t top ,std::vector <std::pair<CAmount, std::string>> &vaddr, UniValue *ret)
+bool CBlockTreeDB::Snapshot2(std::map <std::string, CAmount> &addressAmounts, UniValue *ret)
 {
     int64_t total = 0; int64_t totalAddresses = 0; std::string address;
     int64_t utxos = 0; int64_t ignoredAddresses = 0, cryptoConditionsUTXOs = 0, cryptoConditionsTotals = 0;
     DECLARE_IGNORELIST
     boost::scoped_ptr<CDBIterator> iter(NewIterator());
-    std::map <std::string, CAmount> addressAmounts;
+    //std::map <std::string, CAmount> addressAmounts;
     for (iter->SeekToLast(); iter->Valid(); iter->Prev())
     {
         boost::this_thread::interruption_point();
@@ -486,40 +486,39 @@ int32_t CBlockTreeDB::Snapshot2(int64_t dustthreshold, int32_t top ,std::vector
                     {
                         cryptoConditionsUTXOs++;
                         cryptoConditionsTotals += nValue;
+                        total += nValue;
+                        continue;
+                    }
+                    std::map <std::string, int>::iterator ignored = ignoredMap.find(address);
+                    if (ignored != ignoredMap.end())
+                    {
+                        fprintf(stderr,"ignoring %s\n", address.c_str());
+                        ignoredAddresses++;
                         continue;
                     }
-                    if ( nValue > dustthreshold )
+                    std::map <std::string, CAmount>::iterator pos = addressAmounts.find(address);
+                    if ( pos == addressAmounts.end() )
                     {
-                        std::map <std::string, int>::iterator ignored = ignoredMap.find(address);
-                        if (ignored != ignoredMap.end())
-                        {
-                            fprintf(stderr,"ignoring %s\n", address.c_str());
-                            ignoredAddresses++;
-                            continue;
-                        }
-                        std::map <std::string, CAmount>::iterator pos = addressAmounts.find(address);
-                        if ( pos == addressAmounts.end() )
-                        {
-                            // insert new address + utxo amount
-                            //fprintf(stderr, "inserting new address %s with amount %li\n", address.c_str(), nValue);
-                            addressAmounts[address] = nValue;
-                            totalAddresses++;
-                        }
-                        else
-                        {
-                            // update unspent tally for this address
-                            //fprintf(stderr, "updating address %s with new utxo amount %li\n", address.c_str(), nValue);
-                            addressAmounts[address] += nValue;
-                        }
-                        //fprintf(stderr,"{\"%s\", %.8f},\n",address.c_str(),(double)nValue/COIN);
-                        // total += nValue;
-                        utxos++;
-                    } //else fprintf(stderr,"ignoring amount=0 UTXO for %s\n", address.c_str());
+                        // insert new address + utxo amount
+                        //fprintf(stderr, "inserting new address %s with amount %li\n", address.c_str(), nValue);
+                        addressAmounts[address] = nValue;
+                        totalAddresses++;
+                    }
+                    else
+                    {
+                        // update unspent tally for this address
+                        //fprintf(stderr, "updating address %s with new utxo amount %li\n", address.c_str(), nValue);
+                        addressAmounts[address] += nValue;
+                    }
+                    //fprintf(stderr,"{\"%s\", %.8f},\n",address.c_str(),(double)nValue/COIN);
+                    // total += nValue;
+                    utxos++;
+                    total += nValue;
                 }
                 catch (const std::exception& e)
                 {
                     fprintf(stderr, "DONE %s: LevelDB addressindex exception! - %s\n", __func__, e.what());
-                    break;
+                    return false; //break; this means failiure of DB? we need to exit here if so for consensus code!
                 }
             }
         }
@@ -530,30 +529,18 @@ int32_t CBlockTreeDB::Snapshot2(int64_t dustthreshold, int32_t top ,std::vector
         }
     }
     //fprintf(stderr, "total=%f, totalAddresses=%li, utxos=%li, ignored=%li\n", (double) total / COIN, totalAddresses, utxos, ignoredAddresses);
-    for (std::pair<std::string, CAmount> element : addressAmounts)
-        vaddr.push_back( make_pair(element.second, element.first) );
-    std::sort(vaddr.rbegin(), vaddr.rend());
-    int topN = 0;
-    for (std::vector<std::pair<CAmount, std::string>>::iterator it = vaddr.begin(); it!=vaddr.end(); ++it)
-    {
-        total += it->first;
-        topN++;
-        // If requested, only show top N addresses in output JSON
-       	if ( top == topN )
-            break;
-    }
+    
     // this is for the snapshot RPC, you can skip this by passing a 0 as the last argument.
     if (ret)
     {
-        // Total amount in this snapshot, which is less than circulating supply if top parameter is used
-        // Use the address_total for a total of all address included when using top parameter.
-        ret->push_back(make_pair("total", (double) (total+cryptoConditionsTotals)/ COIN ));
+        // Total circulating supply without CC vouts.
+        ret->push_back(make_pair("total", (double) (total)/ COIN ));
         // Average amount in each address of this snapshot
         ret->push_back(make_pair("average",(double) (total/COIN) / totalAddresses ));
         // Total number of utxos processed in this snaphot
         ret->push_back(make_pair("utxos", utxos));
         // Total number of addresses in this snaphot
-        ret->push_back(make_pair("total_addresses", top ? top : totalAddresses ));
+        ret->push_back(make_pair("total_addresses", totalAddresses ));
         // Total number of ignored addresses in this snaphot
         ret->push_back(make_pair("ignored_addresses", ignoredAddresses));
         // Total number of crypto condition utxos we skipped
@@ -561,22 +548,28 @@ int32_t CBlockTreeDB::Snapshot2(int64_t dustthreshold, int32_t top ,std::vector
         // Total value of skipped crypto condition utxos
         ret->push_back(make_pair("cc_utxo_value", (double) cryptoConditionsTotals / COIN));
         // total of all the address's, does not count coins in CC vouts.
-        ret->push_back(make_pair("address_total", (double) total/ COIN ));
+        ret->push_back(make_pair("total_includeCCvouts", (double) (total+cryptoConditionsTotals)/ COIN ));
         // The snapshot finished at this block height
         ret->push_back(make_pair("ending_height", chainActive.Height()));
     }
-    return(topN);
+    return true;
 }
 
 UniValue CBlockTreeDB::Snapshot(int top)
 {
     int topN = 0;
     std::vector <std::pair<CAmount, std::string>> vaddr;
+    //std::vector <std::vector <std::pair<CAmount, CScript>>> tokenids;
+    std::map <std::string, CAmount> addressAmounts;
     UniValue result(UniValue::VOBJ);
     UniValue addressesSorted(UniValue::VARR);
     result.push_back(Pair("start_time", (int) time(NULL)));
-    if ( Snapshot2(0,top,vaddr,&result) != 0 )
+    if ( Snapshot2(addressAmounts,&result) )
     {
+        for (std::pair<std::string, CAmount> element : addressAmounts)
+            vaddr.push_back( make_pair(element.second, element.first) );
+        std::sort(vaddr.rbegin(), vaddr.rend());
+        int topN = 0;
         for (std::vector<std::pair<CAmount, std::string>>::iterator it = vaddr.begin(); it!=vaddr.end(); ++it)
         {
           	UniValue obj(UniValue::VOBJ);

src/txdb.h

@@ -116,7 +116,7 @@ public:
     bool LoadBlockIndexGuts();
     bool blockOnchainActive(const uint256 &hash);
     UniValue Snapshot(int top);
-    int32_t Snapshot2(int64_t dustthreshold, int32_t top,std::vector <std::pair<CAmount, std::string>> &vaddr, UniValue *ret);
+    bool Snapshot2(std::map <std::string, CAmount> &addressAmounts, UniValue *ret);
 };
 
 #endif // BITCOIN_TXDB_H

src/wallet/rpcwallet.cpp

@@ -5629,6 +5629,19 @@ UniValue payments_create(const UniValue& params, bool fHelp)
     return(PaymentsCreate(cp,(char *)params[0].get_str().c_str()));
 }
 
+UniValue payments_airdrop(const UniValue& params, bool fHelp)
+{
+    struct CCcontract_info *cp,C;
+    if ( fHelp || params.size() != 1 )
+        throw runtime_error("paymentsairdrop \"[lockedblocks,minamount,top,%22paytxid0%22,...,%22paytxidN%22]\"\n");
+    if ( ensure_CCrequirements(EVAL_PAYMENTS) < 0 )
+        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    const CKeyStore& keystore = *pwalletMain;
+    LOCK2(cs_main, pwalletMain->cs_wallet);
+    cp = CCinit(&C,EVAL_PAYMENTS);
+    return(PaymentsAirdrop(cp,(char *)params[0].get_str().c_str()));
+}
+
 UniValue payments_info(const UniValue& params, bool fHelp)
 {
     struct CCcontract_info *cp,C;