Merge pull request #1075 from jl777/dev

Dev

qa/pull-tester/rpc-tests.sh

@@ -14,8 +14,10 @@ testScripts=(
     'ac_private.py'
     'verushash.py'
     'cryptoconditions.py'
+    'cryptoconditions_channels.py'
     'cryptoconditions_dice.py'
     'cryptoconditions_faucet.py'
+    'cryptoconditions_gateways.py'
     'cryptoconditions_oracles.py'
     'cryptoconditions_rewards.py'
     'cryptoconditions_token.py'

qa/rpc-tests/cryptoconditions_channels.py

@@ -0,0 +1,174 @@
+#!/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, 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 CryptoconditionsChannelsTest(BitcoinTestFramework):
+
+    def setup_chain(self):
+        print("Initializing CC test directory "+self.options.tmpdir)
+        self.num_nodes = 2
+        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.addr1    = "RXEXoa1nRmKhMbuZovpcYwQMsicwzccZBp"
+        self.pubkey1  = "024026d4ad4ecfc1f705a9b42ca64af6d2ad947509c085534a30b8861d756c6ff0"
+        self.privkey1 = "UtdydP56pGTFmawHzHr1wDrc4oUwCNW1ttX8Pc3KrvH3MA8P49Wi"
+        self.nodes   = start_nodes(self.num_nodes, self.options.tmpdir,
+                    extra_args=[[
+                    # always give -ac_name as first extra_arg and port as third
+                    '-ac_name=REGTEST',
+                    '-conf='+self.options.tmpdir+'/node0/REGTEST.conf',
+                    '-port=64367',
+                    '-rpcport=64368',
+                    '-regtest',
+                    '-addressindex=1',
+                    '-spentindex=1',
+                    '-ac_supply=5555555',
+                    '-ac_reward=10000000000000',
+                    '-pubkey=' + self.pubkey,
+                    '-ac_cc=2',
+                    '-whitelist=127.0.0.1',
+                    '-debug',
+                    '--daemon',
+                    '-rpcuser=rt',
+                    '-rpcpassword=rt'
+                    ],
+                    ['-ac_name=REGTEST',
+                    '-conf='+self.options.tmpdir+'/node1/REGTEST.conf',
+                    '-port=64365',
+                    '-rpcport=64366',
+                    '-regtest',
+                    '-addressindex=1',
+                    '-spentindex=1',
+                    '-ac_supply=5555555',
+                    '-ac_reward=10000000000000',
+                    '-pubkey=' + self.pubkey1,
+                    '-ac_cc=2',
+                    '-whitelist=127.0.0.1',
+                    '-debug',
+                    '-addnode=127.0.0.1:64367',
+                    '--daemon',
+                    '-rpcuser=rt',
+                    '-rpcpassword=rt']]
+        )
+        self.is_network_split = split
+        self.rpc              = self.nodes[0]
+        self.rpc1             = self.nodes[1]
+        self.sync_all()
+        print("Done setting up network")
+
+    def send_and_mine(self, xtn, rpc_connection):
+        txid = rpc_connection.sendrawtransaction(xtn)
+        assert txid, 'got txid'
+        # we need the tx above to be confirmed in the next block
+        rpc_connection.generate(1)
+        return txid
+
+    def run_channels_tests(self):
+
+
+        """!!! for testing needed test daemon which built with custom flag
+        export CONFIGURE_FLAGS='CPPFLAGS=-DTESTMODE'
+        since in usual mode 101 confirmations are needed for payment/refund
+        """
+
+        rpc = self.nodes[0]
+        rpc1 = self.nodes[1]
+
+        # getting empty channels list
+        result = rpc.channelsinfo()
+        assert_equal(len(result), 2)
+        assert_equal(result["result"], "success")
+        assert_equal(result["name"], "Channels Info")
+
+        # 10 payments, 100000 sat denomination channel opening with second node pubkey
+        new_channel_hex = rpc.channelsopen(self.pubkey1, "10", "100000")
+        assert_success(new_channel_hex)
+        channel_txid = self.send_and_mine(new_channel_hex["hex"], rpc)
+        assert channel_txid, "got channel txid"
+
+        # checking if our new channel in common channels list
+        result = rpc.channelsinfo()
+        assert_equal(len(result), 3)
+
+        # checking info about channel directly
+        result = rpc.channelsinfo(channel_txid)
+        assert_success(result)
+        assert_equal(result["Open"], "10 payments of 100000 satoshi")
+
+        # open transaction should be confirmed
+        rpc.generate(1)
+
+        # trying to make wrong denomination channel payment
+        result = rpc.channelspayment(channel_txid, "199000")
+        assert_error(result)
+
+        # trying to make 0 channel payment
+        result = rpc.channelspayment(channel_txid, "0")
+        assert_error(result)
+
+        # trying to make negative channel payment
+        result = rpc.channelspayment(channel_txid, "-1")
+        assert_error(result)
+
+        # valid channel payment
+        result = rpc.channelspayment(channel_txid, "100000")
+        assert_success(result)
+        payment_tx_id = self.send_and_mine(result["hex"], rpc)
+        assert payment_tx_id, "got txid"
+
+        # now in channelinfo payment information should appear
+        result = rpc.channelsinfo(channel_txid)
+        assert_equal(result["Payment"], "100000 satoshi to {}, 9 payments left".format(self.addr1))
+
+        # executing channel close
+        result = rpc.channelsclose(channel_txid)
+        assert_success(result)
+        channel_close_txid = self.send_and_mine(result["hex"], rpc)
+        assert channel_close_txid, "got txid"
+
+        rpc.generate(2)
+        self.sync_all()
+
+        # now in channelinfo closed flag should appear
+        result = rpc.channelsinfo(channel_txid)
+        assert_equal(result["Close"], "channel")
+
+        # executing channel refund
+        result = rpc.channelsrefund(channel_txid, channel_close_txid)
+        assert_success(result)
+        refund_txid = self.send_and_mine(result["hex"], rpc)
+        assert refund_txid, "got txid"
+
+    def run_test(self):
+        print("Mining blocks...")
+        rpc = self.nodes[0]
+        rpc1 = self.nodes[1]
+        # utxos from block 1 become mature in block 101
+        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_channels_tests()
+
+
+if __name__ == '__main__':
+    CryptoconditionsChannelsTest().main()

qa/rpc-tests/cryptoconditions_gateways.py

@@ -0,0 +1,157 @@
+#!/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, 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 CryptoconditionsGatewaysTest(BitcoinTestFramework):
+
+
+    def setup_chain(self):
+        print("Initializing CC test directory "+self.options.tmpdir)
+        self.num_nodes = 2
+        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.addr1    = "RXEXoa1nRmKhMbuZovpcYwQMsicwzccZBp"
+        self.pubkey1  = "024026d4ad4ecfc1f705a9b42ca64af6d2ad947509c085534a30b8861d756c6ff0"
+        self.privkey1 = "UtdydP56pGTFmawHzHr1wDrc4oUwCNW1ttX8Pc3KrvH3MA8P49Wi"
+        self.nodes   = start_nodes(self.num_nodes, self.options.tmpdir,
+                    extra_args=[[
+                    # always give -ac_name as first extra_arg and port as third
+                    '-ac_name=REGTEST',
+                    '-conf='+self.options.tmpdir+'/node0/REGTEST.conf',
+                    '-port=64367',
+                    '-rpcport=64368',
+                    '-regtest',
+                    '-addressindex=1',
+                    '-spentindex=1',
+                    '-ac_supply=5555555',
+                    '-ac_reward=10000000000000',
+                    '-pubkey=' + self.pubkey,
+                    '-ac_cc=2',
+                    '-whitelist=127.0.0.1',
+                    '-debug',
+                    '--daemon',
+                    '-rpcuser=rt',
+                    '-rpcpassword=rt'
+                    ],
+                    ['-ac_name=REGTEST',
+                    '-conf='+self.options.tmpdir+'/node1/REGTEST.conf',
+                    '-port=64365',
+                    '-rpcport=64366',
+                    '-regtest',
+                    '-addressindex=1',
+                    '-spentindex=1',
+                    '-ac_supply=5555555',
+                    '-ac_reward=10000000000000',
+                    '-pubkey=' + self.pubkey1,
+                    '-ac_cc=2',
+                    '-whitelist=127.0.0.1',
+                    '-debug',
+                    '-addnode=127.0.0.1:64367',
+                    '--daemon',
+                    '-rpcuser=rt',
+                    '-rpcpassword=rt']]
+        )
+        self.is_network_split = split
+        self.rpc              = self.nodes[0]
+        self.rpc1             = self.nodes[1]
+        self.sync_all()
+        print("Done setting up network")
+
+    def send_and_mine(self, xtn, rpc_connection):
+        txid = rpc_connection.sendrawtransaction(xtn)
+        assert txid, 'got txid'
+        # we need the tx above to be confirmed in the next block
+        rpc_connection.generate(1)
+        return txid
+
+    def run_gateways_tests(self):
+        rpc = self.nodes[0]
+        rpc1 = self.nodes[1]
+
+        result = rpc.gatewaysaddress()
+        assert_success(result)
+        for x in ['GatewaysCCaddress', 'myCCaddress', 'Gatewaysmarker', 'myaddress']:
+            assert_equal(result[x][0], 'R')
+
+        assert_equal("03ea9c062b9652d8eff34879b504eda0717895d27597aaeb60347d65eed96ccb40", result["GatewaysPubkey"])
+
+        # getting an empty gateways list
+
+        result = rpc.gatewayslist()
+        assert_equal(result, [])
+
+        # Gateways binding preparation
+
+        # creating oracle
+        oracle_hex = rpc.oraclescreate("Test", "Testing", "Ihh")
+        assert_success(oracle_hex)
+        oracle_txid = self.send_and_mine(oracle_hex["hex"], rpc)
+        assert oracle_txid, "got txid"
+
+        # registering as an oracle publisher
+        reg_hex = rpc.oraclesregister(oracle_txid, "10000")
+        assert_success(reg_hex)
+        reg_txid = self.send_and_mine(reg_hex["hex"], rpc)
+        assert reg_txid, "got txid"
+
+        # subscribing on oracle
+        sub_hex = rpc.oraclessubscribe(oracle_txid, self.pubkey, "1")
+        assert_success(sub_hex)
+        sub_txid = self.send_and_mine(sub_hex["hex"], rpc)
+        assert sub_txid, "got txid"
+
+        # creating token
+        token_hex = rpc.tokencreate("Test", "1", "Testing")
+        assert_success(token_hex)
+        token_txid = self.send_and_mine(token_hex["hex"], rpc)
+        assert token_txid, "got txid"
+
+        # converting tokens
+        convertion_hex = rpc.tokenconvert("241",token_txid,"03ea9c062b9652d8eff34879b504eda0717895d27597aaeb60347d65eed96ccb40","100000000")
+        assert_success(convertion_hex)
+        convertion_txid = self.send_and_mine(convertion_hex["hex"], rpc)
+        assert convertion_txid, "got txid"
+
+        # binding gateway
+        bind_hex = rpc.gatewaysbind(token_txid, oracle_txid, "KMD", "100000000", "1", "1", self.pubkey)
+        assert_success(bind_hex)
+        bind_txid = self.send_and_mine(bind_hex["hex"], rpc)
+        assert bind_txid, "got txid"
+
+        # checking if created gateway in list
+        result = rpc.gatewayslist()
+        assert_equal(result[0], bind_txid)
+
+    def run_test(self):
+        print("Mining blocks...")
+        rpc = self.nodes[0]
+        rpc1 = self.nodes[1]
+        # utxos from block 1 become mature in block 101
+        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_gateways_tests()
+
+
+if __name__ == '__main__':
+    CryptoconditionsGatewaysTest().main()

src/komodo_bitcoind.h

@@ -889,9 +889,9 @@ int32_t komodo_eligiblenotary(uint8_t pubkeys[66][33],int32_t *mids,uint32_t blo
 
 int32_t komodo_minerids(uint8_t *minerids,int32_t height,int32_t width)
 {
-    int32_t i,j,n,nonz,numnotaries; CBlock block; CBlockIndex *pindex; uint8_t notarypubs33[64][33],pubkey33[33];
+    int32_t i,j,nonz,numnotaries; CBlock block; CBlockIndex *pindex; uint8_t notarypubs33[64][33],pubkey33[33];
     numnotaries = komodo_notaries(notarypubs33,height,0);
-    for (i=nonz=0; i<width; i++,n++)
+    for (i=nonz=0; i<width; i++)
     {
         if ( height-i <= 0 )
             continue;
@@ -1123,11 +1123,13 @@ uint64_t komodo_commission(const CBlock *pblock,int32_t height)
     {
         nSubsidy = GetBlockSubsidy(height,Params().GetConsensus());
         //fprintf(stderr,"ht.%d nSubsidy %.8f prod %llu\n",height,(double)nSubsidy/COIN,(long long)(nSubsidy * ASSETCHAINS_COMMISSION));
-        return((nSubsidy * ASSETCHAINS_COMMISSION) / COIN);
+        commission = ((nSubsidy * ASSETCHAINS_COMMISSION) / COIN);
-        n = pblock->vtx[0].vout.size();
+        if ( ASSETCHAINS_FOUNDERS > 1 )
-        for (j=0; j<n; j++)
+        {
-            if ( j != 1 )
+            if ( (height % ASSETCHAINS_FOUNDERS) == 0 )
-                total += pblock->vtx[0].vout[j].nValue;
+                commission = commission * ASSETCHAINS_FOUNDERS;
+            else commission = 0;
+        }
     }
     else
     {
@@ -1141,9 +1143,8 @@ uint64_t komodo_commission(const CBlock *pblock,int32_t height)
                     total += pblock->vtx[i].vout[j].nValue;
             }
         }
+        commission = ((total * ASSETCHAINS_COMMISSION) / COIN);
     }
-    //fprintf(stderr,"txn.%d n.%d commission total %.8f -> %.8f\n",txn_count,n,dstr(total),dstr((total * ASSETCHAINS_COMMISSION) / COIN));
-    commission = ((total * ASSETCHAINS_COMMISSION) / COIN);
     if ( commission < 10000 )
         commission = 0;
     return(commission);
@@ -1806,7 +1807,9 @@ int32_t komodo_checkPOW(int32_t slowflag,CBlock *pblock,int32_t height)
             if ( ASSETCHAINS_SCRIPTPUB.size() > 1 )
             {
                 int32_t scriptlen; uint8_t scripthex[10000];
-                if ( ASSETCHAINS_SCRIPTPUB.size()/2 == pblock->vtx[0].vout[0].scriptPubKey.size() && scriptlen < sizeof(scripthex) )
+                script = (uint8_t *)&pblock->vtx[0].vout[0].scriptPubKey[0];
+                scriptlen = (int32_t)pblock->vtx[0].vout[0].scriptPubKey.size();
+                if ( ASSETCHAINS_SCRIPTPUB.size()/2 == scriptlen && scriptlen < sizeof(scripthex) )
                 {
                     decode_hex(scripthex,scriptlen,(char *)ASSETCHAINS_SCRIPTPUB.c_str());
                     if ( memcmp(scripthex,script,scriptlen) != 0 )

src/komodo_globals.h

@@ -45,10 +45,10 @@ struct komodo_state KOMODO_STATES[34];
 #define _COINBASE_MATURITY 100
 int COINBASE_MATURITY = _COINBASE_MATURITY;//100;
 
-int32_t KOMODO_MININGTHREADS = -1,IS_KOMODO_NOTARY,USE_EXTERNAL_PUBKEY,KOMODO_CHOSEN_ONE,ASSETCHAINS_SEED,KOMODO_ON_DEMAND,KOMODO_EXTERNAL_NOTARIES,KOMODO_PASSPORT_INITDONE,KOMODO_PAX,KOMODO_EXCHANGEWALLET,KOMODO_REWIND,KOMODO_CONNECTING = -1,KOMODO_DEALERNODE,KOMODO_EXTRASATOSHI;
+int32_t KOMODO_MININGTHREADS = -1,IS_KOMODO_NOTARY,USE_EXTERNAL_PUBKEY,KOMODO_CHOSEN_ONE,ASSETCHAINS_SEED,KOMODO_ON_DEMAND,KOMODO_EXTERNAL_NOTARIES,KOMODO_PASSPORT_INITDONE,KOMODO_PAX,KOMODO_EXCHANGEWALLET,KOMODO_REWIND,KOMODO_CONNECTING = -1,KOMODO_DEALERNODE,KOMODO_EXTRASATOSHI,ASSETCHAINS_FOUNDERS;
 int32_t KOMODO_INSYNC,KOMODO_LASTMINED,prevKOMODO_LASTMINED,KOMODO_CCACTIVATE,JUMBLR_PAUSE = 1;
 std::string NOTARY_PUBKEY,ASSETCHAINS_NOTARIES,ASSETCHAINS_OVERRIDE_PUBKEY,DONATION_PUBKEY,ASSETCHAINS_SCRIPTPUB;
-uint8_t NOTARY_PUBKEY33[33],ASSETCHAINS_OVERRIDE_PUBKEY33[33],ASSETCHAINS_OVERRIDE_PUBKEYHASH[20],ASSETCHAINS_PUBLIC,ASSETCHAINS_PRIVATE,ASSETCHAINS_TXPOW,ASSETCHAINS_FOUNDERS;
+uint8_t NOTARY_PUBKEY33[33],ASSETCHAINS_OVERRIDE_PUBKEY33[33],ASSETCHAINS_OVERRIDE_PUBKEYHASH[20],ASSETCHAINS_PUBLIC,ASSETCHAINS_PRIVATE,ASSETCHAINS_TXPOW;
 bool VERUS_MINTBLOCKS;
 
 char ASSETCHAINS_SYMBOL[KOMODO_ASSETCHAIN_MAXLEN],ASSETCHAINS_USERPASS[4096];
@@ -261,4 +261,3 @@ int64_t komodo_current_supply(uint32_t nHeight)
     }
     return((int64_t)(cur_money + (cur_money * ASSETCHAINS_COMMISSION)));
 }
-

src/komodo_utils.h

@@ -1500,6 +1500,9 @@ uint32_t komodo_assetmagic(char *symbol,uint64_t supply,uint8_t *extraptr,int32_
     {
         vcalc_sha256(0,hash.bytes,extraptr,extralen);
         crc0 = hash.uints[0];
+        int32_t i; for (i=0; i<extralen; i++)
+            fprintf(stderr,"%02x",extraptr[i]);
+        fprintf(stderr," extralen.%d crc0.%x\n",extralen,crc0);
     }
     return(calc_crc32(crc0,buf,len));
 }
@@ -1765,11 +1768,13 @@ void komodo_args(char *argv0)
 
         MAX_BLOCK_SIGOPS = 60000;
         ASSETCHAINS_TXPOW = GetArg("-ac_txpow",0) & 3;
-        ASSETCHAINS_FOUNDERS = GetArg("-ac_founders",0) & 1;
+        ASSETCHAINS_FOUNDERS = GetArg("-ac_founders",0);// & 1;
         ASSETCHAINS_SUPPLY = GetArg("-ac_supply",10);
         ASSETCHAINS_COMMISSION = GetArg("-ac_perc",0);
         ASSETCHAINS_OVERRIDE_PUBKEY = GetArg("-ac_pubkey","");
         ASSETCHAINS_SCRIPTPUB = GetArg("-ac_script","");
+        //ASSETCHAINS_FOUNDERS_PERIOD = GetArg("-ac_period",0);
+
         if ( (ASSETCHAINS_STAKED= GetArg("-ac_staked",0)) > 100 )
             ASSETCHAINS_STAKED = 100;
 
@@ -1823,7 +1828,7 @@ void komodo_args(char *argv0)
         }
         if ( ASSETCHAINS_ENDSUBSIDY[0] != 0 || ASSETCHAINS_REWARD[0] != 0 || ASSETCHAINS_HALVING[0] != 0 || ASSETCHAINS_DECAY[0] != 0 || ASSETCHAINS_COMMISSION != 0 || ASSETCHAINS_PUBLIC != 0 || ASSETCHAINS_PRIVATE != 0 || ASSETCHAINS_TXPOW != 0 || ASSETCHAINS_FOUNDERS != 0 || ASSETCHAINS_SCRIPTPUB.size() > 1 )
         {
-            fprintf(stderr,"perc %.4f%% ac_pub=[%02x%02x%02x...]\n",dstr(ASSETCHAINS_COMMISSION)*100,ASSETCHAINS_OVERRIDE_PUBKEY33[0],ASSETCHAINS_OVERRIDE_PUBKEY33[1],ASSETCHAINS_OVERRIDE_PUBKEY33[2]);
+            fprintf(stderr,"perc %.4f%% ac_pub=[%02x%02x%02x...] acsize.%d\n",dstr(ASSETCHAINS_COMMISSION)*100,ASSETCHAINS_OVERRIDE_PUBKEY33[0],ASSETCHAINS_OVERRIDE_PUBKEY33[1],ASSETCHAINS_OVERRIDE_PUBKEY33[2],(int32_t)ASSETCHAINS_SCRIPTPUB.size());
             extraptr = extrabuf;
             memcpy(extraptr,ASSETCHAINS_OVERRIDE_PUBKEY33,33), extralen = 33;
 
@@ -1870,9 +1875,19 @@ void komodo_args(char *argv0)
             val = ASSETCHAINS_COMMISSION | (((uint64_t)ASSETCHAINS_STAKED & 0xff) << 32) | (((uint64_t)ASSETCHAINS_CC & 0xffff) << 40) | ((ASSETCHAINS_PUBLIC != 0) << 7) | ((ASSETCHAINS_PRIVATE != 0) << 6) | ASSETCHAINS_TXPOW;
             extralen += iguana_rwnum(1,&extraptr[extralen],sizeof(val),(void *)&val);
             if ( ASSETCHAINS_FOUNDERS != 0 )
-                extralen += iguana_rwnum(1,&extraptr[extralen],sizeof(ASSETCHAINS_FOUNDERS),(void *)&ASSETCHAINS_FOUNDERS);
+            {
+                uint8_t tmp = 1;
+                extralen += iguana_rwnum(1,&extraptr[extralen],sizeof(tmp),(void *)&tmp);
+                if ( ASSETCHAINS_FOUNDERS > 1 )
+                    extralen += iguana_rwnum(1,&extraptr[extralen],sizeof(ASSETCHAINS_FOUNDERS),(void *)&ASSETCHAINS_FOUNDERS);
+            }
             if ( ASSETCHAINS_SCRIPTPUB.size() > 1 )
-                extralen += iguana_rwnum(1,&extraptr[extralen],(int32_t)ASSETCHAINS_SCRIPTPUB.size(),(void *)ASSETCHAINS_SCRIPTPUB.c_str());
+            {
+                decode_hex(&extraptr[extralen],ASSETCHAINS_SCRIPTPUB.size()/2,(char *)ASSETCHAINS_SCRIPTPUB.c_str());
+                extralen += ASSETCHAINS_SCRIPTPUB.size()/2;
+                //extralen += iguana_rwnum(1,&extraptr[extralen],(int32_t)ASSETCHAINS_SCRIPTPUB.size(),(void *)ASSETCHAINS_SCRIPTPUB.c_str());
+                fprintf(stderr,"append ac_script %s\n",ASSETCHAINS_SCRIPTPUB.c_str());
+            }
         }
 
         addn = GetArg("-seednode","");
@@ -1899,11 +1914,11 @@ void komodo_args(char *argv0)
         while ( (dirname= (char *)GetDataDir(false).string().c_str()) == 0 || dirname[0] == 0 )
         {
             fprintf(stderr,"waiting for datadir\n");
-						#ifndef _WIN32
+#ifndef _WIN32
             sleep(3);
-						#else
+#else
-						boost::this_thread::sleep(boost::posix_time::milliseconds(3000));
+            boost::this_thread::sleep(boost::posix_time::milliseconds(3000));
-						#endif
+#endif
         }
         //fprintf(stderr,"Got datadir.(%s)\n",dirname);
         if ( ASSETCHAINS_SYMBOL[0] != 0 )
@@ -2051,4 +2066,3 @@ void komodo_prefetch(FILE *fp)
     }
     fseek(fp,fpos,SEEK_SET);
 }
-

src/miner.cpp

@@ -148,7 +148,7 @@ CBlockTemplate* CreateNewBlock(const CScript& _scriptPubKeyIn, int32_t gpucount,
     CPubKey pk = CPubKey();
     std::vector<std::vector<unsigned char>> vAddrs;
     txnouttype txT;
-    if (Solver(scriptPubKeyIn, txT, vAddrs))
+    if ( scriptPubKeyIn.size() > 0 && Solver(scriptPubKeyIn, txT, vAddrs))
     {
         if (txT == TX_PUBKEY)
             pk = CPubKey(vAddrs[0]);

src/net.cpp

@@ -1492,13 +1492,18 @@ void ThreadOpenAddedConnections()
             LOCK(cs_vNodes);
             BOOST_FOREACH(CNode* pnode, vNodes)
                 for (list<vector<CService> >::iterator it = lservAddressesToAdd.begin(); it != lservAddressesToAdd.end(); it++)
+                {
                     BOOST_FOREACH(const CService& addrNode, *(it))
                         if (pnode->addr == addrNode)
                         {
                             it = lservAddressesToAdd.erase(it);
-                            it--;
+                            if ( it != lservAddressesToAdd.begin() )
+                                it--;
                             break;
                         }
+                    if (it == lservAddressesToAdd.end())
+                        break;
+                }
         }
         BOOST_FOREACH(vector<CService>& vserv, lservAddressesToAdd)
         {