Merge pull request #1180 from jl777/jl777

Jl777

src/cc/CCMarmara.h

@@ -23,10 +23,17 @@
 #define MARMARA_GROUPSIZE 60
 #define MARMARA_MINLOCK (1440 * 3 * 30)
 #define MARMARA_MAXLOCK (1440 * 24 * 30)
+
 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 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 createtxid);
-UniValue MarmaraIssue(uint64_t txfee,uint8_t funcid,CPubKey senderpk,int64_t amount,std::string currency,int32_t matures,uint256 createtxid);
+UniValue MarmaraReceive(uint64_t txfee,CPubKey senderpk,int64_t amount,std::string currency,int32_t matures,uint256 batontxid);
+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);
 
 bool MarmaraValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx, uint32_t nIn);
 

src/cc/CCinclude.h

@@ -56,6 +56,8 @@ extern uint32_t ASSETCHAINS_CC;
 extern char ASSETCHAINS_SYMBOL[];
 extern std::string CCerror;
 
+#define CC_MAXVINS 1024
+
 #define SMALLVAL 0.000000000000001
 #ifndef _BITS256
 #define _BITS256
@@ -103,15 +105,18 @@ struct oracleprice_info
 #ifdef ENABLE_WALLET
 extern CWallet* pwalletMain;
 #endif
+//extern CCoinsViewCache *pcoinsTip;
 bool GetAddressUnspent(uint160 addressHash, int type,std::vector<std::pair<CAddressUnspentKey,CAddressUnspentValue> > &unspentOutputs);
 CBlockIndex *komodo_getblockindex(uint256 hash);
 int32_t komodo_nextheight();
 
+int32_t CCgetspenttxid(uint256 &spenttxid,int32_t &vini,int32_t &height,uint256 txid,int32_t vout);
+
 static const uint256 zeroid;
 bool myGetTransaction(const uint256 &hash, CTransaction &txOut, uint256 &hashBlock);
 int32_t is_hexstr(char *str,int32_t n);
 bool myAddtomempool(CTransaction &tx, CValidationState *pstate = NULL, bool fSkipExpiry = false);
-//uint64_t myGettxout(uint256 hash,int32_t n);
+int32_t CCgettxout(uint256 txid,int32_t vout,int32_t mempoolflag);
 bool myIsutxo_spentinmempool(uint256 txid,int32_t vout);
 bool mytxid_inmempool(uint256 txid);
 int32_t myIsutxo_spent(uint256 &spenttxid,uint256 txid,int32_t vout);

src/cc/CCtx.cpp

@@ -42,7 +42,7 @@ std::string FinalizeCCTx(uint64_t CCmask,struct CCcontract_info *cp,CMutableTran
 {
     auto consensusBranchId = CurrentEpochBranchId(chainActive.Height() + 1, Params().GetConsensus());
     CTransaction vintx; std::string hex; uint256 hashBlock; uint64_t mask=0,nmask=0,vinimask=0;
-    int64_t utxovalues[64],change,normalinputs=0,totaloutputs=0,normaloutputs=0,totalinputs=0,normalvins=0,ccvins=0; 
+    int64_t utxovalues[CC_MAXVINS],change,normalinputs=0,totaloutputs=0,normaloutputs=0,totalinputs=0,normalvins=0,ccvins=0; 
     int32_t i,utxovout,n,err = 0; char myaddr[64],destaddr[64],unspendable[64];
     uint8_t *privkey,myprivkey[32],unspendablepriv[32],*msg32 = 0; CC *mycond=0,*othercond=0,*othercond2=0,*othercond3=0,*cond; CPubKey unspendablepk;
     n = mtx.vout.size();
@@ -52,7 +52,7 @@ std::string FinalizeCCTx(uint64_t CCmask,struct CCcontract_info *cp,CMutableTran
             normaloutputs += mtx.vout[i].nValue;
         totaloutputs += mtx.vout[i].nValue;
     }
-    if ( (n= mtx.vin.size()) > 64 )
+    if ( (n= mtx.vin.size()) > CC_MAXVINS )
     {
         fprintf(stderr,"FinalizeCCTx: %d is too many vins\n",n);
         return("0");
@@ -247,6 +247,40 @@ int64_t CCutxovalue(char *coinaddr,uint256 utxotxid,int32_t utxovout)
     return(0);
 }
 
+int32_t CCgettxout(uint256 txid,int32_t vout,int32_t mempoolflag)
+{
+    CCoins coins;
+    if ( mempoolflag != 0 )
+    {
+        LOCK(mempool.cs);
+        CCoinsViewMemPool view(pcoinsTip, mempool);
+        if (!view.GetCoins(txid, coins))
+            return(-1);
+        if ( myIsutxo_spentinmempool(txid,vout) != 0 )
+            return(-1);
+    }
+    else
+    {
+        if (!pcoinsTip->GetCoins(txid, coins))
+            return(-1);
+    }
+    if ( vout < coins.vout.size() )
+        return(coins.vout[vout].nValue);
+    else return(-1);
+}
+
+int32_t CCgetspenttxid(uint256 &spenttxid,int32_t &vini,int32_t &height,uint256 txid,int32_t vout)
+{
+    CSpentIndexKey key(txid, vout);
+    CSpentIndexValue value;
+    if ( !GetSpentIndex(key, value) )
+        return(-1);
+    spenttxid = value.txid;
+    vini = (int32_t)value.inputIndex;
+    height = value.blockHeight;
+    return(0);
+}
+
 int64_t CCaddress_balance(char *coinaddr)
 {
     int64_t sum = 0; std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;

src/cc/marmara.cpp

@@ -18,6 +18,25 @@
 /*
  Marmara CC is for the MARMARA project
  
+ 'R': two forms for initial issuance and for accepting existing
+ vins normal
+ vout0 approval to senderpk (issuer or owner of baton)
+ 
+ 'I'
+ vin0 approval from 'R'
+ vins1+ normal
+ vout0 baton to 1st receiverpk
+ vout1 marker to Marmara so all issuances can be tracked (spent when loop is closed)
+ 
+ 'T'
+ vin0 approval from 'R'
+ vin1 baton from 'I'/'T'
+ vins2+ normal
+ vout0 baton to next receiverpk (following the unspent baton back to original is the credit loop)
+ 
+ 'S'
+ vins CC utxos from credit loop
+ 
 */
 
 // start of consensus code
@@ -33,44 +52,6 @@ int64_t IsMarmaravout(struct CCcontract_info *cp,const CTransaction& tx,int32_t
     return(0);
 }
 
-/*bool MarmaraExactAmounts(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx,int32_t minage,uint64_t txfee)
-{
-    static uint256 zerohash;
-    CTransaction vinTx; uint256 hashBlock,activehash; int32_t i,numvins,numvouts; int64_t inputs=0,outputs=0,assetoshis;
-    numvins = tx.vin.size();
-    numvouts = tx.vout.size();
-    for (i=0; i<numvins; i++)
-    {
-        //fprintf(stderr,"vini.%d\n",i);
-        if ( (*cp->ismyvin)(tx.vin[i].scriptSig) != 0 )
-        {
-            //fprintf(stderr,"vini.%d check mempool\n",i);
-            if ( eval->GetTxUnconfirmed(tx.vin[i].prevout.hash,vinTx,hashBlock) == 0 )
-                return eval->Invalid("cant find vinTx");
-            else
-            {
-                //fprintf(stderr,"vini.%d check hash and vout\n",i);
-                if ( hashBlock == zerohash )
-                    return eval->Invalid("cant Marmara from mempool");
-                if ( (assetoshis= IsMarmaravout(cp,vinTx,tx.vin[i].prevout.n)) != 0 )
-                    inputs += assetoshis;
-            }
-        }
-    }
-    for (i=0; i<numvouts; i++)
-    {
-        //fprintf(stderr,"i.%d of numvouts.%d\n",i,numvouts);
-        if ( (assetoshis= IsMarmaravout(cp,tx,i)) != 0 )
-            outputs += assetoshis;
-    }
-    if ( inputs != outputs+txfee )
-    {
-        fprintf(stderr,"inputs %llu vs outputs %llu\n",(long long)inputs,(long long)outputs);
-        return eval->Invalid("mismatched inputs != outputs + txfee");
-    }
-    else return(true);
-}*/
-
 int32_t MarmaraRandomize(uint32_t ind)
 {
     uint64_t val64; uint32_t val,range = (MARMARA_MAXLOCK - MARMARA_MINLOCK);
@@ -138,6 +119,60 @@ CScript MarmaraLoopOpret(uint8_t funcid,uint256 createtxid,CPubKey senderpk,int6
     return(opret);
 }
 
+uint8_t MarmaraDecodeLoopOpret(const CScript scriptPubKey,uint256 &createtxid,CPubKey &senderpk,int64_t &amount,int32_t &matures,std::string &currency)
+{
+    std::vector<uint8_t> vopret; uint8_t *script,e,f;
+    GetOpReturnData(scriptPubKey, vopret);
+    script = (uint8_t *)vopret.data();
+    if ( vopret.size() > 2 && E_UNMARSHAL(vopret,ss >> e; ss >> f; ss >> createtxid; ss >> senderpk; ss >> amount; ss >> matures; ss >> currency) != 0 )
+    {
+        return(f);
+    }
+    return(0);
+}
+
+int32_t MarmaraGetcreatetxid(uint256 &createtxid,uint256 txid)
+{
+    CTransaction tx; uint256 hashBlock; uint8_t funcid; int32_t numvouts,matures; std::string currency; CPubKey senderpk; int64_t amount;
+    if ( myGetTransaction(txid,tx,hashBlock) != 0 && (numvouts= tx.vout.size()) > 1 )
+    {
+        if ( (funcid= MarmaraDecodeLoopOpret(tx.vout[numvouts-1].scriptPubKey,createtxid,senderpk,amount,matures,currency)) == 'I' || funcid == 'T' )
+            return(0);
+        else if ( funcid == 'R' )
+        {
+            if ( createtxid == zeroid )
+                createtxid = txid;
+            return(0);
+        }
+    }
+    return(-1);
+}
+
+int32_t MarmaraGetbatontxid(std::vector<uint256> &creditloop,uint256 &batontxid,uint256 txid)
+{
+    uint256 createtxid,spenttxid; int64_t value; int32_t vini,height,n=0,vout = 0;
+    memset(&batontxid,0,sizeof(batontxid));
+    if ( MarmaraGetcreatetxid(createtxid,txid) == 0 )
+    {
+        txid = createtxid;
+        fprintf(stderr,"txid.%s -> createtxid %s\n",txid.GetHex().c_str(),createtxid.GetHex().c_str());
+        while ( CCgetspenttxid(spenttxid,vini,height,txid,vout) == 0 )
+        {
+            creditloop.push_back(txid);
+            fprintf(stderr,"%d: %s\n",n,txid.GetHex().c_str());
+            n++;
+            if ( (value= CCgettxout(spenttxid,vout,1)) > 0 )
+            {
+                batontxid = spenttxid;
+                fprintf(stderr,"got baton %s %.8f\n",batontxid.GetHex().c_str(),(double)value/COIN);
+                return(n);
+            }
+            txid = spenttxid;
+        }
+    }
+    return(-1);
+}
+
 CScript Marmara_scriptPubKey(int32_t height,CPubKey pk)
 {
     CTxOut ccvout;
@@ -297,16 +332,51 @@ int64_t AddMarmaraCoinbases(struct CCcontract_info *cp,CMutableTransaction &mtx,
     return(totalinputs);
 }
 
-UniValue MarmaraReceive(uint64_t txfee,CPubKey senderpk,int64_t amount,std::string currency,int32_t matures,uint256 createtxid)
+int32_t MarmaraGetCreditloops(int64_t &totalamount,std::vector<uint256> &issuances,struct CCcontract_info *cp,int32_t firstheight,int32_t lastheight,int64_t minamount,int64_t maxamount,CPubKey refpk,std::string refcurrency)
+{
+    char coinaddr[64]; CPubKey Marmarapk,senderpk; int64_t amount; uint256 createtxid,txid,hashBlock; CTransaction tx; int32_t numvouts,vout,matures,n=0; std::string currency;
+    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
+    Marmarapk = GetUnspendable(cp,0);
+    GetCCaddress(cp,coinaddr,Marmarapk);
+    SetCCunspents(unspentOutputs,coinaddr);
+    //fprintf(stderr,"check coinaddr.(%s)\n",coinaddr);
+    for (std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> >::const_iterator it=unspentOutputs.begin(); it!=unspentOutputs.end(); it++)
+    {
+        txid = it->first.txhash;
+        vout = (int32_t)it->first.index;
+        //fprintf(stderr,"txid.%s/v%d\n",txid.GetHex().c_str(),vout);
+        if ( vout == 1 && GetTransaction(txid,tx,hashBlock,false) != 0 )
+        {
+            if ( tx.IsCoinBase() == 0 && (numvouts= tx.vout.size()) > 2 && tx.vout[numvouts - 1].nValue == 0 )
+            {
+                if ( MarmaraDecodeLoopOpret(tx.vout[numvouts-1].scriptPubKey,createtxid,senderpk,amount,matures,currency) == 'I' )
+                {
+                    n++;
+                    if ( currency == refcurrency && matures >= firstheight && matures <= lastheight && amount >= minamount && amount <= maxamount && (refpk.size() == 0 || senderpk == refpk) )
+                    {
+                        issuances.push_back(txid);
+                        totalamount += amount;
+                    }
+                }
+            }
+        } else fprintf(stderr,"error getting tx\n");
+    }
+    return(n);
+}
+
+UniValue MarmaraReceive(uint64_t txfee,CPubKey senderpk,int64_t amount,std::string currency,int32_t matures,uint256 batontxid)
 {
     CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
-    UniValue result(UniValue::VOBJ); CPubKey mypk; struct CCcontract_info *cp,C; std::string rawtx; char *errorstr=0; int32_t needbaton = 0;
+    UniValue result(UniValue::VOBJ); CPubKey mypk; struct CCcontract_info *cp,C; std::string rawtx; char *errorstr=0; uint256 createtxid; int64_t batonamount; int32_t needbaton = 0;
     cp = CCinit(&C,EVAL_MARMARA);
     if ( txfee == 0 )
         txfee = 10000;
     // check for batonownership by senderpk and parameters match createtxid
     mypk = pubkey2pk(Mypubkey());
-    if ( currency != "MARMARA" )
+    memset(&createtxid,0,sizeof(createtxid));
+    if ( batontxid != zeroid && MarmaraGetcreatetxid(createtxid,batontxid) < 0 )
+        errorstr = (char *)"cant get createtxid from batontxid";
+    else if ( currency != "MARMARA" )
         errorstr = (char *)"for now, only MARMARA loops are supported";
     else if ( amount < txfee )
         errorstr = (char *)"amount must be for more than txfee";
@@ -314,13 +384,13 @@ UniValue MarmaraReceive(uint64_t txfee,CPubKey senderpk,int64_t amount,std::stri
         errorstr = (char *)"it must mature in the future";
     if ( errorstr == 0 )
     {
-        if ( createtxid == zeroid )
-            needbaton = 1;
-        if ( AddNormalinputs(mtx,mypk,(1+needbaton)*txfee,1) > 0 )
+        if ( batontxid != zeroid )
+            batonamount = txfee;
+        else batonamount = 2*txfee;
+        if ( AddNormalinputs(mtx,mypk,batonamount + txfee,1) > 0 )
         {
             errorstr = (char *)"couldnt finalize CCtx";
-            if ( needbaton != 0 )
-                mtx.vout.push_back(MakeCC1vout(EVAL_MARMARA,txfee,senderpk));
+            mtx.vout.push_back(MakeCC1vout(EVAL_MARMARA,batonamount,senderpk));
             rawtx = FinalizeCCTx(0,cp,mtx,mypk,txfee,MarmaraLoopOpret('R',createtxid,senderpk,amount,matures,currency));
             if ( rawtx.size() > 0 )
                 errorstr = 0;
@@ -338,6 +408,8 @@ UniValue MarmaraReceive(uint64_t txfee,CPubKey senderpk,int64_t amount,std::stri
         result.push_back(Pair("rawtx",rawtx));
         result.push_back(Pair("funcid","R"));
         result.push_back(Pair("createtxid",createtxid.GetHex()));
+        if ( batontxid != zeroid )
+            result.push_back(Pair("batontxid",batontxid.GetHex()));
         result.push_back(Pair("senderpk",HexStr(senderpk)));
         result.push_back(Pair("amount",ValueFromAmount(amount)));
         result.push_back(Pair("matures",matures));
@@ -346,16 +418,22 @@ UniValue MarmaraReceive(uint64_t txfee,CPubKey senderpk,int64_t amount,std::stri
     return(result);
 }
 
-UniValue MarmaraIssue(uint64_t txfee,uint8_t funcid,CPubKey receiverpk,int64_t amount,std::string currency,int32_t matures,uint256 createtxid)
+UniValue MarmaraIssue(uint64_t txfee,uint8_t funcid,CPubKey receiverpk,int64_t amount,std::string currency,int32_t matures,uint256 approvaltxid,uint256 batontxid)
 {
     CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
-    UniValue result(UniValue::VOBJ); CPubKey mypk; struct CCcontract_info *cp,C; std::string rawtx; char *errorstr=0;
+    UniValue result(UniValue::VOBJ); CPubKey mypk,Marmarapk; struct CCcontract_info *cp,C; std::string rawtx; uint256 createtxid; char *errorstr=0;
     cp = CCinit(&C,EVAL_MARMARA);
     if ( txfee == 0 )
         txfee = 10000;
-    // make sure if transfer that it is not too late
+    // make sure receiverpk is unique to creditloop
+    // make sure less than maxlength
+    Marmarapk = GetUnspendable(cp,0);
     mypk = pubkey2pk(Mypubkey());
-    if ( currency != "MARMARA" )
+    if ( MarmaraGetcreatetxid(createtxid,approvaltxid) < 0 )
+        errorstr = (char *)"cant get createtxid from approvaltxid";
+    else if ( batontxid == zeroid )
+        errorstr = (char *)"null batontxid";
+    else if ( currency != "MARMARA" )
         errorstr = (char *)"for now, only MARMARA loops are supported";
     else if ( amount < txfee )
         errorstr = (char *)"amount must be for more than txfee";
@@ -363,10 +441,15 @@ UniValue MarmaraIssue(uint64_t txfee,uint8_t funcid,CPubKey receiverpk,int64_t a
         errorstr = (char *)"it must mature in the future";
     if ( errorstr == 0 )
     {
-        if ( AddNormalinputs(mtx,mypk,2*txfee,1) > 0 )
+        mtx.vin.push_back(CTxIn(approvaltxid,0,CScript()));
+        if ( funcid == 'T' )
+            mtx.vin.push_back(CTxIn(batontxid,0,CScript()));
+        if ( funcid == 'I' || AddNormalinputs(mtx,mypk,txfee,1) > 0 )
         {
             errorstr = (char *)"couldnt finalize CCtx";
             mtx.vout.push_back(MakeCC1vout(EVAL_MARMARA,txfee,receiverpk));
+            if ( funcid == 'I' )
+                mtx.vout.push_back(MakeCC1vout(EVAL_MARMARA,txfee,Marmarapk));
             rawtx = FinalizeCCTx(0,cp,mtx,mypk,txfee,MarmaraLoopOpret(funcid,createtxid,receiverpk,amount,matures,currency));
             if ( rawtx.size() > 0 )
                 errorstr = 0;
@@ -385,6 +468,9 @@ UniValue MarmaraIssue(uint64_t txfee,uint8_t funcid,CPubKey receiverpk,int64_t a
         char str[2]; str[0] = funcid, str[1] = 0;
         result.push_back(Pair("funcid",str));
         result.push_back(Pair("createtxid",createtxid.GetHex()));
+        result.push_back(Pair("approvaltxid",approvaltxid.GetHex()));
+        if ( funcid == 'T' )
+            result.push_back(Pair("batontxid",batontxid.GetHex()));
         result.push_back(Pair("receiverpk",HexStr(receiverpk)));
         result.push_back(Pair("amount",ValueFromAmount(amount)));
         result.push_back(Pair("matures",matures));
@@ -393,32 +479,215 @@ UniValue MarmaraIssue(uint64_t txfee,uint8_t funcid,CPubKey receiverpk,int64_t a
     return(result);
 }
 
-std::string MarmaraFund(uint64_t txfee,int64_t funds)
+UniValue MarmaraSettlement(uint64_t txfee,uint256 refbatontxid)
 {
-    CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
-    CPubKey mypk,Marmarapk; CScript opret; struct CCcontract_info *cp,C;
-    cp = CCinit(&C,EVAL_MARMARA);
+    UniValue result(UniValue::VOBJ),a(UniValue::VARR); std::vector<uint256> creditloop; uint256 batontxid,createtxid,refcreatetxid,hashBlock; uint8_t funcid; int32_t numerrs=0,i,n,numvouts,matures,refmatures; int64_t amount,refamount; CPubKey Marmarapk,pk; std::string currency,refcurrency; CTransaction tx,batontx; char coinaddr[64],myCCaddr[64],destaddr[64],batonCCaddr[64],str[2]; struct CCcontract_info *cp,C;
     if ( txfee == 0 )
         txfee = 10000;
-    mypk = pubkey2pk(Mypubkey());
-    Marmarapk = GetUnspendable(cp,0);
-    if ( AddNormalinputs(mtx,mypk,funds+txfee,64) > 0 )
-    {
-        mtx.vout.push_back(MakeCC1vout(EVAL_MARMARA,funds,Marmarapk));
-        return(FinalizeCCTx(0,cp,mtx,mypk,txfee,opret));
-    }
-    return("");
-}
-
-UniValue MarmaraInfo()
-{
-    UniValue result(UniValue::VOBJ); char numstr[64];
-    CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
-    CPubKey Marmarapk; struct CCcontract_info *cp,C; int64_t funding;
-    result.push_back(Pair("result","success"));
-    result.push_back(Pair("name","Marmara"));
     cp = CCinit(&C,EVAL_MARMARA);
     Marmarapk = GetUnspendable(cp,0);
+    if ( (n= MarmaraGetbatontxid(creditloop,batontxid,refbatontxid)) > 0 )
+    {
+        if ( GetTransaction(batontxid,batontx,hashBlock,false) != 0 && (numvouts= batontx.vout.size()) > 1 )
+        {
+            if ( (funcid= MarmaraDecodeLoopOpret(batontx.vout[numvouts-1].scriptPubKey,refcreatetxid,pk,refamount,refmatures,refcurrency)) != 0 )
+            {
+                if ( refcreatetxid != creditloop[0] )
+                {
+                    fprintf(stderr,"invalid refcreatetxid, setting to creditloop[0]\n");
+                    refcreatetxid = creditloop[0];
+                    numerrs++;
+                }
+                GetCCaddress(cp,myCCaddr,Mypubkey());
+                Getscriptaddress(batonCCaddr,batontx.vout[0].scriptPubKey);
+                if ( strcmp(myCCaddr,batonCCaddr) == 0 )
+                {
+                    for (i=0; i<n; i++)
+                    {
+                        if ( GetTransaction(creditloop[i],tx,hashBlock,false) != 0 && (numvouts= tx.vout.size()) > 1 )
+                        {
+                            if ( (funcid= MarmaraDecodeLoopOpret(tx.vout[numvouts-1].scriptPubKey,createtxid,pk,amount,matures,currency)) != 0 )
+                            {
+                                GetCCaddress1of2(cp,coinaddr,Marmarapk,pk);
+                                fprintf(stderr,"get locked funds of %s %.8f\n",coinaddr,(double)CCaddress_balance(coinaddr)/COIN);
+                            } else fprintf(stderr,"null funcid for creditloop[%d]\n",i);
+                        } else fprintf(stderr,"couldnt get creditloop[%d]\n",i);
+                    }
+                }
+                else
+                {
+                    result.push_back(Pair("result",(char *)"error"));
+                    result.push_back(Pair("error",(char *)"this node does not have the baton"));
+                    result.push_back(Pair("myCCaddr",myCCaddr));
+                    result.push_back(Pair("batonCCaddr",batonCCaddr));
+                }
+            }
+            else
+            {
+                result.push_back(Pair("result",(char *)"error"));
+                result.push_back(Pair("error",(char *)"couldnt get batontxid opret"));
+            }
+        }
+        else
+        {
+            result.push_back(Pair("result",(char *)"error"));
+            result.push_back(Pair("error",(char *)"couldnt find batontxid"));
+        }
+    }
+    else
+    {
+        result.push_back(Pair("result",(char *)"error"));
+        result.push_back(Pair("error",(char *)"couldnt get creditloop"));
+    }
+    return(result);
+}
+
+UniValue MarmaraCreditloop(uint256 txid)
+{
+    UniValue result(UniValue::VOBJ),a(UniValue::VARR); std::vector<uint256> creditloop; uint256 batontxid,createtxid,refcreatetxid,hashBlock; uint8_t funcid; int32_t numerrs=0,i,n,numvouts,matures,refmatures; int64_t amount,refamount; CPubKey pk; std::string currency,refcurrency; CTransaction tx; char coinaddr[64],myCCaddr[64],destaddr[64],batonCCaddr[64],str[2]; struct CCcontract_info *cp,C;
+    cp = CCinit(&C,EVAL_MARMARA);
+    if ( (n= MarmaraGetbatontxid(creditloop,batontxid,txid)) > 0 )
+    {
+        if ( GetTransaction(batontxid,tx,hashBlock,false) != 0 && (numvouts= tx.vout.size()) > 1 )
+        {
+            result.push_back(Pair("result",(char *)"success"));
+            Getscriptaddress(coinaddr,CScript() << ParseHex(HexStr(Mypubkey())) << OP_CHECKSIG);
+            result.push_back(Pair("myaddress",coinaddr));
+            GetCCaddress(cp,myCCaddr,Mypubkey());
+            result.push_back(Pair("myCCaddress",myCCaddr));
+            result.push_back(Pair("batontxid",batontxid.GetHex()));
+            if ( (funcid= MarmaraDecodeLoopOpret(tx.vout[numvouts-1].scriptPubKey,refcreatetxid,pk,refamount,refmatures,refcurrency)) != 0 )
+            {
+                str[0] = funcid, str[1] = 0;
+                result.push_back(Pair("funcid",str));
+                if ( refcreatetxid != creditloop[0] )
+                {
+                    fprintf(stderr,"invalid refcreatetxid, setting to creditloop[0]\n");
+                    refcreatetxid = creditloop[0];
+                    numerrs++;
+                }
+                result.push_back(Pair("createtxid",refcreatetxid.GetHex()));
+                result.push_back(Pair("amount",ValueFromAmount(refamount)));
+                result.push_back(Pair("matures",refmatures));
+                result.push_back(Pair("currency",refcurrency));
+                result.push_back(Pair("batonpk",HexStr(pk)));
+                Getscriptaddress(coinaddr,CScript() << ParseHex(HexStr(pk)) << OP_CHECKSIG);
+                result.push_back(Pair("batonaddr",coinaddr));
+                GetCCaddress(cp,batonCCaddr,pk);
+                result.push_back(Pair("batonCCaddr",batonCCaddr));
+                Getscriptaddress(coinaddr,tx.vout[0].scriptPubKey);
+                if ( strcmp(coinaddr,batonCCaddr) != 0 )
+                {
+                    result.push_back(Pair("vout0address",coinaddr));
+                    numerrs++;
+                }
+                if ( strcmp(myCCaddr,coinaddr) == 0 )
+                    result.push_back(Pair("ismine",1));
+                else result.push_back(Pair("ismine",0));
+                for (i=0; i<n; i++)
+                {
+                    if ( GetTransaction(creditloop[i],tx,hashBlock,false) != 0 && (numvouts= tx.vout.size()) > 1 )
+                    {
+                        if ( (funcid= MarmaraDecodeLoopOpret(tx.vout[numvouts-1].scriptPubKey,createtxid,pk,amount,matures,currency)) != 0 )
+                        {
+                            UniValue obj(UniValue::VOBJ);
+                            obj.push_back(Pair("txid",creditloop[i].GetHex()));
+                            str[0] = funcid, str[1] = 0;
+                            obj.push_back(Pair("funcid",str));
+                            if ( funcid == 'R' && createtxid == zeroid )
+                            {
+                                createtxid = creditloop[i];
+                                obj.push_back(Pair("issuerpk",HexStr(pk)));
+                                Getscriptaddress(coinaddr,CScript() << ParseHex(HexStr(pk)) << OP_CHECKSIG);
+                                obj.push_back(Pair("issueraddr",coinaddr));
+                                GetCCaddress(cp,coinaddr,pk);
+                                obj.push_back(Pair("issuerCCaddr",coinaddr));
+                            }
+                            else
+                            {
+                                obj.push_back(Pair("receiverpk",HexStr(pk)));
+                                Getscriptaddress(coinaddr,CScript() << ParseHex(HexStr(pk)) << OP_CHECKSIG);
+                                obj.push_back(Pair("receiveraddr",coinaddr));
+                                GetCCaddress(cp,coinaddr,pk);
+                                obj.push_back(Pair("receiverCCaddr",coinaddr));
+                            }
+                            Getscriptaddress(destaddr,tx.vout[0].scriptPubKey);
+                            if ( strcmp(destaddr,coinaddr) != 0 )
+                            {
+                                obj.push_back(Pair("vout0address",destaddr));
+                                numerrs++;
+                            }
+                            if ( createtxid != refcreatetxid || amount != refamount || matures != refmatures || currency != refcurrency )
+                            {
+                                numerrs++;
+                                obj.push_back(Pair("objerror",(char *)"mismatched createtxid or amount or matures or currency"));
+                                obj.push_back(Pair("createtxid",createtxid.GetHex()));
+                                obj.push_back(Pair("amount",ValueFromAmount(amount)));
+                                obj.push_back(Pair("matures",matures));
+                                obj.push_back(Pair("currency",currency));
+                            }
+                            a.push_back(obj);
+                        }
+                    }
+                }
+                result.push_back(Pair("n",n));
+                result.push_back(Pair("numerrors",numerrs));
+                result.push_back(Pair("creditloop",a));
+            }
+            else
+            {
+                result.push_back(Pair("result",(char *)"error"));
+                result.push_back(Pair("error",(char *)"couldnt get batontxid opret"));
+            }
+        }
+        else
+        {
+            result.push_back(Pair("result",(char *)"error"));
+            result.push_back(Pair("error",(char *)"couldnt find batontxid"));
+        }
+    }
+    else
+    {
+        result.push_back(Pair("result",(char *)"error"));
+        result.push_back(Pair("error",(char *)"couldnt get creditloop"));
+    }
+    return(result);
+}
+    
+UniValue MarmaraInfo(CPubKey refpk,int32_t firstheight,int32_t lastheight,int64_t minamount,int64_t maxamount,std::string currency)
+{
+    UniValue result(UniValue::VOBJ),a(UniValue::VARR); int32_t i,n,matches; int64_t totalamount=0; std::vector<uint256> issuances; char coinaddr[64];
+    CPubKey Marmarapk; struct CCcontract_info *cp,C;
+    result.push_back(Pair("result","success"));
+    Getscriptaddress(coinaddr,CScript() << ParseHex(HexStr(Mypubkey())) << OP_CHECKSIG);
+    result.push_back(Pair("myaddress",coinaddr));
+    GetCCaddress(cp,coinaddr,Mypubkey());
+    result.push_back(Pair("myCCaddress",coinaddr));
+    if ( refpk.size() == 33 )
+        result.push_back(Pair("issuer",HexStr(refpk)));
+    if ( currency.size() == 0 )
+        currency = (char *)"MARMARA";
+    if ( firstheight <= lastheight )
+        firstheight = 0, lastheight = (1 << 30);
+    if ( minamount <= maxamount )
+        minamount = 0, maxamount = (1LL << 60);
+    result.push_back(Pair("firstheight",firstheight));
+    result.push_back(Pair("lastheight",lastheight));
+    result.push_back(Pair("minamount",ValueFromAmount(minamount)));
+    result.push_back(Pair("maxamount",ValueFromAmount(maxamount)));
+    result.push_back(Pair("currency",currency));
+    cp = CCinit(&C,EVAL_MARMARA);
+    Marmarapk = GetUnspendable(cp,0);
+    if ( (n= MarmaraGetCreditloops(totalamount,issuances,cp,firstheight,lastheight,minamount,maxamount,refpk,currency)) > 0 )
+    {
+        result.push_back(Pair("n",n));
+        matches = (int32_t)issuances.size();
+        result.push_back(Pair("matches",matches));
+        for (i=0; i<matches; i++)
+            a.push_back(issuances[i].GetHex());
+        result.push_back(Pair("issuances",a));
+        result.push_back(Pair("totalamount",ValueFromAmount(totalamount)));
+    }
     return(result);
 }
 

src/rpc/server.cpp

@@ -447,6 +447,9 @@ static const CRPCCommand vRPCCommands[] =
     { "marmara",       "marmarareceive",   &marmara_receive,      true },
     { "marmara",       "marmaraissue",   &marmara_issue,      true },
     { "marmara",       "marmaratransfer",   &marmara_transfer,      true },
+    { "marmara",       "marmarainfo",   &marmara_info,      true },
+    { "marmara",       "marmaracreditloop",   &marmara_creditloop,      true },
+    { "marmara",       "marmarasettlement",   &marmara_settlement,      true },
 
     // Payments
     { "payments",       "paymentsaddress",   &paymentsaddress,      true },

src/rpc/server.h

@@ -276,6 +276,9 @@ extern UniValue marmara_poolpayout(const UniValue& params, bool fHelp);
 extern UniValue marmara_receive(const UniValue& params, bool fHelp);
 extern UniValue marmara_issue(const UniValue& params, bool fHelp);
 extern UniValue marmara_transfer(const UniValue& params, bool fHelp);
+extern UniValue marmara_info(const UniValue& params, bool fHelp);
+extern UniValue marmara_creditloop(const UniValue& params, bool fHelp);
+extern UniValue marmara_settlement(const UniValue& params, bool fHelp);
 extern UniValue paymentsaddress(const UniValue& params, bool fHelp);
 extern UniValue gatewaysaddress(const UniValue& params, bool fHelp);
 extern UniValue gatewayslist(const UniValue& params, bool fHelp);

src/wallet/rpcwallet.cpp

@@ -5537,7 +5537,7 @@ UniValue marmara_poolpayout(const UniValue& params, bool fHelp)
     if ( fHelp || params.size() != 3 )
     {
         // marmarapoolpayout 0.5 2 '[["024131032ed90941e714db8e6dd176fe5a86c9d873d279edecf005c06f773da686",1000],["02ebc786cb83de8dc3922ab83c21f3f8a2f3216940c3bf9da43ce39e2a3a882c92",100]]';
-        marmarapoolpayout 0 2 '[["024131032ed90941e714db8e6dd176fe5a86c9d873d279edecf005c06f773da686",1000]]'
+        //marmarapoolpayout 0 2 '[["024131032ed90941e714db8e6dd176fe5a86c9d873d279edecf005c06f773da686",1000]]'
         throw runtime_error("marmarapoolpayout perc firstheight \"[[\\\"pubkey\\\":shares], ...]\"\n");
     }
     if ( ensure_CCrequirements() < 0 )
@@ -5550,16 +5550,16 @@ UniValue marmara_poolpayout(const UniValue& params, bool fHelp)
 
 UniValue marmara_receive(const UniValue& params, bool fHelp)
 {
-    UniValue result(UniValue::VOBJ); uint256 createtxid; std::vector<uint8_t> senderpub; int64_t amount; int32_t matures; std::string currency;
+    UniValue result(UniValue::VOBJ); uint256 batontxid; std::vector<uint8_t> senderpub; int64_t amount; int32_t matures; std::string currency;
     if ( fHelp || (params.size() != 5 && params.size() != 4) )
     {
-        // 1st marmarareceive 039433dc3749aece1bd568f374a45da3b0bc6856990d7da3cd175399577940a775 7.5 MARMARA 1440
-        // after marmarareceive 039433dc3749aece1bd568f374a45da3b0bc6856990d7da3cd175399577940a775 7.5 MARMARA 1440 <txid of 1st>
-        throw runtime_error("marmarareceive senderpk amount currency matures createtxid\n");
+        // 1st marmarareceive 028076d42eb20efc10007fafb5ca66a2052523c0d2221e607adf958d1a332159f6 7.5 MARMARA 1440
+        // after marmarareceive 039433dc3749aece1bd568f374a45da3b0bc6856990d7da3cd175399577940a775 7.5 MARMARA 3903 bf6b4d42aa3ce974c853d73b06c78597dd3b5fb493d5d0d944f72c2017f561ad
+        throw runtime_error("marmarareceive senderpk amount currency matures batontxid\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");
-    memset(&createtxid,0,sizeof(createtxid));
+    memset(&batontxid,0,sizeof(batontxid));
     senderpub = ParseHex(params[0].get_str().c_str());
     if (senderpub.size()!= 33)
     {
@@ -5568,19 +5568,21 @@ UniValue marmara_receive(const UniValue& params, bool fHelp)
     }
     amount = atof(params[1].get_str().c_str()) * COIN + 0.00000000499999;
     currency = params[2].get_str();
-    matures = atol(params[3].get_str().c_str()) + chainActive.LastTip()->GetHeight() + 1;
     if ( params.size() == 5 )
-        createtxid = Parseuint256((char *)params[4].get_str().c_str());
-    return(MarmaraReceive(0,pubkey2pk(senderpub),amount,currency,matures,createtxid));
+    {
+        matures = atol(params[3].get_str().c_str());
+        batontxid = Parseuint256((char *)params[4].get_str().c_str());
+    } else matures = atol(params[3].get_str().c_str()) + chainActive.LastTip()->GetHeight() + 1;
+    return(MarmaraReceive(0,pubkey2pk(senderpub),amount,currency,matures,batontxid));
 }
 
 UniValue marmara_issue(const UniValue& params, bool fHelp)
 {
-    UniValue result(UniValue::VOBJ); uint256 createtxid; std::vector<uint8_t> receiverpub; int64_t amount; int32_t matures; std::string currency;
+    UniValue result(UniValue::VOBJ); uint256 approvaltxid; std::vector<uint8_t> receiverpub; int64_t amount; int32_t matures; std::string currency;
     if ( fHelp || params.size() != 5 )
     {
-        // marmaraissue 039433dc3749aece1bd568f374a45da3b0bc6856990d7da3cd175399577940a775 7.5 MARMARA 2693 e5b1ef8ec90e981d3011c8e024cef869b69af2d4dd6837d1ab1d394d3730b7cb
-        throw runtime_error("marmaraissue receiverpk amount currency matures createtxid\n");
+        // marmaraissue 039433dc3749aece1bd568f374a45da3b0bc6856990d7da3cd175399577940a775 7.5 MARMARA 3903 010ff7f9256cefe3b5dee3d72c0eeae9fc6f34884e6f32ffe5b60916df54a9be
+        throw runtime_error("marmaraissue receiverpk amount currency matures approvaltxid\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");
@@ -5593,17 +5595,17 @@ UniValue marmara_issue(const UniValue& params, bool fHelp)
     amount = atof(params[1].get_str().c_str()) * COIN + 0.00000000499999;
     currency = params[2].get_str();
     matures = atol(params[3].get_str().c_str());
-    createtxid = Parseuint256((char *)params[4].get_str().c_str());
-    return(MarmaraIssue(0,'I',pubkey2pk(receiverpub),amount,currency,matures,createtxid));
+    approvaltxid = Parseuint256((char *)params[4].get_str().c_str());
+    return(MarmaraIssue(0,'I',pubkey2pk(receiverpub),amount,currency,matures,approvaltxid,zeroid));
 }
 
 UniValue marmara_transfer(const UniValue& params, bool fHelp)
 {
-    UniValue result(UniValue::VOBJ); uint256 createtxid; std::vector<uint8_t> receiverpub; int64_t amount; int32_t matures; std::string currency;
+    UniValue result(UniValue::VOBJ); uint256 approvaltxid,batontxid; std::vector<uint8_t> receiverpub; int64_t amount; int32_t matures; std::string currency; std::vector<uint256> creditloop;
     if ( fHelp || params.size() != 5 )
     {
-        // marmaratransfer 039433dc3749aece1bd568f374a45da3b0bc6856990d7da3cd175399577940a775 7.5 MARMARA 2693 e5b1ef8ec90e981d3011c8e024cef869b69af2d4dd6837d1ab1d394d3730b7cb
-        throw runtime_error("marmaratransfer receiverpk amount currency matures createtxid\n");
+        // marmaratransfer 028076d42eb20efc10007fafb5ca66a2052523c0d2221e607adf958d1a332159f6 7.5 MARMARA 3903 748a4c80e6f6b725340fb0f52738f38a11c422d59b3034c8366b3d7b33c99a1e
+        throw runtime_error("marmaratransfer receiverpk amount currency matures approvaltxid\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");
@@ -5616,8 +5618,70 @@ UniValue marmara_transfer(const UniValue& params, bool fHelp)
     amount = atof(params[1].get_str().c_str()) * COIN + 0.00000000499999;
     currency = params[2].get_str();
     matures = atol(params[3].get_str().c_str());
-    createtxid = Parseuint256((char *)params[4].get_str().c_str());
-    return(MarmaraIssue(0,'T',pubkey2pk(receiverpub),amount,currency,matures,createtxid));
+    approvaltxid = Parseuint256((char *)params[4].get_str().c_str());
+    if ( MarmaraGetbatontxid(creditloop,batontxid,approvaltxid) < 0 )
+        throw runtime_error("couldnt find batontxid\n");
+    return(MarmaraIssue(0,'T',pubkey2pk(receiverpub),amount,currency,matures,approvaltxid,batontxid));
+}
+
+UniValue marmara_info(const UniValue& params, bool fHelp)
+{
+    UniValue result(UniValue::VOBJ); CPubKey issuerpk; std::vector<uint8_t> issuerpub; int64_t minamount,maxamount; int32_t firstheight,lastheight; std::string currency;
+    if ( fHelp || params.size() < 4 || params.size() > 6 )
+    {
+        throw runtime_error("marmarainfo firstheight lastheight minamount maxamount [currency issuerpk]\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");
+    firstheight = atol(params[0].get_str().c_str());
+    lastheight = atol(params[1].get_str().c_str());
+    minamount = atof(params[2].get_str().c_str()) * COIN + 0.00000000499999;
+    maxamount = atof(params[3].get_str().c_str()) * COIN + 0.00000000499999;
+    if ( params.size() >= 5 )
+        currency = params[4].get_str();
+    if ( params.size() == 6 )
+    {
+        issuerpub = ParseHex(params[5].get_str().c_str());
+        if ( issuerpub.size()!= 33 )
+        {
+            ERR_RESULT("invalid issuer pubkey");
+            return result;
+        }
+        issuerpk = pubkey2pk(issuerpub);
+    }
+    result = MarmaraInfo(issuerpk,firstheight,lastheight,minamount,maxamount,currency);
+    return(result);
+}
+
+UniValue marmara_creditloop(const UniValue& params, bool fHelp)
+{
+    UniValue result(UniValue::VOBJ); uint256 txid;
+    if ( fHelp || params.size() != 1 )
+    {
+        // marmaracreditloop 010ff7f9256cefe3b5dee3d72c0eeae9fc6f34884e6f32ffe5b60916df54a9be
+        throw runtime_error("marmaracreditloop txid\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");
+    txid = Parseuint256((char *)params[0].get_str().c_str());
+    result = MarmaraCreditloop(txid);
+    return(result);
+}
+
+UniValue marmara_settlement(const UniValue& params, bool fHelp)
+{
+    UniValue result(UniValue::VOBJ); uint256 batontxid;
+    if ( fHelp || params.size() != 1 )
+    {
+        // marmarasettlement 010ff7f9256cefe3b5dee3d72c0eeae9fc6f34884e6f32ffe5b60916df54a9be
+        // marmarasettlement cc23bf81733556dc06db2fd9c9f4178cad44bdc237d6e62101cf0cdafb5195f7
+        throw runtime_error("marmarasettlement batontxid\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");
+    batontxid = Parseuint256((char *)params[0].get_str().c_str());
+    result = MarmaraSettlement(0,batontxid);
+    return(result);
 }
 
 UniValue channelslist(const UniValue& params, bool fHelp)