Merge branch 'FSM' into jl777

# Conflicts:
#	src/cc/rogue/main.c

qa/rpc-tests/cryptoconditions_channels.py

@@ -31,7 +31,8 @@ class CryptoconditionsChannelsTest(CryptoconditionsTestFramework):
         result = rpc.channelsaddress(self.pubkey)
         assert_success(result)
         # test that additional CCaddress key is returned
-        for x in ['myCCaddress', 'ChannelsCCaddress', 'Channelsmarker', 'myaddress', 'CCaddress']:
+        for x in ['ChannelsCC1of2TokensAddress', 'myCCAddress(Channels)', 'ChannelsCC1of2Address', 'myAddress', \
+                  'myCCaddress', 'ChannelsNormalAddress', 'PubkeyCCaddress(Channels)', 'ChannelsCCAddress']:
             assert_equal(result[x][0], 'R')
 
         # getting empty channels list

qa/rpc-tests/cryptoconditions_dice.py

@@ -24,15 +24,19 @@ class CryptoconditionsDiceTest(CryptoconditionsTestFramework):
         result = rpc1.getbalance()
         assert_greater_than(result, 100000)
 
-        dice  = rpc.diceaddress()
-        assert_equal(dice['result'], 'success')
-        for x in ['myCCaddress', 'DiceCCaddress', 'Dicemarker', 'myaddress']:
-            assert_equal(dice[x][0], 'R')
-
-        dice  = rpc.diceaddress(self.pubkey)
-        assert_equal(dice['result'], 'success')
-        for x in ['myCCaddress', 'DiceCCaddress', 'Dicemarker', 'myaddress', 'CCaddress']:
-            assert_equal(dice[x][0], 'R')
+        result  = rpc.diceaddress()
+        for x in result.keys():
+            print(x+": "+str(result[x]))  
+        assert_equal(result['result'], 'success')
+        for x in ['myCCaddress', 'DiceCCAddress', 'myaddress']:
+            assert_equal(result[x][0], 'R')
+
+        result  = rpc.diceaddress(self.pubkey)
+        for x in result.keys():
+            print(x+": "+str(result[x]))   
+        assert_equal(result['result'], 'success')
+        for x in ['myCCaddress', 'DiceCCAddress', 'myaddress', 'DiceCCTokensAddress', 'DiceNormalAddress']:
+            assert_equal(result[x][0], 'R')
 
         # no dice created yet
         result  = rpc.dicelist()

qa/rpc-tests/cryptoconditions_faucet.py

@@ -24,16 +24,20 @@ class CryptoconditionsFaucetTest(CryptoconditionsTestFramework):
         assert_greater_than(result['balance'], 0.0)
         balance = result['balance']
 
-        faucet  = rpc.faucetaddress()
-        assert_equal(faucet['result'], 'success')
+        result  = rpc.faucetaddress()
+        assert_equal(result['result'], 'success')
+        for x in result.keys():
+            print(x+": "+str(result[x]))   
         # verify all keys look like valid AC addrs, could be better
-        for x in ['myCCaddress', 'FaucetCCaddress', 'Faucetmarker', 'myaddress']:
-            assert_equal(faucet[x][0], 'R')
+        for x in ['myCCaddress', 'FaucetCCTokensAddress', 'FaucetNormalAddress', 'myaddress']:
+            assert_equal(result[x][0], 'R')
 
         result  = rpc.faucetaddress(self.pubkey)
         assert_success(result)
+        for x in result.keys():
+            print(x+": "+str(result[x]))   
         # test that additional CCaddress key is returned
-        for x in ['myCCaddress', 'FaucetCCaddress', 'Faucetmarker', 'myaddress', 'CCaddress']:
+        for x in ['myCCaddress', 'FaucetCCTokensAddress', 'FaucetNormalAddress', 'myaddress']:
             assert_equal(result[x][0], 'R')
 
         # no funds in the faucet yet

qa/rpc-tests/cryptoconditions_heir.py

@@ -20,16 +20,16 @@ class CryptoconditionsHeirTest(CryptoconditionsTestFramework):
         rpc = self.nodes[0]
         rpc1 = self.nodes[1]
 
-        result = rpc.heiraddress()
+        result = rpc.heiraddress('')
         assert_success(result)
         # verify all keys look like valid AC addrs, could be better
-        for x in ['myCCaddress', 'HeirCCaddress', 'Heirmarker', 'myaddress']:
+        for x in ['HeirNormalAddress', 'HeirCCTokensAddress', 'myaddress', 'myCCaddress', 'HeirCCAddress']:
             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']:
+        for x in ['HeirNormalAddress', 'myCCaddress', 'myaddress', 'HeirCC1of2Address', 'HeirCCAddress', 'HeirCC1of2TokensAddress']:
             assert_equal(result[x][0], 'R')
 
         # getting empty heir list

qa/rpc-tests/cryptoconditions_oracles.py

@@ -22,12 +22,12 @@ class CryptoconditionsOraclesTest(CryptoconditionsTestFramework):
 
         result = rpc.oraclesaddress()
         assert_success(result)
-        for x in ['OraclesCCaddress', 'Oraclesmarker', 'myCCaddress', 'myaddress']:
+        for x in ['myCCaddress', 'OraclesCCAddress', 'OraclesNormalAddress', 'myaddress', 'OraclesCCTokensAddress']:
             assert_equal(result[x][0], 'R')
 
         result = rpc.oraclesaddress(self.pubkey)
         assert_success(result)
-        for x in ['OraclesCCaddress', 'Oraclesmarker', 'myCCaddress', 'myaddress']:
+        for x in ['myCCaddress', 'OraclesCCAddress', 'OraclesNormalAddress', 'myaddress', 'OraclesCCTokensAddress']:
             assert_equal(result[x][0], 'R')
 
         # there are no oracles created yet

qa/rpc-tests/cryptoconditions_rewards.py

@@ -15,13 +15,15 @@ from cryptoconditions import assert_success, assert_error, generate_random_strin
 class CryptoconditionsRewardsTest(CryptoconditionsTestFramework):
 
     def run_rewards_tests(self):
+
         rpc = self.nodes[0]
+
         result = rpc.rewardsaddress()
-        for x in ['RewardsCCaddress', 'myCCaddress', 'Rewardsmarker', 'myaddress']:
+        for x in ['myCCaddress', 'myaddress', 'RewardsCCAddress', 'RewardsCCTokensAddress', 'RewardsNormalAddress']:
             assert_equal(result[x][0], 'R')
 
         result = rpc.rewardsaddress(self.pubkey)
-        for x in ['RewardsCCaddress', 'myCCaddress', 'Rewardsmarker', 'myaddress', 'CCaddress']:
+        for x in ['myCCaddress', 'myaddress', 'RewardsCCAddress', 'RewardsCCTokensAddress', 'RewardsNormalAddress']:
             assert_equal(result[x][0], 'R')
 
         # no rewards yet

qa/rpc-tests/cryptoconditions_token.py

@@ -21,22 +21,22 @@ class CryptoconditionsTokenTest(CryptoconditionsTestFramework):
 
         result = rpc.tokenaddress()
         assert_success(result)
-        for x in ['TokensCCaddress', 'myCCaddress', 'Tokensmarker', 'myaddress']:
+        for x in ['TokensCCAddress', 'myCCaddress', 'myCCAddress(Tokens)', 'myaddress', 'TokensNormalAddress']:
             assert_equal(result[x][0], 'R')
 
         result = rpc.tokenaddress(self.pubkey)
         assert_success(result)
-        for x in ['TokensCCaddress', 'myCCaddress', 'Tokensmarker', 'myaddress', 'CCaddress']:
+        for x in ['TokensCCAddress', 'myCCaddress', 'myCCAddress(Tokens)', 'myaddress', 'TokensNormalAddress']:
             assert_equal(result[x][0], 'R')
 
         result = rpc.assetsaddress()
         assert_success(result)
-        for x in ['AssetsCCaddress', 'myCCaddress', 'Assetsmarker', 'myaddress']:
+        for x in ['AssetsCCAddress', 'myCCaddress', 'myCCAddress(Assets)', 'myaddress', 'AssetsNormalAddress']:
             assert_equal(result[x][0], 'R')
 
         result = rpc.assetsaddress(self.pubkey)
         assert_success(result)
-        for x in ['AssetsCCaddress', 'myCCaddress', 'Assetsmarker', 'myaddress', 'CCaddress']:
+        for x in ['AssetsCCAddress', 'myCCaddress', 'myCCAddress(Assets)', 'myaddress', 'AssetsNormalAddress']:
             assert_equal(result[x][0], 'R')
 
         # there are no tokens created yet
@@ -61,7 +61,7 @@ class CryptoconditionsTokenTest(CryptoconditionsTestFramework):
         assert_equal(result[0], tokenid)
 
         # there are no token orders yet
-        result = rpc.tokenorders()
+        result = rpc.tokenorders(tokenid)
         assert_equal(result, [])
 
         # getting token balance for non existing tokenid
@@ -117,7 +117,7 @@ class CryptoconditionsTokenTest(CryptoconditionsTestFramework):
         tokenask = rpc.tokenask("100", tokenid, "7.77")
         tokenaskhex = tokenask['hex']
         tokenaskid = self.send_and_mine(tokenask['hex'], rpc)
-        result = rpc.tokenorders()
+        result = rpc.tokenorders(tokenid)
         order = result[0]
         assert order, "found order"
 
@@ -136,7 +136,7 @@ class CryptoconditionsTokenTest(CryptoconditionsTestFramework):
         assert txid, "found txid"
 
         # should be no token orders
-        result = rpc.tokenorders()
+        result = rpc.tokenorders(tokenid)
         assert_equal(result, [])
 
         # checking ask cancellation
@@ -157,7 +157,7 @@ class CryptoconditionsTokenTest(CryptoconditionsTestFramework):
         # from valid node
         cancel = rpc.tokencancelask(tokenid, testorderid)
         self.send_and_mine(cancel["hex"], rpc)
-        result = rpc.tokenorders()
+        result = rpc.tokenorders(tokenid)
         assert_equal(result, [])
 
 
@@ -184,7 +184,7 @@ class CryptoconditionsTokenTest(CryptoconditionsTestFramework):
         tokenbid = rpc.tokenbid("100", tokenid, "10")
         tokenbidhex = tokenbid['hex']
         tokenbidid = self.send_and_mine(tokenbid['hex'], rpc)
-        result = rpc.tokenorders()
+        result = rpc.tokenorders(tokenid)
         order = result[0]
         assert order, "found order"
 
@@ -203,7 +203,7 @@ class CryptoconditionsTokenTest(CryptoconditionsTestFramework):
         assert txid, "found txid"
 
         # should be no token orders
-        result = rpc.tokenorders()
+        result = rpc.tokenorders(tokenid)
         assert_equal(result, [])
 
         # checking bid cancellation
@@ -220,7 +220,7 @@ class CryptoconditionsTokenTest(CryptoconditionsTestFramework):
         # from valid node
         cancel = rpc.tokencancelbid(tokenid, testorderid)
         self.send_and_mine(cancel["hex"], rpc)
-        result = rpc.tokenorders()
+        result = rpc.tokenorders(tokenid)
         assert_equal(result, [])
 
         # invalid token transfer amount (have to add status to CC code!)

src/cc/assets.cpp

@@ -297,6 +297,7 @@ bool AssetsValidate(struct CCcontract_info *cpAssets,Eval* eval,const CTransacti
                         return eval->Invalid("vout2 doesnt go to origpubkey fillbuy");
                     else if ( inputs != tx.vout[2].nValue + tx.vout[4].nValue )
                         return eval->Invalid("asset inputs doesnt match vout2+3 fillbuy");
+                    preventCCvouts ++;
                 }
                 else if( ConstrainVout(tx.vout[2], 1, origTokensCCaddr, inputs) == 0 )      // tokens to originator cc addr (tokens+nonfungible evals)
                     return eval->Invalid("vout2 doesnt match inputs fillbuy");
@@ -468,7 +469,7 @@ bool AssetsValidate(struct CCcontract_info *cpAssets,Eval* eval,const CTransacti
     }
 
     // what does this do?
-	bool bPrevent = PreventCC(eval, tx, preventCCvins, numvins, preventCCvouts, numvouts);
+	bool bPrevent = PreventCC(eval, tx, preventCCvins, numvins, preventCCvouts, numvouts);  // seems we do not need this call as we already checked vouts well
 	//std::cerr << "AssetsValidate() PreventCC returned=" << bPrevent << std::endl;
 	return (bPrevent);
 }