src/cc/CCinclude.h

   1 /******************************************************************************
   2  * Copyright © 2014-2018 The SuperNET Developers.                             *
   3  *                                                                            *
   4  * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
   5  * the top-level directory of this distribution for the individual copyright  *
   6  * holder information and the developer policies on copyright and licensing.  *
   7  *                                                                            *
   8  * Unless otherwise agreed in a custom licensing agreement, no part of the    *
   9  * SuperNET software, including this file may be copied, modified, propagated *
  10  * or distributed except according to the terms contained in the LICENSE file *
  11  *                                                                            *
  12  * Removal or modification of this copyright notice is prohibited.            *
  13  *                                                                            *
  14  ******************************************************************************/
  15
  16 #ifndef CC_INCLUDE_H
  17 #define CC_INCLUDE_H
  18
  19 /*
  20 there are only a very few types in bitcoin. pay to pubkey, pay to pubkey hash and pay to script hash
  21 p2pk, p2pkh, p2sh
  22 there are actually more that are possible, but those three are 99%+ of bitcoin transactions
  23 so you can pay to a pubkey, or to its hash. or to a script's hash. the last is how most of the more complex scripts are invoked. to spend a p2sh vout, you need to provide the redeemscript, this script's hash is what the p2sh address was.
  24 all of the above are the standard bitcoin vout types and there should be plenty of materials about it
  25 Encrypted by a verified device
  26 what I did with the CC contracts is created a fourth type of vout, the CC vout. this is using the cryptoconditions standard and it is even a different signature mechanism. ed25519 instead of secp256k1. it is basically a big extension to the bitcoin script. There is a special opcode that is added that says it is a CC script.
  27
  28 but it gets more interesting
  29 each CC script has an evalcode
  30 this is just an arbitrary number. but what it does is allows to create a self-contained universe of CC utxo that all have the same evalcode and that is how a faucet CC differentiates itself from a dice CC, the eval code is different
  31
  32 one effect from using a different eval code is that even if the rest of the CC script is the same, the bitcoin address that is calculated is different. what this means is that for each pubkey, there is a unique address for each different eval code!
  33 and this allows efficient segregation of one CC contracts transactions from another
  34 the final part that will make it all clear how the funds can be locked inside the contract. this is what makes a contract, a contract. I put both the privkey and pubkey for a randomly chosen address and associate it with each CC contract. That means anybody can sign outputs for that privkey. However, it is a CC output, so in addition to the signature, whatever constraints a CC contract implements must also be satistifed. This allows funds to be locked and yet anybody is able to spend it, assuming they satisfy the CC's rules
  35
  36 one other technical note is that komodod has the insight-explorer extensions built in. so it can lookup directly all transactions to any address. this is a key performance boosting thing as if it wasnt there, trying to get all the utxo for an address not in the wallet is quite time consuming
  37 */
  38
  39 #include <cc/eval.h>
  40 #include <script/cc.h>
  41 #include <script/script.h>
  42 #include <cryptoconditions.h>
  43 #include "../script/standard.h"
  44 #include "../base58.h"
  45 #include "../core_io.h"
  46 #include "../key_io.h"
  47 #include "../script/sign.h"
  48 #include "../wallet/wallet.h"
  49 #include <univalue.h>
  50 #include <exception>
  51 #include "../komodo_defs.h"
  52
  53 extern int32_t KOMODO_CONNECTING,KOMODO_CCACTIVATE;
  54 extern uint32_t ASSETCHAINS_CC;
  55 extern std::string CCerror;
  56
  57 #define SMALLVAL 0.000000000000001
  58
  59 struct CC_utxo
  60 {
  61     uint256 txid;
  62     int64_t nValue;
  63     int32_t vout;
  64 };
  65
  66 // these are the parameters stored after Verus crypto-condition vouts. new versions may change
  67 // the format
  68 struct CC_meta
  69 {
  70     std::vector<unsigned char> version;
  71     uint8_t evalCode;
  72     bool is1of2;
  73     uint8_t numDestinations;
  74     // followed by address destinations
  75 };
  76
  77 struct CCcontract_info
  78 {
  79     char unspendableCCaddr[64],CChexstr[72],normaladdr[64],unspendableaddr2[64],unspendableaddr3[64];
  80     uint8_t CCpriv[32],unspendablepriv2[32],unspendablepriv3[32];
  81     CPubKey unspendablepk2,unspendablepk3;
  82     bool (*validate)(struct CCcontract_info *cp, Eval* eval, const CTransaction &tx, uint32_t nIn);
  83     bool (*ismyvin)(CScript const& scriptSig);
  84     uint8_t evalcode,evalcode2,evalcode3,didinit;
  85 };
  86 struct CCcontract_info *CCinit(struct CCcontract_info *cp,uint8_t evalcode);
  87
  88 struct oracleprice_info
  89 {
  90     CPubKey pk;
  91     std::vector <uint8_t> data;
  92     int32_t height;
  93 };
  94
  95 #ifdef ENABLE_WALLET
  96 extern CWallet* pwalletMain;
  97 #endif
  98 bool GetAddressUnspent(const uint160& addressHash, int type, std::vector<CAddressUnspentDbEntry>& unspentOutputs);
  99
 100 static const uint256 zeroid;
 101 bool myGetTransaction(const uint256 &hash, CTransaction &txOut, uint256 &hashBlock);
 102 int32_t is_hexstr(char *str,int32_t n);
 103 bool myAddtomempool(CTransaction &tx, CValidationState *pstate = NULL, int32_t simHeight = 0, bool *missinginputs = NULL);
 104 //uint64_t myGettxout(uint256 hash,int32_t n);
 105 bool myIsutxo_spentinmempool(uint256 txid,int32_t vout);
 106 int32_t myIsutxo_spent(uint256 &spenttxid,uint256 txid,int32_t vout);
 107 bool mySendrawtransaction(std::string res);
 108 int32_t decode_hex(uint8_t *bytes,int32_t n,char *hex);
 109 int32_t iguana_rwnum(int32_t rwflag,uint8_t *serialized,int32_t len,void *endianedp);
 110 int32_t iguana_rwbignum(int32_t rwflag,uint8_t *serialized,int32_t len,uint8_t *endianedp);
 111 CScript GetScriptForMultisig(int nRequired, const std::vector<CPubKey>& keys);
 112 int64_t CCaddress_balance(char *coinaddr);
 113 CPubKey CCtxidaddr(char *txidaddr,uint256 txid);
 114 bool GetCCParams(Eval* eval, const CTransaction &tx, uint32_t nIn,
 115                  CTransaction &txOut, std::vector<std::vector<unsigned char>> &preConditions, std::vector<std::vector<unsigned char>> &params);
 116
 117 int64_t OraclePrice(int32_t height,uint256 reforacletxid,char *markeraddr,char *format);
 118 uint8_t DecodeOraclesCreateOpRet(const CScript &scriptPubKey,std::string &name,std::string &description,std::string &format);
 119 uint256 OracleMerkle(int32_t height,uint256 reforacletxid,char *format,std::vector<struct oracle_merklepair>publishers);
 120 uint256 OraclesBatontxid(uint256 oracletxid,CPubKey pk);
 121 int64_t AddAssetInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPubKey pk,uint256 assetid,int64_t total,int32_t maxinputs);
 122 bool DecodeHexTx(CTransaction& tx, const std::string& strHexTx);
 123 bool DecodeAssetCreateOpRet(const CScript &scriptPubKey,std::vector<uint8_t> &origpubkey,std::string &name,std::string &description);
 124 uint8_t DecodeAssetOpRet(const CScript &scriptPubKey,uint256 &assetid,uint256 &assetid2,int64_t &price,std::vector<uint8_t> &origpubkey);
 125 uint8_t DecodeOraclesData(const CScript &scriptPubKey,uint256 &oracletxid,uint256 &batontxid,CPubKey &pk,std::vector <uint8_t>&data);
 126 int32_t oracle_format(uint256 *hashp,int64_t *valp,char *str,uint8_t fmt,uint8_t *data,int32_t offset,int32_t datalen);
 127 CScript EncodeAssetOpRet(uint8_t funcid,uint256 assetid,uint256 assetid2,int64_t price,std::vector<uint8_t> origpubkey);
 128
 129 // CCcustom
 130 CPubKey GetUnspendable(struct CCcontract_info *cp,uint8_t *unspendablepriv);
 131
 132 // CCutils
 133 CPubKey buf2pk(uint8_t *buf33);
 134 void endiancpy(uint8_t *dest,uint8_t *src,int32_t len);
 135 uint256 DiceHashEntropy(uint256 &entropy,uint256 _txidpriv);
 136 CTxOut MakeCC1vout(uint8_t evalcode,CAmount nValue,CPubKey pk);
 137 CTxOut MakeCC1of2vout(uint8_t evalcode,CAmount nValue,CPubKey pk,CPubKey pk2);
 138 CC *MakeCCcond1(uint8_t evalcode,CPubKey pk);
 139 CC *MakeCCcond1(uint8_t evalcode,CTxDestination dest);
 140 CC *MakeCCcondAny(uint8_t evalcode,std::vector<CTxDestination> dests);
 141 CC *MakeCCcond1of2(uint8_t evalcode,CPubKey pk1,CPubKey pk2);
 142 CC *MakeCCcondMofN(uint8_t evalcode, const std::vector<CTxDestination> &dests, int M);
 143 CC *GetCryptoCondition(CScript const& scriptSig);
 144 void CCaddr2set(struct CCcontract_info *cp,uint8_t evalcode,CPubKey pk,uint8_t *priv,char *coinaddr);
 145 void CCaddr3set(struct CCcontract_info *cp,uint8_t evalcode,CPubKey pk,uint8_t *priv,char *coinaddr);
 146 bool IsCCInput(CScript const& scriptSig);
 147 int32_t unstringbits(char *buf,uint64_t bits);
 148 uint64_t stringbits(char *str);
 149 uint256 revuint256(uint256 txid);
 150 char *uint256_str(char *dest,uint256 txid);
 151 char *pubkey33_str(char *dest,uint8_t *pubkey33);
 152 uint256 Parseuint256(char *hexstr);
 153 CPubKey pubkey2pk(std::vector<uint8_t> pubkey);
 154 int64_t CCfullsupply(uint256 tokenid);
 155 int64_t CCtoken_balance(char *destaddr,uint256 tokenid);
 156 bool _GetCCaddress(char *destaddr,uint8_t evalcode,CPubKey pk);
 157 bool GetCCaddress(struct CCcontract_info *cp,char *destaddr,CPubKey pk);
 158 bool GetCCaddress1of2(struct CCcontract_info *cp,char *destaddr,CPubKey pk,CPubKey pk2);
 159 bool ConstrainVout(CTxOut vout,int32_t CCflag,char *cmpaddr,int64_t nValue);
 160 bool PreventCC(Eval* eval,const CTransaction &tx,int32_t preventCCvins,int32_t numvins,int32_t preventCCvouts,int32_t numvouts);
 161 bool Getscriptaddress(char *destaddr,const CScript &scriptPubKey);
 162 std::vector<uint8_t> Mypubkey();
 163 bool Myprivkey(uint8_t myprivkey[]);
 164 int64_t CCduration(int32_t &numblocks,uint256 txid);
 165
 166 // CCtx
 167 bool SignTx(CMutableTransaction &mtx,int32_t vini,int64_t utxovalue,const CScript scriptPubKey);
 168 std::string FinalizeCCTx(uint64_t skipmask,struct CCcontract_info *cp,CMutableTransaction &mtx,CPubKey mypk,uint64_t txfee,CScript opret);
 169 void SetCCunspents(std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > &unspentOutputs,char *coinaddr);
 170 void SetCCtxids(std::vector<std::pair<CAddressIndexKey, CAmount> > &addressIndex,char *coinaddr);
 171 int64_t AddNormalinputs(CMutableTransaction &mtx,CPubKey mypk,int64_t total,int32_t maxinputs);
 172 int64_t CCutxovalue(char *coinaddr,uint256 utxotxid,int32_t utxovout);
 173
 174 // curve25519 and sha256
 175 bits256 curve25519_shared(bits256 privkey,bits256 otherpub);
 176 bits256 curve25519_basepoint9();
 177 bits256 curve25519(bits256 mysecret,bits256 basepoint);
 178 void vcalc_sha256(char deprecated[(256 >> 3) * 2 + 1],uint8_t hash[256 >> 3],uint8_t *src,int32_t len);
 179 bits256 bits256_doublesha256(char *deprecated,uint8_t *data,int32_t datalen);
 180
 181 #endif