src/pbaas/pbaas.cpp

   1 /********************************************************************
   2  * (C) 2019 Michael Toutonghi
   3  *
   4  * Distributed under the MIT software license, see the accompanying
   5  * file COPYING or http://www.opensource.org/licenses/mit-license.php.
   6  *
   7  * This provides support for PBaaS initialization, notarization, and cross-chain token
   8  * transactions and enabling liquid or non-liquid tokens across the
   9  * Verus ecosystem.
  10  *
  11  */
  12
  13 #include "base58.h"
  14 #include "main.h"
  15 #include "rpc/pbaasrpc.h"
  16 #include "timedata.h"
  17 #include "transaction_builder.h"
  18
  19 CConnectedChains ConnectedChains;
  20
  21 bool IsVerusActive()
  22 {
  23     return (strcmp(ASSETCHAINS_SYMBOL, "VRSC") == 0 || strcmp(ASSETCHAINS_SYMBOL, "VRSCTEST") == 0);
  24 }
  25
  26 bool IsVerusMainnetActive()
  27 {
  28     return (strcmp(ASSETCHAINS_SYMBOL, "VRSC") == 0);
  29 }
  30
  31 // this adds an opret to a mutable transaction and returns the voutnum if it could be added
  32 int32_t AddOpRetOutput(CMutableTransaction &mtx, const CScript &opRetScript)
  33 {
  34     if (opRetScript.IsOpReturn() && opRetScript.size() <= MAX_OP_RETURN_RELAY)
  35     {
  36         CTxOut vOut = CTxOut();
  37         vOut.scriptPubKey = opRetScript;
  38         vOut.nValue = 0;
  39         mtx.vout.push_back(vOut);
  40         return mtx.vout.size() - 1;
  41     }
  42     else
  43     {
  44         return -1;
  45     }
  46 }
  47
  48 // returns a pointer to a base chain object, which can be cast to the
  49 // object type indicated in its objType member
  50 uint256 GetChainObjectHash(const CBaseChainObject &bo)
  51 {
  52     union {
  53         const CBaseChainObject *retPtr;
  54         const CChainObject<CBlockHeaderAndProof> *pNewHeader;
  55         const CChainObject<CPartialTransactionProof> *pNewTx;
  56         const CChainObject<CBlockHeaderProof> *pNewHeaderRef;
  57         const CChainObject<CPriorBlocksCommitment> *pPriors;
  58         const CChainObject<uint256> *pNewProofRoot;
  59         const CChainObject<CReserveTransfer> *pExport;
  60         const CChainObject<CCrossChainProof> *pCrossChainProof;
  61         const CChainObject<CCompositeChainObject> *pCompositeChainObject;
  62     };
  63
  64     retPtr = &bo;
  65
  66     switch(bo.objectType)
  67     {
  68         case CHAINOBJ_HEADER:
  69             return pNewHeader->GetHash();
  70
  71         case CHAINOBJ_TRANSACTION_PROOF:
  72             return pNewTx->GetHash();
  73
  74         case CHAINOBJ_HEADER_REF:
  75             return pNewHeaderRef->GetHash();
  76
  77         case CHAINOBJ_PRIORBLOCKS:
  78             return pPriors->GetHash();
  79
  80         case CHAINOBJ_PROOF_ROOT:
  81             return pNewProofRoot->object;
  82
  83         case CHAINOBJ_RESERVETRANSFER:
  84             return pExport->GetHash();
  85
  86         case CHAINOBJ_CROSSCHAINPROOF:
  87             return pCrossChainProof->GetHash();
  88
  89         case CHAINOBJ_COMPOSITEOBJECT:
  90             return pCrossChainProof->GetHash();
  91
  92     }
  93     return uint256();
  94 }
  95
  96 // used to export coins from one chain to another, if they are not native, they are represented on the other
  97 // chain as tokens
  98 bool ValidateCrossChainExport(struct CCcontract_info *cp, Eval* eval, const CTransaction &tx, uint32_t nIn, bool fulfilled)
  99 {
 100     return true;
 101 }
 102
 103 bool IsCrossChainExportInput(const CScript &scriptSig)
 104 {
 105     return true;
 106 }
 107
 108 // used to validate import of coins from one chain to another. if they are not native and are supported,
 109 // they are represented o the chain as tokens
 110 bool ValidateCrossChainImport(struct CCcontract_info *cp, Eval* eval, const CTransaction &tx, uint32_t nIn, bool fulfilled)
 111 {
 112     return true;
 113 }
 114 bool IsCrossChainImportInput(const CScript &scriptSig)
 115 {
 116     return true;
 117 }
 118
 119 // used to validate a specific service reward based on the spending transaction
 120 bool ValidateServiceReward(struct CCcontract_info *cp, Eval* eval, const CTransaction &tx, uint32_t nIn, bool fulfilled)
 121 {
 122     // for each type of service reward, we need to check and see if the spender is
 123     // correctly formatted to be a valid spend of the service reward. for notarization
 124     // we ensure that the notarization and its outputs are valid and that the spend
 125     // applies to the correct billing period
 126     return true;
 127 }
 128 bool IsServiceRewardInput(const CScript &scriptSig)
 129 {
 130     return true;
 131 }
 132
 133 // used as a proxy token output for a reserve currency on its fractional reserve chain
 134 bool ValidateReserveOutput(struct CCcontract_info *cp, Eval* eval, const CTransaction &tx, uint32_t nIn, bool fulfilled)
 135 {
 136     return true;
 137 }
 138 bool IsReserveOutputInput(const CScript &scriptSig)
 139 {
 140     return true;
 141 }
 142
 143 bool ValidateReserveTransfer(struct CCcontract_info *cp, Eval* eval, const CTransaction &tx, uint32_t nIn, bool fulfilled)
 144 {
 145     return true;
 146 }
 147 bool IsReserveTransferInput(const CScript &scriptSig)
 148 {
 149     return true;
 150 }
 151
 152 bool ValidateReserveDeposit(struct CCcontract_info *cp, Eval* eval, const CTransaction &tx, uint32_t nIn, bool fulfilled)
 153 {
 154     return true;
 155 }
 156 bool IsReserveDepositInput(const CScript &scriptSig)
 157 {
 158     return true;
 159 }
 160
 161 bool ValidateCurrencyState(struct CCcontract_info *cp, Eval* eval, const CTransaction &tx, uint32_t nIn, bool fulfilled)
 162 {
 163     return true;
 164 }
 165 bool IsCurrencyStateInput(const CScript &scriptSig)
 166 {
 167     return true;
 168 }
 169
 170 // used to convert a fractional reserve currency into its reserve and back
 171 bool ValidateReserveExchange(struct CCcontract_info *cp, Eval* eval, const CTransaction &tx, uint32_t nIn, bool fulfilled)
 172 {
 173     return true;
 174 }
 175 bool IsReserveExchangeInput(const CScript &scriptSig)
 176 {
 177     return true;
 178 }
 179
 180
 181 /*
 182  * Verifies that the input objects match the hashes and returns the transaction.
 183  *
 184  * If the opRetTx has the op ret, this calculates based on the actual transaction and
 185  * validates the hashes. If the opRetTx does not have the opRet itself, this validates
 186  * by ensuring that all objects are present on this chain, composing the opRet, and
 187  * ensuring that the transaction then hashes to the correct txid.
 188  *
 189  */
 190 bool ValidateOpretProof(CScript &opRet, COpRetProof &orProof)
 191 {
 192     // enumerate through the objects and validate that they are objects of the expected type that hash
 193     // to the value expected. return true if so
 194     return true;
 195 }
 196
 197 int8_t ObjTypeCode(const CBlockHeaderProof &obj)
 198 {
 199     return CHAINOBJ_HEADER;
 200 }
 201
 202 int8_t ObjTypeCode(const uint256 &obj)
 203 {
 204     return CHAINOBJ_PROOF_ROOT;
 205 }
 206
 207 int8_t ObjTypeCode(const CPartialTransactionProof &obj)
 208 {
 209     return CHAINOBJ_TRANSACTION_PROOF;
 210 }
 211
 212 int8_t ObjTypeCode(const CBlockHeaderAndProof &obj)
 213 {
 214     return CHAINOBJ_HEADER_REF;
 215 }
 216
 217 int8_t ObjTypeCode(const CPriorBlocksCommitment &obj)
 218 {
 219     return CHAINOBJ_PRIORBLOCKS;
 220 }
 221
 222 int8_t ObjTypeCode(const CReserveTransfer &obj)
 223 {
 224     return CHAINOBJ_RESERVETRANSFER;
 225 }
 226
 227 int8_t ObjTypeCode(const CCrossChainProof &obj)
 228 {
 229     return CHAINOBJ_CROSSCHAINPROOF;
 230 }
 231
 232 int8_t ObjTypeCode(const CCompositeChainObject &obj)
 233 {
 234     return CHAINOBJ_COMPOSITEOBJECT;
 235 }
 236
 237 // this adds an opret to a mutable transaction that provides the necessary evidence of a signed, cheating stake transaction
 238 CScript StoreOpRetArray(const std::vector<CBaseChainObject *> &objPtrs)
 239 {
 240     CScript vData;
 241     CDataStream s = CDataStream(SER_NETWORK, PROTOCOL_VERSION);
 242     s << (int32_t)OPRETTYPE_OBJECTARR;
 243     bool error = false;
 244
 245     for (auto pobj : objPtrs)
 246     {
 247         try
 248         {
 249             if (!DehydrateChainObject(s, pobj))
 250             {
 251                 error = true;
 252                 break;
 253             }
 254         }
 255         catch(const std::exception& e)
 256         {
 257             std::cerr << e.what() << '\n';
 258             error = true;
 259             break;
 260         }
 261     }
 262
 263     //std::vector<unsigned char> schars(s.begin(), s.begin() + 200);
 264     //printf("stream vector chars: %s\n", HexBytes(&schars[0], schars.size()).c_str());
 265
 266     std::vector<unsigned char> vch(s.begin(), s.end());
 267     return error ? CScript() : CScript() << OP_RETURN << vch;
 268 }
 269
 270 void DeleteOpRetObjects(std::vector<CBaseChainObject *> &ora)
 271 {
 272     for (auto pobj : ora)
 273     {
 274         switch(pobj->objectType)
 275         {
 276             case CHAINOBJ_HEADER:
 277             {
 278                 delete (CChainObject<CBlockHeaderAndProof> *)pobj;
 279                 break;
 280             }
 281
 282             case CHAINOBJ_TRANSACTION_PROOF:
 283             {
 284                 delete (CChainObject<CPartialTransactionProof> *)pobj;
 285                 break;
 286             }
 287
 288             case CHAINOBJ_PROOF_ROOT:
 289             {
 290                 delete (CChainObject<uint256> *)pobj;
 291                 break;
 292             }
 293
 294             case CHAINOBJ_HEADER_REF:
 295             {
 296                 delete (CChainObject<CBlockHeaderProof> *)pobj;
 297                 break;
 298             }
 299
 300             case CHAINOBJ_PRIORBLOCKS:
 301             {
 302                 delete (CChainObject<CPriorBlocksCommitment> *)pobj;
 303                 break;
 304             }
 305
 306             case CHAINOBJ_RESERVETRANSFER:
 307             {
 308                 delete (CChainObject<CReserveTransfer> *)pobj;
 309                 break;
 310             }
 311
 312             case CHAINOBJ_CROSSCHAINPROOF:
 313             {
 314                 delete (CChainObject<CCrossChainProof> *)pobj;
 315                 break;
 316             }
 317
 318             case CHAINOBJ_COMPOSITEOBJECT:
 319             {
 320                 delete (CChainObject<CCompositeChainObject> *)pobj;
 321                 break;
 322             }
 323
 324             default:
 325             {
 326                 printf("ERROR: invalid object type (%u), likely corrupt pointer %p\n", pobj->objectType, pobj);
 327                 printf("generate code that won't be optimized away %s\n", CCurrencyValueMap(std::vector<uint160>({ASSETCHAINS_CHAINID}), std::vector<CAmount>({200000000})).ToUniValue().write(1,2).c_str());
 328                 printf("This is here to generate enough code for a good break point system chain name: %s\n", ConnectedChains.ThisChain().name.c_str());
 329
 330                 delete pobj;
 331             }
 332         }
 333     }
 334     ora.clear();
 335 }
 336
 337 std::vector<CBaseChainObject *> RetrieveOpRetArray(const CScript &opRetScript)
 338 {
 339     std::vector<unsigned char> vch;
 340     std::vector<CBaseChainObject *> vRet;
 341     if (opRetScript.IsOpReturn() && GetOpReturnData(opRetScript, vch) && vch.size() > 0)
 342     {
 343         CDataStream s = CDataStream(vch, SER_NETWORK, PROTOCOL_VERSION);
 344
 345         int32_t opRetType;
 346
 347         try
 348         {
 349             s >> opRetType;
 350             if (opRetType == OPRETTYPE_OBJECTARR)
 351             {
 352                 CBaseChainObject *pobj;
 353                 while (!s.empty() && (pobj = RehydrateChainObject(s)))
 354                 {
 355                     vRet.push_back(pobj);
 356                 }
 357                 if (!s.empty())
 358                 {
 359                     printf("failed to load all objects in opret");
 360                     DeleteOpRetObjects(vRet);
 361                     vRet.clear();
 362                 }
 363             }
 364         }
 365         catch(const std::exception& e)
 366         {
 367             std::cerr << e.what() << '\n';
 368             DeleteOpRetObjects(vRet);
 369             vRet.clear();
 370         }
 371     }
 372     return vRet;
 373 }
 374
 375 CServiceReward::CServiceReward(const CTransaction &tx, bool validate)
 376 {
 377     nVersion = PBAAS_VERSION_INVALID;
 378     for (auto out : tx.vout)
 379     {
 380         COptCCParams p;
 381         if (IsPayToCryptoCondition(out.scriptPubKey, p))
 382         {
 383             // always take the first for now
 384             if (p.evalCode == EVAL_SERVICEREWARD)
 385             {
 386                 FromVector(p.vData[0], *this);
 387                 break;
 388             }
 389         }
 390     }
 391
 392     if (validate)
 393     {
 394
 395     }
 396 }
 397
 398 CCrossChainExport::CCrossChainExport(const CTransaction &tx, int32_t *pCCXOutputNum)
 399 {
 400     int32_t _ccxOutputNum = 0;
 401     int32_t &ccxOutputNum = pCCXOutputNum ? *pCCXOutputNum : _ccxOutputNum;
 402
 403     for (int i = 0; i < tx.vout.size(); i++)
 404     {
 405         COptCCParams p;
 406         if (tx.vout[i].scriptPubKey.IsPayToCryptoCondition(p) &&
 407             p.IsValid() &&
 408             p.evalCode == EVAL_CROSSCHAIN_EXPORT)
 409         {
 410             FromVector(p.vData[0], *this);
 411             ccxOutputNum = i;
 412             break;
 413         }
 414     }
 415 }
 416
 417 CCurrencyDefinition::CCurrencyDefinition(const CScript &scriptPubKey)
 418 {
 419     nVersion = PBAAS_VERSION_INVALID;
 420     COptCCParams p;
 421     if (scriptPubKey.IsPayToCryptoCondition(p) && p.IsValid())
 422     {
 423         if (p.evalCode == EVAL_CURRENCY_DEFINITION)
 424         {
 425             FromVector(p.vData[0], *this);
 426         }
 427     }
 428 }
 429
 430 std::vector<CCurrencyDefinition> CCurrencyDefinition::GetCurrencyDefinitions(const CTransaction &tx)
 431 {
 432     std::vector<CCurrencyDefinition> retVal;
 433     for (auto &out : tx.vout)
 434     {
 435         CCurrencyDefinition oneCur = CCurrencyDefinition(out.scriptPubKey);
 436         if (oneCur.IsValid())
 437         {
 438             retVal.push_back(oneCur);
 439         }
 440     }
 441     return retVal;
 442 }
 443
 444 #define _ASSETCHAINS_TIMELOCKOFF 0xffffffffffffffff
 445 extern uint64_t ASSETCHAINS_TIMELOCKGTE, ASSETCHAINS_TIMEUNLOCKFROM, ASSETCHAINS_TIMEUNLOCKTO;
 446 extern int64_t ASSETCHAINS_SUPPLY, ASSETCHAINS_REWARD[3], ASSETCHAINS_DECAY[3], ASSETCHAINS_HALVING[3], ASSETCHAINS_ENDSUBSIDY[3], ASSETCHAINS_ERAOPTIONS[3];
 447 extern int32_t PBAAS_STARTBLOCK, PBAAS_ENDBLOCK, ASSETCHAINS_LWMAPOS;
 448 extern uint32_t ASSETCHAINS_ALGO, ASSETCHAINS_VERUSHASH, ASSETCHAINS_LASTERA;
 449 extern std::string VERUS_CHAINNAME;
 450 extern uint160 VERUS_CHAINID;
 451
 452 // ensures that the chain definition is valid and that there are no other definitions of the same name
 453 // that have been confirmed.
 454 bool ValidateChainDefinition(struct CCcontract_info *cp, Eval* eval, const CTransaction &tx, uint32_t nIn, bool fulfilled)
 455 {
 456     // the chain definition output can be spent when the chain is at the end of its life and only then
 457     // TODO
 458     return false;
 459 }
 460
 461 // ensures that the chain definition is valid and that there are no other definitions of the same name
 462 // that have been confirmed.
 463 bool CheckChainDefinitionOutputs(struct CCcontract_info *cp, Eval* eval, const CTransaction &tx, uint32_t nIn)
 464 {
 465     // checked before a chain definition output script is accepted as a valid transaction
 466
 467     // basics - we need a chain definition transaction to kick off a PBaaS chain. it must have:
 468     // 1) valid chain definition output with parameters in proper ranges and no duplicate name
 469     // 2) notarization output with conformant values
 470     // 3) finalization output
 471     // 3) notarization funding
 472     //
 473
 474     // get the source transaction
 475     uint256 blkHash;
 476     CTransaction thisTx;
 477     if (!GetTransaction(tx.vin[nIn].prevout.hash, thisTx, blkHash))
 478     {
 479         LogPrintf("failed to retrieve transaction %s\n", tx.vin[nIn].prevout.hash.GetHex().c_str());
 480         return false;
 481     }
 482
 483     std::vector<CCurrencyDefinition> chainDefs = CCurrencyDefinition::GetCurrencyDefinitions(thisTx);
 484     CPBaaSNotarization notarization(thisTx);
 485     CTransactionFinalization finalization(thisTx);
 486     bool isVerusActive = IsVerusActive();
 487
 488     if (!notarization.IsValid() || !finalization.IsValid())
 489     {
 490         LogPrintf("transaction specified, %s, must have valid notarization, and finaization outputs\n", tx.vin[nIn].prevout.hash.GetHex().c_str());
 491         return false;
 492     }
 493
 494     std::set<uint160> allCurrencyIDs;
 495     for (auto &curPair : ConnectedChains.ReserveCurrencies())
 496     {
 497         allCurrencyIDs.insert(curPair.first);
 498     }
 499     allCurrencyIDs.insert(ConnectedChains.ThisChain().GetID());
 500     if (!isVerusActive)
 501     {
 502         allCurrencyIDs.insert(ConnectedChains.notaryChain.GetID());
 503     }
 504
 505     bool isCoinbase = thisTx.IsCoinBase();
 506     bool isVerified = false;
 507     CIdentity activatedID(thisTx);
 508
 509     // currency definitions can be valid as follows:
 510     // 1. original definition in a transaction that simultaneously sets the active currency bit on the identity of the same
 511     //    name and ID.
 512     // 2. outputs of a coinbase transaction in block 1 that defines the parent currency, new currency, and any reserve currencies
 513     // 3. currency import from the defining chain of the currency, which has not been implemented as of this comment
 514     if (activatedID.IsValid() &&
 515         activatedID.HasActiveCurrency() &&
 516         chainDefs.size() == 1 &&
 517         activatedID.parent == ASSETCHAINS_CHAINID &&
 518         activatedID.GetID() == chainDefs[0].GetID())
 519     {
 520         isVerified = true;
 521     }
 522     else if (isCoinbase && chainDefs.size() >= 1 && !isVerusActive)
 523     {
 524         int32_t height1 = 1;
 525         CScript expect = CScript() << height1;
 526         opcodetype opcode = (opcodetype)*expect.begin();
 527
 528         if (opcode >= OP_1 && opcode <= OP_16)
 529         {
 530             isVerified = (thisTx.vin[0].scriptSig.size() >= 1 && CScript::DecodeOP_N(opcode) == height1) ||
 531                             (thisTx.vin[0].scriptSig.size() >= 2 && thisTx.vin[0].scriptSig[0] == OP_PUSHDATA1 && (int)thisTx.vin[0].scriptSig[1] == height1);
 532         }
 533         else
 534         {
 535             isVerified = thisTx.vin[0].scriptSig.size() >= expect.size() && std::equal(expect.begin(), expect.end(), thisTx.vin[0].scriptSig.begin());
 536         }
 537
 538         for (auto &chainDef : chainDefs)
 539         {
 540             uint160 chainID = chainDef.GetID();
 541             if (!chainDef.IsValid())
 542             {
 543                 LogPrintf("transaction specified, %s, must not contain invalid chain definitions\n", tx.vin[nIn].prevout.hash.GetHex().c_str());
 544                 return false;
 545             }
 546             if (!allCurrencyIDs.count(chainID))
 547             {
 548                 LogPrintf("transaction specified, %s, must not contain invalid chain definitions\n", tx.vin[nIn].prevout.hash.GetHex().c_str());
 549                 return false;
 550             }
 551             allCurrencyIDs.erase(chainID);
 552         }
 553         if (allCurrencyIDs.size())
 554         {
 555             LogPrintf("transaction specified, %s, does not contain all required chain definitions\n", tx.vin[nIn].prevout.hash.GetHex().c_str());
 556             return false;
 557         }
 558     }
 559
 560     return isVerified;
 561 }
 562
 563 CCurrencyValueMap CCrossChainExport::CalculateExportFee(const CCurrencyValueMap &fees, int numIn)
 564 {
 565     CCurrencyValueMap retVal;
 566
 567     if (numIn > MAX_EXPORT_INPUTS)
 568     {
 569         return retVal;
 570     }
 571     static const arith_uint256 satoshis(100000000);
 572
 573     arith_uint256 ratio(50000000 + ((25000000 / MAX_EXPORT_INPUTS) * (numIn - 1)));
 574
 575     for (auto &feePair : fees.valueMap)
 576     {
 577         retVal.valueMap[feePair.first] = (((arith_uint256(feePair.second) * ratio)) / satoshis).GetLow64();
 578     }
 579     return retVal;
 580 }
 581
 582 CCurrencyValueMap CCrossChainExport::CalculateExportFee() const
 583 {
 584     return CalculateExportFee(totalFees, numInputs);
 585 }
 586
 587 CCurrencyValueMap CCrossChainExport::CalculateImportFee() const
 588 {
 589     CCurrencyValueMap retVal;
 590
 591     for (auto &feePair : CalculateExportFee().valueMap)
 592     {
 593         CAmount feeAmount = feePair.second;
 594         auto it = totalFees.valueMap.find(feePair.first);
 595         retVal.valueMap[feePair.first] = (it != totalFees.valueMap.end() ? it->second : 0) - feeAmount;
 596     }
 597     return retVal;
 598 }
 599
 600 bool CConnectedChains::RemoveMergedBlock(uint160 chainID)
 601 {
 602     bool retval = false;
 603     LOCK(cs_mergemining);
 604
 605     //printf("RemoveMergedBlock ID: %s\n", chainID.GetHex().c_str());
 606
 607     auto chainIt = mergeMinedChains.find(chainID);
 608     if (chainIt != mergeMinedChains.end())
 609     {
 610         arith_uint256 target;
 611         target.SetCompact(chainIt->second.block.nBits);
 612         for (auto removeRange = mergeMinedTargets.equal_range(target); removeRange.first != removeRange.second; removeRange.first++)
 613         {
 614             // make sure we don't just match by target
 615             if (removeRange.first->second->GetID() == chainID)
 616             {
 617                 mergeMinedTargets.erase(removeRange.first);
 618                 break;
 619             }
 620         }
 621         mergeMinedChains.erase(chainID);
 622         dirty = retval = true;
 623
 624         // if we get to 0, give the thread a kick to stop waiting for mining
 625         //if (!mergeMinedChains.size())
 626         //{
 627         //    sem_submitthread.post();
 628         //}
 629     }
 630     return retval;
 631 }
 632
 633 // remove merge mined chains added and not updated since a specific time
 634 void CConnectedChains::PruneOldChains(uint32_t pruneBefore)
 635 {
 636     vector<uint160> toRemove;
 637
 638     LOCK(cs_mergemining);
 639     for (auto blkData : mergeMinedChains)
 640     {
 641         if (blkData.second.block.nTime < pruneBefore)
 642         {
 643             toRemove.push_back(blkData.first);
 644         }
 645     }
 646
 647     for (auto id : toRemove)
 648     {
 649         //printf("Pruning chainID: %s\n", id.GetHex().c_str());
 650         RemoveMergedBlock(id);
 651     }
 652 }
 653
 654 // adds or updates merge mined blocks
 655 // returns false if failed to add
 656 bool CConnectedChains::AddMergedBlock(CPBaaSMergeMinedChainData &blkData)
 657 {
 658     // determine if we should replace one or add to the merge mine vector
 659     {
 660         LOCK(cs_mergemining);
 661
 662         arith_uint256 target;
 663         uint160 cID = blkData.GetID();
 664         auto it = mergeMinedChains.find(cID);
 665         if (it != mergeMinedChains.end())
 666         {
 667             RemoveMergedBlock(cID);             // remove it if already there
 668         }
 669         target.SetCompact(blkData.block.nBits);
 670
 671         //printf("AddMergedBlock name: %s, ID: %s\n", blkData.chainDefinition.name.c_str(), cID.GetHex().c_str());
 672
 673         mergeMinedTargets.insert(make_pair(target, &(mergeMinedChains.insert(make_pair(cID, blkData)).first->second)));
 674         dirty = true;
 675     }
 676     return true;
 677 }
 678
 679 bool CConnectedChains::GetChainInfo(uint160 chainID, CRPCChainData &rpcChainData)
 680 {
 681     {
 682         LOCK(cs_mergemining);
 683         auto chainIt = mergeMinedChains.find(chainID);
 684         if (chainIt != mergeMinedChains.end())
 685         {
 686             rpcChainData = (CRPCChainData)chainIt->second;
 687             return true;
 688         }
 689         return false;
 690     }
 691 }
 692
 693 // this returns a pointer to the data without copy and assumes the lock is held
 694 CPBaaSMergeMinedChainData *CConnectedChains::GetChainInfo(uint160 chainID)
 695 {
 696     {
 697         auto chainIt = mergeMinedChains.find(chainID);
 698         if (chainIt != mergeMinedChains.end())
 699         {
 700             return &chainIt->second;
 701         }
 702         return NULL;
 703     }
 704 }
 705
 706 void CConnectedChains::QueueNewBlockHeader(CBlockHeader &bh)
 707 {
 708     //printf("QueueNewBlockHeader %s\n", bh.GetHash().GetHex().c_str());
 709     {
 710         LOCK(cs_mergemining);
 711
 712         qualifiedHeaders[UintToArith256(bh.GetHash())] = bh;
 713     }
 714     sem_submitthread.post();
 715 }
 716
 717 void CConnectedChains::CheckImports()
 718 {
 719     sem_submitthread.post();
 720 }
 721
 722 // get the latest block header and submit one block at a time, returning after there are no more
 723 // matching blocks to be found
 724 vector<pair<string, UniValue>> CConnectedChains::SubmitQualifiedBlocks()
 725 {
 726     std::set<uint160> inHeader;
 727     bool submissionFound;
 728     CPBaaSMergeMinedChainData chainData;
 729     vector<pair<string, UniValue>>  results;
 730
 731     CBlockHeader bh;
 732     arith_uint256 lastHash;
 733     CPBaaSBlockHeader pbh;
 734
 735     do
 736     {
 737         submissionFound = false;
 738         {
 739             LOCK(cs_mergemining);
 740             // attempt to submit with the lowest hash answers first to increase the likelihood of submitting
 741             // common, merge mined headers for notarization, drop out on any submission
 742             for (auto headerIt = qualifiedHeaders.begin(); !submissionFound && headerIt != qualifiedHeaders.end(); headerIt = qualifiedHeaders.begin())
 743             {
 744                 // add the PBaaS chain ids from this header to a set for search
 745                 for (uint32_t i = 0; headerIt->second.GetPBaaSHeader(pbh, i); i++)
 746                 {
 747                     inHeader.insert(pbh.chainID);
 748                 }
 749
 750                 uint160 chainID;
 751                 // now look through all targets that are equal to or above the hash of this header
 752                 for (auto chainIt = mergeMinedTargets.lower_bound(headerIt->first); !submissionFound && chainIt != mergeMinedTargets.end(); chainIt++)
 753                 {
 754                     chainID = chainIt->second->GetID();
 755                     if (inHeader.count(chainID))
 756                     {
 757                         // first, check that the winning header matches the block that is there
 758                         CPBaaSPreHeader preHeader(chainIt->second->block);
 759                         preHeader.SetBlockData(headerIt->second);
 760
 761                         // check if the block header matches the block's specific data, only then can we create a submission from this block
 762                         if (headerIt->second.CheckNonCanonicalData(chainID))
 763                         {
 764                             // save block as is, remove the block from merged headers, replace header, and submit
 765                             chainData = *chainIt->second;
 766
 767                             *(CBlockHeader *)&chainData.block = headerIt->second;
 768
 769                             submissionFound = true;
 770                         }
 771                         //else // not an error condition. code is here for debugging
 772                         //{
 773                         //    printf("Mismatch in non-canonical data for chain %s\n", chainIt->second->chainDefinition.name.c_str());
 774                         //}
 775                     }
 776                     //else // not an error condition. code is here for debugging
 777                     //{
 778                     //    printf("Not found in header %s\n", chainIt->second->chainDefinition.name.c_str());
 779                     //}
 780                 }
 781
 782                 // if this header matched no block, discard and move to the next, otherwise, we'll drop through
 783                 if (submissionFound)
 784                 {
 785                     // once it is going to be submitted, remove block from this chain until a new one is added again
 786                     RemoveMergedBlock(chainID);
 787                     break;
 788                 }
 789                 else
 790                 {
 791                     qualifiedHeaders.erase(headerIt);
 792                 }
 793             }
 794         }
 795         if (submissionFound)
 796         {
 797             // submit one block and loop again. this approach allows multiple threads
 798             // to collectively empty the submission queue, mitigating the impact of
 799             // any one stalled daemon
 800             UniValue submitParams(UniValue::VARR);
 801             submitParams.push_back(EncodeHexBlk(chainData.block));
 802             UniValue result, error;
 803             try
 804             {
 805                 result = RPCCall("submitblock", submitParams, chainData.rpcUserPass, chainData.rpcPort, chainData.rpcHost);
 806                 result = find_value(result, "result");
 807                 error = find_value(result, "error");
 808             }
 809             catch (exception e)
 810             {
 811                 result = UniValue(e.what());
 812             }
 813             results.push_back(make_pair(chainData.chainDefinition.name, result));
 814             if (result.isStr() || !error.isNull())
 815             {
 816                 printf("Error submitting block to %s chain: %s\n", chainData.chainDefinition.name.c_str(), result.isStr() ? result.get_str().c_str() : error.get_str().c_str());
 817             }
 818             else
 819             {
 820                 printf("Successfully submitted block to %s chain\n", chainData.chainDefinition.name.c_str());
 821             }
 822         }
 823     } while (submissionFound);
 824     return results;
 825 }
 826
 827 // add all merge mined chain PBaaS headers into the blockheader and return the easiest nBits target in the header
 828 uint32_t CConnectedChains::CombineBlocks(CBlockHeader &bh)
 829 {
 830     vector<uint160> inHeader;
 831     vector<UniValue> toCombine;
 832     arith_uint256 blkHash = UintToArith256(bh.GetHash());
 833     arith_uint256 target(0);
 834
 835     CPBaaSBlockHeader pbh;
 836
 837     {
 838         LOCK(cs_mergemining);
 839
 840         CPBaaSSolutionDescriptor descr = CVerusSolutionVector::solutionTools.GetDescriptor(bh.nSolution);
 841
 842         for (uint32_t i = 0; i < descr.numPBaaSHeaders; i++)
 843         {
 844             if (bh.GetPBaaSHeader(pbh, i))
 845             {
 846                 inHeader.push_back(pbh.chainID);
 847             }
 848         }
 849
 850         // loop through the existing PBaaS chain ids in the header
 851         // remove any that are not either this Chain ID or in our local collection and then add all that are present
 852         for (uint32_t i = 0; i < inHeader.size(); i++)
 853         {
 854             auto it = mergeMinedChains.find(inHeader[i]);
 855             if (inHeader[i] != ASSETCHAINS_CHAINID && (it == mergeMinedChains.end()))
 856             {
 857                 bh.DeletePBaaSHeader(i);
 858             }
 859         }
 860
 861         for (auto chain : mergeMinedChains)
 862         {
 863             // get the native PBaaS header for each chain and put it into the
 864             // header we are given
 865             // it must have itself in as a PBaaS header
 866             uint160 cid = chain.second.GetID();
 867             if (chain.second.block.GetPBaaSHeader(pbh, cid) != -1)
 868             {
 869                 if (!bh.AddUpdatePBaaSHeader(pbh))
 870                 {
 871                     LogPrintf("Failure to add PBaaS block header for %s chain\n", chain.second.chainDefinition.name.c_str());
 872                     break;
 873                 }
 874                 else
 875                 {
 876                     arith_uint256 t;
 877                     t.SetCompact(chain.second.block.nBits);
 878                     if (t > target)
 879                     {
 880                         target = t;
 881                     }
 882                 }
 883             }
 884             else
 885             {
 886                 LogPrintf("Merge mined block for %s does not contain PBaaS information\n", chain.second.chainDefinition.name.c_str());
 887             }
 888         }
 889         dirty = false;
 890     }
 891
 892     return target.GetCompact();
 893 }
 894
 895 bool CConnectedChains::IsVerusPBaaSAvailable()
 896 {
 897     return notaryChainVersion >= "0.8.0";
 898 }
 899
 900 extern string PBAAS_HOST, PBAAS_USERPASS;
 901 extern int32_t PBAAS_PORT;
 902 bool CConnectedChains::CheckVerusPBaaSAvailable(UniValue &chainInfoUni, UniValue &chainDefUni)
 903 {
 904     if (chainInfoUni.isObject() && chainDefUni.isObject())
 905     {
 906         UniValue uniVer = find_value(chainInfoUni, "VRSCversion");
 907         if (uniVer.isStr())
 908         {
 909             LOCK(cs_mergemining);
 910             notaryChainVersion = uni_get_str(uniVer);
 911             notaryChainHeight = uni_get_int(find_value(chainInfoUni, "blocks"));
 912             CCurrencyDefinition chainDef(chainDefUni);
 913             notaryChain = CRPCChainData(chainDef, PBAAS_HOST, PBAAS_PORT, PBAAS_USERPASS);
 914         }
 915     }
 916     return IsVerusPBaaSAvailable();
 917 }
 918
 919 uint32_t CConnectedChains::NotaryChainHeight()
 920 {
 921     LOCK(cs_mergemining);
 922     return notaryChainHeight;
 923 }
 924
 925 bool CConnectedChains::CheckVerusPBaaSAvailable()
 926 {
 927     if (IsVerusActive())
 928     {
 929         notaryChainVersion = "";
 930     }
 931     else
 932     {
 933         // if this is a PBaaS chain, poll for presence of Verus / root chain and current Verus block and version number
 934         // tolerate only 15 second timeout
 935         UniValue chainInfo, chainDef;
 936         try
 937         {
 938             UniValue params(UniValue::VARR);
 939             chainInfo = find_value(RPCCallRoot("getinfo", params), "result");
 940             if (!chainInfo.isNull())
 941             {
 942                 params.push_back(VERUS_CHAINNAME);
 943                 chainDef = find_value(RPCCallRoot("getcurrency", params), "result");
 944
 945                 if (!chainDef.isNull() && CheckVerusPBaaSAvailable(chainInfo, chainDef))
 946                 {
 947                     // if we have not past block 1 yet, store the best known update of our current state
 948                     if ((!chainActive.LastTip() || !chainActive.LastTip()->GetHeight()))
 949                     {
 950                         bool success = false;
 951                         params.clear();
 952                         params.push_back(EncodeDestination(CIdentityID(thisChain.GetID())));
 953                         chainDef = find_value(RPCCallRoot("getcurrency", params), "result");
 954                         if (!chainDef.isNull())
 955                         {
 956                             CCurrencyDefinition currencyDef(chainDef);
 957                             if (currencyDef.IsValid())
 958                             {
 959                                 thisChain = currencyDef;
 960                                 if (NotaryChainHeight() >= thisChain.startBlock)
 961                                 {
 962                                     readyToStart = true;    // this only gates mining of block one, to be sure we have the latest definition
 963                                 }
 964                                 success = true;
 965                             }
 966                         }
 967                         return success;
 968                     }
 969                     return true;
 970                 }
 971             }
 972         } catch (exception e)
 973         {
 974             LogPrintf("%s: Error communicating with %s chain\n", __func__, VERUS_CHAINNAME);
 975         }
 976     }
 977     notaryChainVersion = "";
 978     return false;
 979 }
 980
 981 int CConnectedChains::GetThisChainPort() const
 982 {
 983     int port;
 984     string host;
 985     for (auto node : defaultPeerNodes)
 986     {
 987         SplitHostPort(node.networkAddress, port, host);
 988         if (port)
 989         {
 990             return port;
 991         }
 992     }
 993     return 0;
 994 }
 995
 996 CCoinbaseCurrencyState CConnectedChains::GetCurrencyState(CCurrencyDefinition &curDef, int32_t height, int32_t curDefHeight)
 997 {
 998     uint160 chainID = curDef.GetID();
 999     CCoinbaseCurrencyState currencyState;
1000     std::vector<CAddressIndexDbEntry> notarizationIndex;
1001
1002     if (chainID == ASSETCHAINS_CHAINID)
1003     {
1004         CBlock block;
1005         if (IsVerusActive() ||
1006             CConstVerusSolutionVector::activationHeight.ActiveVersion(height) < CActivationHeight::ACTIVATE_PBAAS ||
1007             height == 0 ||
1008             height > chainActive.Height() ||
1009             !chainActive[height] ||
1010             !ReadBlockFromDisk(block, chainActive[height], Params().GetConsensus()) ||
1011             !(currencyState = CCoinbaseCurrencyState(block.vtx[0])).IsValid())
1012         {
1013             currencyState = GetInitialCurrencyState(thisChain);
1014         }
1015     }
1016     // if this is a token on this chain, it will be simply notarized
1017     else if (curDef.systemID == ASSETCHAINS_CHAINID)
1018     {
1019         // get the last unspent notarization for this currency, which is valid by definition for a token
1020         CPBaaSNotarization notarization;
1021         if (notarization.GetLastNotarization(chainID, EVAL_ACCEPTEDNOTARIZATION, curDefHeight, height))
1022         {
1023             currencyState = notarization.currencyState;
1024             currencyState.ClearForNextBlock();
1025
1026             // if notarization is earlier than start block, get the transactions between this notarization and
1027             // current height to add to currency totals
1028             if (notarization.notarizationHeight < curDef.startBlock)
1029             {
1030                 // get chain transfers that should apply before the start block
1031                 // until there is a post-start block notarization, we always consider the
1032                 // currency state to be up to just before the start block
1033                 std::multimap<uint160, std::pair<CInputDescriptor, CReserveTransfer>> unspentTransfers;
1034                 if (GetChainTransfers(unspentTransfers, chainID, notarization.notarizationHeight,
1035                                       height < curDef.startBlock ? height : curDef.startBlock - 1))
1036                 {
1037                     // at this point, all pre-allocation, minted, and pre-converted currency are included
1038                     // in the currency state before final notarization
1039                     std::map<uint160, int32_t> currencyIndexes = currencyState.GetReserveMap();
1040                     if (curDef.IsFractional())
1041                     {
1042                         currencyState.supply = curDef.initialFractionalSupply;
1043                     }
1044                     else
1045                     {
1046                         // supply is determined by purchases * current conversion rate
1047                         currencyState.supply = currencyState.initialSupply;
1048                     }
1049
1050                     for (auto &transfer : unspentTransfers)
1051                     {
1052                         if (transfer.second.second.flags & CReserveTransfer::PRECONVERT)
1053                         {
1054                             CAmount conversionFee = CReserveTransactionDescriptor::CalculateConversionFee(transfer.second.second.nValue);
1055
1056                             currencyState.reserveIn[currencyIndexes[transfer.second.second.currencyID]] += transfer.second.second.nValue;
1057                             curDef.preconverted[currencyIndexes[transfer.second.second.currencyID]] += transfer.second.second.nValue;
1058                             if (curDef.IsFractional())
1059                             {
1060                                 currencyState.reserves[currencyIndexes[transfer.second.second.currencyID]] += transfer.second.second.nValue - conversionFee;
1061                             }
1062                             else
1063                             {
1064                                 currencyState.supply += CCurrencyState::ReserveToNativeRaw(transfer.second.second.nValue - conversionFee, currencyState.PriceInReserve(currencyIndexes[transfer.second.second.currencyID]));
1065                             }
1066
1067                             if (transfer.second.second.currencyID == curDef.systemID)
1068                             {
1069                                 currencyState.nativeConversionFees += conversionFee;
1070                                 currencyState.nativeFees += conversionFee + transfer.second.second.CalculateTransferFee(transfer.second.second.destination);
1071                             }
1072                             else
1073                             {
1074                                 currencyState.fees[currencyIndexes[transfer.second.second.currencyID]] +=
1075                                             conversionFee + transfer.second.second.CalculateTransferFee(transfer.second.second.destination);
1076                                 currencyState.conversionFees[currencyIndexes[transfer.second.second.currencyID]] += conversionFee;
1077                             }
1078                         }
1079                         else if (transfer.second.second.flags & CReserveTransfer::PREALLOCATE)
1080                         {
1081                             currencyState.emitted += transfer.second.second.nValue;
1082                         }
1083                     }
1084                     currencyState.supply += currencyState.emitted;
1085                     if (curDef.conversions.size() != curDef.currencies.size())
1086                     {
1087                         curDef.conversions = std::vector<int64_t>(curDef.currencies.size());
1088                     }
1089                     for (int i = 0; i < curDef.conversions.size(); i++)
1090                     {
1091                         currencyState.conversionPrice[i] = curDef.conversions[i] = currencyState.PriceInReserve(i);
1092                     }
1093                 }
1094             }
1095         }
1096     }
1097     else
1098     {
1099         CChainNotarizationData cnd;
1100         uint32_t ecode = IsVerusActive() ?
1101                          EVAL_ACCEPTEDNOTARIZATION :
1102                          (chainID == notaryChain.GetID() ? EVAL_EARNEDNOTARIZATION : EVAL_ACCEPTEDNOTARIZATION);
1103         if (GetNotarizationData(chainID, ecode, cnd))
1104         {
1105             int32_t transfersFrom = curDefHeight;
1106             if (cnd.lastConfirmed != -1)
1107             {
1108                 transfersFrom = cnd.vtx[cnd.lastConfirmed].second.notarizationHeight;
1109             }
1110             int32_t transfersUntil = cnd.lastConfirmed == -1 ? curDef.startBlock - 1 :
1111                                        (cnd.vtx[cnd.lastConfirmed].second.notarizationHeight < curDef.startBlock ?
1112                                         (height < curDef.startBlock ? height : curDef.startBlock - 1) :
1113                                         cnd.vtx[cnd.lastConfirmed].second.notarizationHeight);
1114             if (transfersUntil < curDef.startBlock)
1115             {
1116                 // get chain transfers that should apply before the start block
1117                 // until there is a post-start block notarization, we always consider the
1118                 // currency state to be up to just before the start block
1119                 std::multimap<uint160, std::pair<CInputDescriptor, CReserveTransfer>> unspentTransfers;
1120                 if (GetChainTransfers(unspentTransfers, chainID, transfersFrom, transfersUntil))
1121                 {
1122                     // at this point, all pre-allocation, minted, and pre-converted currency are included
1123                     // in the currency state before final notarization
1124                     std::map<uint160, int32_t> currencyIndexes = currencyState.GetReserveMap();
1125                     if (curDef.IsFractional())
1126                     {
1127                         currencyState.supply = curDef.initialFractionalSupply;
1128                     }
1129                     else
1130                     {
1131                         // supply is determined by purchases * current conversion rate
1132                         currencyState.supply = currencyState.initialSupply;
1133                     }
1134
1135                     for (auto &transfer : unspentTransfers)
1136                     {
1137                         if (transfer.second.second.flags & CReserveTransfer::PRECONVERT)
1138                         {
1139                             CAmount conversionFee = CReserveTransactionDescriptor::CalculateConversionFee(transfer.second.second.nValue);
1140
1141                             currencyState.reserveIn[currencyIndexes[transfer.second.second.currencyID]] += transfer.second.second.nValue;
1142                             curDef.preconverted[currencyIndexes[transfer.second.second.currencyID]] += transfer.second.second.nValue;
1143                             if (curDef.IsFractional())
1144                             {
1145                                 currencyState.reserves[currencyIndexes[transfer.second.second.currencyID]] += transfer.second.second.nValue - conversionFee;
1146                             }
1147                             else
1148                             {
1149                                 currencyState.supply += CCurrencyState::ReserveToNativeRaw(transfer.second.second.nValue - conversionFee, currencyState.PriceInReserve(currencyIndexes[transfer.second.second.currencyID]));
1150                             }
1151
1152                             if (transfer.second.second.currencyID == curDef.systemID)
1153                             {
1154                                 currencyState.nativeConversionFees += conversionFee;
1155                                 currencyState.nativeFees += conversionFee + transfer.second.second.CalculateTransferFee(transfer.second.second.destination);
1156                             }
1157                             else
1158                             {
1159                                 currencyState.fees[currencyIndexes[transfer.second.second.currencyID]] +=
1160                                             conversionFee + transfer.second.second.CalculateTransferFee(transfer.second.second.destination);
1161                                 currencyState.conversionFees[currencyIndexes[transfer.second.second.currencyID]] += conversionFee;
1162                             }
1163                         }
1164                         else if (transfer.second.second.flags & CReserveTransfer::PREALLOCATE)
1165                         {
1166                             currencyState.emitted += transfer.second.second.nValue;
1167                         }
1168                     }
1169                     currencyState.supply += currencyState.emitted;
1170                     if (curDef.conversions.size() != curDef.currencies.size())
1171                     {
1172                         curDef.conversions = std::vector<int64_t>(curDef.currencies.size());
1173                     }
1174                     for (int i = 0; i < curDef.conversions.size(); i++)
1175                     {
1176                         currencyState.conversionPrice[i] = curDef.conversions[i] = currencyState.PriceInReserve(i);
1177                     }
1178                 }
1179             }
1180             else
1181             {
1182                 std::pair<uint256, CPBaaSNotarization> notPair = cnd.lastConfirmed != -1 ? cnd.vtx[cnd.lastConfirmed] : cnd.vtx[cnd.forks[cnd.bestChain][0]];
1183                 currencyState = notPair.second.currencyState;
1184             }
1185         }
1186     }
1187     return currencyState;
1188 }
1189
1190 CCoinbaseCurrencyState CConnectedChains::GetCurrencyState(const uint160 &currencyID, int32_t height)
1191 {
1192     int32_t curDefHeight;
1193     CCurrencyDefinition curDef;
1194     if (GetCurrencyDefinition(currencyID, curDef, &curDefHeight))
1195     {
1196         return GetCurrencyState(curDef, height, curDefHeight);
1197     }
1198     else
1199     {
1200         LogPrintf("%s: currency %s:%s not found\n", __func__, currencyID.GetHex().c_str(), EncodeDestination(CIdentityID(currencyID)).c_str());
1201         printf("%s: currency %s:%s not found\n", __func__, currencyID.GetHex().c_str(), EncodeDestination(CIdentityID(currencyID)).c_str());
1202     }
1203     return CCoinbaseCurrencyState();
1204 }
1205
1206 CCoinbaseCurrencyState CConnectedChains::GetCurrencyState(int32_t height)
1207 {
1208     return GetCurrencyState(thisChain.GetID(), height);
1209 }
1210
1211 bool CConnectedChains::SetLatestMiningOutputs(const std::vector<pair<int, CScript>> &minerOutputs, CTxDestination &firstDestinationOut)
1212 {
1213     LOCK(cs_mergemining);
1214
1215     if (!minerOutputs.size() || !ExtractDestination(minerOutputs[0].second, firstDestinationOut))
1216     {
1217         return false;
1218     }
1219     latestMiningOutputs = minerOutputs;
1220     latestDestination = firstDestinationOut;
1221     return true;
1222 }
1223
1224 CCurrencyDefinition CConnectedChains::GetCachedCurrency(const uint160 &currencyID)
1225 {
1226     CCurrencyDefinition currencyDef;
1227     auto it = currencyDefCache.find(currencyID);
1228     if ((it != currencyDefCache.end() && !(currencyDef = it->second).IsValid()) ||
1229         (it == currencyDefCache.end() && !GetCurrencyDefinition(currencyID, currencyDef)))
1230     {
1231         printf("%s: definition for transfer currency ID %s not found\n\n", __func__, EncodeDestination(CIdentityID(currencyID)).c_str());
1232         LogPrintf("%s: definition for transfer currency ID %s not found\n\n", __func__, EncodeDestination(CIdentityID(currencyID)).c_str());
1233         return currencyDef;
1234     }
1235     if (it == currencyDefCache.end())
1236     {
1237         currencyDefCache[currencyID] = currencyDef;
1238     }
1239     return currencyDefCache[currencyID];
1240 }
1241
1242 CCurrencyDefinition CConnectedChains::UpdateCachedCurrency(const uint160 &currencyID, uint32_t height)
1243 {
1244     // due to the main lock being taken on the thread that waits for transaction checks,
1245     // low level functions like this must be called either from a thread that holds LOCK(cs_main),
1246     // or script validation, where it is held either by this thread or one waiting for it.
1247     // in the long run, the daemon synchonrization model should be improved
1248     CCurrencyDefinition currencyDef = GetCachedCurrency(currencyID);
1249     CCoinbaseCurrencyState curState = GetCurrencyState(currencyDef, height);
1250     currencyDefCache[currencyID] = currencyDef;
1251     return currencyDef;
1252 }
1253
1254 void CConnectedChains::AggregateChainTransfers(const CTxDestination &feeOutput, uint32_t nHeight)
1255 {
1256     // all chains aggregate reserve transfer transactions, so aggregate and add all necessary export transactions to the mem pool
1257     {
1258         if (!nHeight)
1259         {
1260             return;
1261         }
1262
1263         std::multimap<uint160, std::pair<CInputDescriptor, CReserveTransfer>> transferOutputs;
1264
1265         LOCK(cs_main);
1266
1267         uint160 thisChainID = ConnectedChains.ThisChain().GetID();
1268
1269         // get all available transfer outputs to aggregate into export transactions
1270         if (GetUnspentChainTransfers(transferOutputs))
1271         {
1272             if (!transferOutputs.size())
1273             {
1274                 return;
1275             }
1276
1277             std::vector<pair<CInputDescriptor, CReserveTransfer>> txInputs;
1278             uint160 bookEnd({uint160(ParseHex("ffffffffffffffffffffffffffffffffffffffff"))});
1279             uint160 lastChain = bookEnd;
1280             transferOutputs.insert(std::make_pair(bookEnd, std::make_pair(CInputDescriptor(), CReserveTransfer())));
1281             CCurrencyDefinition lastChainDef;
1282
1283             for (auto &output : transferOutputs)
1284             {
1285                 CCurrencyDefinition sourceDef, destDef, systemDef;
1286
1287                 if (output.first != bookEnd)
1288                 {
1289                     if (!output.second.second.IsValid())
1290                     {
1291                         printf("%s: invalid reserve transfer in index for currency %s\n", __func__, EncodeDestination(CIdentityID(output.second.second.currencyID)).c_str());
1292                         LogPrintf("%s: invalid reserve transfer in index for currency %s\n", __func__, EncodeDestination(CIdentityID(output.second.second.currencyID)).c_str());
1293                         continue;
1294                     }
1295
1296                     sourceDef = GetCachedCurrency(output.second.second.currencyID);
1297                     destDef = GetCachedCurrency(output.second.second.destCurrencyID);
1298                     systemDef = GetCachedCurrency(destDef.systemID);
1299
1300                     if (!sourceDef.IsValid())
1301                     {
1302                         printf("%s: cannot find source currency %s\n", __func__, EncodeDestination(CIdentityID(output.second.second.currencyID)).c_str());
1303                         LogPrintf("%s: cannot find source currency %s\n", __func__, EncodeDestination(CIdentityID(output.second.second.currencyID)).c_str());
1304                         continue;
1305                     }
1306                     if (!destDef.IsValid())
1307                     {
1308                         printf("%s: cannot find destination currency %s\n", __func__, EncodeDestination(CIdentityID(output.second.second.destCurrencyID)).c_str());
1309                         LogPrintf("%s: cannot find destination currency %s\n", __func__, EncodeDestination(CIdentityID(output.second.second.destCurrencyID)).c_str());
1310                         continue;
1311                     }
1312                     if (!systemDef.IsValid())
1313                     {
1314                         printf("%s: cannot find destination system definition %s\n", __func__, EncodeDestination(CIdentityID(destDef.systemID)).c_str());
1315                         LogPrintf("%s: cannot find destination system definition %s\n", __func__, EncodeDestination(CIdentityID(destDef.systemID)).c_str());
1316                         continue;
1317                     }
1318
1319                     // if destination is a token on the current chain, consider it its own system
1320                     if (destDef.systemID == thisChainID)
1321                     {
1322                         systemDef = destDef;
1323                     }
1324                 }
1325
1326                 // get chain target and see if it is the same
1327                 if (lastChain == bookEnd || output.first == lastChain)
1328                 {
1329                     txInputs.push_back(output.second);
1330                 }
1331                 else
1332                 {
1333                     // when we get here, we have a consecutive number of transfer outputs to consume in txInputs
1334                     // we need an unspent export output to export, or use the last one of it is an export to the same
1335                     // system
1336                     std::multimap<uint160, pair<int, CInputDescriptor>> exportOutputs;
1337                     lastChainDef = UpdateCachedCurrency(lastChain, nHeight);
1338
1339                     if (GetUnspentChainExports(lastChain, exportOutputs) && exportOutputs.size())
1340                     {
1341                         auto &lastExport = *exportOutputs.begin();
1342                         bool oneFullSize = txInputs.size() >= CCrossChainExport::MIN_INPUTS;
1343
1344                         if (((nHeight - lastExport.second.first) >= CCrossChainExport::MIN_BLOCKS) || oneFullSize)
1345                         {
1346                             boost::optional<CTransaction> oneExport;
1347
1348                             // make one or more transactions that spends the last export and all possible cross chain transfers
1349                             while (txInputs.size())
1350                             {
1351                                 TransactionBuilder tb(Params().GetConsensus(), nHeight);
1352
1353                                 int inputsLeft = txInputs.size();
1354                                 int numInputs = inputsLeft > CCrossChainExport::MAX_EXPORT_INPUTS ? CCrossChainExport::MAX_EXPORT_INPUTS : inputsLeft;
1355
1356                                 if (numInputs > CCrossChainExport::MAX_EXPORT_INPUTS)
1357                                 {
1358                                     numInputs = CCrossChainExport::MAX_EXPORT_INPUTS;
1359                                 }
1360                                 inputsLeft = txInputs.size() - numInputs;
1361
1362                                 // if we have already made one and don't have enough to make another
1363                                 // without going under the input minimum, wait until next time for the others
1364                                 if (numInputs > 0 && numInputs < CCrossChainExport::MIN_INPUTS && oneFullSize)
1365                                 {
1366                                     break;
1367                                 }
1368
1369                                 // each time through, we make one export transaction with the remainder or a subset of the
1370                                 // reserve transfer inputs. inputs can be:
1371                                 // 1. transfers of reserve for fractional reserve chains
1372                                 // 2. pre-conversions for pre-launch participation in the premine
1373                                 // 3. reserve market conversions to send between Verus and a fractional reserve chain and always output the native coin
1374                                 //
1375                                 // If we are on the Verus chain, all inputs will include native coins. On a PBaaS chain, inputs can either be native
1376                                 // or reserve token inputs.
1377                                 //
1378                                 // On the Verus chain, total native amount, minus the fee, must be sent to the reserve address of the specific chain
1379                                 // as reserve deposit with native coin equivalent. Pre-conversions and conversions will be realized on the PBaaS chain
1380                                 // as part of the import process
1381                                 //
1382                                 // If we are on the PBaaS chain, conversions must happen before coins are sent this way back to the reserve chain.
1383                                 // Verus reserve outputs can be directly aggregated and transferred, with fees paid through conversion and the
1384                                 // remaining Verus reserve coin will be burned on the PBaaS chain as spending it is allowed, once notarized, on the
1385                                 // Verus chain.
1386                                 //
1387                                 CCurrencyValueMap totalTxFees;
1388                                 CCurrencyValueMap totalAmounts;
1389                                 CAmount exportOutVal = 0;
1390                                 std::vector<CBaseChainObject *> chainObjects;
1391
1392                                 // first, we must add the export output from the current export thread to this chain
1393                                 if (oneExport.is_initialized())
1394                                 {
1395                                     // spend the last export transaction output
1396                                     CTransaction &tx = oneExport.get();
1397                                     COptCCParams p;
1398                                     int j;
1399                                     for (j = 0; j < tx.vout.size(); j++)
1400                                     {
1401                                         if (::IsPayToCryptoCondition(tx.vout[j].scriptPubKey, p) && p.evalCode == EVAL_CROSSCHAIN_EXPORT)
1402                                         {
1403                                             break;
1404                                         }
1405                                     }
1406
1407                                     // had to be found and valid if we made the tx
1408                                     assert(j < tx.vout.size() && p.IsValid());
1409
1410                                     tb.AddTransparentInput(COutPoint(tx.GetHash(), j), tx.vout[j].scriptPubKey, tx.vout[j].nValue);
1411                                     exportOutVal = tx.vout[j].nValue;
1412                                 }
1413                                 else
1414                                 {
1415                                     // spend the recentExportIt output
1416                                     tb.AddTransparentInput(lastExport.second.second.txIn.prevout, lastExport.second.second.scriptPubKey, lastExport.second.second.nValue);
1417                                     exportOutVal = lastExport.second.second.nValue;
1418                                 }
1419
1420                                 COptCCParams p;
1421                                 std::vector<int> toRemove;
1422
1423                                 for (int j = 0; j < numInputs; j++)
1424                                 {
1425                                     tb.AddTransparentInput(txInputs[j].first.txIn.prevout, txInputs[j].first.scriptPubKey, txInputs[j].first.nValue, txInputs[j].first.txIn.nSequence);
1426                                     CCurrencyValueMap newTransferInput = txInputs[j].first.scriptPubKey.ReserveOutValue();
1427                                     newTransferInput.valueMap[ASSETCHAINS_CHAINID] = txInputs[j].first.nValue;
1428
1429                                     // TODO: make fee currency calculation more flexible on conversion
1430                                     // rules should be pay fee in native currency of destination system
1431                                     // if source is same currency
1432                                     CCurrencyValueMap newTransferOutput;
1433                                     bool isMint = (txInputs[j].second.flags & (CReserveTransfer::PREALLOCATE | CReserveTransfer::MINT_CURRENCY));
1434                                     if (isMint)
1435                                     {
1436                                         newTransferOutput.valueMap[txInputs[j].second.currencyID] = txInputs[j].second.nFees;
1437                                     }
1438                                     else
1439                                     {
1440                                         newTransferOutput.valueMap[txInputs[j].second.currencyID] = txInputs[j].second.nValue + txInputs[j].second.nFees;
1441                                     }
1442
1443                                     //printf("input:\n%s\n", newTransferInput.ToUniValue().write().c_str());
1444                                     //printf("output:\n%s\n", newTransferOutput.ToUniValue().write().c_str());
1445
1446                                     if ((newTransferInput - newTransferOutput).HasNegative())
1447                                     {
1448                                         // if this transfer is invalid and claims to carry more funds than it does, we consume it since it won't properly verify as a transfer, and
1449                                         // it is too expensive to let it force evaluation repeatedly. this condition should not get by normal checks, but just in case, don't let it slow transfers
1450                                         // we should formalize this into a chain contribution or amount adjustment.
1451                                         printf("%s: transaction %s claims incorrect value:\n%s\nactual:\n%s\n", __func__,
1452                                                     txInputs[j].first.txIn.prevout.hash.GetHex().c_str(),
1453                                                     newTransferInput.ToUniValue().write().c_str(),
1454                                                     newTransferOutput.ToUniValue().write().c_str());
1455                                         LogPrintf("%s: transaction %s claims incorrect value:\n%s\nactual:\n%s\n", __func__,
1456                                                     txInputs[j].first.txIn.prevout.hash.GetHex().c_str(),
1457                                                     newTransferInput.ToUniValue().write().c_str(),
1458                                                     newTransferOutput.ToUniValue().write().c_str());
1459                                         toRemove.push_back(j);
1460                                     }
1461                                     else
1462                                     {
1463                                         CAmount valueOut = isMint ? 0 : txInputs[j].second.nValue;
1464                                         CCurrencyValueMap newFees;
1465                                         totalTxFees += txInputs[j].second.CalculateFee(txInputs[j].second.flags, valueOut);
1466                                         totalAmounts += newTransferInput;
1467                                         chainObjects.push_back(new CChainObject<CReserveTransfer>(ObjTypeCode(txInputs[j].second), txInputs[j].second));
1468                                     }
1469                                 }
1470
1471                                 // remove in reverse order so one removal does not affect the position of the next
1472                                 for (int j = toRemove.size() - 1; j >= 0; j--)
1473                                 {
1474                                     txInputs.erase(txInputs.begin() + toRemove[j]);
1475                                     numInputs--;
1476                                 }
1477
1478                                 // this logic may cause us to create a tx that will get rejected, but we will never wait too long
1479                                 if (!numInputs || (oneFullSize && (nHeight - lastExport.second.first) < CCrossChainExport::MIN_BLOCKS && numInputs < CCrossChainExport::MIN_INPUTS))
1480                                 {
1481                                     continue;
1482                                 }
1483
1484                                 //printf("%s: total export amounts:\n%s\n", __func__, totalAmounts.ToUniValue().write().c_str());
1485
1486                                 CCrossChainExport ccx(lastChain, numInputs, totalAmounts, totalTxFees);
1487
1488                                 // make extra outputs for fees in each currency
1489                                 for (auto &outPair : ccx.CalculateExportFee().CanonicalMap().valueMap)
1490                                 {
1491                                     CReserveTransfer feeOut(CReserveTransfer::VALID + CReserveTransfer::FEE_OUTPUT,
1492                                                             outPair.first, outPair.second, 0, outPair.first, DestinationToTransferDestination(feeOutput));
1493                                     chainObjects.push_back(new CChainObject<CReserveTransfer>(ObjTypeCode(feeOut), feeOut));
1494                                 }
1495
1496                                 // do a preliminary check
1497                                 CReserveTransactionDescriptor rtxd;
1498                                 std::vector<CTxOut> vOutputs;
1499                                 CCoinbaseCurrencyState currencyState = GetInitialCurrencyState(lastChainDef);
1500                                 if (!currencyState.IsValid() ||
1501                                     !rtxd.AddReserveTransferImportOutputs(ConnectedChains.ThisChain().GetID(), lastChainDef, currencyState, chainObjects, vOutputs))
1502                                 {
1503                                     DeleteOpRetObjects(chainObjects);
1504
1505                                     printf("%s: failed to create valid exports\n", __func__);
1506                                     LogPrintf("%s: failed to create valid exports\n", __func__);
1507
1508                                     // debugging output
1509                                     printf("%s: failed to export outputs:\n", __func__);
1510                                     for (auto oneout : vOutputs)
1511                                     {
1512                                         UniValue uniOut;
1513                                         ScriptPubKeyToJSON(oneout.scriptPubKey, uniOut, false);
1514                                         printf("%s\n", uniOut.write(true, 2).c_str());
1515                                     }
1516                                 }
1517                                 else
1518                                 {
1519                                     CCcontract_info CC;
1520                                     CCcontract_info *cp;
1521
1522                                     /*
1523                                     // debugging out
1524                                     printf("%s: exported outputs:\n", __func__);
1525                                     for (auto &oneout : chainObjects)
1526                                     {
1527                                         if (oneout->objectType == CHAINOBJ_RESERVETRANSFER)
1528                                         {
1529                                             CReserveTransfer &rt = ((CChainObject<CReserveTransfer> *)(oneout))->object;
1530                                             printf("%s\n", rt.ToUniValue().write(true, 2).c_str());
1531                                         }
1532                                     }
1533                                     */
1534
1535                                     CScript opRet = StoreOpRetArray(chainObjects);
1536                                     DeleteOpRetObjects(chainObjects);
1537
1538                                     // now send transferred currencies to a reserve deposit
1539                                     cp = CCinit(&CC, EVAL_RESERVE_DEPOSIT);
1540
1541                                     for (auto &oneCurrencyOut : ccx.totalAmounts.valueMap)
1542                                     {
1543                                         CCurrencyDefinition oneDef = currencyDefCache[oneCurrencyOut.first];
1544
1545                                         // if the destination is the not the source currency, and
1546                                         // the destination is not another blockchain that controls the source currency, store in reserve
1547                                         if (!(oneCurrencyOut.first == lastChain ||
1548                                             (lastChainDef.systemID != ASSETCHAINS_CHAINID && oneDef.systemID == lastChainDef.systemID)))
1549                                         {
1550                                             CAmount nativeOut = oneDef.GetID() == ASSETCHAINS_CHAINID ? oneCurrencyOut.second : 0;
1551
1552                                             // send the entire amount to a reserve deposit output of the specific chain
1553                                             // we receive our fee on the other chain, when it comes back, or if a token,
1554                                             // when it gets imported back to the chain
1555                                             std::vector<CTxDestination> indexDests({CKeyID(lastChainDef.GetConditionID(EVAL_RESERVE_DEPOSIT)), CKeyID(lastChainDef.GetID())});
1556                                             std::vector<CTxDestination> dests({CPubKey(ParseHex(CC.CChexstr))});
1557
1558                                             CTokenOutput ro = CTokenOutput(oneCurrencyOut.first, nativeOut ? 0 : oneCurrencyOut.second);
1559                                             tb.AddTransparentOutput(MakeMofNCCScript(CConditionObj<CTokenOutput>(EVAL_RESERVE_DEPOSIT, dests, 1, &ro), &indexDests),
1560                                                                     nativeOut);
1561                                         }
1562                                     }
1563
1564                                     cp = CCinit(&CC, EVAL_CROSSCHAIN_EXPORT);
1565
1566                                     // send native amount of zero to a cross chain export output of the specific chain
1567                                     std::vector<CTxDestination> indexDests = std::vector<CTxDestination>({CKeyID(lastChainDef.GetConditionID(EVAL_CROSSCHAIN_EXPORT))});
1568                                     if (lastChainDef.systemID != ASSETCHAINS_CHAINID)
1569                                     {
1570                                         indexDests.push_back(CKeyID(CCrossChainRPCData::GetConditionID(lastChainDef.systemID, EVAL_CROSSCHAIN_EXPORT)));
1571                                     }
1572                                     std::vector<CTxDestination> dests = std::vector<CTxDestination>({CPubKey(ParseHex(CC.CChexstr)).GetID()});
1573
1574                                     tb.AddTransparentOutput(MakeMofNCCScript(CConditionObj<CCrossChainExport>(EVAL_CROSSCHAIN_EXPORT, dests, 1, &ccx), &indexDests),
1575                                                             exportOutVal);
1576
1577                                     // when exports are confirmed as having been imported, they are finalized
1578                                     // until then, a finalization UTXO enables an index search to only find transactions
1579                                     // that have work to complete on this chain, or have not had their cross-chain import
1580                                     // acknowledged
1581                                     cp = CCinit(&CC, EVAL_FINALIZE_EXPORT);
1582                                     CTransactionFinalization finalization(0);
1583
1584                                     //printf("%s: Finalizing export with index dest %s\n", __func__, EncodeDestination(CKeyID(CCrossChainRPCData::GetConditionID(lastChainDef.systemID, EVAL_FINALIZE_EXPORT))).c_str());
1585
1586                                     indexDests = std::vector<CTxDestination>({CKeyID(CCrossChainRPCData::GetConditionID(lastChainDef.systemID, EVAL_FINALIZE_EXPORT))});
1587                                     dests = std::vector<CTxDestination>({CPubKey(ParseHex(CC.CChexstr)).GetID()});
1588                                     tb.AddTransparentOutput(MakeMofNCCScript(CConditionObj<CTransactionFinalization>(EVAL_FINALIZE_EXPORT, dests, 1, &finalization), &indexDests), 0);
1589
1590                                     tb.AddOpRet(opRet);
1591                                     tb.SetFee(0);
1592
1593                                     /* {
1594                                         UniValue uni(UniValue::VOBJ);
1595                                         TxToUniv(tb.mtx, uint256(), uni);
1596                                         printf("%s: about to send reserve deposits with tx:\n%s\n", __func__, uni.write(1,2).c_str());
1597                                     } */
1598
1599                                     TransactionBuilderResult buildResult(tb.Build());
1600
1601                                     if (!buildResult.IsError() && buildResult.IsTx())
1602                                     {
1603                                         // replace the last one only if we have a valid new one
1604                                         CTransaction tx = buildResult.GetTxOrThrow();
1605
1606                                         LOCK2(cs_main, mempool.cs);
1607                                         static int lastHeight = 0;
1608                                         // remove conflicts, so that we get in
1609                                         std::list<CTransaction> removed;
1610                                         mempool.removeConflicts(tx, removed);
1611
1612                                         // add to mem pool, prioritize according to the fee we will get, and relay
1613                                         //printf("Created and signed export transaction %s\n", tx.GetHash().GetHex().c_str());
1614                                         //LogPrintf("Created and signed export transaction %s\n", tx.GetHash().GetHex().c_str());
1615                                         if (myAddtomempool(tx))
1616                                         {
1617                                             uint256 hash = tx.GetHash();
1618                                             CAmount nativeExportFees = ccx.totalFees.valueMap[ASSETCHAINS_CHAINID];
1619                                             mempool.PrioritiseTransaction(hash, hash.GetHex(), (double)(nativeExportFees << 1), nativeExportFees);
1620                                         }
1621                                         else
1622                                         {
1623                                             UniValue uni(UniValue::VOBJ);
1624                                             TxToUniv(tx, uint256(), uni);
1625                                             //printf("%s: created invalid transaction:\n%s\n", __func__, uni.write(1,2).c_str());
1626                                             LogPrintf("%s: created invalid transaction:\n%s\n", __func__, uni.write(1,2).c_str());
1627                                             break;
1628                                         }
1629                                     }
1630                                     else
1631                                     {
1632                                         // we can't do any more useful work for this chain if we failed here
1633                                         printf("Failed to create export transaction: %s\n", buildResult.GetError().c_str());
1634                                         LogPrintf("Failed to create export transaction: %s\n", buildResult.GetError().c_str());
1635                                         break;
1636                                     }
1637                                 }
1638
1639                                 // erase the inputs we've attempted to spend
1640                                 txInputs.erase(txInputs.begin(), txInputs.begin() + numInputs);
1641                             }
1642                         }
1643                     }
1644                 }
1645                 lastChain = output.first;
1646             }
1647             CheckImports();
1648         }
1649     }
1650 }
1651
1652 void CConnectedChains::SignAndCommitImportTransactions(const CTransaction &lastImportTx, const std::vector<CTransaction> &transactions)
1653 {
1654     int nHeight = chainActive.LastTip()->GetHeight();
1655     uint32_t consensusBranchId = CurrentEpochBranchId(nHeight, Params().GetConsensus());
1656     LOCK2(cs_main, mempool.cs);
1657
1658     uint256 lastHash, lastSignedHash;
1659     CCoinsViewCache view(pcoinsTip);
1660
1661     // sign and commit the transactions
1662     for (auto &_tx : transactions)
1663     {
1664         CMutableTransaction newTx(_tx);
1665
1666         if (!lastHash.IsNull())
1667         {
1668             //printf("last hash before signing: %s\n", lastHash.GetHex().c_str());
1669             for (auto &oneIn : newTx.vin)
1670             {
1671                 //printf("checking input with hash: %s\n", oneIn.prevout.hash.GetHex().c_str());
1672                 if (oneIn.prevout.hash == lastHash)
1673                 {
1674                     oneIn.prevout.hash = lastSignedHash;
1675                     //printf("updated hash before signing: %s\n", lastSignedHash.GetHex().c_str());
1676                 }
1677             }
1678         }
1679         lastHash = _tx.GetHash();
1680         CTransaction tx = newTx;
1681
1682         // sign the transaction and submit
1683         bool signSuccess = false;
1684         for (int i = 0; i < tx.vin.size(); i++)
1685         {
1686             SignatureData sigdata;
1687             CAmount value;
1688             CScript outputScript;
1689
1690             if (tx.vin[i].prevout.hash == lastImportTx.GetHash())
1691             {
1692                 value = lastImportTx.vout[tx.vin[i].prevout.n].nValue;
1693                 outputScript = lastImportTx.vout[tx.vin[i].prevout.n].scriptPubKey;
1694             }
1695             else
1696             {
1697                 CCoins coins;
1698                 if (!view.GetCoins(tx.vin[i].prevout.hash, coins))
1699                 {
1700                     fprintf(stderr,"%s: cannot get input coins from tx: %s, output: %d\n", __func__, tx.vin[i].prevout.hash.GetHex().c_str(), tx.vin[i].prevout.n);
1701                     LogPrintf("%s: cannot get input coins from tx: %s, output: %d\n", __func__, tx.vin[i].prevout.hash.GetHex().c_str(), tx.vin[i].prevout.n);
1702                     break;
1703                 }
1704                 value = coins.vout[tx.vin[i].prevout.n].nValue;
1705                 outputScript = coins.vout[tx.vin[i].prevout.n].scriptPubKey;
1706             }
1707
1708             signSuccess = ProduceSignature(TransactionSignatureCreator(nullptr, &tx, i, value, SIGHASH_ALL), outputScript, sigdata, consensusBranchId);
1709
1710             if (!signSuccess)
1711             {
1712                 fprintf(stderr,"%s: failure to sign transaction\n", __func__);
1713                 LogPrintf("%s: failure to sign transaction\n", __func__);
1714                 break;
1715             } else {
1716                 UpdateTransaction(newTx, i, sigdata);
1717             }
1718         }
1719
1720         if (signSuccess)
1721         {
1722             // push to local node and sync with wallets
1723             CValidationState state;
1724             bool fMissingInputs;
1725             CTransaction signedTx(newTx);
1726
1727             //DEBUGGING
1728             //TxToJSON(tx, uint256(), jsonTX);
1729             //printf("signed transaction:\n%s\n", jsonTX.write(1, 2).c_str());
1730
1731             if (!AcceptToMemoryPool(mempool, state, signedTx, false, &fMissingInputs)) {
1732                 if (state.IsInvalid()) {
1733                     fprintf(stderr,"%s: rejected by memory pool for %s\n", __func__, state.GetRejectReason().c_str());
1734                     LogPrintf("%s: rejected by memory pool for %s\n", __func__, state.GetRejectReason().c_str());
1735                 } else {
1736                     if (fMissingInputs) {
1737                         fprintf(stderr,"%s: missing inputs\n", __func__);
1738                         LogPrintf("%s: missing inputs\n", __func__);
1739                     }
1740                     else
1741                     {
1742                         fprintf(stderr,"%s: rejected by memory pool for\n", __func__);
1743                         LogPrintf("%s: rejected by memory pool for\n", __func__);
1744                     }
1745                 }
1746                 break;
1747             }
1748             else
1749             {
1750                 UpdateCoins(signedTx, view, nHeight);
1751                 lastSignedHash = signedTx.GetHash();
1752             }
1753         }
1754         else
1755         {
1756             break;
1757         }
1758     }
1759 }
1760
1761 CCurrencyValueMap CalculatePreconversions(const CCurrencyDefinition &chainDef, int32_t definitionHeight, CCurrencyValueMap &fees)
1762 {
1763     // if we are getting information on the current chain, we assume that preconverted amounts have been
1764     // pre-calculated. otherwise, we will calculate them.
1765     CCurrencyValueMap retVal;
1766     if (chainDef.GetID() != ConnectedChains.ThisChain().GetID())
1767     {
1768         std::multimap<uint160, pair<CInputDescriptor, CReserveTransfer>> transferInputs;
1769         CCurrencyValueMap preconvertedAmounts;
1770
1771         if (GetChainTransfers(transferInputs, chainDef.GetID(), definitionHeight, chainDef.startBlock - 1, CReserveTransfer::PRECONVERT | CReserveTransfer::VALID))
1772         {
1773             auto curMap = chainDef.GetCurrenciesMap();
1774             for (auto &transfer : transferInputs)
1775             {
1776                 if (!(transfer.second.second.flags & CReserveTransfer::PREALLOCATE) && curMap.count(transfer.second.second.currencyID))
1777                 {
1778                     CAmount conversionFee = CReserveTransactionDescriptor::CalculateConversionFee(transfer.second.second.nValue);
1779                     preconvertedAmounts.valueMap[transfer.second.second.currencyID] += (transfer.second.second.nValue - conversionFee);
1780                     fees.valueMap[transfer.second.second.currencyID] += transfer.second.second.nFees + conversionFee;
1781                 }
1782             }
1783             retVal = preconvertedAmounts;
1784             if (!chainDef.IsToken() && !(chainDef.ChainOptions() & chainDef.OPTION_FEESASRESERVE))
1785             {
1786                 retVal += fees;
1787             }
1788         }
1789     }
1790     else
1791     {
1792         retVal = CCurrencyValueMap(chainDef.currencies, chainDef.preconverted);
1793     }
1794     return retVal;
1795 }
1796
1797 // This creates a new token notarization input and output and attaches them to a new import transaction,
1798 // given the next export transaction about to be imported and its height
1799 bool CConnectedChains::NewImportNotarization(const CCurrencyDefinition &_curDef,
1800                                              uint32_t height,
1801                                              const CTransaction &lastImportTx,
1802                                              uint32_t exportHeight,
1803                                              const CTransaction &exportTx,
1804                                              CMutableTransaction &mnewTx,
1805                                              CCoinbaseCurrencyState &newCurState)
1806 {
1807     if (!_curDef.IsValid() || !_curDef.IsToken())
1808     {
1809         LogPrintf("%s: cannot create import notarization for invalid or non-token currencies\n", __func__);
1810         return false;
1811     }
1812
1813     uint160 currencyID = _curDef.GetID();
1814
1815     CCurrencyDefinition curDef = _curDef;
1816
1817     CPBaaSNotarization lastNotarization(lastImportTx);
1818     if (!lastNotarization.IsValid())
1819     {
1820         LogPrintf("%s: error getting notarization transaction %s\n", __func__, lastImportTx.GetHash().GetHex().c_str());
1821         return false;
1822     }
1823
1824     CCrossChainExport ccx(exportTx);
1825     if (!ccx.IsValid())
1826     {
1827         LogPrintf("%s: invalid export transaction %s\n", __func__, lastImportTx.GetHash().GetHex().c_str());
1828         return false;
1829     }
1830
1831     std::vector<CCurrencyDefinition> txCurrencies = CCurrencyDefinition::GetCurrencyDefinitions(lastImportTx);
1832
1833     bool isDefinition = false;
1834     for (auto &oneCur : txCurrencies)
1835     {
1836         if (oneCur.GetID() == currencyID)
1837         {
1838             isDefinition = true;
1839         }
1840     }
1841
1842     int32_t definitionHeight = exportHeight;
1843     CChainNotarizationData cnd;
1844     if (isDefinition)
1845     {
1846         CTransaction dummyTx;
1847         uint256 blkHash;
1848
1849         if (!myGetTransaction(lastImportTx.GetHash(), dummyTx, blkHash) || blkHash.IsNull())
1850         {
1851             LogPrintf("%s: invalid last import transaction for %s\n", __func__, curDef.name.c_str());
1852             return false;
1853         }
1854         definitionHeight = mapBlockIndex[blkHash]->GetHeight();
1855     }
1856     else if (GetNotarizationData(curDef.GetID(), EVAL_ACCEPTEDNOTARIZATION, cnd) && cnd.vtx.size())
1857     {
1858         lastNotarization = cnd.vtx[cnd.forks[cnd.bestChain].back()].second;
1859     }
1860     else
1861     {
1862         LogPrintf("%s: cannot get last notarization for %s\n", __func__, curDef.name.c_str());
1863         return false;
1864     }
1865
1866
1867     CBlockIndex *pindex;
1868     CTxDestination notarizationID = VERUS_DEFAULTID.IsNull() ? CTxDestination(CIdentityID(currencyID)) : CTxDestination(VERUS_DEFAULTID);
1869
1870     // if this is the first notarization after start, make the notarization and determine if we should
1871     // launch or refund
1872     if (isDefinition)
1873     {
1874         bool refunding = false;
1875
1876         pindex = chainActive[curDef.startBlock];
1877
1878         // check if the chain is qualified for a refund
1879         CCurrencyValueMap minPreMap, preConvertedMap, fees;
1880         preConvertedMap = CalculatePreconversions(curDef, definitionHeight, fees).CanonicalMap();
1881         curDef.preconverted = preConvertedMap.AsCurrencyVector(curDef.currencies);
1882
1883         CCoinbaseCurrencyState initialCur = GetInitialCurrencyState(curDef);
1884         newCurState = initialCur;
1885
1886         if (curDef.minPreconvert.size() && curDef.minPreconvert.size() == curDef.currencies.size())
1887         {
1888             minPreMap = CCurrencyValueMap(curDef.currencies, curDef.minPreconvert).CanonicalMap();
1889         }
1890
1891         if (minPreMap.valueMap.size() && preConvertedMap < minPreMap)
1892         {
1893             // we force the supply to zero
1894             // in any case where there was a minimum participation,
1895             // the result of the supply cannot be zero, enabling us to easily determine that this
1896             // represents a failed launch
1897             newCurState.supply = 0;
1898             newCurState.SetRefunding(true);
1899             refunding = true;
1900         }
1901         else if (curDef.IsFractional() &&
1902                  exportTx.vout.size() &&
1903                  exportTx.vout.back().scriptPubKey.IsOpReturn())
1904         {
1905             // we are not refunding, and it is possible that we also have
1906             // normal conversions in addition to pre-conversions. add any conversions that may
1907             // be present into the new currency state
1908             CReserveTransactionDescriptor rtxd;
1909             std::vector<CBaseChainObject *> exportObjects;
1910             std::vector<CTxOut> vOutputs;
1911
1912             exportObjects = RetrieveOpRetArray(exportTx.vout.back().scriptPubKey);
1913
1914             bool isValidExport = rtxd.AddReserveTransferImportOutputs(currencyID, curDef, initialCur, exportObjects, vOutputs, &newCurState);
1915             DeleteOpRetObjects(exportObjects);
1916             if (!isValidExport)
1917             {
1918                 LogPrintf("%s: invalid export opreturn for transaction %s\n", __func__, exportTx.GetHash().GetHex().c_str());
1919                 return false;
1920             }
1921         }
1922     }
1923     else
1924     {
1925         pindex = chainActive.LastTip();
1926         if (!pindex)
1927         {
1928             LogPrintf("%s: invalid active chain\n", __func__);
1929             return false;
1930         }
1931
1932         // this is not the first notarization, so the last notarization will let us know if this is a refund or not
1933         CCurrencyValueMap minPreMap;
1934
1935         CCoinbaseCurrencyState initialCur = lastNotarization.currencyState;
1936         newCurState = initialCur;
1937
1938         if (curDef.minPreconvert.size() && curDef.minPreconvert.size() == curDef.currencies.size())
1939         {
1940             minPreMap = CCurrencyValueMap(curDef.currencies, curDef.minPreconvert).CanonicalMap();
1941         }
1942
1943         // we won't change currency state in notarizations after failure to launch, if success, recalculate as needed
1944         if (!(lastNotarization.currencyState.IsRefunding()))
1945         {
1946             // calculate new currency state from this import
1947             // we are not refunding, and it is possible that we also have
1948             // normal conversions in addition to pre-conversions. add any conversions that may
1949             // be present into the new currency state
1950             CReserveTransactionDescriptor rtxd;
1951             std::vector<CBaseChainObject *> exportObjects;
1952             std::vector<CTxOut> vOutputs;
1953
1954             exportObjects = RetrieveOpRetArray(exportTx.vout.back().scriptPubKey);
1955
1956             bool isValidExport = rtxd.AddReserveTransferImportOutputs(currencyID, curDef, initialCur, exportObjects, vOutputs, &newCurState);
1957             DeleteOpRetObjects(exportObjects);
1958             if (!isValidExport)
1959             {
1960                 LogPrintf("%s: invalid export opreturn for transaction %s\n", __func__, exportTx.GetHash().GetHex().c_str());
1961                 return false;
1962             }
1963         }
1964     }
1965
1966     uint256 lastImportTxHash = lastImportTx.GetHash();
1967
1968     // now, add the initial notarization to the import tx
1969     // we will begin refund or import after notarization is accepted and returned by GetNotarizationData
1970     CPBaaSNotarization pbn = CPBaaSNotarization(curDef.notarizationProtocol,
1971                                                 currencyID,
1972                                                 notarizationID,
1973                                                 pindex->GetHeight(),
1974                                                 chainActive.GetMMV().GetRoot(),
1975                                                 chainActive.GetMMRNode(pindex->GetHeight()).hash,
1976                                                 ArithToUint256(GetCompactPower(pindex->nNonce, pindex->nBits, pindex->nVersion)),
1977                                                 newCurState,
1978                                                 lastImportTxHash,
1979                                                 lastNotarization.notarizationHeight,
1980                                                 uint256(), 0, COpRetProof(), std::vector<CNodeData>());
1981
1982     // create notarization output
1983     CCcontract_info CC;
1984     CCcontract_info *cp;
1985
1986     std::vector<CTxDestination> dests;
1987     std::vector<CTxDestination> indexDests;
1988
1989     // make the accepted notarization output
1990     cp = CCinit(&CC, EVAL_ACCEPTEDNOTARIZATION);
1991
1992     if (curDef.notarizationProtocol == curDef.NOTARIZATION_NOTARY_CHAINID)
1993     {
1994         dests = std::vector<CTxDestination>({CIdentityID(currencyID)});
1995     }
1996     else if (curDef.notarizationProtocol == curDef.NOTARIZATION_AUTO)
1997     {
1998         dests = std::vector<CTxDestination>({CPubKey(ParseHex(CC.CChexstr))});
1999     }
2000     else
2001     {
2002         return false;
2003     }
2004     indexDests = std::vector<CTxDestination>({CKeyID(curDef.GetConditionID(EVAL_ACCEPTEDNOTARIZATION))});
2005     mnewTx.vout.push_back(CTxOut(0, MakeMofNCCScript(CConditionObj<CPBaaSNotarization>(EVAL_ACCEPTEDNOTARIZATION, dests, 1, &pbn), &indexDests)));
2006
2007     // make the finalization output
2008     cp = CCinit(&CC, EVAL_FINALIZE_NOTARIZATION);
2009
2010     if (curDef.notarizationProtocol == curDef.NOTARIZATION_AUTO)
2011     {
2012         dests = std::vector<CTxDestination>({CPubKey(ParseHex(CC.CChexstr))});
2013     }
2014
2015     // finish transaction by adding the prior input and finalization, sign, then put it in the mempool
2016     // all output for notarizing will be paid as mining fees, so there's no need to relay
2017     uint32_t confirmedOut, finalizeOut;
2018     if (!GetNotarizationAndFinalization(EVAL_ACCEPTEDNOTARIZATION, lastImportTx, pbn, &confirmedOut, &finalizeOut))
2019     {
2020         printf("ERROR: could not find expected initial notarization for currency %s\n", curDef.name.c_str());
2021         return false;
2022     }
2023
2024     mnewTx.vin.push_back(CTxIn(COutPoint(lastImportTxHash, confirmedOut)));
2025     mnewTx.vin.push_back(CTxIn(COutPoint(lastImportTxHash, finalizeOut)));
2026
2027     // we need to store the input that we confirmed if we spent finalization outputs
2028     CTransactionFinalization nf(mnewTx.vin.size() - 1);
2029
2030     indexDests = std::vector<CTxDestination>({CKeyID(curDef.GetConditionID(EVAL_FINALIZE_NOTARIZATION))});
2031
2032     // update crypto condition with final notarization output data
2033     mnewTx.vout.push_back(CTxOut(0,
2034             MakeMofNCCScript(CConditionObj<CTransactionFinalization>(EVAL_FINALIZE_NOTARIZATION, dests, 1, &nf), &indexDests)));
2035
2036     return true;
2037 }
2038
2039 // process token related, local imports and exports
2040 void CConnectedChains::ProcessLocalImports()
2041 {
2042     // first determine all export threads on the current chain that are valid to import
2043     std::multimap<uint160, std::pair<int, CInputDescriptor>> exportOutputs;
2044     std::multimap<uint160, CTransaction> importThreads;
2045     uint160 thisChainID = thisChain.GetID();
2046
2047     LOCK2(cs_main, mempool.cs);
2048     uint32_t nHeight = chainActive.Height();
2049
2050     // get all pending, local exports and put them into a map
2051     std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue>> unspentOutputs;
2052     std::map<uint160, std::pair<uint32_t, CTransaction>> currenciesToImport;    // height of earliest tx
2053     CCurrencyDefinition oneCurrency;
2054
2055     printf("%s: Searching for %s\n", __func__, EncodeDestination(CKeyID(ConnectedChains.ThisChain().GetConditionID(EVAL_FINALIZE_EXPORT))).c_str());
2056     if (GetAddressUnspent(ConnectedChains.ThisChain().GetConditionID(EVAL_FINALIZE_EXPORT), 1, unspentOutputs))
2057     {
2058         CCrossChainExport ccx, ccxDummy;
2059         CTransaction txOut, txImport;
2060         CPartialTransactionProof lastExport;
2061         CCrossChainImport cci;
2062         uint256 blkHash;
2063         for (auto &oneOut : unspentOutputs)
2064         {
2065             COptCCParams p;
2066             if (oneOut.second.script.IsPayToCryptoCondition(p) &&
2067                 p.IsValid() &&
2068                 p.evalCode == EVAL_FINALIZE_EXPORT &&
2069                 p.vData.size() &&
2070                 CTransactionFinalization(p.vData[0]).IsValid() &&
2071                 myGetTransaction(oneOut.first.txhash, txOut, blkHash) &&
2072                 (ccx = CCrossChainExport(txOut)).IsValid() &&
2073                 (oneCurrency = GetCachedCurrency(ccx.systemID)).IsValid() &&
2074                 oneCurrency.startBlock <= nHeight &&
2075                 !currenciesToImport.count(ccx.systemID) &&
2076                 GetLastImport(ccx.systemID, txImport, lastExport, cci, ccxDummy))
2077             {
2078                 auto blockIt = mapBlockIndex.find(blkHash);
2079                 if (blockIt != mapBlockIndex.end() && chainActive.Contains(blockIt->second))
2080                 {
2081                     currenciesToImport.insert(make_pair(ccx.systemID, make_pair(blockIt->second->GetHeight(), txImport)));
2082                 }
2083             }
2084         }
2085     }
2086
2087     CMutableTransaction txTemplate = CreateNewContextualCMutableTransaction(Params().GetConsensus(), nHeight);
2088     for (auto &oneIT : currenciesToImport)
2089     {
2090         std::vector<CTransaction> importTxes;
2091         int32_t importOutNum = 0;
2092         CCrossChainImport oneImportInput(oneIT.second.second, &importOutNum);
2093         if (oneImportInput.IsValid())
2094         {
2095             std::vector<CAddressUnspentDbEntry> reserveDeposits;
2096             GetAddressUnspent(currencyDefCache[oneIT.first].GetConditionID(EVAL_RESERVE_DEPOSIT), CScript::P2CC, reserveDeposits);
2097             CCurrencyValueMap tokenImportAvailable;
2098             CAmount nativeImportAvailable = 0;
2099             for (auto &oneOut : reserveDeposits)
2100             {
2101                 nativeImportAvailable += oneOut.second.satoshis;
2102                 tokenImportAvailable += oneOut.second.script.ReserveOutValue();
2103                 //printf("nativeImportAvailable:%ld, tokenImportAvailable:%s\n", nativeImportAvailable, tokenImportAvailable.ToUniValue().write().c_str());
2104             }
2105             nativeImportAvailable += oneIT.second.second.vout[importOutNum].nValue;
2106             tokenImportAvailable += oneIT.second.second.vout[importOutNum].ReserveOutValue();
2107             //printf("nativeImportAvailable:%ld, tokenImportAvailable:%s\n", nativeImportAvailable, tokenImportAvailable.ToUniValue().write().c_str());
2108             if (CreateLatestImports(currencyDefCache[oneIT.first], oneIT.second.second, txTemplate, CTransaction(), tokenImportAvailable, nativeImportAvailable, importTxes))
2109             {
2110                 // fund the first import transaction with all reserveDeposits
2111                 // change amounts are passed through on the import thread
2112                 //
2113                 // TODO: manage when this becomes to large by splitting reserve deposits over the
2114                 // transactions
2115                 if (importTxes.size())
2116                 {
2117                     CMutableTransaction oneImport = importTxes[0];
2118                     int32_t outNum = 0;
2119                     CCrossChainImport cci(importTxes[0], &outNum);
2120                     if (cci.IsValid())
2121                     {
2122                         // add the reserve deposit inputs to the first transaction
2123                         // the  outputs should have been automatically propagated through
2124                         // fixup inputs if necessary
2125                         if (reserveDeposits.size())
2126                         {
2127                             UniValue jsonTX(UniValue::VOBJ);
2128                             std::vector<uint256> prevHashes;
2129
2130                             for (int i = 0; i < importTxes.size() - 1; i++)
2131                             {
2132                                 prevHashes.push_back(importTxes[i].GetHash());
2133                             }
2134
2135                             // TODO - get reserve deposits from exports, not all at once, as in refunds
2136                             for (auto &oneOut : reserveDeposits)
2137                             {
2138                                 oneImport.vin.push_back(CTxIn(oneOut.first.txhash, oneOut.first.index));
2139                             }
2140
2141                             importTxes[0] = oneImport;
2142
2143                             for (int i = 0; i < importTxes.size() - 1; i++)
2144                             {
2145                                 oneImport = importTxes[i + 1];
2146                                 for (auto &oneIn : oneImport.vin)
2147                                 {
2148                                     if (oneIn.prevout.hash == prevHashes[i])
2149                                     {
2150                                         //printf("updating hash before signing to new value\nold: %s\nnew: %s\n", oneIn.prevout.hash.GetHex().c_str(), importTxes[i].GetHash().GetHex().c_str());
2151                                         oneIn.prevout.hash = importTxes[i].GetHash();
2152                                     }
2153                                 }
2154                                 importTxes[i + 1] = oneImport;
2155                             }
2156
2157                         }
2158                         SignAndCommitImportTransactions(oneIT.second.second, importTxes);
2159                     }
2160                 }
2161             }
2162         }
2163     }
2164 }
2165
2166 void CConnectedChains::SubmissionThread()
2167 {
2168     try
2169     {
2170         arith_uint256 lastHash;
2171         int64_t lastImportTime = 0;
2172         uint32_t lastHeight = 0;
2173
2174         // wait for something to check on, then submit blocks that should be submitted
2175         while (true)
2176         {
2177             boost::this_thread::interruption_point();
2178
2179             if (IsVerusActive())
2180             {
2181                 // blocks get discarded after no refresh for 5 minutes by default, probably should be more often
2182                 //printf("SubmissionThread: pruning\n");
2183                 PruneOldChains(GetAdjustedTime() - 300);
2184                 bool submit = false;
2185                 {
2186                     LOCK(cs_mergemining);
2187                     if (mergeMinedChains.size() == 0 && qualifiedHeaders.size() != 0)
2188                     {
2189                         qualifiedHeaders.clear();
2190                     }
2191                     submit = qualifiedHeaders.size() != 0 && mergeMinedChains.size() != 0;
2192
2193                     //printf("SubmissionThread: qualifiedHeaders.size(): %lu, mergeMinedChains.size(): %lu\n", qualifiedHeaders.size(), mergeMinedChains.size());
2194                 }
2195                 if (submit)
2196                 {
2197                     //printf("SubmissionThread: calling submit qualified blocks\n");
2198                     SubmitQualifiedBlocks();
2199                 }
2200
2201                 ProcessLocalImports();
2202
2203                 if (!submit)
2204                 {
2205                     sem_submitthread.wait();
2206                 }
2207             }
2208             else
2209             {
2210                 // if this is a PBaaS chain, poll for presence of Verus / root chain and current Verus block and version number
2211                 if (CheckVerusPBaaSAvailable())
2212                 {
2213                     // check to see if we have recently earned a block with an earned notarization that qualifies for
2214                     // submitting an accepted notarization
2215                     if (earnedNotarizationHeight)
2216                     {
2217                         CBlock blk;
2218                         int32_t txIndex = -1, height;
2219                         {
2220                             LOCK(cs_mergemining);
2221                             if (earnedNotarizationHeight && earnedNotarizationHeight <= chainActive.Height() && earnedNotarizationBlock.GetHash() == chainActive[earnedNotarizationHeight]->GetBlockHash())
2222                             {
2223                                 blk = earnedNotarizationBlock;
2224                                 earnedNotarizationBlock = CBlock();
2225                                 txIndex = earnedNotarizationIndex;
2226                                 height = earnedNotarizationHeight;
2227                                 earnedNotarizationHeight = 0;
2228                             }
2229                         }
2230
2231                         if (txIndex != -1)
2232                         {
2233                             //printf("SubmissionThread: testing notarization\n");
2234                             CTransaction lastConfirmed;
2235                             uint256 txId = CreateAcceptedNotarization(blk, txIndex, height);
2236
2237                             if (!txId.IsNull())
2238                             {
2239                                 printf("Submitted notarization for acceptance: %s\n", txId.GetHex().c_str());
2240                                 LogPrintf("Submitted notarization for acceptance: %s\n", txId.GetHex().c_str());
2241                             }
2242                         }
2243                     }
2244
2245                     // every "n" seconds, look for imports to include in our blocks from the Verus chain
2246                     if ((GetAdjustedTime() - lastImportTime) >= 30 || lastHeight < (chainActive.LastTip() ? 0 : chainActive.LastTip()->GetHeight()))
2247                     {
2248                         lastImportTime = GetAdjustedTime();
2249                         lastHeight = (chainActive.LastTip() ? 0 : chainActive.LastTip()->GetHeight());
2250
2251                         // see if our notary has a confirmed notarization for us
2252                         UniValue params(UniValue::VARR);
2253                         UniValue result;
2254
2255                         params.push_back(thisChain.name);
2256
2257                         try
2258                         {
2259                             result = find_value(RPCCallRoot("getlastimportin", params), "result");
2260                         } catch (exception e)
2261                         {
2262                             result = NullUniValue;
2263                         }
2264
2265                         if (!result.isNull())
2266                         {
2267                             auto txUniStr = find_value(result, "lastimporttransaction");
2268                             auto txLastConfirmedStr = find_value(result, "lastconfirmednotarization");
2269                             auto txTemplateStr = find_value(result, "importtxtemplate");
2270                             CAmount nativeImportAvailable = uni_get_int64(find_value(result, "nativeimportavailable"));
2271                             CCurrencyValueMap tokenImportAvailable(find_value(params[0], "tokenimportavailable"));
2272
2273                             CTransaction lastImportTx, lastConfirmedTx, templateTx;
2274
2275                             if (txUniStr.isStr() && txTemplateStr.isStr() &&
2276                                 DecodeHexTx(lastImportTx, txUniStr.get_str()) &&
2277                                 DecodeHexTx(lastConfirmedTx, txLastConfirmedStr.get_str()) &&
2278                                 DecodeHexTx(templateTx, txTemplateStr.get_str()))
2279                             {
2280                                 std::vector<CTransaction> importTxes;
2281                                 if (CreateLatestImports(notaryChain.chainDefinition, lastImportTx, templateTx, lastConfirmedTx, tokenImportAvailable, nativeImportAvailable, importTxes))
2282                                 {
2283                                     for (auto importTx : importTxes)
2284                                     {
2285                                         UniValue txResult;
2286                                         params.setArray();
2287                                         params.push_back(EncodeHexTx(importTx));
2288
2289                                         try
2290                                         {
2291                                             txResult = find_value(RPCCallRoot("signrawtransaction", params), "result");
2292                                             if (txResult.isObject() && !(txResult = find_value(txResult, "hex")).isNull() && txResult.isStr() && txResult.get_str().size())
2293                                             {
2294                                                 params.setArray();
2295                                                 params.push_back(txResult);
2296                                                 txResult = find_value(RPCCallRoot("sendrawtransaction", params), "result");
2297                                             }
2298                                             else
2299                                             {
2300                                                 txResult = NullUniValue;
2301                                             }
2302
2303                                         } catch (exception e)
2304                                         {
2305                                             txResult = NullUniValue;
2306                                         }
2307                                         uint256 testId;
2308                                         if (txResult.isStr())
2309                                         {
2310                                             testId.SetHex(txResult.get_str());
2311                                         }
2312                                         if (testId.IsNull())
2313                                         {
2314                                             break;
2315                                         }
2316                                     }
2317                                 }
2318                             }
2319                         }
2320                     }
2321                 }
2322                 sleep(3);
2323             }
2324             boost::this_thread::interruption_point();
2325         }
2326     }
2327     catch (const boost::thread_interrupted&)
2328     {
2329         LogPrintf("Verus merge mining thread terminated\n");
2330     }
2331 }
2332
2333 void CConnectedChains::SubmissionThreadStub()
2334 {
2335     ConnectedChains.SubmissionThread();
2336 }
2337
2338 void CConnectedChains::QueueEarnedNotarization(CBlock &blk, int32_t txIndex, int32_t height)
2339 {
2340     // called after winning a block that contains an earned notarization
2341     // the earned notarization and its height are queued for processing by the submission thread
2342     // when a new notarization is added, older notarizations are removed, but all notarizations in the current height are
2343     // kept
2344     LOCK(cs_mergemining);
2345
2346     // we only care about the last
2347     earnedNotarizationHeight = height;
2348     earnedNotarizationBlock = blk;
2349     earnedNotarizationIndex = txIndex;
2350 }
2351
2352 bool IsChainDefinitionInput(const CScript &scriptSig)
2353 {
2354     uint32_t ecode;
2355     return scriptSig.IsPayToCryptoCondition(&ecode) && ecode == EVAL_CURRENCY_DEFINITION;
2356 }
2357