Merge branch 'FSM' into jl777

qa/pull-tester/cc-tests.sh

@@ -18,6 +18,7 @@ testScripts=(
     'cryptoconditions_rewards.py'
     'cryptoconditions_token.py'
     #'cryptoconditions_gateways.py'
+    'cryptoconditions_heir.py'
     # TODO: cant reconnect nodes back in channels test because of crash (seems regtest only specific)
     'cryptoconditions_channels.py'
 );

qa/rpc-tests/cryptoconditions_heir.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python2
+# Copyright (c) 2018 SuperNET developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+
+import time
+from test_framework.test_framework import CryptoconditionsTestFramework
+from test_framework.authproxy import JSONRPCException
+from test_framework.util import assert_equal, assert_greater_than, \
+    initialize_chain_clean, initialize_chain, start_nodes, start_node, connect_nodes_bi, \
+    stop_nodes, sync_blocks, sync_mempools, wait_bitcoinds, rpc_port, assert_raises
+from cryptoconditions import assert_success, assert_error, generate_random_string
+
+
+class CryptoconditionsHeirTest(CryptoconditionsTestFramework):
+
+    def run_heir_tests(self):
+
+        rpc = self.nodes[0]
+        rpc1 = self.nodes[1]
+
+        result = rpc.heiraddress()
+        assert_success(result)
+        # verify all keys look like valid AC addrs, could be better
+        for x in ['myCCaddress', 'HeirCCaddress', 'Heirmarker', 'myaddress']:
+            assert_equal(result[x][0], 'R')
+
+        result = rpc.heiraddress(self.pubkey)
+        assert_success(result)
+        # test that additional CCaddress key is returned
+        for x in ['myCCaddress', 'HeirCCaddress', 'Heirmarker', 'myaddress', 'CCaddress']:
+            assert_equal(result[x][0], 'R')
+
+        # getting empty heir list
+        result = rpc.heirlist()
+        assert_equal(len(result), 1)
+        assert_success(result)
+
+        # valid heirfund case with coins
+        result = rpc.heirfund("0", "1000", "UNITHEIR", self.pubkey1, "10")
+        assert_success(result)
+
+        heir_fund_txid = self.send_and_mine(result["hextx"], rpc)
+        assert heir_fund_txid, "got heir funding txid"
+
+        # heir fund txid should be in heirlist now
+        result = rpc.heirlist()
+        assert_equal(len(result), 2)
+        assert_success(result)
+        assert_equal(result["fundingtxid"], heir_fund_txid)
+
+        # checking heirinfo
+        result = rpc.heirinfo(heir_fund_txid)
+        assert_success(result)
+        assert_equal(result["fundingtxid"], heir_fund_txid)
+        assert_equal(result["name"], "UNITHEIR")
+        assert_equal(result["owner"], self.pubkey)
+        assert_equal(result["heir"], self.pubkey1)
+        assert_equal(result["funding total in coins"], "1000.00000000")
+        assert_equal(result["funding available in coins"], "1000.00000000")
+        assert_equal(result["inactivity time setting, sec"], "10")
+        assert_equal(result["spending allowed for the heir"], "false")
+
+        # TODO: heirlist keys are duplicating now
+
+        # waiting for 11 seconds to be sure that needed time passed for heir claiming
+        time.sleep(11)
+        rpc.generate(1)
+        self.sync_all()
+        result = rpc.heirinfo(heir_fund_txid)
+        assert_equal(result["funding available in coins"], "1000.00000000")
+        assert_equal(result["spending allowed for the heir"], "true")
+
+        # have to check that second node have coins to cover txfee at least
+        rpc.sendtoaddress(rpc1.getnewaddress(), 1)
+        rpc.sendtoaddress(rpc1.getnewaddress(), 1)
+        rpc.generate(2)
+        self.sync_all()
+        second_node_balance = rpc1.getbalance()
+        assert_greater_than(second_node_balance, 0.1)
+
+        # let's claim whole heir sum from second node
+        result = rpc1.heirclaim("0", "1000", heir_fund_txid)
+        assert_success(result)
+
+        heir_claim_txid = self.send_and_mine(result["hextx"], rpc1)
+        assert heir_claim_txid, "got claim txid"
+
+        # balance of second node after heirclaim should increase for 1000 coins - txfees
+        # + get one block reward when broadcasted heir_claim_txid
+        result = round(rpc1.getbalance()) - round(second_node_balance)
+        assert_greater_than(result, 100999)
+
+        self.sync_all()
+
+        # no more funds should be available for claiming
+        result = rpc.heirinfo(heir_fund_txid)
+        assert_equal(result["funding available in coins"], "0.00000000")
+
+        # TODO: valid heirfund case with tokens
+
+    def run_test(self):
+        print("Mining blocks...")
+        rpc = self.nodes[0]
+        rpc1 = self.nodes[1]
+        # utxos from block 1 become mature in block 101
+        if not self.options.noshutdown:
+            rpc.generate(101)
+        self.sync_all()
+        rpc.getinfo()
+        rpc1.getinfo()
+        # this corresponds to -pubkey above
+        print("Importing privkeys")
+        rpc.importprivkey(self.privkey)
+        rpc1.importprivkey(self.privkey1)
+        self.run_heir_tests()
+
+
+if __name__ == '__main__':
+    CryptoconditionsHeirTest().main()

src/cc/dapps/zmigrate.c

@@ -649,21 +649,21 @@ int64_t z_getbalance(char *refcoin,char *acname,char *coinaddr)
 
 int32_t z_exportkey(char *privkey,char *refcoin,char *acname,char *zaddr)
 {
-    cJSON *retjson; char *retstr,cmpstr[64]; int64_t amount=0; int32_t retval = -1;
+    cJSON *retjson; char *retstr,cmpstr[64]; int64_t amount=0;
     privkey[0] = 0;
     if ( (retjson= get_komodocli(refcoin,&retstr,acname,"z_exportkey",zaddr,"","","")) != 0 )
     {
         fprintf(stderr,"z_exportkey.(%s) %s returned json!\n",refcoin,acname);
         free_json(retjson);
+        return(-1);
     }
     else if ( retstr != 0 )
     {
         //printf("retstr %s -> %.8f\n",retstr,dstr(amount));
         strcpy(privkey,retstr);
         free(retstr);
-        retval = 0;
+        return(0);
     }
-    return(retval);
 }
 
 int32_t getnewaddress(char *coinaddr,char *refcoin,char *acname)
@@ -700,6 +700,23 @@ int32_t z_getnewaddress(char *coinaddr,char *refcoin,char *acname,char *typestr)
     return(retval);
 }
 
+int32_t z_getnewaddress(char *coinaddr,char *refcoin,char *acname,char *typestr)
+{
+    cJSON *retjson; char *retstr; int64_t amount=0;
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"z_getnewaddress",typestr,"","","")) != 0 )
+    {
+        fprintf(stderr,"z_getnewaddress.(%s) %s returned json!\n",refcoin,acname);
+        free_json(retjson);
+        return(-1);
+    }
+    else if ( retstr != 0 )
+    {
+        strcpy(coinaddr,retstr);
+        free(retstr);
+        return(0);
+    }
+}
+
 int64_t find_onetime_amount(char *coinstr,char *coinaddr)
 {
     cJSON *array,*item; int32_t i,n; char *addr; int64_t amount = 0;
@@ -824,6 +841,39 @@ int32_t z_mergetoaddress(char *opidstr,char *coinstr,char *acname,char *destaddr
     return(retval);
 }
 
+int32_t z_mergetoaddress(char *opidstr,char *coinstr,char *acname,char *destaddr)
+{
+    cJSON *retjson; char *retstr,addr[128],*opstr; int32_t retval = -1;
+    sprintf(addr,"[\\\"ANY_SPROUT\\\"]");
+    //printf("z_sendmany from.(%s) -> %s\n",addr,destaddr);
+    if ( (retjson= get_komodocli(coinstr,&retstr,acname,"z_mergetoaddress",addr,destaddr,"","")) != 0 )
+    {
+        /*{
+         "remainingUTXOs": 0,
+         "remainingTransparentValue": 0.00000000,
+         "remainingNotes": 222,
+         "remainingShieldedValue": 5413.39093055,
+         "mergingUTXOs": 0,
+         "mergingTransparentValue": 0.00000000,
+         "mergingNotes": 10,
+         "mergingShieldedValue": 822.47447172,
+         "opid": "opid-f28f6261-4120-436c-aca5-859870a40a70"
+         }*/
+        if ( (opstr= jstr(retjson,"opid")) != 0 )
+            strcpy(opidstr,opstr);
+        retval = jint(retjson,"remainingNotes");
+        fprintf(stderr,"%s\n",jprint(retjson,0));
+        free_json(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        fprintf(stderr,"z_mergetoaddress.(%s) -> opid.(%s)\n",coinstr,retstr);
+        strcpy(opidstr,retstr);
+        free(retstr);
+    }
+    return(retval);
+}
+
 int32_t empty_mempool(char *coinstr,char *acname)
 {
     cJSON *array; int32_t n;

src/chain.h

@@ -351,7 +351,7 @@ public:
         nSolution      = block.nSolution;
     }
 
-    int32_t SetHeight(int32_t height)
+    void SetHeight(int32_t height)
     {
         this->chainPower.nHeight = height;
     }

src/chainparams.cpp

@@ -229,7 +229,7 @@ int32_t MAX_BLOCK_SIZE(int32_t height) // make sure to change MAX_PROTOCOL_MESSA
 {
     //fprintf(stderr,"MAX_BLOCK_SIZE %d vs. %d\n",height,mainParams.consensus.vUpgrades[Consensus::UPGRADE_SAPLING].nActivationHeight);
     if ( height <= 0 || (mainParams.consensus.vUpgrades[Consensus::UPGRADE_SAPLING].nActivationHeight > 0 && height >= mainParams.consensus.vUpgrades[Consensus::UPGRADE_SAPLING].nActivationHeight) )
-        return(4096 * 1024);
+        return(_MAX_BLOCK_SIZE);
     else return(2000000);
 }
 

src/consensus/params.h

@@ -130,8 +130,8 @@ struct Params {
     int64_t AveragingWindowTimespan() const { return nPowAveragingWindow * nPowTargetSpacing; }
     int64_t MinActualTimespan() const { return (AveragingWindowTimespan() * (100 - nPowMaxAdjustUp  )) / 100; }
     int64_t MaxActualTimespan() const { return (AveragingWindowTimespan() * (100 + nPowMaxAdjustDown)) / 100; }
-    int32_t SetSaplingHeight(int32_t height) { vUpgrades[Consensus::UPGRADE_SAPLING].nActivationHeight = height; }
+    void SetSaplingHeight(int32_t height) { vUpgrades[Consensus::UPGRADE_SAPLING].nActivationHeight = height; }
-    int32_t SetOverwinterHeight(int32_t height) { vUpgrades[Consensus::UPGRADE_OVERWINTER].nActivationHeight = height; }
+    void SetOverwinterHeight(int32_t height) { vUpgrades[Consensus::UPGRADE_OVERWINTER].nActivationHeight = height; }
     uint256 nMinimumChainWork;
 };
 } // namespace Consensus

src/crypto/verus_hash.h

@@ -86,6 +86,7 @@ class CVerusHashV2
             result = buf2;
             curPos = 0;
             std::fill(buf1, buf1 + sizeof(buf1), 0);
+            return *this; 
         }
 
         int64_t *ExtraI64Ptr() { return (int64_t *)(curBuf + 32); }

src/komodo_utils.h

@@ -1704,7 +1704,6 @@ void komodo_args(char *argv0)
     KOMODO_STOPAT = GetArg("-stopat",0);
     MAX_REORG_LENGTH = GetArg("-maxreorg",MAX_REORG_LENGTH);
     WITNESS_CACHE_SIZE = MAX_REORG_LENGTH+10;
-
     ASSETCHAINS_CC = GetArg("-ac_cc",0);
     KOMODO_CCACTIVATE = GetArg("-ac_ccactivate",0);
     ASSETCHAINS_PUBLIC = GetArg("-ac_public",0);

src/main.cpp

@@ -3940,7 +3940,8 @@ bool static DisconnectTip(CValidationState &state, bool fBare = false) {
 
 int32_t komodo_activate_sapling(CBlockIndex *pindex)
 {
-    uint32_t blocktime,prevtime; CBlockIndex *prev; int32_t i,transition=0,height,prevht,activation = 0;
+    uint32_t blocktime,prevtime; CBlockIndex *prev; int32_t i,transition=0,height,prevht;
+    int32_t activation = 0;
     if ( pindex == 0 )
     {
         fprintf(stderr,"komodo_activate_sapling null pindex\n");
@@ -3998,6 +3999,7 @@ int32_t komodo_activate_sapling(CBlockIndex *pindex)
         fprintf(stderr,"%s sapling activation at %d\n",ASSETCHAINS_SYMBOL,activation);
         ASSETCHAINS_SAPLING = activation;
     }
+    return activation;
 }
 
 static int64_t nTimeReadFromDisk = 0;

src/main.h

@@ -78,7 +78,7 @@ static const bool DEFAULT_ALERTS = true;
 /** Minimum alert priority for enabling safe mode. */
 static const int ALERT_PRIORITY_SAFE_MODE = 4000;
 /** Maximum reorg length we will accept before we shut down and alert the user. */
-static unsigned int MAX_REORG_LENGTH = (_COINBASE_MATURITY - 1);
+static unsigned int MAX_REORG_LENGTH = _COINBASE_MATURITY - 1;
 /** Maximum number of signature check operations in an IsStandard() P2SH script */
 static const unsigned int MAX_P2SH_SIGOPS = 15;
 /** The maximum number of sigops we're willing to relay/mine in a single tx */

src/net.h

@@ -33,6 +33,7 @@
 #include "sync.h"
 #include "uint256.h"
 #include "utilstrencodings.h"
+#include "util.h"
 
 #include <deque>
 #include <stdint.h>
@@ -63,7 +64,11 @@ static const unsigned int MAX_INV_SZ = 50000;
 /** The maximum number of new addresses to accumulate before announcing. */
 static const unsigned int MAX_ADDR_TO_SEND = 1000;
 /** Maximum length of incoming protocol messages (no message over 2 MiB is currently acceptable). */
-static const unsigned int MAX_PROTOCOL_MESSAGE_LENGTH = 4 * 1024 * 1024; // depends on MAX_BLOCK_SIZE
+<<<<<<< HEAD
+static const unsigned int MAX_PROTOCOL_MESSAGE_LENGTH = _MAX_BLOCK_SIZE;
+=======
+static const unsigned int MAX_PROTOCOL_MESSAGE_LENGTH = 4 * 1024 * 1024;
+>>>>>>> origin/FSM
 /** Maximum length of strSubVer in `version` message */
 static const unsigned int MAX_SUBVERSION_LENGTH = 256;
 /** -listen default */

src/util.h

@@ -3,6 +3,21 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+/******************************************************************************
+ * Copyright © 2014-2019 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+
 /**
  * Server/client environment: argument handling, config file parsing,
  * logging, thread wrappers
@@ -29,6 +44,8 @@
 #include <boost/signals2/signal.hpp>
 #include <boost/thread/exceptions.hpp>
 
+#define _MAX_BLOCK_SIZE (4096 * 1024) // changing just _MAX_BLOCK_SIZE will hardfork to that size
+
 static const bool DEFAULT_LOGTIMEMICROS = false;
 static const bool DEFAULT_LOGIPS        = false;
 static const bool DEFAULT_LOGTIMESTAMPS = true;

src/wallet/rpcwallet.cpp

@@ -4886,10 +4886,11 @@ UniValue z_mergetoaddress(const UniValue& params, bool fHelp)
 
     if (useAnySprout || useAnySapling || zaddrs.size() > 0) {
         // Get available notes
-        std::vector<CSproutNotePlaintextEntry> sproutEntries,skipsprout;
+        std::vector<CSproutNotePlaintextEntry> sproutEntries;
+        //std::vector<SaplingNoteEntry> saplingEntries;
+        //pwalletMain->GetFilteredNotes(sproutEntries, saplingEntries, zaddrs);
         std::vector<SaplingNoteEntry> saplingEntries,skipsapling;
         pwalletMain->GetFilteredNotes(sproutEntries, useAnySprout == 0 ? saplingEntries : skipsapling, zaddrs);
-
         // If Sapling is not active, do not allow sending from a sapling addresses.
         if (!saplingActive && saplingEntries.size() > 0) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, Sapling has not activated");

src/wallet/wallet.h

@@ -77,7 +77,6 @@ static const unsigned int MAX_FREE_TRANSACTION_CREATE_SIZE = 1000;
 //  unless there is some exceptional network disruption.
 extern unsigned int WITNESS_CACHE_SIZE;
 
-
 //! Size of HD seed in bytes
 static const size_t HD_WALLET_SEED_LENGTH = 32;