Merge pull request #12 from jl777/FSM

Fsm

qa/pull-tester/cc-tests.sh

@@ -13,12 +13,13 @@ export BITCOIND=${REAL_BITCOIND}
 
 testScripts=(
     'cryptoconditions_faucet.py'
-    'cryptoconditions_channels.py'
     'cryptoconditions_dice.py'
     'cryptoconditions_oracles.py'
     'cryptoconditions_rewards.py'
     'cryptoconditions_token.py'
     #'cryptoconditions_gateways.py'
+    # TODO: cant reconnect nodes back in channels test because of crash (seems regtest only specific)
+    'cryptoconditions_channels.py'
 );
 
 extArg="-extended"

qa/rpc-tests/cryptoconditions_channels.py

@@ -4,6 +4,7 @@
 # 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, \
@@ -71,6 +72,58 @@ def run_channels_tests(self):
         result = rpc.channelsinfo(channel_txid)
         assert_equal(result["Transactions"][1]["Payment"], payment_tx_id)
 
+        # number of payments should be equal 1 (one denomination used)
+        result = rpc.channelsinfo(channel_txid)["Transactions"][1]["Number of payments"]
+        assert_equal(result, 1)
+        # payments left param should reduce 1 and be equal 9 now ( 10 - 1 = 9 )
+        result = rpc.channelsinfo(channel_txid)["Transactions"][1]["Payments left"]
+        assert_equal(result, 9)
+
+        # lets try payment with x2 amount to ensure that counters works correct
+        result = rpc.channelspayment(channel_txid, "200000")
+        assert_success(result)
+        payment_tx_id = self.send_and_mine(result["hex"], rpc)
+        assert payment_tx_id, "got txid"
+
+        result = rpc.channelsinfo(channel_txid)
+        assert_equal(result["Transactions"][2]["Payment"], payment_tx_id)
+
+        result = rpc.channelsinfo(channel_txid)["Transactions"][2]["Number of payments"]
+        assert_equal(result, 2)
+
+        result = rpc.channelsinfo(channel_txid)["Transactions"][2]["Payments left"]
+        assert_equal(result, 7)
+
+        # check if payment value really transferred
+        raw_transaction = rpc.getrawtransaction(payment_tx_id, 1)
+
+        result = raw_transaction["vout"][3]["valueSat"]
+        assert_equal(result, 200000)
+
+        result = rpc1.validateaddress(raw_transaction["vout"][3]["scriptPubKey"]["addresses"][0])["ismine"]
+        assert_equal(result, 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()
+        result = rpc1.getbalance()
+        assert_greater_than(result, 0.1)
+
+        # trying to initiate channels payment from node B without any secret
+        # TODO: have to add RPC validation
+        payment_hex = rpc1.channelspayment(channel_txid, "100000")
+        try:
+            result = rpc1.sendrawtransaction(payment_hex["hex"])
+        except Exception as e:
+            pass
+
+        # trying to initiate channels payment from node B with secret from previous payment
+        result = rpc1.channelspayment(channel_txid, "100000", rpc1.channelsinfo(channel_txid)["Transactions"][1]["Secret"])
+        #result = rpc1.sendrawtransaction(payment_hex["hex"])
+        assert_error(result)
+
         # executing channel close
         result = rpc.channelsclose(channel_txid)
         assert_success(result)
@@ -82,14 +135,100 @@ def run_channels_tests(self):
 
         # now in channelinfo closed flag should appear
         result = rpc.channelsinfo(channel_txid)
-        assert_equal(result["Transactions"][2]["Close"], channel_close_txid)
+        assert_equal(result["Transactions"][3]["Close"], channel_close_txid)
 
         # 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"
 
+        # TODO: check if it refunded to opener address
+        raw_transaction = rpc.getrawtransaction(refund_txid, 1)
+
+        result = raw_transaction["vout"][2]["valueSat"]
+        assert_equal(result, 700000)
+
+        result = rpc.validateaddress(raw_transaction["vout"][2]["scriptPubKey"]["addresses"][0])["ismine"]
+        assert_equal(result, True)
+
+
+        # creating and draining channel (10 payment by 100000 satoshies in total to fit full capacity)
+        new_channel_hex1 = rpc.channelsopen(self.pubkey1, "10", "100000")
+        assert_success(new_channel_hex1)
+        channel1_txid = self.send_and_mine(new_channel_hex1["hex"], rpc)
+        assert channel1_txid, "got channel txid"
+
+        # need to have 2+ confirmations in the test mode
+        rpc.generate(2)
+        self.sync_all()
+
+        for i in range(10):
+            result = rpc.channelspayment(channel1_txid, "100000")
+            assert_success(result)
+            payment_tx_id = self.send_and_mine(result["hex"], rpc)
+            assert payment_tx_id, "got txid"
+
+        # last payment should indicate that 0 payments left
+        result = rpc.channelsinfo(channel1_txid)["Transactions"][10]["Payments left"]
+        assert_equal(result, 0)
+
+        # no more payments possible
+        result = rpc.channelspayment(channel1_txid, "100000")
+        assert_error(result)
+
+        # creating new channel to test the case when node B initiate payment when node A revealed secret in offline
+        # 10 payments, 100000 sat denomination channel opening with second node pubkey
+        new_channel_hex2 = rpc.channelsopen(self.pubkey1, "10", "100000")
+        assert_success(new_channel_hex)
+        channel2_txid = self.send_and_mine(new_channel_hex2["hex"], rpc)
+        assert channel2_txid, "got channel txid"
+
+        rpc.generate(2)
+        self.sync_all()
+
+        # disconnecting first node from network
+        rpc.setban("127.0.0.0/24","add")
+        assert_equal(rpc.getinfo()["connections"], 0)
+        assert_equal(rpc1.getinfo()["connections"], 0)
+
+        rpc1.generate(1)
+
+        # sending one payment to mempool to reveal the secret but not mine it
+        payment_hex = rpc.channelspayment(channel2_txid, "100000")
+        result = rpc.sendrawtransaction(payment_hex["hex"])
+        assert result, "got payment txid"
+
+        secret = rpc.channelsinfo(channel2_txid)["Transactions"][1]["Secret"]
+        assert secret, "Secret revealed"
+
+        # secret shouldn't be available for node B
+        secret_not_revealed = None
+        try:
+            rpc1.channelsinfo(channel2_txid)["Transactions"][1]["Secret"]
+        except Exception:
+            secret_not_revealed = True
+        assert_equal(secret_not_revealed, True)
+
+        # trying to initiate payment from second node with revealed secret
+        assert_equal(rpc1.getinfo()["connections"], 0)
+        dc_payment_hex = rpc1.channelspayment(channel2_txid, "100000", secret)
+        assert_success(dc_payment_hex)
+        result = rpc1.sendrawtransaction(dc_payment_hex["hex"])
+        assert result, "got channelspayment transaction id"
+
+        # TODO: it crash first node after block generating on mempools merging
+        # # restoring connection between nodes
+        # rpc.setban("127.0.0.0/24","remove")
+        # #rpc.generate(1)
+        # #rpc1.generate(1)
+        # sync_blocks(self.nodes)
+        # rpc.generate(1)
+        # sync_blocks(self.nodes)
+        # sync_mempools(self.nodes)
+        # assert_equal(rpc.getinfo()["connections"], 1)
+        # assert_equal(rpc1.getinfo()["connections"], 1)
+
     def run_test(self):
         print("Mining blocks...")
         rpc = self.nodes[0]

qa/rpc-tests/cryptoconditions_token.py

@@ -15,21 +15,35 @@
 class CryptoconditionsTokenTest(CryptoconditionsTestFramework):
 
     def run_token_tests(self):
-        rpc    = self.nodes[0]
+
+        rpc  = self.nodes[0]
+        rpc1 = self.nodes[1]
+
         result = rpc.tokenaddress()
         assert_success(result)
-        for x in ['AssetsCCaddress', 'myCCaddress', 'Assetsmarker', 'myaddress']:
+        for x in ['TokensCCaddress', 'myCCaddress', 'Tokensmarker', 'myaddress']:
             assert_equal(result[x][0], 'R')
 
         result = rpc.tokenaddress(self.pubkey)
         assert_success(result)
+        for x in ['TokensCCaddress', 'myCCaddress', 'Tokensmarker', 'myaddress', 'CCaddress']:
+            assert_equal(result[x][0], 'R')
+
+        result = rpc.assetsaddress()
+        assert_success(result)
+        for x in ['AssetsCCaddress', 'myCCaddress', 'Assetsmarker', 'myaddress']:
+            assert_equal(result[x][0], 'R')
+
+        result = rpc.assetsaddress(self.pubkey)
+        assert_success(result)
         for x in ['AssetsCCaddress', 'myCCaddress', 'Assetsmarker', 'myaddress', 'CCaddress']:
             assert_equal(result[x][0], 'R')
+
         # there are no tokens created yet
         result = rpc.tokenlist()
         assert_equal(result, [])
 
-        # trying to create token with negaive supply
+        # trying to create token with negative supply
         result = rpc.tokencreate("NUKE", "-1987420", "no bueno supply")
         assert_error(result)
 
@@ -50,12 +64,9 @@ def run_token_tests(self):
         result = rpc.tokenorders()
         assert_equal(result, [])
 
-        # getting token balance for pubkey
+        # getting token balance for non existing tokenid
         result = rpc.tokenbalance(self.pubkey)
-        assert_success(result)
-        assert_equal(result['balance'], 0)
-        assert_equal(result['CCaddress'], 'RCRsm3VBXz8kKTsYaXKpy7pSEzrtNNQGJC')
-        assert_equal(result['tokenid'], self.pubkey)
+        assert_error(result)
 
         # get token balance for token with pubkey
         result = rpc.tokenbalance(tokenid, self.pubkey)
@@ -131,11 +142,25 @@ def run_token_tests(self):
         # checking ask cancellation
         testorder = rpc.tokenask("100", tokenid, "7.77")
         testorderid = self.send_and_mine(testorder['hex'], rpc)
+        # from other node (ensuring that second node have enough balance to cover txfee
+        # to get the actual error - not "not enough balance" one
+        rpc.sendtoaddress(rpc1.getnewaddress(), 1)
+        rpc.sendtoaddress(rpc1.getnewaddress(), 1)
+        rpc.generate(2)
+        self.sync_all()
+        result = rpc1.getbalance()
+        assert_greater_than(result, 0.1)
+
+        result = rpc1.tokencancelask(tokenid, testorderid)
+        assert_error(result)
+
+        # from valid node
         cancel = rpc.tokencancelask(tokenid, testorderid)
         self.send_and_mine(cancel["hex"], rpc)
         result = rpc.tokenorders()
         assert_equal(result, [])
 
+
         # invalid numtokens bid
         result = rpc.tokenbid("-1", tokenid, "1")
         assert_error(result)
@@ -184,6 +209,15 @@ def run_token_tests(self):
         # checking bid cancellation
         testorder = rpc.tokenbid("100", tokenid, "7.77")
         testorderid = self.send_and_mine(testorder['hex'], rpc)
+
+        # from other node
+        result = rpc1.getbalance()
+        assert_greater_than(result, 0.1)
+
+        result = rpc1.tokencancelbid(tokenid, testorderid)
+        assert_error(result)
+
+        # from valid node
         cancel = rpc.tokencancelbid(tokenid, testorderid)
         self.send_and_mine(cancel["hex"], rpc)
         result = rpc.tokenorders()
@@ -220,5 +254,6 @@ def run_test(self):
         rpc1.importprivkey(self.privkey1)
         self.run_token_tests()
 
+
 if __name__ == '__main__':
     CryptoconditionsTokenTest().main()

src/Makefile.am

@@ -571,7 +571,8 @@ komodod_LDADD += \
   $(LIBBITCOIN_CRYPTO) \
   $(LIBVERUS_CRYPTO) \
   $(LIBVERUS_PORTABLE_CRYPTO) \
-  $(LIBZCASH_LIBS)
+  $(LIBZCASH_LIBS) \
+  cclib.so
 
 if ENABLE_PROTON
 komodod_LDADD += $(LIBBITCOIN_PROTON) $(PROTON_LIBS)

src/bitcoind.cpp

@@ -94,7 +94,8 @@ void WaitForShutdown(boost::thread_group* threadGroup)
 //
 // Start
 //
-extern int32_t IS_KOMODO_NOTARY,USE_EXTERNAL_PUBKEY,ASSETCHAIN_INIT;
+extern int32_t IS_KOMODO_NOTARY,USE_EXTERNAL_PUBKEY;
+extern uint32_t ASSETCHAIN_INIT;
 extern std::string NOTARY_PUBKEY;
 int32_t komodo_is_issuer();
 void komodo_passport_iteration();

src/cc/CC made easy.md

@@ -212,7 +212,7 @@ bool FaucetExactAmounts(struct CCcontract_info *cp,Eval* eval,const CTransaction
 
 bool FaucetValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx)
 
-int64_t AddFaucetInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPubKey pk,int64_t total,int32_t maxinputs)
+int64_t AddFaucetInputs(struct CCcontract_infoCC_info *cp,CMutableTransaction &mtx,CPubKey pk,int64_t total,int32_t maxinputs)
 
 std::string FaucetGet(uint64_t txfee)
 

src/cc/CCHeir.h

@@ -27,10 +27,10 @@ bool HeirValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx,
 class CoinHelper;
 class TokenHelper;
 
-UniValue HeirFundCoinCaller(uint64_t txfee, int64_t funds, std::string heirName, CPubKey heirPubkey, int64_t inactivityTimeSec, uint256 tokenid);
-UniValue HeirFundTokenCaller(uint64_t txfee, int64_t funds, std::string heirName, CPubKey heirPubkey, int64_t inactivityTimeSec, uint256 tokenid);
-UniValue HeirClaimCaller(uint256 fundingtxid, uint64_t txfee, int64_t amount);
-UniValue HeirAddCaller(uint256 fundingtxid, uint64_t txfee, int64_t amount);
+UniValue HeirFundCoinCaller(int64_t txfee, int64_t satoshis, std::string heirName, CPubKey heirPubkey, int64_t inactivityTimeSec, uint256 tokenid);
+UniValue HeirFundTokenCaller(int64_t txfee, int64_t satoshis, std::string heirName, CPubKey heirPubkey, int64_t inactivityTimeSec, uint256 tokenid);
+UniValue HeirClaimCaller(uint256 fundingtxid, int64_t txfee, std::string amount);
+UniValue HeirAddCaller(uint256 fundingtxid, int64_t txfee, std::string amount);
 
 UniValue HeirInfo(uint256 fundingtxid);
 UniValue HeirList();

src/cc/CCMarmara.h

@@ -23,15 +23,18 @@
 #define MARMARA_GROUPSIZE 60
 #define MARMARA_MINLOCK (1440 * 3 * 30)
 #define MARMARA_MAXLOCK (1440 * 24 * 30)
+#define MARMARA_VINS 16
 
+extern uint8_t ASSETCHAINS_MARMARA;
 uint64_t komodo_block_prg(uint32_t nHeight);
 int32_t MarmaraGetcreatetxid(uint256 &createtxid,uint256 txid);
 int32_t MarmaraGetbatontxid(std::vector<uint256> &creditloop,uint256 &batontxid,uint256 txid);
 UniValue MarmaraCreditloop(uint256 txid);
 UniValue MarmaraSettlement(uint64_t txfee,uint256 batontxid);
+UniValue MarmaraLock(uint64_t txfee,int64_t amount,int32_t height);
 
 UniValue MarmaraPoolPayout(uint64_t txfee,int32_t firstheight,double perc,char *jsonstr); // [[pk0, shares0], [pk1, shares1], ...]
-UniValue MarmaraReceive(uint64_t txfee,CPubKey senderpk,int64_t amount,std::string currency,int32_t matures,uint256 batontxid);
+UniValue MarmaraReceive(uint64_t txfee,CPubKey senderpk,int64_t amount,std::string currency,int32_t matures,uint256 batontxid,bool automaticflag);
 UniValue MarmaraIssue(uint64_t txfee,uint8_t funcid,CPubKey receiverpk,int64_t amount,std::string currency,int32_t matures,uint256 approvaltxid,uint256 batontxid);
 UniValue MarmaraInfo(CPubKey refpk,int32_t firstheight,int32_t lastheight,int64_t minamount,int64_t maxamount,std::string currency);