Merge pull request #985 from Mixa84/FSM

Gateways withdraw update

src/cc/CCGateways.h

@@ -25,10 +25,13 @@ std::string GatewaysBind(uint64_t txfee,std::string coin,uint256 tokenid,int64_t
 std::string GatewaysDeposit(uint64_t txfee,uint256 bindtxid,int32_t height,std::string refcoin,uint256 cointxid,int32_t claimvout,std::string deposithex,std::vector<uint8_t>proof,CPubKey destpub,int64_t amount);
 std::string GatewaysClaim(uint64_t txfee,uint256 bindtxid,std::string refcoin,uint256 deposittxid,CPubKey destpub,int64_t amount);
 std::string GatewaysWithdraw(uint64_t txfee,uint256 bindtxid,std::string refcoin,CPubKey withdrawpub,int64_t amount);
+std::string GatewaysPartialSign(uint64_t txfee,uint256 txidaddr,std::string refcoin,std::string hex);
+std::string GatewaysCompleteSigning(uint64_t txfee,uint256 txidaddr,std::string refcoin,std::string hex);
+std::string GatewaysMarkDone(uint64_t txfee,uint256 withdrawtxid,std::string refcoin);
 UniValue GatewaysPendingWithdraws(uint256 bindtxid,std::string refcoin);
-std::string GatewaysMarkdone(uint64_t txfee,uint256 withdrawtxid,std::string refcoin,uint256 cointxid);
+UniValue GatewaysProcessedWithdraws(uint256 bindtxid,std::string refcoin);
 UniValue GatewaysMultisig(char *txidaddr);
-std::string GatewaysPartialSign(uint64_t txfee,uint256 txidaddr,std::string refcoin, std::string hex);
+
 
 // CCcustom
 UniValue GatewaysInfo(uint256 bindtxid);

src/cc/CCassetstx.cpp

@@ -222,7 +222,7 @@ std::string AssetTransfer(int64_t txfee,uint256 assetid,std::vector<uint8_t> des
     if ( txfee == 0 )
         txfee = 10000;
     mypk = pubkey2pk(Mypubkey());
-    if ( AddNormalinputs(mtx,mypk,txfee,1) > 0 )
+    if ( AddNormalinputs(mtx,mypk,txfee,3) > 0 )
     {
         /*n = outputs.size();
         if ( n == amounts.size() )
@@ -257,7 +257,7 @@ std::string AssetConvert(int64_t txfee,uint256 assetid,std::vector<uint8_t> dest
     if ( txfee == 0 )
         txfee = 10000;
     mypk = pubkey2pk(Mypubkey());
-    if ( AddNormalinputs(mtx,mypk,txfee,1) > 0 )
+    if ( AddNormalinputs(mtx,mypk,txfee,3) > 0 )
     {
         if ( (inputs= AddAssetInputs(cp,mtx,mypk,assetid,total,60)) > 0 )
         {
@@ -313,7 +313,7 @@ std::string CreateSell(int64_t txfee,int64_t askamount,uint256 assetid,int64_t p
     if ( txfee == 0 )
         txfee = 10000;
     mypk = pubkey2pk(Mypubkey());
-    if ( AddNormalinputs(mtx,mypk,txfee,1) > 0 )
+    if ( AddNormalinputs(mtx,mypk,txfee,3) > 0 )
     {
         mask = ~((1LL << mtx.vin.size()) - 1);
         if ( (inputs= AddAssetInputs(cp,mtx,mypk,assetid,askamount,60)) > 0 )
@@ -347,7 +347,7 @@ std::string CreateSwap(int64_t txfee,int64_t askamount,uint256 assetid,uint256 a
     if ( txfee == 0 )
         txfee = 10000;
     mypk = pubkey2pk(Mypubkey());
-    if ( AddNormalinputs(mtx,mypk,txfee,1) > 0 )
+    if ( AddNormalinputs(mtx,mypk,txfee,3) > 0 )
     {
         mask = ~((1LL << mtx.vin.size()) - 1);
         if ( (inputs= AddAssetInputs(cp,mtx,mypk,assetid,askamount,60)) > 0 )
@@ -379,7 +379,7 @@ std::string CancelBuyOffer(int64_t txfee,uint256 assetid,uint256 bidtxid)
     if ( txfee == 0 )
         txfee = 10000;
     mypk = pubkey2pk(Mypubkey());
-    if ( AddNormalinputs(mtx,mypk,txfee,1) > 0 )
+    if ( AddNormalinputs(mtx,mypk,txfee,3) > 0 )
     {
         mask = ~((1LL << mtx.vin.size()) - 1);
         if ( GetTransaction(bidtxid,vintx,hashBlock,false) != 0 )
@@ -400,7 +400,7 @@ std::string CancelSell(int64_t txfee,uint256 assetid,uint256 asktxid)
     if ( txfee == 0 )
         txfee = 10000;
     mypk = pubkey2pk(Mypubkey());
-    if ( AddNormalinputs(mtx,mypk,txfee,1) > 0 )
+    if ( AddNormalinputs(mtx,mypk,txfee,3) > 0 )
     {
         mask = ~((1LL << mtx.vin.size()) - 1);
         if ( GetTransaction(asktxid,vintx,hashBlock,false) != 0 )
@@ -426,7 +426,7 @@ std::string FillBuyOffer(int64_t txfee,uint256 assetid,uint256 bidtxid,int64_t f
     if ( txfee == 0 )
         txfee = 10000;
     mypk = pubkey2pk(Mypubkey());
-    if ( AddNormalinputs(mtx,mypk,txfee,1) > 0 )
+    if ( AddNormalinputs(mtx,mypk,txfee,3) > 0 )
     {
         mask = ~((1LL << mtx.vin.size()) - 1);
         if ( GetTransaction(bidtxid,vintx,hashBlock,false) != 0 )
@@ -474,7 +474,7 @@ std::string FillSell(int64_t txfee,uint256 assetid,uint256 assetid2,uint256 askt
     if ( txfee == 0 )
         txfee = 10000;
     mypk = pubkey2pk(Mypubkey());
-    if ( AddNormalinputs(mtx,mypk,txfee,1) > 0 )
+    if ( AddNormalinputs(mtx,mypk,txfee,3) > 0 )
     {
         mask = ~((1LL << mtx.vin.size()) - 1);
         if ( GetTransaction(asktxid,vintx,hashBlock,false) != 0 )

src/cc/CCinclude.h

@@ -57,9 +57,12 @@ extern char ASSETCHAINS_SYMBOL[];
 extern std::string CCerror;
 
 #define SMALLVAL 0.000000000000001
-#define MIN_NOTARIZATION_CONFIRMS 2
+#ifndef _BITS256
-union _bits256 { uint8_t bytes[32]; uint16_t ushorts[16]; uint32_t uints[8]; uint64_t ulongs[4]; uint64_t txid; };
+#define _BITS256
-typedef union _bits256 bits256;
+    union _bits256 { uint8_t bytes[32]; uint16_t ushorts[16]; uint32_t uints[8]; uint64_t ulongs[4]; uint64_t txid; };
+    typedef union _bits256 bits256;
+#endif
+
 
 struct CC_utxo
 {
@@ -167,7 +170,7 @@ bool Getscriptaddress(char *destaddr,const CScript &scriptPubKey);
 std::vector<uint8_t> Mypubkey();
 bool Myprivkey(uint8_t myprivkey[]);
 int64_t CCduration(int32_t &numblocks,uint256 txid);
-bool isCCTxNotarizedConfirmed(uint256 txid);
+bool komodo_txnotarizedconfirmed(uint256 txid);
 // CCtx
 bool SignTx(CMutableTransaction &mtx,int32_t vini,int64_t utxovalue,const CScript scriptPubKey);
 std::string FinalizeCCTx(uint64_t skipmask,struct CCcontract_info *cp,CMutableTransaction &mtx,CPubKey mypk,uint64_t txfee,CScript opret);

src/cc/CCutils.cpp

@@ -13,11 +13,20 @@
  *                                                                            *
  ******************************************************************************/
 
-#include "CCinclude.h"
-
 /*
  CCutils has low level functions that are universally useful for all contracts.
  */
+#include "CCinclude.h"
+#include "komodo_structs.h"
+
+#ifdef TESTMODE           
+    #define MIN_NON_NOTARIZED_CONFIRMS 2
+#else
+    #define MIN_NON_NOTARIZED_CONFIRMS 60
+#endif // TESTMODE
+int32_t komodo_dpowconfs(int32_t height,int32_t numconfs);
+struct komodo_state *komodo_stateptr(char *symbol,char *dest);
+extern uint32_t KOMODO_DPOWCONFS;
 
 void endiancpy(uint8_t *dest,uint8_t *src,int32_t len)
 {
@@ -453,12 +462,50 @@ int64_t CCduration(int32_t &numblocks,uint256 txid)
     return(duration);
 }
 
-bool isCCTxNotarizedConfirmed(uint256 txid)
+bool komodo_txnotarizedconfirmed(uint256 txid)
 {
-    int32_t confirms;
+    char str[65];
+    uint32_t confirms,notarized,txheight;
+    CTransaction tx;
+    uint256 hashBlock;
+    CBlockIndex *pindex;    
+    char symbol[KOMODO_ASSETCHAIN_MAXLEN],dest[KOMODO_ASSETCHAIN_MAXLEN]; struct komodo_state *sp;
 
-    CCduration(confirms,txid);
+    if ( myGetTransaction(txid,tx,hashBlock) == 0 )
-    if (confirms >= MIN_NOTARIZATION_CONFIRMS)
+    {
+        fprintf(stderr,"komodo_txnotarizedconfirmed cant find txid %s\n",txid.ToString().c_str());
+        return(0);
+    }
+    else if ( hashBlock == zeroid )
+    {
+        fprintf(stderr,"komodo_txnotarizedconfirmed no hashBlock for txid %s\n",txid.ToString().c_str());
+        return(0);
+    }
+    else if ( (pindex= mapBlockIndex[hashBlock]) == 0 || (txheight= pindex->GetHeight()) <= 0 )
+    {
+        fprintf(stderr,"komodo_txnotarizedconfirmed no txheight.%d %p for txid %s\n",txheight,pindex,txid.ToString().c_str());
+        return(0);
+    }
+    else if ( (pindex= chainActive.LastTip()) == 0 || pindex->GetHeight() < txheight )
+    {
+        fprintf(stderr,"komodo_txnotarizedconfirmed backwards heights for txid %s hts.(%d %d)\n",txid.ToString().c_str(),txheight,(int32_t)pindex->GetHeight());
+        return(0);
+    }    
+    confirms=1 + pindex->GetHeight() - txheight;        
+    if ( KOMODO_DPOWCONFS != 0 && txheight > 0 && confirms > 0 && (sp= komodo_stateptr(symbol,dest)) != 0 )
+    {
+        if ( (notarized=sp->NOTARIZED_HEIGHT) > 0 )
+        {   
+            if ( txheight >= sp->NOTARIZED_HEIGHT )
+                confirms=1;
+        }
+    }
+#ifdef TESTMODE           
+    notarized=0;
+#endif //TESTMODE
+    if (notarized>0 && confirms > 1)
+        return (true);
+    else if (notarized==0 && confirms >= MIN_NON_NOTARIZED_CONFIRMS)
         return (true);
     return (false);
 }

src/cc/channels.cpp

@@ -199,7 +199,7 @@ bool ChannelsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &
                         //vout.3: normal output of payment amount to receiver pubkey
                         //vout.n-2: normal change
                         //vout.n-1: opreturn - 'P' opentxid senderspubkey receiverspubkey depth numpayments secret
-                        if (isCCTxNotarizedConfirmed(opentxid) == 0)
+                        if (komodo_txnotarizedconfirmed(opentxid) == 0)
                             return eval->Invalid("channelOpen is not yet confirmed(notarised)!");
                         else if ( IsCCInput(tx.vin[0].scriptSig) != 0 )
                             return eval->Invalid("vin.0 is normal for channelPayment!");
@@ -261,7 +261,7 @@ bool ChannelsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &
                         //vout.2: CC vout marker to receiver pubkey
                         //vout.n-2: normal change
                         //vout.n-1: opreturn - 'C' opentxid senderspubkey receiverspubkey 0 0 0
-                        if (isCCTxNotarizedConfirmed(opentxid) == 0)
+                        if (komodo_txnotarizedconfirmed(opentxid) == 0)
                             return eval->Invalid("channelOpen is not yet confirmed(notarised)!");
                         else if ( IsCCInput(tx.vin[0].scriptSig) != 0 )
                             return eval->Invalid("vin.0 is normal for channelClose!");
@@ -304,9 +304,9 @@ bool ChannelsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &
                         //vout.2: normal output of CC input to senders pubkey
                         //vout.n-2: normal change
                         //vout.n-1: opreturn - 'R' opentxid senderspubkey receiverspubkey numpayments payment closetxid
-                        if (isCCTxNotarizedConfirmed(opentxid) == 0)
+                        if (komodo_txnotarizedconfirmed(opentxid) == 0)
                             return eval->Invalid("channelOpen is not yet confirmed(notarised)!");
-                        else if (isCCTxNotarizedConfirmed(param3) == 0)
+                        else if (komodo_txnotarizedconfirmed(param3) == 0)
                             return eval->Invalid("channelClose is not yet confirmed(notarised)!");
                         else if ( IsCCInput(tx.vin[0].scriptSig) != 0 )
                             return eval->Invalid("vin.0 is normal for channelRefund!");
@@ -479,7 +479,7 @@ std::string ChannelPayment(uint64_t txfee,uint256 opentxid,int64_t amount, uint2
         fprintf(stderr, "invalid channel open txid\n");
         return ("");
     }
-    if (AddNormalinputs(mtx,mypk,2*txfee,1) > 0)
+    if (AddNormalinputs(mtx,mypk,2*txfee,3) > 0)
     {
         if ((funds=AddChannelsInputs(cp,mtx,channelOpenTx,prevtxid)) !=0 && (change=funds-amount-txfee)>=0)
         {
@@ -595,7 +595,7 @@ std::string ChannelClose(uint64_t txfee,uint256 opentxid)
         fprintf(stderr,"cannot close, you are not channel owner\n");
         return("");
     }
-    if ( AddNormalinputs(mtx,mypk,2*txfee,1) > 0 )
+    if ( AddNormalinputs(mtx,mypk,2*txfee,3) > 0 )
     {
         if ((funds=AddChannelsInputs(cp,mtx,channelOpenTx,prevtxid)) !=0 && funds-txfee>0)
         {
@@ -658,7 +658,7 @@ std::string ChannelRefund(uint64_t txfee,uint256 opentxid,uint256 closetxid)
         fprintf(stderr,"cannot refund, you are not the channel owenr\n");
         return("");
     }
-    if ( AddNormalinputs(mtx,mypk,2*txfee,1) > 0 )
+    if ( AddNormalinputs(mtx,mypk,2*txfee,3) > 0 )
     {
         if ((funds=AddChannelsInputs(cp,mtx,channelOpenTx,prevtxid)) !=0 && funds-txfee>0)
         {

src/cc/dapps/oraclefeed.c

@@ -329,12 +329,17 @@ cJSON *get_komodocli(char *refcoin,char **retstrp,char *acname,char *method,char
         sprintf(cmdstr,"%s %s %s %s %s %s > %s\n",REFCOIN_CLI,method,arg0,arg1,arg2,arg3,fname);
         printf("ref.(%s) REFCOIN_CLI (%s)\n",refcoin,cmdstr);
     }   
+#ifdef TESTMODE    
+    fprintf(stderr,"cmd: %s\n",cmdstr); 
+#endif // TESTMODE
     system(cmdstr);
     *retstrp = 0;
     if ( (jsonstr= filestr(&fsize,fname)) != 0 )
     {       
         jsonstr[strlen(jsonstr)-1]='\0';
-        //fprintf(stderr,"%s -> jsonstr.(%s)\n",cmdstr,jsonstr);
+#ifdef TESTMODE   
+        fprintf(stderr,"jsonstr.(%s)\n",jsonstr);
+#endif // TESTMODE
         if ( (jsonstr[0] != '{' && jsonstr[0] != '[') || (retjson= cJSON_Parse(jsonstr)) == 0 )
             *retstrp = jsonstr;
         else free(jsonstr);
@@ -483,6 +488,22 @@ cJSON *get_gatewayspending(char *refcoin,char *acname,char *bindtxidstr)
     return(0);
 }
 
+cJSON *get_gatewaysprocessed(char *refcoin,char *acname,char *bindtxidstr)
+{
+    cJSON *retjson; char *retstr;
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"gatewaysprocessed",bindtxidstr,refcoin,"","")) != 0 )
+    {
+        //printf("pending.(%s)\n",jprint(retjson,0));
+        return(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        fprintf(stderr,"%s get_gatewaysprocessed.(%s) error.(%s)\n",refcoin,acname,retstr);
+        free(retstr);
+    }
+    return(0);
+}
+
 cJSON *get_rawmempool(char *refcoin,char *acname)
 {
     cJSON *retjson; char *retstr;
@@ -550,10 +571,12 @@ int32_t validateaddress(char *refcoin,char *acname,char *depositaddr, char* comp
     return (res);
 }
 
-void importaddress(char *refcoin,char *acname,char *depositaddr)
+void importaddress(char *refcoin,char *acname,char *depositaddr, char *label,int rescan)
 {
-    cJSON *retjson; char *retstr;
+    cJSON *retjson; char *retstr; char rescanstr[10];
-    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"importaddress",depositaddr,"","true","")) != 0 )
+    if (rescan) strcpy(rescanstr,"true");
+    else strcpy(rescanstr,"false");
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"importaddress",depositaddr,label,rescanstr,"")) != 0 )
     {
         printf("importaddress.(%s)\n",jprint(retjson,0));
         free_json(retjson);
@@ -610,7 +633,7 @@ cJSON *getinputarray(int64_t *totalp,cJSON *unspents,int64_t required)
     return(vins);
 }
 
-char *createmultisig(char *refcoin,char *acname,char *depositaddr,char *signeraddr,char *withdrawaddr,int64_t satoshis)
+char *createrawtx(char *refcoin,char *acname,char *depositaddr,char *withdrawaddr,char *txidaddr,int64_t satoshis)
 {
     char *retstr,*retstr2,array[128],*txstr = 0; cJSON *retjson2,*retjson,*vins,*vouts; int64_t txfee,total,change = 0;
     if ( strcmp(refcoin,"BTC") == 0 )
@@ -618,7 +641,7 @@ char *createmultisig(char *refcoin,char *acname,char *depositaddr,char *signerad
     else txfee = 10000;
     if ( satoshis < txfee )
     {
-        printf("createmultisig satoshis %.8f < txfee %.8f\n",(double)satoshis/SATOSHIDEN,(double)txfee/SATOSHIDEN);
+        printf("createrawtx satoshis %.8f < txfee %.8f\n",(double)satoshis/SATOSHIDEN,(double)txfee/SATOSHIDEN);
         return(0);
     }
     satoshis -= txfee;
@@ -631,8 +654,9 @@ char *createmultisig(char *refcoin,char *acname,char *depositaddr,char *signerad
             if ( total >= satoshis )
             {
                 vouts = cJSON_CreateObject();
-                jaddnum(vouts,withdrawaddr,(double)satoshis/SATOSHIDEN);
+                jaddnum(vouts,withdrawaddr,(double)(satoshis-2*txfee)/SATOSHIDEN);
-                if ( total > satoshis+txfee )
+                jaddnum(vouts,txidaddr,(double)txfee/SATOSHIDEN);
+                if ( total > satoshis)
                 {
                     change = (total - satoshis);
                     jaddnum(vouts,depositaddr,(double)change/SATOSHIDEN);
@@ -645,29 +669,30 @@ char *createmultisig(char *refcoin,char *acname,char *depositaddr,char *signerad
                 sprintf(argB,"\'%s\'",tmpB);                
                 if ( (retjson2= get_komodocli(refcoin,&txstr,acname,"createrawtransaction",argA,argB,"","")) != 0 )
                 {
-                    printf("createmultisig: unexpected JSON2.(%s)\n",jprint(retjson2,0));
+                    printf("createrawtx: unexpected JSON2.(%s)\n",jprint(retjson2,0));
                     free_json(retjson2);
                 }
                 else if ( txstr == 0 )
-                    printf("createmultisig: null txstr and JSON2\n");
+                    printf("createrawtx: null txstr and JSON2\n");
                 free(tmpA);
                 free(tmpB);
                 free(argA);
                 free(argB);
             }
+            else printf("not enough funds to create withdraw tx\n");
         }
         free_json(retjson);
     }
     else if ( retstr != 0 )
     {
-        printf("createmultisig: unexpected null JSON, retstr.(%s)\n",retstr);
+        printf("createrawtx: unexpected null JSON, retstr.(%s)\n",retstr);
         free(retstr);
     }
-    else printf("createmultisig: null retstr and JSON\n");
+    else printf("createrawtx: null retstr and JSON\n");
     return(txstr);
 }
 
-cJSON *addmultisignature(char *refcoin,char *acname,char *signeraddr,char *rawtx)
+cJSON *addsignature(char *refcoin,char *acname,char *rawtx)
 {
     char *retstr,*hexstr; cJSON *retjson;
     if ( (retjson= get_komodocli(refcoin,&retstr,acname,"signrawtransaction",rawtx,"","","")) != 0 )
@@ -681,6 +706,11 @@ cJSON *addmultisignature(char *refcoin,char *acname,char *signeraddr,char *rawtx
         }
         free_json(retjson);
     }
+    else if ( retstr != 0 )
+    {
+        printf("error parsing signrawtransaction.(%s)\n",retstr);
+        free(retstr);
+    }
     return(0);
 }
 
@@ -696,6 +726,11 @@ char *get_gatewaysmultisig(char *refcoin,char *acname,char *txidaddr,int32_t *K)
         *K=jint(retjson,"number_of_signs");   
         free_json(retjson);
     }
+    else if ( retstr != 0 )
+    {
+        printf("error parsing gatewaysmultisig.(%s)\n",retstr);
+        free(retstr);
+    }
     return(hex);
 }
 
@@ -714,11 +749,27 @@ bits256 gatewayspartialsign(char *refcoin,char *acname,bits256 txid,char *hex)
     return (zeroid);
 }
 
-void gatewaysmarkdone(char *refcoin,char *acname,bits256 withtxid,char *coin,bits256 cointxid)
+void gatewayscompletesigning(char *refcoin,char *acname,bits256 withtxid,char *coin,char *hex)
 {
     char str[65],str2[65],*retstr; cJSON *retjson;
     printf("spend %s %s/v2 as marker\n",acname,bits256_str(str,withtxid));
-    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"gatewaysmarkdone",bits256_str(str,withtxid),coin,bits256_str(str2,cointxid),"")) != 0 )
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"gatewayscompletesigning",bits256_str(str,withtxid),coin,hex,"")) != 0 )
+    {
+        komodobroadcast(refcoin,acname,retjson);
+        free_json(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        printf("error parsing gatewayscompletesigning.(%s)\n",retstr);
+        free(retstr);
+    }
+}
+
+void gatewaysmarkdone(char *refcoin,char *acname,bits256 withtxid,char *coin)
+{
+    char str[65],str2[65],*retstr; cJSON *retjson;
+    printf("spend %s %s/v2 as marker\n",acname,bits256_str(str,withtxid));
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"gatewaysmarkdone",bits256_str(str,withtxid),coin,"","")) != 0 )
     {
         komodobroadcast(refcoin,acname,retjson);
         free_json(retjson);
@@ -771,6 +822,22 @@ int32_t get_gatewaysinfo(char *refcoin,char *acname,char *depositaddr,int32_t *M
     else return(0);
 }
 
+int32_t tx_notarizedconfirmed(char *refcoin,char *acname,bits256 txid)
+{
+    char *retstr,str[65]; cJSON *retjson; int32_t result;
+    if ( (retjson= get_komodocli(refcoin,&retstr,acname,"txnotarizedconfirmed",bits256_str(str,txid),"","","")) != 0 )
+    {
+        if (is_cJSON_True(jobj(retjson,"result")) != 0 ) result=1;
+        else result=0;        
+        free_json(retjson);
+    }
+    else if ( retstr != 0 )
+    {
+        printf("error parsing txnotarizedconfirmed.(%s)\n",retstr);
+        free(retstr);
+    }
+}
+
 int32_t tx_has_voutaddress(char *refcoin,char *acname,bits256 txid,char *coinaddr)
 {
     cJSON *txobj,*vouts,*vout,*vins,*vin,*sobj,*addresses; char *addr,str[65]; int32_t i,j,n,numarray,retval = 0, hasvout=0;
@@ -789,7 +856,6 @@ int32_t tx_has_voutaddress(char *refcoin,char *acname,bits256 txid,char *coinadd
                             addr = jstri(addresses,j);
                             if ( strcmp(addr,coinaddr) == 0 )
                             {                                
-                                //fprintf(stderr,"found %s in %s v%d\n",coinaddr,bits256_str(str,txid),i);
                                 hasvout = 1;
                                 break;
                             }
@@ -799,22 +865,43 @@ int32_t tx_has_voutaddress(char *refcoin,char *acname,bits256 txid,char *coinadd
                 if (hasvout==1) break;
             }
         }        
-        // if (hasvout==1 && (vins=jarray(&numarray,txobj,"vin"))!=0)
-        // {                          
-        //     for (int i=0;i<numarray;i++)
-        //     {
-        //         if ((vin=jitem(vins,i))!=0 && validateaddress(refcoin,acname,jstr(vin,"address"),"ismine")!=0)
-        //         {
-        //             retval=1;
-        //             break;
-        //         }
-        //     }                       
-        // }
         free_json(txobj);
     }
     return(hasvout);
 }
 
+
+int32_t markerexists(char *refcoin,char *acname,char *coinaddr)
+{
+    cJSON *array; int32_t i,n,num=0; bits256 txid;
+    if ( (array= get_addressutxos(refcoin,acname,coinaddr)) != 0 )
+    {
+        num=cJSON_GetArraySize(array);
+        free_json(array); 
+    }
+    if ( num == 0 )
+    {
+        if ( (array= get_rawmempool(refcoin,acname)) != 0 )
+        {
+            if ( (n= cJSON_GetArraySize(array)) != 0 )
+            {
+                for (i=0; i<n; i++)
+                {
+                    txid = jbits256i(array,i);
+                    if ( tx_has_voutaddress(refcoin,acname,txid,coinaddr) > 0 )
+                    {
+                        num = 1;
+                        break;
+                    }
+                }
+            }
+            free_json(array);
+        } 
+    }
+    fprintf(stderr,"Num=%d\n",num);
+    return(num);
+            
+}
 int32_t markerfromthisnodeorunconfirmed(char *refcoin,char *acname,char *coinaddr)
 {
     cJSON *array,*item,*rawtx,*vins,*vin; bits256 txid,tmptxid; int32_t i,n,m,num=0; char *retstr;
@@ -887,54 +974,42 @@ void update_gatewayspending(char *refcoin,char *acname,char *bindtxidstr,int32_t
                     //process item.0 {"txid":"10ec8f4dad6903df6b249b361b879ac77b0617caad7629b97e10f29fa7e99a9b","txidaddr":"RMbite4TGugVmkGmu76ytPHDEQZQGSUjxz","withdrawaddr":"RNJmgYaFF5DbnrNUX6pMYz9rcnDKC2tuAc","amount":"1.00000000","depositaddr":"RHV2As4rox97BuE3LK96vMeNY8VsGRTmBj","signeraddr":"RHV2As4rox97BuE3LK96vMeNY8VsGRTmBj"}
                     if ( (txidaddr= jstr(item,"txidaddr")) != 0 && (withdrawaddr= jstr(item,"withdrawaddr")) != 0 && (depositaddr= jstr(item,"depositaddr")) != 0 && (signeraddr= jstr(item,"signeraddr")) != 0 )
                     {
-                        if ( (satoshis= jdouble(item,"amount")*SATOSHIDEN) != 0 && markerfromthisnodeorunconfirmed("KMD",acname,txidaddr) == 0)
+                        if ( (satoshis= jdouble(item,"amount")*SATOSHIDEN) != 0 && is_cJSON_True(jobj(item,"confirmed_or_notarized")) != 0 && markerfromthisnodeorunconfirmed("KMD",acname,txidaddr) == 0)
                         {                               
-                            // the actual withdraw
                             if ( strcmp(depositaddr,signeraddr) == 0 )
                             {                                
-                                txid= sendtoaddress("KMD",acname,txidaddr,10000);
+                                rawtx = createrawtx(refcoin,"",depositaddr,withdrawaddr,txidaddr,satoshis);
-                                if (bits256_nonz(txid) != 0)
+                                if ( rawtx != 0 )
                                 {
-                                    cointxid = sendtoaddress(refcoin,"",withdrawaddr,satoshis);
+                                    if ( (clijson= addsignature(refcoin,"",rawtx)) != 0 && is_cJSON_True(jobj(clijson,"complete")) != 0)
-                                    if ( bits256_nonz(cointxid) != 0)
                                     {                                        
-                                        fprintf(stderr,"withdraw %s %s %s %.8f processed\n",refcoin,bits256_str(str,cointxid),withdrawaddr,(double)satoshis/SATOSHIDEN);
+                                        gatewayscompletesigning("KMD",acname,origtxid,refcoin,jstr(clijson,"hex"));                                        
-                                        gatewaysmarkdone("KMD",acname,origtxid,refcoin,cointxid);
+                                        fprintf(stderr,"withdraw %.8f %s to %s processed\n",(double)satoshis/SATOSHIDEN,refcoin,withdrawaddr);
-                                        processed++;
+                                        free_json(clijson);
                                     }
-                                    else
+                                    processed++;
-                                    {
+                                    free(rawtx);
-                                        fprintf(stderr,"ERROR withdraw %s %s %s %.8f processed\n",refcoin,bits256_str(str,cointxid),withdrawaddr,(double)satoshis/SATOSHIDEN);
+                                } else fprintf(stderr,"couldnt create rawtx\n");                               
-                                    }
-                                }
-                                else
-                                {
-                                    fprintf(stderr,"ERROR sending withdraw marker %s %s to %s %.8f processed\n",refcoin,bits256_str(str,cointxid),txidaddr,(double)10000/SATOSHIDEN);
-                                }
                             }
                             else
                             {
                                 if ( (rawtx= get_gatewaysmultisig(refcoin,acname,txidaddr,&K)) == 0)
                                 {
-                                    rawtx = createmultisig(refcoin,"",depositaddr,signeraddr,withdrawaddr,satoshis);
+                                    rawtx = createrawtx(refcoin,"",depositaddr,withdrawaddr,txidaddr,satoshis);
                                 }
                                 if ( rawtx != 0 )
                                 {
-                                    if ( (clijson= addmultisignature(refcoin,"",signeraddr,rawtx)) != 0 )
+                                    if ( (clijson= addsignature(refcoin,"",rawtx)) != 0 )
                                     {
                                         if ( is_cJSON_True(jobj(clijson,"complete")) != 0 )
                                         {   
-                                            cointxid = komodobroadcast(refcoin,"",clijson);
+                                            gatewayscompletesigning("KMD",acname,origtxid,refcoin,jstr(clijson,"hex"));                                          
-                                            if ( bits256_nonz(cointxid) != 0 )
+                                            fprintf(stderr,"withdraw %.8f %s M.%d N.%d to %s processed\n",(double)satoshis/SATOSHIDEN,refcoin,M,N,withdrawaddr);
-                                            {
-                                                fprintf(stderr,"withdraw %s M.%d N.%d %s %s %.8f processed\n",refcoin,M,N,bits256_str(str,cointxid),withdrawaddr,(double)satoshis/SATOSHIDEN);
-                                                gatewaysmarkdone("KMD",acname,origtxid,refcoin,cointxid);
-                                            }
                                         }
                                         else if ( jint(clijson,"partialtx") != 0 )
                                         {
                                             txid=gatewayspartialsign(refcoin,acname,origtxid,jstr(clijson,"hex"));                                            
-                                            fprintf(stderr,"%d of %d partialtx %s sent\n",K+1,N,bits256_str(str,txid));
+                                            fprintf(stderr,"%d sign(s) %dof%d partialtx %s sent\n",K+1,M,N,bits256_str(str,txid));
                                         }
                                         free_json(clijson);
                                     }
@@ -949,6 +1024,33 @@ void update_gatewayspending(char *refcoin,char *acname,char *bindtxidstr,int32_t
         }
         free_json(retjson);
     }
+    if ( (retjson= get_gatewaysprocessed("KMD",acname,bindtxidstr)) != 0 )
+    {
+        if ( jint(retjson,"queueflag") != 0 && (coinstr= jstr(retjson,"coin")) != 0 && strcmp(coinstr,refcoin) == 0 )
+        {            
+            if ( (pending=jarray(&n,retjson,"processed")) != 0 )
+            {                
+                for (i=0; i<n; i++)
+                {
+                    item = jitem(pending,i);
+                    origtxid = jbits256(item,"txid");                    
+                    txidaddr = jstr(item,"withdrawtxidaddr");
+                    if (validateaddress(refcoin,"",txidaddr,"iswatchonly")==0 && validateaddress(refcoin,"",txidaddr,"ismine")==0)
+                        importaddress(refcoin,"",txidaddr,jstr(item,"txid"),0);
+                    if ( txidaddr != 0 && markerexists(refcoin,"",txidaddr)==0)
+                    {   
+                        cointxid = komodobroadcast(refcoin,"",item);
+                        if ( bits256_nonz(cointxid) != 0 )
+                        {
+                            withdrawaddr = jstr(item,"withdrawaddr");
+                            fprintf(stderr,"withdraw %.8f %s to %s - %s broadcasted on %s\n",(double)satoshis/SATOSHIDEN,refcoin,withdrawaddr,bits256_str(str,cointxid),refcoin);   
+                            gatewaysmarkdone("KMD",acname,origtxid,refcoin);
+                        }
+                    }
+                }
+            }
+        }
+    }
 }
 
 int32_t get_oracledata(char *refcoin,char *acname,int32_t prevheight,char *hexstr,int32_t maxsize,char *format)
@@ -1050,9 +1152,9 @@ int32_t main(int32_t argc,char **argv)
                     printf("cant find bindtxid.(%s)\n",bindtxidstr);
                     exit(0);
                 }
-                if (validateaddress(refcoin,"",depositaddr,"iswatchonly")==0)
+                if (validateaddress(refcoin,"",depositaddr,"iswatchonly")==0 && validateaddress(refcoin,"",depositaddr,"ismine")==0)
                 {
-                    if (M==N==1) importaddress(refcoin,"",depositaddr);
+                    if (M==N==1) importaddress(refcoin,"",depositaddr,bindtxidstr,0);
                     else addmultisigaddress(refcoin,"",M,pubkeys,bindtxidstr);
                 }
                 if (pubkeys!=0) free(pubkeys);

src/cc/dice.cpp

@@ -1498,7 +1498,7 @@ std::string DiceBetFinish(uint8_t &funcid,uint256 &entropyused,int32_t &entropyv
         {
             if ( vin0txid == zeroid || vin0vout < 0 )
             {
-                if ( AddNormalinputs(mtx,mypk,2*txfee,1) == 0 ) // must be a single vin!!
+                if ( AddNormalinputs(mtx,mypk,2*txfee,3) == 0 ) // must be a single vin!!
                 {
                     CCerror = "no txfee inputs for win/lose";
                     fprintf(stderr,"%s\n", CCerror.c_str() );

src/cc/oracles.cpp

@@ -739,7 +739,7 @@ std::string OracleCreate(int64_t txfee,std::string name,std::string description,
         txfee = 10000;
     mypk = pubkey2pk(Mypubkey());
     Oraclespk = GetUnspendable(cp,0);
-    if ( AddNormalinputs(mtx,mypk,2*txfee,1) > 0 )
+    if ( AddNormalinputs(mtx,mypk,2*txfee,3) > 0 )
     {
         mtx.vout.push_back(CTxOut(txfee,CScript() << ParseHex(HexStr(Oraclespk)) << OP_CHECKSIG));
         return(FinalizeCCTx(0,cp,mtx,mypk,txfee,EncodeOraclesCreateOpRet('C',name,description,format)));
@@ -778,7 +778,7 @@ std::string OracleSubscribe(int64_t txfee,uint256 oracletxid,CPubKey publisher,i
         txfee = 10000;
     mypk = pubkey2pk(Mypubkey());
     markerpubkey = CCtxidaddr(markeraddr,oracletxid);
-    if ( AddNormalinputs(mtx,mypk,amount + 2*txfee,1) > 0 )
+    if ( AddNormalinputs(mtx,mypk,amount + 2*txfee,64) > 0 )
     {
         mtx.vout.push_back(MakeCC1vout(cp->evalcode,amount,publisher));
         mtx.vout.push_back(CTxOut(txfee,CScript() << ParseHex(HexStr(markerpubkey)) << OP_CHECKSIG));

src/cc/prices.cpp

@@ -229,7 +229,7 @@ std::string PricesCreateFunding(uint64_t txfee,uint256 bettoken,uint256 oracletx
         return("");
     }
     fprintf(stderr,"error check bettoken\n");
-    if ( AddNormalinputs(mtx,mypk,3*txfee,3) > 0 )
+    if ( AddNormalinputs(mtx,mypk,3*txfee,4) > 0 )
     {
         mtx.vout.push_back(CTxOut(txfee,CScript() << ParseHex(HexStr(mypk)) << OP_CHECKSIG));
         mtx.vout.push_back(CTxOut(txfee,CScript() << ParseHex(HexStr(pricespk)) << OP_CHECKSIG));

src/komodo_structs.h

@@ -48,8 +48,11 @@
 #define KOMODO_KVDURATION 1440
 #define KOMODO_ASSETCHAIN_MAXLEN 65
 
-union _bits256 { uint8_t bytes[32]; uint16_t ushorts[16]; uint32_t uints[8]; uint64_t ulongs[4]; uint64_t txid; };
+#ifndef _BITS256
-typedef union _bits256 bits256;
+#define _BITS256
+    union _bits256 { uint8_t bytes[32]; uint16_t ushorts[16]; uint32_t uints[8]; uint64_t ulongs[4]; uint64_t txid; };
+    typedef union _bits256 bits256;
+#endif    
 
 union _bits320 { uint8_t bytes[40]; uint16_t ushorts[20]; uint32_t uints[10]; uint64_t ulongs[5]; uint64_t txid; };
 typedef union _bits320 bits320;

src/rpc/misc.cpp

@@ -47,6 +47,7 @@ int32_t Jumblr_secretaddradd(char *secretaddr);
 uint64_t komodo_interestsum();
 int32_t komodo_longestchain();
 int32_t komodo_notarized_height(int32_t *prevhtp,uint256 *hashp,uint256 *txidp);
+bool komodo_txnotarizedconfirmed(uint256 txid);
 uint32_t komodo_chainactive_timestamp();
 int32_t komodo_whoami(char *pubkeystr,int32_t height,uint32_t timestamp);
 extern uint64_t KOMODO_INTERESTSUM,KOMODO_WALLETBALANCE;
@@ -1295,6 +1296,32 @@ UniValue getspentinfo(const UniValue& params, bool fHelp)
     return obj;
 }
 
+UniValue txnotarizedconfirmed(const UniValue& params, bool fHelp)
+{
+    bool notarizedconfirmed; uint256 txid;
+
+    if (fHelp || params.size() < 1 || params.size() > 1)
+    {
+        string msg = "txnotarizedconfirmed txid\n"
+            "\nReturns true if transaction is notarized on chain that has dPoW or if confirmation number is greater than 60 on chain taht does not have dPoW.\n"           
+
+            "\nArguments:\n"
+            "1. txid      (string, required) Transaction id.\n"            
+
+            "\nResult:\n"
+            "{\n"
+            "  true,  (bool) The value the check.\n"            
+            "}\n"            
+        ;
+        throw runtime_error(msg);
+    }
+    txid = uint256S((char *)params[0].get_str().c_str());
+    notarizedconfirmed=komodo_txnotarizedconfirmed(txid);
+    UniValue result(UniValue::VOBJ);
+    result.push_back(Pair("result", notarizedconfirmed));    
+    return result;
+}
+
 static const CRPCCommand commands[] =
 { //  category              name                      actor (function)         okSafeMode
   //  --------------------- ------------------------  -----------------------  ----------

src/rpc/server.cpp

@@ -437,10 +437,12 @@ static const CRPCCommand vRPCCommands[] =
     { "gateways",       "gatewaysdeposit",   &gatewaysdeposit,      true },
     { "gateways",       "gatewaysclaim",     &gatewaysclaim,        true },
     { "gateways",       "gatewayswithdraw",  &gatewayswithdraw,     true },
-    { "gateways",       "gatewayspending",   &gatewayspending,      true },
-    { "gateways",       "gatewaysmultisig",  &gatewaysmultisig,     true },
-    { "gateways",       "gatewaysmarkdone",  &gatewaysmarkdone,     true },
     { "gateways",       "gatewayspartialsign",  &gatewayspartialsign,     true },
+    { "gateways",       "gatewayscompletesigning",  &gatewayscompletesigning,     true },
+    { "gateways",       "gatewaysmarkdone",  &gatewaysmarkdone,     true },
+    { "gateways",       "gatewayspending",   &gatewayspending,      true },
+    { "gateways",       "gatewaysprocessed",   &gatewaysprocessed,  true },
+    { "gateways",       "gatewaysmultisig",  &gatewaysmultisig,     true },
 
     // dice
     { "dice",       "dicelist",      &dicelist,         true },
@@ -482,6 +484,7 @@ static const CRPCCommand vRPCCommands[] =
     { "util",               "createmultisig",         &createmultisig,         true  },
     { "util",               "validateaddress",        &validateaddress,        true  }, /* uses wallet if enabled */
     { "util",               "verifymessage",          &verifymessage,          true  },
+    { "util",               "txnotarizedconfirmed",   &txnotarizedconfirmed,   true  },
     { "util",               "estimatefee",            &estimatefee,            true  },
     { "util",               "estimatepriority",       &estimatepriority,       true  },
     { "util",               "z_validateaddress",      &z_validateaddress,      true  }, /* uses wallet if enabled */

src/rpc/server.h

@@ -265,10 +265,12 @@ extern UniValue gatewaysbind(const UniValue& params, bool fHelp);
 extern UniValue gatewaysdeposit(const UniValue& params, bool fHelp);
 extern UniValue gatewaysclaim(const UniValue& params, bool fHelp);
 extern UniValue gatewayswithdraw(const UniValue& params, bool fHelp);
-extern UniValue gatewayspending(const UniValue& params, bool fHelp);
-extern UniValue gatewaysmarkdone(const UniValue& params, bool fHelp);
-extern UniValue gatewaysmultisig(const UniValue& params, bool fHelp);
 extern UniValue gatewayspartialsign(const UniValue& params, bool fHelp);
+extern UniValue gatewayscompletesigning(const UniValue& params, bool fHelp);
+extern UniValue gatewaysmarkdone(const UniValue& params, bool fHelp);
+extern UniValue gatewayspending(const UniValue& params, bool fHelp);
+extern UniValue gatewaysprocessed(const UniValue& params, bool fHelp);
+extern UniValue gatewaysmultisig(const UniValue& params, bool fHelp);
 extern UniValue channelsinfo(const UniValue& params, bool fHelp);
 extern UniValue channelsopen(const UniValue& params, bool fHelp);
 extern UniValue channelspayment(const UniValue& params, bool fHelp);
@@ -337,6 +339,7 @@ extern UniValue walletpassphrasechange(const UniValue& params, bool fHelp);
 extern UniValue walletlock(const UniValue& params, bool fHelp);
 extern UniValue encryptwallet(const UniValue& params, bool fHelp);
 extern UniValue validateaddress(const UniValue& params, bool fHelp);
+extern UniValue txnotarizedconfirmed(const UniValue& params, bool fHelp);
 extern UniValue getinfo(const UniValue& params, bool fHelp);
 extern UniValue setpubkey(const UniValue& params, bool fHelp);
 extern UniValue getwalletinfo(const UniValue& params, bool fHelp);

src/wallet/rpcwallet.cpp

@@ -5981,6 +5981,8 @@ UniValue gatewaysbind(const UniValue& params, bool fHelp)
         if ( params.size() < 6+i+1 )
             throw runtime_error("not enough parameters for N pubkeys\n");
         pubkey = ParseHex(params[6+i].get_str().c_str());
+        if (pubkey.size()!= 33)    
+            throw runtime_error("invalid destination pubkey");
         pubkeys.push_back(pubkey2pk(pubkey));
     }
     hex = GatewaysBind(0,coin,tokenid,totalsupply,oracletxid,M,N,pubkeys);
@@ -6013,6 +6015,8 @@ UniValue gatewaysdeposit(const UniValue& params, bool fHelp)
     amount = atof((char *)params[8].get_str().c_str()) * COIN + 0.00000000499999;
     if ( amount <= 0 || claimvout < 0 )
         throw runtime_error("invalid param: amount, numpks or claimvout\n");
+    if (destpub.size()!= 33)    
+        throw runtime_error("invalid destination pubkey");       
     hex = GatewaysDeposit(0,bindtxid,height,coin,cointxid,claimvout,deposithex,proof,pubkey2pk(destpub),amount);
 
     RETURN_IF_ERROR(CCerror);
@@ -6038,6 +6042,8 @@ UniValue gatewaysclaim(const UniValue& params, bool fHelp)
     deposittxid = Parseuint256((char *)params[2].get_str().c_str());
     destpub = ParseHex(params[3].get_str());
     amount = atof((char *)params[4].get_str().c_str()) * COIN + 0.00000000499999;    
+    if (destpub.size()!= 33)    
+        throw runtime_error("invalid destination pubkey");  
     hex = GatewaysClaim(0,bindtxid,coin,deposittxid,pubkey2pk(destpub),amount);
     RETURN_IF_ERROR(CCerror);
     if ( hex.size() > 0 )
@@ -6061,6 +6067,8 @@ UniValue gatewayswithdraw(const UniValue& params, bool fHelp)
     coin = params[1].get_str();
     withdrawpub = ParseHex(params[2].get_str());
     amount = atof((char *)params[3].get_str().c_str()) * COIN + 0.00000000499999;    
+    if (withdrawpub.size()!= 33)    
+        throw runtime_error("invalid destination pubkey");  
     hex = GatewaysWithdraw(0,bindtxid,coin,pubkey2pk(withdrawpub),amount);
     RETURN_IF_ERROR(CCerror);
     if ( hex.size() > 0 )
@@ -6071,19 +6079,61 @@ UniValue gatewayswithdraw(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue gatewaysmarkdone(const UniValue& params, bool fHelp)
+UniValue gatewayspartialsign(const UniValue& params, bool fHelp)
 {
-    UniValue result(UniValue::VOBJ); uint256 withdrawtxid,cointxid; std::string hex,coin;
+    UniValue result(UniValue::VOBJ); std::string coin,parthex,hex; uint256 txid;
     if ( fHelp || params.size() != 3 )
-        throw runtime_error("gatewaysmarkdone withdrawtxid coin cointxid\n");
+        throw runtime_error("gatewayspartialsign txidaddr refcoin hex\n");
+    if ( ensure_CCrequirements() < 0 )
+        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    const CKeyStore& keystore = *pwalletMain;
+    LOCK2(cs_main, pwalletMain->cs_wallet);    
+    txid = Parseuint256((char *)params[0].get_str().c_str());
+    coin = params[1].get_str();
+    parthex = params[2].get_str();
+    hex = GatewaysPartialSign(0,txid,coin,parthex);
+    if ( hex.size() > 0 )
+    {
+        result.push_back(Pair("result", "success"));
+        result.push_back(Pair("hex",hex));
+    } else ERR_RESULT("couldnt gatewayspartialsign");
+    return(result);
+}
+
+UniValue gatewayscompletesigning(const UniValue& params, bool fHelp)
+{
+    UniValue result(UniValue::VOBJ); uint256 withdrawtxid; std::string txhex,hex,coin;
+    if ( fHelp || params.size() != 3 )
+        throw runtime_error("gatewayscompletesigning withdrawtxid coin hex\n");
     if ( ensure_CCrequirements() < 0 )
         throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     withdrawtxid = Parseuint256((char *)params[0].get_str().c_str());
     coin = params[1].get_str();
-    cointxid = Parseuint256((char *)params[2].get_str().c_str());
+    txhex = params[2].get_str();
-    hex = GatewaysMarkdone(0,withdrawtxid,coin,cointxid);
+    hex = GatewaysCompleteSigning(0,withdrawtxid,coin,txhex);
+    RETURN_IF_ERROR(CCerror);
+    if ( hex.size() > 0 )
+    {
+        result.push_back(Pair("result", "success"));
+        result.push_back(Pair("hex", hex));
+    } else ERR_RESULT("couldnt gatewayscompletesigning");
+    return(result);
+}
+
+UniValue gatewaysmarkdone(const UniValue& params, bool fHelp)
+{
+    UniValue result(UniValue::VOBJ); uint256 completetxid; std::string hex,coin;
+    if ( fHelp || params.size() != 2 )
+        throw runtime_error("gatewaysmarkdone completesigningtx coin\n");
+    if ( ensure_CCrequirements() < 0 )
+        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    const CKeyStore& keystore = *pwalletMain;
+    LOCK2(cs_main, pwalletMain->cs_wallet);
+    completetxid = Parseuint256((char *)params[0].get_str().c_str());
+    coin = params[1].get_str();    
+    hex = GatewaysMarkDone(0,completetxid,coin);
     RETURN_IF_ERROR(CCerror);
     if ( hex.size() > 0 )
     {
@@ -6105,6 +6155,18 @@ UniValue gatewayspending(const UniValue& params, bool fHelp)
     return(GatewaysPendingWithdraws(bindtxid,coin));
 }
 
+UniValue gatewaysprocessed(const UniValue& params, bool fHelp)
+{
+    uint256 bindtxid; std::string coin;
+    if ( fHelp || params.size() != 2 )
+        throw runtime_error("gatewaysprocessed bindtxid coin\n");
+    if ( ensure_CCrequirements() < 0 )
+        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    bindtxid = Parseuint256((char *)params[0].get_str().c_str());
+    coin = params[1].get_str();
+    return(GatewaysProcessedWithdraws(bindtxid,coin));
+}
+
 UniValue gatewaysmultisig(const UniValue& params, bool fHelp)
 {
     UniValue result(UniValue::VOBJ); std::string hex; char *txidaddr;
@@ -6118,28 +6180,6 @@ UniValue gatewaysmultisig(const UniValue& params, bool fHelp)
     return(GatewaysMultisig(txidaddr));
 }
 
-UniValue gatewayspartialsign(const UniValue& params, bool fHelp)
-{
-    UniValue result(UniValue::VOBJ); std::string coin,parthex,hex; uint256 txid;
-    if ( fHelp || params.size() != 3 )
-        throw runtime_error("gatewayspartialsign txidaddr refcoin hex\n");
-    if ( ensure_CCrequirements() < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
-    const CKeyStore& keystore = *pwalletMain;
-    LOCK2(cs_main, pwalletMain->cs_wallet);
-    txid = Parseuint256((char *)params[0].get_str().c_str());
-    coin = params[1].get_str();
-    parthex = params[2].get_str();
-    hex = GatewaysPartialSign(0,txid,coin,parthex);
-    RETURN_IF_ERROR(CCerror);
-    if ( hex.size() > 0 )
-    {
-        result.push_back(Pair("result", "success"));
-        result.push_back(Pair("hex",hex));
-    } else ERR_RESULT("couldnt gatewaysmultisig");
-    return(result);
-}
-
 UniValue oracleslist(const UniValue& params, bool fHelp)
 {
     if ( fHelp || params.size() > 0 )