Merge pull request #810 from letolabs/cctests

First cryptoconditions sync

qa/pull-tester/rpc-tests.sh

@@ -11,6 +11,7 @@ export BITCOIND=${REAL_BITCOIND}
 #Run the tests
 
 testScripts=(
+    'cryptoconditions.py'
     'paymentdisclosure.py'
     'prioritisetransaction.py'
     'wallet_treestate.py'

qa/pull-tester/tests-config.sh.in

@@ -13,6 +13,6 @@ EXEEXT="@EXEEXT@"
 @ENABLE_ZMQ_TRUE@ENABLE_ZMQ=1
 @ENABLE_PROTON_TRUE@ENABLE_PROTON=1
 
-REAL_BITCOIND="$BUILDDIR/src/zcashd${EXEEXT}"
+REAL_BITCOIND="$BUILDDIR/src/komodod${EXEEXT}"
-REAL_BITCOINCLI="$BUILDDIR/src/zcash-cli${EXEEXT}"
+REAL_BITCOINCLI="$BUILDDIR/src/komodo-cli${EXEEXT}"
 

qa/rpc-tests/README.md

@@ -18,9 +18,9 @@ Possible options:
 
 ```
 -h, --help       show this help message and exit
-  --nocleanup      Leave bitcoinds and test.* datadir on exit or error
+  --nocleanup      Leave komodods and test.* datadir on exit or error
-  --noshutdown     Don't stop bitcoinds after the test execution
+  --noshutdown     Don't stop komodods after the test execution
-  --srcdir=SRCDIR  Source directory containing bitcoind/bitcoin-cli (default:
+  --srcdir=SRCDIR  Source directory containing komodod/komodo-cli (default:
                    ../../src)
   --tmpdir=TMPDIR  Root directory for datadirs
   --tracerpc       Print out all RPC calls as they are made
@@ -31,7 +31,7 @@ If you set the environment variable `PYTHON_DEBUG=1` you will get some debug out
 A 200-block -regtest blockchain and wallets for four nodes
 is created the first time a regression test is run and
 is stored in the cache/ directory.  Each node has the miner
-subsidy from 25 mature blocks (25*10=250 ZEC) in its wallet.
+subsidy from 25 mature blocks (25*10=250 KMD) in its wallet.
 
 After the first run, the cache/ blockchain and wallets are
 copied into a temporary directory and used as the initial
@@ -42,5 +42,5 @@ to recover with:
 
 ```bash
 rm -rf cache
-killall zcashd
+killall komodod
 ```

qa/rpc-tests/cryptoconditions.py

@@ -0,0 +1,231 @@
+#!/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.
+
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.authproxy import JSONRPCException
+from test_framework.util import assert_equal, assert_greater_than, \
+    initialize_chain_clean, start_nodes, start_node, connect_nodes_bi, \
+    stop_nodes, sync_blocks, sync_mempools, wait_bitcoinds, rpc_port
+
+import time
+from decimal import Decimal
+
+class CryptoConditionsTest (BitcoinTestFramework):
+
+    def setup_chain(self):
+        print("Initializing CC test directory "+self.options.tmpdir)
+        self.num_nodes = 1
+        initialize_chain_clean(self.options.tmpdir, self.num_nodes)
+
+    def setup_network(self, split = False):
+        print("Setting up network...")
+        self.addr    = "RWPg8B91kfK5UtUN7z6s6TeV9cHSGtVY8D"
+        self.pubkey  = "02676d00110c2cd14ae24f95969e8598f7ccfaa675498b82654a5b5bd57fc1d8cf"
+        self.privkey = "UqMgxk7ySPNQ4r9nKAFPjkXy6r5t898yhuNCjSZJLg3RAM4WW1m9"
+        self.nodes   = start_nodes(self.num_nodes, self.options.tmpdir,
+                    extra_args=[[
+                    # always give -ac_name as first extra_arg
+                    '-ac_name=REGTEST',
+                    '-conf='+self.options.tmpdir+'/node0/REGTEST.conf',
+                    '-port=64367',
+                    '-rpcport=64368',
+                    '-regtest',
+                    '-addressindex=1',
+                    '-spentindex=1',
+                    '-ac_supply=5555555',
+                    '-ac_reward=10000000',
+                    '-pubkey=' + self.pubkey,
+                    '-ac_cc=1',
+                    '-whitelist=127.0.0.1',
+                    '-debug',
+                    '-daemon',
+                    '-rpcuser=rt',
+                    '-rpcpassword=rt'
+                    ]]
+        )
+        self.is_network_split = split
+        self.sync_all()
+        print("Done setting up network")
+
+    def run_faucet_tests(self):
+        rpc     = self.nodes[0]
+
+        # basic sanity tests
+        result = rpc.getwalletinfo()
+        assert_equal(result['txcount'], 101)
+        assert_greater_than(result['balance'], 0.0)
+        balance = result['balance']
+
+        faucet  = rpc.faucetaddress()
+        assert_equal(faucet['result'], 'success')
+        # verify all keys look like valid AC addrs, could be better
+        for x in ['myCCaddress', 'FaucetCCaddress', 'Faucetmarker', 'myaddress']:
+            assert_equal(faucet[x][0], 'R')
+
+        # no funds in the faucet yet
+        result = rpc.faucetget()
+        assert_equal(result['result'], 'error')
+
+        result = rpc.faucetinfo()
+        assert_equal(result['result'], 'success')
+
+        result = rpc.faucetfund("0")
+        assert_equal(result['result'], 'error')
+
+        result = rpc.faucetfund("-1")
+        assert_equal(result['result'], 'error')
+
+        # we need at least 1 + txfee to get
+        result = rpc.faucetfund("2")
+        assert_equal(result['result'], 'success')
+        assert result['hex'], "hex key found"
+
+        # broadcast the xtn
+        result = rpc.sendrawtransaction(result['hex'])
+        txid   = result[0]
+        assert txid, "found txid"
+
+        # we need the tx above to be confirmed in the next block
+        rpc.generate(1)
+
+        # clear the rawmempool
+        result = rpc.getrawmempool()
+
+        result   = rpc.getwalletinfo()
+        balance2 =  result['balance']
+        # make sure our balance is less now
+        assert_greater_than(balance, balance2)
+
+        result = rpc.faucetinfo()
+        assert_equal(result['result'], 'success')
+        assert_greater_than( result['funding'], 0 )
+
+        result = rpc.faucetget()
+        assert_equal(result['result'], 'success')
+        assert result['hex'], "hex key found"
+
+        # broadcast the xtn
+        result = rpc.sendrawtransaction(result['hex'])
+        txid   = result[0]
+        assert txid, "found txid"
+
+        # confirm above tx
+        rpc.generate(1)
+        result = rpc.getwalletinfo()
+
+        # we should have slightly more funds from the faucet now
+        assert_greater_than(result['balance'], balance2)
+
+    def run_dice_tests(self):
+        rpc     = self.nodes[0]
+
+        dice  = rpc.diceaddress()
+        assert_equal(dice['result'], 'success')
+        for x in ['myCCaddress', 'DiceCCaddress', 'Dicemarker', 'myaddress']:
+            assert_equal(dice[x][0], 'R')
+
+        # no dice created yet
+        result  = rpc.dicelist()
+        assert_equal(result, [])
+
+        #result  = rpc.dicefund("LUCKY",10000,1,10000,10,5)
+        #assert_equal(result, [])
+
+    def run_token_tests(self):
+        rpc    = self.nodes[0]
+        result = rpc.tokenaddress()
+        assert_equal(result['result'], 'success')
+        for x in ['AssetsCCaddress', 'myCCaddress', 'Assetsmarker', 'myaddress']:
+            assert_equal(result[x][0], 'R')
+
+        result = rpc.tokenaddress(self.pubkey)
+        assert_equal(result['result'], 'success')
+        for x in ['AssetsCCaddress', 'myCCaddress', 'Assetsmarker', 'myaddress', 'CCaddress']:
+            assert_equal(result[x][0], 'R')
+
+        result = rpc.tokencreate("DUKE", "1987.420", "duke")
+        assert_equal(result['result'], 'success')
+
+        # there are no tokens created yet
+        result = rpc.tokenlist()
+        assert_equal(result, [])
+
+        # there are no token orders yet
+        result = rpc.tokenorders()
+        assert_equal(result, [])
+
+        result = rpc.tokenbalance(self.pubkey)
+        assert_equal(result['balance'], 0)
+        assert_equal(result['result'], 'success')
+        assert_equal(result['CCaddress'], 'RCRsm3VBXz8kKTsYaXKpy7pSEzrtNNQGJC')
+        assert_equal(result['tokenid'], self.pubkey)
+
+        # this is not a valid assetid
+        result = rpc.tokeninfo(self.pubkey)
+        assert_equal(result['result'], 'error')
+
+    def run_rewards_tests(self):
+        rpc     = self.nodes[0]
+        result = rpc.rewardsaddress()
+        for x in ['RewardsCCaddress', 'myCCaddress', 'Rewardsmarker', 'myaddress']:
+            assert_equal(result[x][0], 'R')
+
+        result = rpc.rewardsaddress(self.pubkey)
+        for x in ['RewardsCCaddress', 'myCCaddress', 'Rewardsmarker', 'myaddress', 'CCaddress']:
+            assert_equal(result[x][0], 'R')
+
+        # no rewards yet
+        result = rpc.rewardslist()
+        assert_equal(result, [])
+
+        # looking up non-existent reward should return error
+        result = rpc.rewardsinfo("none")
+        assert_equal(result['result'], 'error')
+
+        result = rpc.rewardscreatefunding("STUFF", "1000", "5", "1", "10", "10")
+        assert result['hex'], 'got raw xtn'
+        txid = rpc.sendrawtransaction(result['hex'])
+        assert txid, 'got txid'
+
+        # confirm the above xtn
+        rpc.generate(1)
+        result = rpc.rewardsinfo(txid)
+        assert_equal(result['result'], 'success')
+        assert_equal(result['name'], 'STUFF')
+        assert_equal(result['APR'], "5.00000000")
+        assert_equal(result['minseconds'], 86400)
+        assert_equal(result['maxseconds'], 864000)
+        assert_equal(result['funding'], "1000.00000000")
+        assert_equal(result['mindeposit'], "10.00000000")
+        assert_equal(result['fundingtxid'], txid)
+
+        # funding amount must be positive
+        result = rpc.rewardsaddfunding("STUFF", txid, "0")
+        assert_equal(result['result'], 'error')
+
+        result = rpc.rewardsaddfunding("STUFF", txid, "100")
+        assert_equal(result['result'], 'success')
+
+    def run_test (self):
+        print("Mining blocks...")
+        rpc     = self.nodes[0]
+
+        # utxos from block 1 become mature in block 101
+        rpc.generate(101)
+        self.sync_all()
+
+        # this corresponds to -pubkey above
+        print("Importing privkey")
+        rpc.importprivkey(self.privkey)
+
+
+        self.run_faucet_tests()
+        self.run_rewards_tests()
+        self.run_dice_tests()
+        self.run_token_tests()
+
+
+if __name__ == '__main__':
+    CryptoConditionsTest ().main ()

qa/rpc-tests/test_framework/test_framework.py

@@ -90,11 +90,11 @@ class BitcoinTestFramework(object):
 
         parser = optparse.OptionParser(usage="%prog [options]")
         parser.add_option("--nocleanup", dest="nocleanup", default=False, action="store_true",
-                          help="Leave bitcoinds and test.* datadir on exit or error")
+                          help="Leave komodods and test.* datadir on exit or error")
         parser.add_option("--noshutdown", dest="noshutdown", default=False, action="store_true",
-                          help="Don't stop bitcoinds after the test execution")
+                          help="Don't stop komodods after the test execution")
         parser.add_option("--srcdir", dest="srcdir", default="../../src",
-                          help="Source directory containing bitcoind/bitcoin-cli (default: %default)")
+                          help="Source directory containing komodod/komodo-cli (default: %default)")
         parser.add_option("--tmpdir", dest="tmpdir", default=tempfile.mkdtemp(prefix="test"),
                           help="Root directory for datadirs")
         parser.add_option("--tracerpc", dest="trace_rpc", default=False, action="store_true",
@@ -137,7 +137,7 @@ class BitcoinTestFramework(object):
             stop_nodes(self.nodes)
             wait_bitcoinds()
         else:
-            print("Note: bitcoinds were not stopped and may still be running")
+            print("Note: komodods were not stopped and may still be running")
 
         if not self.options.nocleanup and not self.options.noshutdown:
             print("Cleaning up")
@@ -151,7 +151,7 @@ class BitcoinTestFramework(object):
             sys.exit(1)
 
 
-# Test framework for doing p2p comparison testing, which sets up some bitcoind
+# Test framework for doing p2p comparison testing, which sets up some komodod
 # binaries:
 # 1 binary: test binary
 # 2 binaries: 1 test binary, 1 ref binary
@@ -165,10 +165,10 @@ class ComparisonTestFramework(BitcoinTestFramework):
 
     def add_options(self, parser):
         parser.add_option("--testbinary", dest="testbinary",
-                          default=os.getenv("BITCOIND", "bitcoind"),
+                          default=os.getenv("BITCOIND", "komodod"),
                           help="bitcoind binary to test")
         parser.add_option("--refbinary", dest="refbinary",
-                          default=os.getenv("BITCOIND", "bitcoind"),
+                          default=os.getenv("BITCOIND", "komodod"),
                           help="bitcoind binary to use for reference nodes (if any)")
 
     def setup_chain(self):

qa/rpc-tests/test_framework/util.py

@@ -1,4 +1,5 @@
 # Copyright (c) 2014 The Bitcoin Core developers
+# Copyright (c) 2018 The SuperNET developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
@@ -75,38 +76,55 @@ def initialize_datadir(dirname, n):
     datadir = os.path.join(dirname, "node"+str(n))
     if not os.path.isdir(datadir):
         os.makedirs(datadir)
-    with open(os.path.join(datadir, "zcash.conf"), 'w') as f:
+    # kmd AC's don't use this, they use the conf auto-created when the AC is created
+    # plus CLI arguments. This is for komodod tests
+    print("Writing to " + os.path.join(datadir,"komodo.conf"))
+    with open(os.path.join(datadir, "komodo.conf"), 'w') as f:
         f.write("regtest=1\n");
+        f.write("txindex=1\n");
+        f.write("server=1\n");
         f.write("showmetrics=0\n");
         f.write("rpcuser=rt\n");
         f.write("rpcpassword=rt\n");
-        f.write("port="+str(p2p_port(n))+"\n");
+        #f.write("port="+str(p2p_port(n))+"\n");
-        f.write("rpcport="+str(rpc_port(n))+"\n");
+        #rpcport = str(rpc_port(n))
+        #f.write("rpcport="+rpcport+"\n");
+        #print "RPC port=" + rpcport
         f.write("listenonion=0\n");
+        # TODO: maybe make these optional, defaulted to on for now
+        f.write("addressindex=1\n");
+        f.write("spentindex=1\n");
+        f.write("timestampindex=1\n");
     return datadir
 
 def initialize_chain(test_dir):
     """
     Create (or copy from cache) a 200-block-long chain and
     4 wallets.
-    bitcoind and bitcoin-cli must be in search path.
+    komodod and komodo-cli must be in search path.
     """
 
+    print("initialize_chain")
     if not os.path.isdir(os.path.join("cache", "node0")):
         devnull = open("/dev/null", "w+")
-        # Create cache directories, run bitcoinds:
+        # Create cache directories, run komodods:
         for i in range(4):
             datadir=initialize_datadir("cache", i)
-            args = [ os.getenv("BITCOIND", "bitcoind"), "-keypool=1", "-datadir="+datadir, "-discover=0" ]
+            args = [ os.getenv("BITCOIND", "komodod"), "-keypool=1", "-datadir="+datadir, "-discover=0" ]
             if i > 0:
                 args.append("-connect=127.0.0.1:"+str(p2p_port(0)))
             bitcoind_processes[i] = subprocess.Popen(args)
+            cmd      = os.getenv("BITCOINCLI", "komodo-cli")
+            cmd_args = cmd + " -datadir="+datadir + " -rpcwait getblockcount"
             if os.getenv("PYTHON_DEBUG", ""):
-                print "initialize_chain: bitcoind started, calling bitcoin-cli -rpcwait getblockcount"
+                print "initialize_chain: komodod started, calling: " + cmd_args
-            subprocess.check_call([ os.getenv("BITCOINCLI", "bitcoin-cli"), "-datadir="+datadir,
+            strcmd = cmd + " " + "-datadir="+datadir + " -rpcwait getblockcount"
-                                    "-rpcwait", "getblockcount"], stdout=devnull)
+
+            print("Running " + strcmd)
+            subprocess.check_call(strcmd, shell=True);
+            #subprocess.check_call([ cmd, "-rpcwait", "getblockcount"], stdout=devnull)
             if os.getenv("PYTHON_DEBUG", ""):
-                print "initialize_chain: bitcoin-cli -rpcwait getblockcount completed"
+                print "initialize_chain: komodo-cli -rpcwait getblockcount completed"
         devnull.close()
         rpcs = []
         for i in range(4):
@@ -144,7 +162,7 @@ def initialize_chain(test_dir):
         from_dir = os.path.join("cache", "node"+str(i))
         to_dir = os.path.join(test_dir,  "node"+str(i))
         shutil.copytree(from_dir, to_dir)
-        initialize_datadir(test_dir, i) # Overwrite port/rpcport in zcash.conf
+        initialize_datadir(test_dir, i) # Overwrite port/rpcport in komodo.conf
 
 def initialize_chain_clean(test_dir, num_nodes):
     """
@@ -177,34 +195,50 @@ def _rpchost_to_args(rpchost):
 
 def start_node(i, dirname, extra_args=None, rpchost=None, timewait=None, binary=None):
     """
-    Start a bitcoind and return RPC connection to it
+    Start a komodod and return RPC connection to it
     """
     datadir = os.path.join(dirname, "node"+str(i))
     if binary is None:
-        binary = os.getenv("BITCOIND", "bitcoind")
+        binary = os.getenv("BITCOIND", "komodod")
     args = [ binary, "-datadir="+datadir, "-keypool=1", "-discover=0", "-rest" ]
     if extra_args is not None: args.extend(extra_args)
+    #print("args=" + ' '.join(args))
     bitcoind_processes[i] = subprocess.Popen(args)
     devnull = open("/dev/null", "w+")
+
+    cmd = os.getenv("BITCOINCLI", "komodo-cli")
+    print("cmd=" + cmd)
+    cmd_args = ' '.join(extra_args) + " -rpcwait getblockcount "
     if os.getenv("PYTHON_DEBUG", ""):
-        print "start_node: bitcoind started, calling bitcoin-cli -rpcwait getblockcount"
+        print "start_node: komodod started, calling : " + cmd + " " + cmd_args
-    subprocess.check_call([ os.getenv("BITCOINCLI", "bitcoin-cli"), "-datadir="+datadir] +
+    strcmd = cmd + " " + cmd_args
-                          _rpchost_to_args(rpchost)  +
+
-                          ["-rpcwait", "getblockcount"], stdout=devnull)
+    print("Running " + strcmd)
+    import time
+    time.sleep(2)
+    subprocess.check_call(strcmd, shell=True);
+    #subprocess.check_call([ os.getenv("BITCOINCLI", "komodo-cli"), "-datadir="+datadir] +
+    #                      _rpchost_to_args(rpchost)  +
+    #                      ["-rpcwait", "-rpcport=6438", "getblockcount"], stdout=devnull)
     if os.getenv("PYTHON_DEBUG", ""):
-        print "start_node: calling bitcoin-cli -rpcwait getblockcount returned"
+        print "start_node: calling komodo-cli -rpcwait getblockcount returned"
     devnull.close()
-    url = "http://rt:rt@%s:%d" % (rpchost or '127.0.0.1', rpc_port(i))
+    if extra_args[0] == '-ac_name=REGTEST':
+        url = "http://rt:rt@%s:%d" % (rpchost or '127.0.0.1', 64368)
+    else:
+        url = "http://rt:rt@%s:%d" % (rpchost or '127.0.0.1', rpc_port(i))
+    print("connecting to " + url)
     if timewait is not None:
         proxy = AuthServiceProxy(url, timeout=timewait)
     else:
         proxy = AuthServiceProxy(url)
+    print("created proxy")
     proxy.url = url # store URL on proxy for info
     return proxy
 
 def start_nodes(num_nodes, dirname, extra_args=None, rpchost=None, binary=None):
     """
-    Start multiple bitcoinds, return RPC connections to them
+    Start multiple komodods, return RPC connections to them
     """
     if extra_args is None: extra_args = [ None for i in range(num_nodes) ]
     if binary is None: binary = [ None for i in range(num_nodes) ]

src/cc/CCassetstx.cpp

@@ -60,12 +60,14 @@ UniValue AssetInfo(uint256 assetid)
     if ( GetTransaction(assetid,vintx,hashBlock,false) == 0 )
     {
         fprintf(stderr,"cant find assetid\n");
+        result.push_back(Pair("result","error"));
         result.push_back(Pair("error","cant find assetid"));
-        return(0);
+        return(result);
     }
     if ( vintx.vout.size() > 0 && DecodeAssetCreateOpRet(vintx.vout[vintx.vout.size()-1].scriptPubKey,origpubkey,name,description) == 0 )
     {
         fprintf(stderr,"assetid isnt assetcreation txid\n");
+        result.push_back(Pair("result","error"));
         result.push_back(Pair("error","assetid isnt assetcreation txid"));
     }
     result.push_back(Pair("result","success"));
@@ -182,13 +184,13 @@ std::string CreateAsset(int64_t txfee,int64_t assetsupply,std::string name,std::
     if ( assetsupply < 0 )
     {
         fprintf(stderr,"negative assetsupply %lld\n",(long long)assetsupply);
-        return(0);
+        return("");
     }
     cp = CCinit(&C,EVAL_ASSETS);
     if ( name.size() > 32 || description.size() > 4096 )
     {
         fprintf(stderr,"name.%d or description.%d is too big\n",(int32_t)name.size(),(int32_t)description.size());
-        return(0);
+        return("");
     }
     if ( txfee == 0 )
         txfee = 10000;
@@ -199,7 +201,7 @@ std::string CreateAsset(int64_t txfee,int64_t assetsupply,std::string name,std::
         mtx.vout.push_back(CTxOut(txfee,CScript() << ParseHex(cp->CChexstr) << OP_CHECKSIG));
         return(FinalizeCCTx(0,cp,mtx,mypk,txfee,EncodeAssetCreateOpRet('c',Mypubkey(),name,description)));
     }
-    return(0);
+    return("");
 }
                
 std::string AssetTransfer(int64_t txfee,uint256 assetid,std::vector<uint8_t> destpubkey,int64_t total)
@@ -208,7 +210,7 @@ std::string AssetTransfer(int64_t txfee,uint256 assetid,std::vector<uint8_t> des
     if ( total < 0 )
     {
         fprintf(stderr,"negative total %lld\n",(long long)total);
-        return(0);
+        return("");
     }
     cp = CCinit(&C,EVAL_ASSETS);
     if ( txfee == 0 )
@@ -234,7 +236,7 @@ std::string AssetTransfer(int64_t txfee,uint256 assetid,std::vector<uint8_t> des
             } else fprintf(stderr,"not enough CC asset inputs for %.8f\n",(double)total/COIN);
         //} else fprintf(stderr,"numoutputs.%d != numamounts.%d\n",n,(int32_t)amounts.size());
     }
-    return(0);
+    return("");
 }
 
 std::string CreateBuyOffer(int64_t txfee,int64_t bidamount,uint256 assetid,int64_t pricetotal)
@@ -243,17 +245,17 @@ std::string CreateBuyOffer(int64_t txfee,int64_t bidamount,uint256 assetid,int64
     if ( bidamount < 0 || pricetotal < 0 )
     {
         fprintf(stderr,"negative bidamount %lld, pricetotal %lld\n",(long long)bidamount,(long long)pricetotal);
-        return(0);
+        return("");
     }
     if ( GetTransaction(assetid,vintx,hashBlock,false) == 0 )
     {
         fprintf(stderr,"cant find assetid\n");
-        return(0);
+        return("");
     }
     if ( vintx.vout.size() > 0 && DecodeAssetCreateOpRet(vintx.vout[vintx.vout.size()-1].scriptPubKey,origpubkey,name,description) == 0 )
     {
         fprintf(stderr,"assetid isnt assetcreation txid\n");
-        return(0);
+        return("");
     }
     cp = CCinit(&C,EVAL_ASSETS);
     if ( txfee == 0 )
@@ -264,7 +266,7 @@ std::string CreateBuyOffer(int64_t txfee,int64_t bidamount,uint256 assetid,int64
         mtx.vout.push_back(MakeCC1vout(EVAL_ASSETS,bidamount,GetUnspendable(cp,0)));
         return(FinalizeCCTx(0,cp,mtx,mypk,txfee,EncodeAssetOpRet('b',assetid,zeroid,pricetotal,Mypubkey())));
     }
-    return(0);
+    return("");
 }
 
 std::string CreateSell(int64_t txfee,int64_t askamount,uint256 assetid,int64_t pricetotal)
@@ -273,7 +275,7 @@ std::string CreateSell(int64_t txfee,int64_t askamount,uint256 assetid,int64_t p
     if ( askamount < 0 || pricetotal < 0 )
     {
         fprintf(stderr,"negative askamount %lld, askamount %lld\n",(long long)pricetotal,(long long)askamount);
-        return(0);
+        return("");
     }
     cp = CCinit(&C,EVAL_ASSETS);
     if ( txfee == 0 )
@@ -296,18 +298,18 @@ std::string CreateSell(int64_t txfee,int64_t askamount,uint256 assetid,int64_t p
         } else fprintf(stderr,"need some assets to place ask\n");
     }
     fprintf(stderr,"need some native coins to place ask\n");
-    return(0);
+    return("");
 }
 
 std::string CreateSwap(int64_t txfee,int64_t askamount,uint256 assetid,uint256 assetid2,int64_t pricetotal)
 {
     CMutableTransaction mtx; CPubKey mypk; uint64_t mask; int64_t inputs,CCchange; CScript opret; struct CCcontract_info *cp,C;
     fprintf(stderr,"asset swaps disabled\n");
-    return(0);
+    return("");
     if ( askamount < 0 || pricetotal < 0 )
     {
         fprintf(stderr,"negative askamount %lld, askamount %lld\n",(long long)pricetotal,(long long)askamount);
-        return(0);
+        return("");
     }
     cp = CCinit(&C,EVAL_ASSETS);
     if ( txfee == 0 )
@@ -335,7 +337,7 @@ std::string CreateSwap(int64_t txfee,int64_t askamount,uint256 assetid,uint256 a
         } else fprintf(stderr,"need some assets to place ask\n");
     }
     fprintf(stderr,"need some native coins to place ask\n");
-    return(0);
+    return("");
 }
 
 std::string CancelBuyOffer(int64_t txfee,uint256 assetid,uint256 bidtxid)
@@ -356,7 +358,7 @@ std::string CancelBuyOffer(int64_t txfee,uint256 assetid,uint256 bidtxid)
             return(FinalizeCCTx(mask,cp,mtx,mypk,txfee,EncodeAssetOpRet('o',assetid,zeroid,0,Mypubkey())));
         }
     }
-    return(0);
+    return("");
 }
 
 std::string CancelSell(int64_t txfee,uint256 assetid,uint256 asktxid)
@@ -377,7 +379,7 @@ std::string CancelSell(int64_t txfee,uint256 assetid,uint256 asktxid)
             return(FinalizeCCTx(mask,cp,mtx,mypk,txfee,EncodeAssetOpRet('x',assetid,zeroid,0,Mypubkey())));
         }
     }
-    return(0);
+    return("");
 }
 
 std::string FillBuyOffer(int64_t txfee,uint256 assetid,uint256 bidtxid,int64_t fillamount)
@@ -386,7 +388,7 @@ std::string FillBuyOffer(int64_t txfee,uint256 assetid,uint256 bidtxid,int64_t f
     if ( fillamount < 0 )
     {
         fprintf(stderr,"negative fillamount %lld\n",(long long)fillamount);
-        return(0);
+        return("");
     }
     cp = CCinit(&C,EVAL_ASSETS);
     if ( txfee == 0 )
@@ -426,12 +428,12 @@ std::string FillSell(int64_t txfee,uint256 assetid,uint256 assetid2,uint256 askt
     if ( fillunits < 0 )
     {
         fprintf(stderr,"negative fillunits %lld\n",(long long)fillunits);
-        return(0);
+        return("");
     }
     if ( assetid2 != zeroid )
     {
         fprintf(stderr,"asset swaps disabled\n");
-        return(0);
+        return("");
     }
 
     cp = CCinit(&C,EVAL_ASSETS);
@@ -475,5 +477,5 @@ std::string FillSell(int64_t txfee,uint256 assetid,uint256 assetid2,uint256 askt
             } else fprintf(stderr,"filltx not enough utxos\n");
         }
     }
-    return(0);
+    return("");
 }

src/cc/rewards.cpp

@@ -371,12 +371,14 @@ UniValue RewardsInfo(uint256 rewardsid)
     if ( GetTransaction(rewardsid,vintx,hashBlock,false) == 0 )
     {
         fprintf(stderr,"cant find fundingtxid\n");
+        result.push_back(Pair("result","error"));
         result.push_back(Pair("error","cant find fundingtxid"));
         return(result);
     }
     if ( vintx.vout.size() > 0 && DecodeRewardsFundingOpRet(vintx.vout[vintx.vout.size()-1].scriptPubKey,sbits,APR,minseconds,maxseconds,mindeposit) == 0 )
     {
         fprintf(stderr,"fundingtxid isnt rewards creation txid\n");
+        result.push_back(Pair("result","error"));
         result.push_back(Pair("error","fundingtxid isnt rewards creation txid"));
         return(result);
     }

src/txdb.cpp

@@ -430,7 +430,7 @@ extern UniValue CBlockTreeDB::Snapshot(int top)
     };
 
     int64_t startingHeight = chainActive.Height();
-    fprintf(stderr, "Starting snapshot at height %li\n", startingHeight);
+    //fprintf(stderr, "Starting snapshot at height %lli\n", startingHeight);
     for (iter->SeekToLast(); iter->Valid(); iter->Prev())
     {
         boost::this_thread::interruption_point();
@@ -487,7 +487,7 @@ extern UniValue CBlockTreeDB::Snapshot(int top)
     }
 
     UniValue addresses(UniValue::VARR);
-    fprintf(stderr, "total=%f, totalAddresses=%li, utxos=%li, ignored=%li\n", (double) total / COIN, totalAddresses, utxos, ignoredAddresses);
+    //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) );

src/wallet/rpcwallet.cpp

@@ -4925,11 +4925,13 @@ UniValue diceaddress(const UniValue& params, bool fHelp)
 UniValue faucetaddress(const UniValue& params, bool fHelp)
 {
     struct CCcontract_info *cp,C; std::vector<unsigned char> pubkey;
+    int errno;
     cp = CCinit(&C,EVAL_FAUCET);
     if ( fHelp || params.size() > 1 )
         throw runtime_error("faucetaddress [pubkey]\n");
-    if ( ensure_CCrequirements() < 0 )
+    errno = ensure_CCrequirements();
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    if ( errno < 0 )
+        throw runtime_error(strprintf("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet. ERR=%d\n", errno));
     if ( params.size() == 1 )
         pubkey = ParseHex(params[0].get_str().c_str());
     return(CCaddress(cp,(char *)"Faucet",pubkey));
@@ -5022,7 +5024,7 @@ UniValue rewardslock(const UniValue& params, bool fHelp)
 
 UniValue rewardsaddfunding(const UniValue& params, bool fHelp)
 {
-    UniValue result(UniValue::VOBJ); char *name; uint256 fundingtxid; uint64_t amount; std::string hex;
+    UniValue result(UniValue::VOBJ); char *name; uint256 fundingtxid; int64_t amount; std::string hex;
     if ( fHelp || params.size() != 3 )
         throw runtime_error("rewardsaddfunding name fundingtxid amount\n");
     if ( ensure_CCrequirements() < 0 )
@@ -5033,11 +5035,19 @@ UniValue rewardsaddfunding(const UniValue& params, bool fHelp)
     fundingtxid = Parseuint256((char *)params[1].get_str().c_str());
     amount = atof(params[2].get_str().c_str()) * COIN;
     hex = RewardsAddfunding(0,name,fundingtxid,amount);
-    if ( hex.size() > 0 )
+    if (amount > 0) {
-    {
+        if ( hex.size() > 0 )
-        result.push_back(Pair("result", "success"));
+        {
-        result.push_back(Pair("hex", hex));
+            result.push_back(Pair("result", "success"));
-    } else result.push_back(Pair("error", "couldnt create rewards addfunding transaction"));
+            result.push_back(Pair("hex", hex));
+        } else {
+            result.push_back(Pair("result", "error"));
+            result.push_back(Pair("error", "couldnt create rewards addfunding transaction"));
+        }
+    } else {
+            result.push_back(Pair("result", "error"));
+            result.push_back(Pair("error", "funding amount must be positive"));
+    }
     return(result);
 }
 
@@ -5138,7 +5148,7 @@ UniValue faucetinfo(const UniValue& params, bool fHelp)
 
 UniValue faucetfund(const UniValue& params, bool fHelp)
 {
-    UniValue result(UniValue::VOBJ); uint64_t funds; std::string hex;
+    UniValue result(UniValue::VOBJ); int64_t funds; std::string hex;
     if ( fHelp || params.size() > 1 )
         throw runtime_error("faucetfund amount\n");
     if ( ensure_CCrequirements() < 0 )
@@ -5146,12 +5156,20 @@ UniValue faucetfund(const UniValue& params, bool fHelp)
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     funds = atof(params[0].get_str().c_str()) * COIN;
-    hex = FaucetFund(0,funds);
+    if (funds > 0) {
-    if ( hex.size() > 0 )
+        hex = FaucetFund(0,(uint64_t) funds);
-    {
+        if ( hex.size() > 0 )
-        result.push_back(Pair("result", "success"));
+        {
-        result.push_back(Pair("hex", hex));
+            result.push_back(Pair("result", "success"));
-    } else result.push_back(Pair("error", "couldnt create faucet funding transaction"));
+            result.push_back(Pair("hex", hex));
+        } else {
+            result.push_back(Pair("result", "error"));
+            result.push_back(Pair("error", "couldnt create faucet funding transaction"));
+        }
+    } else {
+        result.push_back(Pair("result", "error"));
+        result.push_back(Pair("error", "funding amount must be positive"));
+    }
     return(result);
 }
 
@@ -5169,7 +5187,10 @@ UniValue faucetget(const UniValue& params, bool fHelp)
     {
         result.push_back(Pair("result", "success"));
         result.push_back(Pair("hex", hex));
-    } else result.push_back(Pair("error", "couldnt create faucet get transaction"));
+    } else {
+        result.push_back(Pair("result", "error"));
+        result.push_back(Pair("error", "couldnt create faucet get transaction"));
+    }
     return(result);
 }