diff --git a/qa/rpc-tests/cryptoconditions.py b/qa/rpc-tests/cryptoconditions.py
index 2e5dad26e..e7d3065cc 100755
--- a/qa/rpc-tests/cryptoconditions.py
+++ b/qa/rpc-tests/cryptoconditions.py
@@ -149,12 +149,137 @@ class CryptoConditionsTest (BitcoinTestFramework):
         result  = rpc.dicelist()
         assert_equal(result, [])
 
+        # creating dice plan with too long name (>8 chars)
+        result = rpc.dicefund("THISISTOOLONG", "10000", "10", "10000", "10", "5")
+        assert_error(result)
+
+        # creating dice plan with < 100 funding
+        result = rpc.dicefund("LUCKY","10","1","10000","10","5")
+        assert_error(result)
+
+        # creating dice plan with 0 blocks timeout
+        result = rpc.dicefund("LUCKY","10","1","10000","10","0")
+        assert_error(result)
+
+        # creating dice plan
+        dicefundtx  = rpc.dicefund("LUCKY","1000","1","800","10","5")
+        diceid = self.send_and_mine(dicefundtx['hex'])
+
+        # checking if it in plans list now
+        result = rpc.dicelist()
+        assert_equal(result[0], diceid)
+
+        # set dice name for futher usage
+        dicename = "LUCKY"
+
+        # adding zero funds to plan
+        result = rpc.diceaddfunds(dicename,diceid,"0")
+        assert_error(result)
+
+        # adding negative funds to plan
+        result = rpc.diceaddfunds(dicename,diceid,"-1")
+        assert_error(result)
+
+        # adding funds to plan
+        addfundstx = rpc.diceaddfunds(dicename,diceid,"1100")
+        result = self.send_and_mine(addfundstx['hex'])
+
+        # checking if funds added to plan
+        result = rpc.diceinfo(diceid)
+        assert_equal(result["funding"], "2100.00000000")
+
+        # not valid dice info checking
         result = rpc.diceinfo("invalid")
         assert_error(result)
 
-        result = rpc.dicefund("THISISTOOLONG", "10000", "10", "10000", "10", "5")
+        # placing 0 amount bet
+        result = rpc.dicebet(dicename,diceid,"0","1")
         assert_error(result)
 
+        # placing negative amount bet
+        result = rpc.dicebet(dicename,diceid,"-1","1")
+        assert_error(result)
+
+        # placing bet more than maxbet
+        result = rpc.dicebet(dicename,diceid,"900","1")
+        assert_error(result)
+
+        # placing bet with amount more than funding
+        result = rpc.dicebet(dicename,diceid,"3000","1")
+        assert_error(result)
+
+        # placing bet with potential won more than funding
+        result = rpc.dicebet(dicename,diceid,"750","9")
+        assert_error(result)
+
+        # placing 0 odds bet
+        result = rpc.dicebet(dicename,diceid,"1","0")
+        assert_error(result)
+
+        # placing negative odds bet
+        result = rpc.dicebet(dicename,diceid,"1","-1")
+        assert_error(result)
+
+        # placing bet with odds more than allowed
+        result = rpc.dicebet(dicename,diceid,"1","11")
+        assert_error(result)
+
+        # placing bet with not correct dice name
+        result = rpc.dicebet("nope",diceid,"100","1")
+        assert_error(result)
+
+        # placing bet with not correct dice id
+        result = rpc.dicebet(dicename,self.pubkey,"100","1")
+        assert_error(result)
+
+        # valid bet placing
+        placebet = rpc.dicebet(dicename,diceid,"100","1")
+        betid = self.send_and_mine(placebet["hex"])
+        assert result, "bet placed"
+
+        # check bet status
+        result = rpc.dicestatus(dicename,diceid,betid)
+        assert_success(result)
+
+        # have to make some entropy for the next test
+        entropytx = 0
+        fundingsum = 1
+        while entropytx < 10:
+             fundingsuminput = str(fundingsum)
+             fundinghex = rpc.diceaddfunds(dicename,diceid,fundingsuminput)
+             result = self.send_and_mine(fundinghex['hex'])
+             entropytx = entropytx + 1
+             fundingsum = fundingsum + 1
+
+        rpc.generate(2)
+
+        # note initial dice funding state at this point.
+        # TODO: track player balance somehow (hard to do because of mining and fees)
+        diceinfo = rpc.diceinfo(diceid)
+        funding = float(diceinfo['funding'])
+
+        # placing  same amount bets with amount 1 and odds  1:2, checking if balance changed correct
+        losscounter = 0
+        wincounter = 0
+        betcounter = 0
+
+        while (betcounter < 10):
+            placebet = rpc.dicebet(dicename,diceid,"1","1")
+            betid = self.send_and_mine(placebet["hex"])
+            finish = rpc.dicefinish(dicename,diceid,betid)
+            self.send_and_mine(finish["hex"])
+            betresult = rpc.dicestatus(dicename,diceid,betid)
+            betcounter = betcounter + 1
+            if betresult["status"] == "loss":
+                losscounter = losscounter + 1
+            elif betresult["status"]  == "win":
+                wincounter = wincounter + 1
+
+        # funding balance should increase if player loss, decrease if player won
+        fundbalanceguess = funding + losscounter - wincounter
+        fundinfoactual = rpc.diceinfo(diceid)
+        assert_equal(round(fundbalanceguess),round(float(fundinfoactual['funding'])))
+
     def run_token_tests(self):
         rpc    = self.nodes[0]
         result = rpc.tokenaddress()
@@ -170,12 +295,15 @@ class CryptoConditionsTest (BitcoinTestFramework):
         result = rpc.tokenlist()
         assert_equal(result, [])
 
+        # trying to create token with negaive supply
         result = rpc.tokencreate("NUKE", "-1987420", "no bueno supply")
         assert_error(result)
 
+        # creating token with name more than 32 chars
         result = rpc.tokencreate("NUKE123456789012345678901234567890", "1987420", "name too long")
         assert_error(result)
 
+        # creating valid token
         result = rpc.tokencreate("DUKE", "1987.420", "Duke's custom token")
         assert_success(result)
 
@@ -276,23 +404,23 @@ class CryptoConditionsTest (BitcoinTestFramework):
 
         # invalid numtokens bid
         result = rpc.tokenbid("-1", tokenid, "1")
-        assert_error(result);
+        assert_error(result)
 
         # invalid numtokens bid
         result = rpc.tokenbid("0", tokenid, "1")
-        assert_error(result);
+        assert_error(result)
 
         # invalid price bid
         result = rpc.tokenbid("1", tokenid, "-1")
-        assert_error(result);
+        assert_error(result)
 
         # invalid price bid
         result = rpc.tokenbid("1", tokenid, "0")
-        assert_error(result);
+        assert_error(result)
 
         # invalid tokenid bid
         result = rpc.tokenbid("100", "deadbeef", "1")
-        assert_error(result);
+        assert_error(result)
 
         tokenbid = rpc.tokenbid("100", tokenid, "10")
         tokenbidhex = tokenbid['hex']
@@ -330,11 +458,11 @@ class CryptoConditionsTest (BitcoinTestFramework):
         # invalid token transfer amount (have to add status to CC code!)
         randompubkey = "021a559101e355c907d9c553671044d619769a6e71d624f68bfec7d0afa6bd6a96"
         result = rpc.tokentransfer(tokenid,randompubkey,"0")
-        assert_error(result);
+        assert_error(result)
 
         # invalid token transfer amount (have to add status to CC code!)
         result = rpc.tokentransfer(tokenid,randompubkey,"-1")
-        assert_error(result);
+        assert_error(result)
 
         # valid token transfer
         sendtokens = rpc.tokentransfer(tokenid,randompubkey,"1")
@@ -361,14 +489,31 @@ class CryptoConditionsTest (BitcoinTestFramework):
         result = rpc.rewardsinfo("none")
         assert_error(result)
 
+        # creating rewards plan with name > 8 chars, should return error
+        result = rpc.rewardscreatefunding("STUFFSTUFF", "7777", "25", "0", "10", "10")
+        assert_error(result)
+
+        # creating rewards plan with 0 funding
+        result = rpc.rewardscreatefunding("STUFF", "0", "25", "0", "10", "10")
+        assert_error(result)
+
+        # creating rewards plan with 0 maxdays
+        result = rpc.rewardscreatefunding("STUFF", "7777", "25", "0", "10", "0")
+        assert_error(result)
+
+        # creating rewards plan with > 25% APR
+        result = rpc.rewardscreatefunding("STUFF", "7777", "30", "0", "10", "10")
+        assert_error(result)
+
+        # creating valid rewards plan
         result = rpc.rewardscreatefunding("STUFF", "7777", "25", "0", "10", "10")
         assert result['hex'], 'got raw xtn'
-        txid = rpc.sendrawtransaction(result['hex'])
-        assert txid, 'got txid'
+        fundingtxid = rpc.sendrawtransaction(result['hex'])
+        assert fundingtxid, 'got txid'
 
         # confirm the above xtn
         rpc.generate(1)
-        result = rpc.rewardsinfo(txid)
+        result = rpc.rewardsinfo(fundingtxid)
         assert_success(result)
         assert_equal(result['name'], 'STUFF')
         assert_equal(result['APR'], "25.00000000")
@@ -376,39 +521,38 @@ class CryptoConditionsTest (BitcoinTestFramework):
         assert_equal(result['maxseconds'], 864000)
         assert_equal(result['funding'], "7777.00000000")
         assert_equal(result['mindeposit'], "10.00000000")
-        assert_equal(result['fundingtxid'], txid)
+        assert_equal(result['fundingtxid'], fundingtxid)
 
-        # funding amount must be positive
-        result = rpc.rewardsaddfunding("STUFF", txid, "0")
+        # checking if new plan in rewardslist
+        result = rpc.rewardslist()
+        assert_equal(result[0], fundingtxid)
+
+        # creating reward plan with already existing name, should return error
+        result = rpc.rewardscreatefunding("STUFF", "7777", "25", "0", "10", "10")
         assert_error(result)
 
-        result = rpc.rewardsaddfunding("STUFF", txid, "555")
-        assert_success(result)
-        fundingtxid = result['hex']
-        assert fundingtxid, "got funding txid"
-
-        result = rpc.rewardslock("STUFF", fundingtxid, "7")
+        # add funding amount must be positive
+        result = rpc.rewardsaddfunding("STUFF", fundingtxid, "-1")
         assert_error(result)
 
-        # the previous xtn has not been broadcasted yet
-        result = rpc.rewardsunlock("STUFF", fundingtxid)
+        # add funding amount must be positive
+        result = rpc.rewardsaddfunding("STUFF", fundingtxid, "0")
         assert_error(result)
 
-        # wrong plan name
-        result = rpc.rewardsunlock("SHTUFF", fundingtxid)
-        assert_error(result)
+        # adding valid funding
+        result = rpc.rewardsaddfunding("STUFF", fundingtxid, "555")
+        addfundingtxid = self.send_and_mine(result['hex'])
+        assert addfundingtxid, 'got funding txid'
 
-        txid = rpc.sendrawtransaction(fundingtxid)
-        assert txid, 'got txid from sendrawtransaction'
+        # checking if funding added to rewardsplan
+        result = rpc.rewardsinfo(fundingtxid)
+        assert_equal(result['funding'], "8332.00000000")
 
-        # confirm the xtn above
-        rpc.generate(1)
-
-        # amount must be positive
+        # trying to lock funds, locking funds amount must be positive
         result = rpc.rewardslock("STUFF", fundingtxid, "-5")
         assert_error(result)
 
-        # amount must be positive
+        # trying to lock funds, locking funds amount must be positive
         result = rpc.rewardslock("STUFF", fundingtxid, "0")
         assert_error(result)
 
@@ -416,25 +560,26 @@ class CryptoConditionsTest (BitcoinTestFramework):
         result = rpc.rewardslock("STUFF", fundingtxid, "7")
         assert_error(result)
 
-        # not working
-        #result = rpc.rewardslock("STUFF", fundingtxid, "10")
-        #assert_success(result)
-        #locktxid = result['hex']
-        #assert locktxid, "got lock txid"
+        # locking funds in rewards plan
+        result = rpc.rewardslock("STUFF", fundingtxid, "10")
+        assert_success(result)
+        locktxid = result['hex']
+        assert locktxid, "got lock txid"
 
         # locktxid has not been broadcast yet
-        #result = rpc.rewardsunlock("STUFF", locktxid)
-        #assert_error(result)
+        result = rpc.rewardsunlock("STUFF", fundingtxid, locktxid)
+        assert_error(result)
 
         # broadcast xtn
-        #txid = rpc.sendrawtransaction(locktxid)
-        #assert txid, 'got txid from sendrawtransaction'
+        txid = rpc.sendrawtransaction(locktxid)
+        assert txid, 'got txid from sendrawtransaction'
 
         # confirm the xtn above
-        #rpc.generate(1)
+        rpc.generate(1)
 
-        #result = rpc.rewardsunlock("STUFF", locktxid)
-        #assert_error(result)
+        # will not unlock since reward amount is less than tx fee
+        result = rpc.rewardsunlock("STUFF", fundingtxid, locktxid)
+        assert_error(result)
 
 
     def run_test (self):
diff --git a/src/Makefile.am b/src/Makefile.am
index 8b10c06e0..5252b1fa0 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -267,6 +267,14 @@ libbitcoin_server_a_SOURCES = \
   cc/dice.cpp \
   cc/lotto.cpp \
   cc/fsm.cpp \
+  cc/MofN.cpp \
+  cc/oracles.cpp \
+  cc/prices.cpp \
+  cc/pegs.cpp \
+  cc/triggers.cpp \
+  cc/payments.cpp \
+  cc/gateways.cpp \
+  cc/channels.cpp \
   cc/auction.cpp \
   cc/betprotocol.cpp \
   chain.cpp \
diff --git a/src/cc/CC made easy b/src/cc/CC made easy
new file mode 100644
index 000000000..4158e061e
--- /dev/null
+++ b/src/cc/CC made easy	
@@ -0,0 +1,589 @@
+/******************************************************************************
+ * Copyright © 2014-2018 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+
+How to write utxo based CryptoConditions contracts for KMD chains
+by jl777
+
+This is not the only smart contracts methodology that is possible to build on top of OP_CHECKCRYPTOCONDITION, just the first one. All the credit for getting OP_CHECKCRYPTOCONDITION working in the Komodo codebase goes to @libscott. I am just hooking into the code that he made and tried to make it just a little easier to make new contracts.
+
+There is probably some fancy marketing name to use, but for now, I will just call it "CC contract" for short, knowing that it is not 100% technically accurate as the CryptoConditions aspect is not really the main attribute. However, the KMD contracts were built to make the CryptoConditions codebase that was integrated into it to be more accessible.
+
+Since CC contracts run native C/C++ code, it is turing complete and that means that any contract that is possible to do on any other platform will be possible to create via CC contract.
+
+utxo based contracts are a bit harder to start writing than for balance based contracts. However, they are much more secure as they leverage the existing bitcoin utxo system. That makes it much harder to have bugs that issue a zillion new coins from a bug, since all the CC contract operations needs to also obey the existing bitcoin utxo protocol.
+
+This document will be heavily example based so it will utilize many of the existing reference CC contracts. After understanding this document, you should be in a good position to start creating either a new CC contract to be integrated into komodod or to make rpc based dapps directly.
+
+Chapter 0 - Bitcoin Protocol Basics
+There are many aspects of the bitcoin protocol that isnt needed to understand the CC contracts dependence on it. Such details will not be discussed. The primary aspect is the utxo, unspent transaction output. Just a fancy name for txid/vout, so when you sendtoaddress some coins, it creates a txid and the first output is vout.0, combine it and txid/0 is a specific utxo.
+
+Of course, to understand even this level of detail requires that you understand what a txid is, but there are plenty of reference materials on that. It is basically the 64 char long set of letters and numbers that you get when you send funds.
+
+Implicit with the utxo is that it prevents double spends. Once you spend a utxo, you cant spend it again. This is quite an important characteristic and while advanced readers will point out chain reorgs can allow a double spend, we will not confuse the issue with such details. The important thing is that given a blockchain at a specific height's blockhash, you can know if a txid/vout has been spent or not.
+
+There are also the transactions that are in memory waiting to be mined, the mempool. And it is possible for the utxo to be spent by a tx in the mempool. However since it isnt confirmed yet, it is still unspent at the current height, even if we are pretty sure it will be spent in the next block.
+
+A useful example is to think about a queue of people lined up to get into an event. They need to have a valid ticket and also to get into the queue. After some time passes, they get their ticket stamped and allowed into the event.
+
+In the utxo case, the ticket is the spending transaction and the event is the confirmed blockchain. The queue is the mempool.
+
+
+Chapter 1 - OP_CHECKCRYPTOCONDITION
+In the prior chapter the utxo was explained. However, the specific mechanism used to send a payment was not explained. Contrary to what most people might think, on the blockchain there are not entries that say "pay X amount to address". Instead what exists is a bitcoin script that must be satisfied in order for the funds to be able to be spent.
+
+Originally, there was the pay to pubkey script:
+<pubkey> <checksig>
+
+About as simple of a payment script that you can get. Basically the pubkey's signature is checked and if it is valid, you get to spend it. One problem satoshi realized was that with Quantum Computers such payment scripts are vulnerable! So, he made a way to have a cold address, ie. an address whose pubkey isnt known. At least it isnt known until it is spent, so it is only Quantum resistant prior to the first spend. This line of reasoning is why we have one time use addresses and a new change address for each transaction. Maybe in some ways, this is too forward thinking as it makes things a lot more confusing to use and easier to lose track of all the required private keys.
+
+However, it is here to stay and its script is:
+<hash the pubkey> <pubkey> <verify hash matches> <checksig>
+
+With this, the blockchain has what maps to "pay to address", just that the address is actually a base58 encoded (prefix + pubkeyhash). Hey, if it wasnt complicated, it would be easy!
+
+In order to spend a p2pkh (pay to pubkey hash) utxo, you need to divulge the pubkey in addition to having a valid signature. After the first spend from an address, its security is degraded to p2pk (pay to pubkey) as its pubkey is now known. The net result is that each reused address takes 25 extra bytes on the blockchain, and that is why for addresses that are expected to be reused, I just use the p2pk script.
+
+Originally, bitcoin allowed any type of script opcodes to be used directly. The problem was some of them caused problems and satoshi decided to disable them and only allow standard forms of payments. Thus the p2pk and p2pkh became 99%+ of bitcoin transactions. However, going from having a fully scriptable language that can create countless payment scripts (and bugs!), to having just 2... well it was a "short term" limitation. It did last for some years but eventually a compromise p2sh script was allowed to be standard. This is a pay to script hash, so it can have a standard format as the normal p2pkh, but have infinitely more flexibility.
+
+<hash the script> <script> <verify hash matches>
+
+Wait, something is wrong! If it was just that, then anybody that found out what the required script (called redeemscript) was, they could just spend it. I forgot to say that the redeemscript is then used to determine if the payment can be spent or not. So you can have a normal p2pk or p2pkh redeemscript inside a p2sh script.
+
+OK, I know that just got really confusing. Let us have a more clear example:
+
+redeemscript <- pay to pubkey
+p2sh becomes the hash of the redeem script + the compares
+
+So to spend it, you need to divulge the redeemscript, which in turn requires you to divulge the pubkey. Put it all together and the p2sh mechanism verifies you not only had the correct redeemscript by comparing its hash, but that when the redeemscript is run, it is satisfied. In this case, that the pubkey's signature was valid.
+
+If you are still following, there is some good news! OP_CHECKCRYPTOCONDITION scripts are actually simpler than p2sh scripts in some sense as there isnt this extra level of script inside a scripthash. @libscott implemented the addition of OP_CHECKCRYPTOCONDITION to the set of bitcoin opcodes and what it does is makes sure that a CryptoConditions script is properly signed.
+
+Which gets us to the CryptoConditions specification, which is a monster of a IETF (Internet standards) draft and has hundred(s) of pages of specification. I am sure you are happy to know that you dont really need to know about it much at all! Just know that you can create all sorts of cryptoconditions and its binary encoding can be used in a bitcoin utxo. If the standard CC contracts dont have the power you need, it is always possible to expand on it. So far, most all the CC contracts only need the power of a 1of1 CC script, which is 1 signature combined with custom constraints. The realtime payment channels CC is the only one of the reference CC contracts so far that didnt fit into this model, it needed a 1of2 CC script.
+
+The best part is that all these opcode level things are not needed at all. I just wanted to explain it for those that need to know all the details of everything.
+
+Chapter 2 - CC contract basics
+Each CC contract has an eval code, this is just an arbitrary number that is associated with a specific CC contract. The details about a specific CC contract are all determined by the validation logic, that is ultimately what implements a CC contract.
+
+However, unlike the normal bitcoin payments, where it is validated with only information in the transaction, a CC contract has the power to do pretty much anything. It has full access to the blockchain and even the mempool, though using mempool information is inherently more risky and needs to be done carefully or for exclusions, rather than inclusions.
+
+However, this is the CC contract basics chapter, so let us ignore mempool issues and deal with just the basics. Fundamentally there is no structure for OP_CHECKCRYPTOCONDITION serialized scripts, but if you are like me, you want to avoid having to read and understand a 1000 page IETF standard. What we really want to do is have a logical way to make a new contract and have it be able to be coded and debugged in an efficient way.
+
+That means to just follow a known working template and only changing the things where the existing templates are not sufficient, ie. the core differentiator of your CC contract.
+
+In the ~/komodo/src/cc/eval.h file all the eval codes are defined, currently:
+
+#define FOREACH_EVAL(EVAL)             \
+EVAL(EVAL_IMPORTPAYOUT, 0xe1)  \
+EVAL(EVAL_IMPORTCOIN,   0xe2)  \
+EVAL(EVAL_ASSETS,   0xe3)  \
+EVAL(EVAL_FAUCET, 0xe4) \
+EVAL(EVAL_REWARDS, 0xe5) \
+EVAL(EVAL_DICE, 0xe6) \
+EVAL(EVAL_FSM, 0xe7) \
+EVAL(EVAL_AUCTION, 0xe8) \
+EVAL(EVAL_LOTTO, 0xe9) \
+EVAL(EVAL_MOFN, 0xea) \
+EVAL(EVAL_CHANNELS, 0xeb) \
+EVAL(EVAL_ORACLES, 0xec) \
+EVAL(EVAL_PRICES, 0xed) \
+EVAL(EVAL_PEGS, 0xee) \
+EVAL(EVAL_TRIGGERS, 0xef) \
+EVAL(EVAL_PAYMENTS, 0xf0) \
+EVAL(EVAL_GATEWAYS, 0xf1)
+
+Ultimately, we will probably end up with all 256 eval codes used, for now there is plenty of room. I imagined that similar to my coins repo, we can end up with a much larger than 256 number of CC contracts and you select the 256 that you want active for your blockchain. That does mean any specific chain will be limited to "only" having 256 contracts. Since there seems to be so few actually useful contracts so far, this limit seems to be sufficient. I am told that the evalcode can be of any length, but the current CC contracts assumes it is one byte.
+
+The simplest CC script would be one that requires a signature from a pubkey along with a CC validation. This is the equivalent of the pay to pubkey bitcoin script and is what most of the initial CC contracts use. Only the channels one needed more than this and it will be explained in its chapter.
+
+We end up with CC scripts of the form (evalcode) + (pubkey) + (other stuff), dont worry about the other stuff, it is automatically handled with some handy internal functions. The important thing to note is that each CC contract of this form needs a single pubkey and eval code and from that we get the CC script. Using the standard bitcoin's "hash and make an address from it" method, this means that the same pubkey will generate a different address for each different CC contract!
+
+This is an important point, so I will say it in a different way. In bitcoin there used to be uncompressed pubkeys which had both the right and left half combined, into a giant 64 byte pubkey. But since you can derive one from the other, compressed pubkeys became the standard, that is why you have bitcoin pubkeys of 33 bytes instead of 65 bytes. There is a 02, 03 or 04 prefix, to mean odd or even or big pubkey. This means there are two different pubkeys for each privkey, the compressed and uncompressed. And in fact you can have two different bitcoin protocol addresses that are spendable by the same privkey. If you use some paper wallet generators, you might have noticed this.
+
+CC contracts are like that, where each pubkey gets a different address for each evalcode. It is the same pubkey, just different address due to the actual script having a different evalcode, it ends up with a different hash and thus a different address. Now funds send to a specific CC address is only accessible by that CC contract and must follow the rules of that contract.
+
+I also added another very useful feature where the convention is for each CC contract to have a special address that is known to all, including its private key. Before you panic about publishing the private key, remember that to spend a CC output, you need to properly sign it AND satisfy all the rules. By everyone having the privkey for the CC contract, everybody can do the "properly sign" part, but they still need to follow the rest of the rules.
+
+From a user's perspective, there is the global CC address for a CC contract and some contracts also use the user pubkey's CC address. Having a pair of new addresses for each contract can get a bit confusing at first, but eventually we will get easy to use GUI that will make it all easy to use.
+
+
+Chapter 3 - CC vins and vouts
+You might want to review the bitcoin basics and other materials to refresh about how bitcoin outputs become inputs. It is a bit complicated, but ultimately it is about one specific amount of coins that are spent, once spent it is combined with the other coins that are also spent in that transaction and then various outputs are created.
+
+vin0 + vin1 + vin2 -> vout0 + vout1
+
+That is a 3 input, 2 output transaction. The value from the three inputs are combined and then split into vout0 and vout1, each of the vouts gets a spend script that must be satisfied to be able to be spent. Which means for all three of out vins, all the requirements (as specified in the output that created them) are satisfied.
+
+Yes, I know this is a bit too complicated without a nice chart, so we will hope that a nice chart is added here:
+
+[nice chart goes here]
+
+Out of all the aspects of the CC contracts, the flexibility that different vins and vouts created was the biggest surprise. When I started writing the first of these a month ago, I had no idea the power inherent in the smart utxo contracts. I was just happy to have a way to lock funds and release them upon some specific conditions.
+
+After the assets/tokens CC contract, I realized that it was just a tip of the iceberg. I knew it was Turing complete, but after all these years of restricted bitcoin script, to have the full power of any arbitrary algorithm, it was eye opening. Years of writing blockchain code and having really bad consequences with every bug naturally makes you gun shy about doing aggressive things at the consensus level. And that is the way it should be, if not very careful, some really bad things can and do happen. The foundation of building on top of the existing (well tested and reliable) utxo system is what makes the CC contracts less likely for the monster bugs. That being said, lack of validation can easily allow an improperly coded CC contract to have its funds drained.
+
+The CC contract breaks out of the standard limitations of a bitcoin transaction. Already, what I wrote explains the reason, but it was not obvious even to me at first, so likely you might have missed it too. If you are wondering what on earth I am talking about, THAT is what I am talking about!
+
+To recap, we have now a new standard bitcoin output type called a CC output. Further, there can be up to 256 different types of CC outputs active on any given blockchain. We also know that to spend any output, you need to satisfy its spending script, which in our case is the signature and whatever constraints the CC validation imposes. We also have the convention of a globally shared keypair, which gives us a general CC address that can have funds sent to it, along with a user pubkey specific CC address.
+
+Let us go back to the 3+2 transaction example:
+
+vin0 + vin1 + vin2 -> vout0 + vout1
+
+Given the prior paragraph, try to imagine the possibilities the simple 3+2 transaction can be. Each vin could be a normal vin, from the global contract address, the user's CC address and the vouts can also have this range. Theoretically, there can be 257 * 257 * 257 * 257 * 257 forms of a 3+2 transaction!
+
+In reality, we really dont want that much degrees of freedom as it will ensure a large degree of bugs! So we need to reduce things to a more manageable level where there are at most 3 types for each, and preferably just 1 type. That will make the job of validating it much simpler and simple is better as long as we dont sacrifice the power. We dont.
+
+Ultimately the CC contract is all about how it constrains its inputs, but before it can constrain them, they need to be created as outputs. More about this in the CC validation chapter.
+
+Chapter 4 - CC rpc extensions
+Currently, CC contracts need to be integrated at the source level. This limits who is able to create and add new CC contracts, which at first is good, but eventually will be a too strict limitation. The runtime bindings chapter will touch on how to break out of the source based limitation, but there is another key interface level, the RPC.
+
+By convention, each CC contract adds an associated set of rpc calls to the komodo-cli. This not only simplifies the creation of the CC contract transactions, it further will allow dapps to be created just via rpc calls. That will require there being enough foundational CC contracts already in place. As we find new usecases that cannot be implemented via rpc, then a new CC contract is made that can handle that (and more) and the power of the rpc level increases. This is a long term process.
+
+The typical rpc calls that are added <CC>address, <CClist>, <CCinfo> return the various special CC addresses, the list of CC contract instances and info about each CC contract instance. Along with an rpc that creates a CC instance and of course the calls to invoke a CC instance.
+
+The role of the rpc calls are to create properly signed rawtransactions that are ready for broadcasting. This then allows using only the rpc calls to not only invoke but to create a specific instance of a CC. The faucet contract is special in that it only has a single instance, so some of these rpc calls are skipped.
+
+So, there is no MUSTHAVE rpc calls, just a sane convention to follow so it fits into the general pattern.
+
+One thing that I forgot to describe was how to create a special CC address and even though this is not really an rpc issue, it is kind of separate from the core CC functions, so I will show how to do it here:
+
+const char *FaucetCCaddr = "R9zHrofhRbub7ER77B7NrVch3A63R39GuC";
+const char *FaucetNormaladdr = "RKQV4oYs4rvxAWx1J43VnT73rSTVtUeckk";
+char FaucetCChexstr[67] = { "03682b255c40d0cde8faee381a1a50bbb89980ff24539cb8518e294d3a63cefe12" };
+uint8_t FaucetCCpriv[32] = { 0xd4, 0x4f, 0xf2, 0x31, 0x71, 0x7d, 0x28, 0x02, 0x4b, 0xc7, 0xdd, 0x71, 0xa0, 0x39, 0xc4, 0xbe, 0x1a, 0xfe, 0xeb, 0xc2, 0x46, 0xda, 0x76, 0xf8, 0x07, 0x53, 0x3d, 0x96, 0xb4, 0xca, 0xa0, 0xe9 };
+
+Above are the specifics for the faucet CC, but each one has the equivalent in CCcustom.cpp. At the bottom of the file is a big switch statement where these values are copied into an in memory data structure for each CC type. This allows all the CC codebase to access these special addresses in a standard way.
+
+In order to get the above values, follow these steps:
+A. use getnewaddress to get a new address and put that in the <CC>Normaladdr = ""; line
+B. use validateaddress <newaddress from A> to get the pubkey, which is put into the <CC>hexstr[67] = ""; line
+C. stop the daemon and start with -pubkey=<pubkey from B> and do a <CC>address rpc call. In the console you will get a printout of the hex for the privkey, assuming the if ( 0 ) in Myprivkey() is enabled (CCutils.cpp)
+D. update the CCaddress and privkey and dont forget to change the -pubkey= parameter
+
+The first rpc command to add is <CC>address and to do that, add a line to rpcserver.h and update the commands array in rpcserver.cpp
+
+In the rpcwallet.cpp file you will find the actual rpc functions, find one of the <CC>address ones, copy paste, change the eval code to your eval code and customize the function. Oh, and dont forget to add an entry into eval.h
+
+Now you have made your own CC contract, but it wont link as you still need to implement the actual functions of it. This will be covered in the following chapters.
+
+
+Chapter 5 - CC validation
+CC validation is what its all about, not the "hokey pokey"!
+
+Each CC must have its own validation function and when the blockchain is validating a transaction, it will call the CC validation code. It is totally up to the CC validation whether to validate it or not.
+
+Any set of rules that you can think of and implement can be part of the validation. Make sure that there is no ambiguity! Make sure that all transactions that should be rejected are in fact rejected.
+
+Also, make sure any rpc calls that create a CC transaction dont create anything that doesnt validate.
+
+Really, that is all that needs to be said about validation that is generic, as it is just a concept and gets a dedicated function to determine if a transaction is valid or not.
+
+For most of the initial CC contracts, I made a function code for various functions of the CC contract and add that along with the creation txid. That enables the validation of the transactions much easier, as the required data is right there in the opreturn.
+
+You do need to be careful not to cause a deadlock as the CC validation code is called while already locked in the main loop of the bitcoin protocol. As long as the provided CC contracts are used as models, you should keep out of deadlock troubles.
+
+
+Chapter 6 - faucet example
+Finally, we are ready for the first actual example of a CC contract. The faucet. This is a very simple contract and it ran into some interesting bugs in the first incarnation.
+
+The code in ~/komodo/src/cc/faucet.cpp is the ultimate documentation for it with all the details, so I will just address the conceptual issues here.
+
+The idea is that people send funds to the faucet by locking it in faucet's global CC address and anybody is allowed to create a faucetget transaction that spends it.
+
+There are only 7 functions in faucet.cpp, a bit over 200 lines including comments. The first three are for validation, the last four for the rpc calls to use.
+
+int64_t IsFaucetvout(struct CCcontract_info *cp,const CTransaction& tx,int32_t v)
+
+bool FaucetExactAmounts(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx,int32_t minage,uint64_t txfee)
+
+bool FaucetValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx)
+
+int64_t AddFaucetInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPubKey pk,int64_t total,int32_t maxinputs)
+
+std::string FaucetGet(uint64_t txfee)
+
+std::string FaucetFund(uint64_t txfee,int64_t funds)
+
+UniValue FaucetInfo()
+
+Functions in rpcwallet implement:
+
+faucetaddress fully implemented in rpcwallet.cpp
+faucetfund calls FaucetFund
+faucetget calls FaucetGet
+faucetinfo calls FaucetInfo
+
+Now you might not be a programmer, but I hope you are able to understand the above sequence. user types in a cli call, komodo-cli processes it by calling the rpc function, which in turn calls the function inside faucet.cpp
+
+No magic, just simple conversion of a user command line call that runs code inside the komodod. Both the faucetfund and faucetget create properly signed rawtransaction that is ready to be broadcast to the network using the standard sendrawtransaction rpc. It doesnt automatically do this to allow the GUI to have a confirmation step with all the details before doing an irrevocable CC contract transaction.
+
+faucetfund allows anybody to add funds to the faucet
+faucetget allows anybody to get 0.1 coins from the faucet as long as they dont violate the rules.
+
+And we come to what it is all about. The rules of the faucet. Initially it was much less strict and that allowed it to be drained slowly, but automatically and it prevented most from being able to use the faucet.
+
+To make it much harder to leech, it was made so each faucetget returned only 0.1 coins (down from 1.0) so it was worth 90% less. It was also made so that it had to be to a fresh address with less than 3 transactions. Finally each txid was constrained to start and end with 00! This is a cool trick to force usage of precious CPU time (20 to 60 seconds depending on system) to generate a valid txid. Like PoW mining for the txid and I expect other CC contracts to use a similar mechanism if they want to rate limit usage.
+
+Combined, it became such a pain to get 0.1 coins, the faucet leeching problem was solved. It might not seem like too much trouble to change an address to get another 0.1 coins, but the way things are setup you need to launch the komodod -pubkey=<your pubkey> to change the pubkey that is active for a node. That means to change the pubkey being used, the komodod needs to be restarted and this creates a lot of issues for any automation trying to do this. Combined with the PoW required, only when 0.1 coins becomes worth a significant effort will faucet leeching return. In that case, the PoW requirement can be increased and coin amount decreased, likely with a faucet2 CC contract as I dont expect many such variations to be needed.
+
+Chapter 7 - rewards example
+The next CC contract in complexity is the rewards CC contract. This is designed to capture what most people like about masternodes, without anything else, ie. the rewards!
+
+The idea is to allow people to lock funds for some amount of time and get an extra reward. We also want to support having more than one rewards plan at a time and to allow customization of plan details. One twist that makes it a bit unexpected is that anybody should be able to unlock the funds that were locked, as long as it ends up in the locking address. The reason for this is that SPV servers want to be supported and while locking can be done via normal sendrawtransaction, it requires a native node to do the unlocking. By allowing anybody to be able to unlock, then there can be a special node that unlocks all locked funds when they are ready. This way, from the user's point of view, they lock the funds and after it is matured, it reappears in their wallet.
+
+The above requirements leads us to using the global CC address for the rewards contract to lock the funds in. That allows anybody to properly sign the unlock, but of course that is not enough, we need to make sure they are following all the unlock requirements. Primarily that the funds go back to the locking address.
+
+The four aspects of the rewards plan that are customizable are:
+APR, minseconds, maxseconds, mindeposit
+
+This allows each plan to set a different APR (up to 25%, anything above is becoming silly), the minimum time funds must be locked, the maximum time they are earning rewards and the minimum that can be deposited.
+
+So the tx that creates the rewards plan will have these attributes and it is put into the OP_RETURN data. All the other calls will reference the plan creation txid and inherit these parameters from the creation tx. This means it is an important validation to do, to make sure the funding txid is a valid funding txid.
+
+Since it is possible that the initial funding will be used up, there needs to be a way for more funding to be added to the rewards plan.
+
+Having multiple possible rewards plans means it is useful to have rpc calls to get information about them. Hence: rewardslist returns the list of rewards creation txids and rewardsinfo <txid> returns the details about a specific rewards plan.
+
+A locking transaction sends funds to the rewards CC address, along with a normal (small) tx to the address that the unlock should go to. This allows the validation of the proper unlocking. Also, it is important to make sure only locking transactions are able to be unlocked. Additionally, the minimum time needs to elapse before unlocking is allowed.
+
+All of these things are done in rewards.cpp, with the validation code being about 200 lines and a total of 700 lines or so. Bigger than faucet, but most of the code is the non-consensus code to create the proper transactions. In order to simplify the validation, specific vin and vout positions are designated to have specific required values:
+
+createfunding
+vins.*: normal inputs
+vout.0: CC vout for funding
+vout.1: normal marker vout for easy searching
+vout.2: normal change
+vout.n-1: opreturn 'F' sbits APR minseconds maxseconds mindeposit
+
+addfunding
+vins.*: normal inputs
+vout.0: CC vout for funding
+vout.1: normal change
+vout.n-1: opreturn 'A' sbits fundingtxid
+
+lock
+vins.*: normal inputs
+vout.0: CC vout for locked funds
+vout.1: normal output to unlock address
+vout.2: change
+vout.n-1: opreturn 'L' sbits fundingtxid
+
+unlock
+vin.0: locked funds CC vout.0 from lock
+vin.1+: funding CC vout.0 from 'F' and 'A' and 'U'
+vout.0: funding CC change
+vout.1: normal output to unlock address
+vout.n-1: opreturn 'U' sbits fundingtxid
+
+It is recommended to create such a vin/vout allocation for each CC contract to make sure that the rpc calls that create the transaction and the validation code have a specific set of constraints that can be checked for.
+
+Chapter 8 - assets example
+In some respects the assets CC is the most complex, it was actually the first one that I coded. It is however using a simple model, even for the DEX functions, so while it is quite involved, it does not have the challenge/response complexity of dice.
+
+There are two major aspects to creating tokens. First is to create and track it, down to every specific satoshi. The second is solving how to implement DEX functions of trading assets.
+
+The model used is "colored coins". This means that the token creating txid issues the assets as denoted by all the satoshis, so locking 1 COIN issues 100 million tokens. This multiplication will allow creation of plenty of assets. We want to preserve all the tokens created across all allowed operations. The way this is achieved is that all operations attaches the token creation txid in its OP_RETURN, along with the specified operation.
+
+Ownership of tokens are represented by the colored satoshis in the CC address for the user's pubkey. This allows using the standard utxo system to automatically track ownership of the tokens. This automatic inheritance is one of the big advantages of utxo CC contracts that compensates for the slightly more work needed to implement a CC contract.
+
+So now we have the standard CC addresss, list and info commands that provide the CC addresses, list of all tokens and info on specific tokens and the ability to create and transfer tokens. Any amount of tokens can be created from 1 to very large numbers and using standard addressbalance, addressutxo type of commands, the details of all assets owned can be determined for a specific pubkey.
+
+Now we can solve the DEX part of the tokenization, which turns out to be much simpler than initially imagined. We start with bidding for a specific token. Funds for the bid are locked into the global CC address, along with the desired token and price. This creates a bid utxo that is able to be listed via an orderbook rpc call. To fill the bid, a specific bid utxo is spent with the appropriate number of assets and change and updated price for the unfilled amount. if the entire amount is filled, then it wont appear in the orderbook anymore.
+
+asks work by locking assets along with the required price. Partial fills can be supported and the rpc calls can mask the utxo-ness of the funds/assets needed by automatically gathering the required amount of funds to fill the specific amount.
+
+With calls to cancel the pending bid or ask, we get a complete set of rpc calls that can support a COIN-centric DEX.
+
+In the future, it is expected that a token swap rpc can be supported to allow directly swapping one token for another, but at first it is expected that there wont be sufficient volumes for such token to token swaps, so it was left out of the initial implementation.
+
+With just these rpc calls and associated validation, we get the ability to issue tokens and trade them on a DEX!
+
+create
+vin.0: normal input
+vout.0: issuance assetoshis to CC
+vout.1: tag sent to normal address of AssetsCCaddress
+vout.2: normal output for change (if any)
+vout.n-1: opreturn [EVAL_ASSETS] ['c'] [origpubkey] "<assetname>" "<description>"
+
+transfer
+vin.0: normal input
+vin.1 .. vin.n-1: valid CC outputs
+vout.0 to n-2: assetoshis output to CC
+vout.n-2: normal output for change (if any)
+vout.n-1: opreturn [EVAL_ASSETS] ['t'] [assetid]
+
+buyoffer:
+vins.*: normal inputs (bid + change)
+vout.0: amount of bid to unspendable
+vout.1: normal output for change (if any)
+vout.n-1: opreturn [EVAL_ASSETS] ['b'] [assetid] [amount of asset required] [origpubkey]
+
+cancelbuy:
+vin.0: normal input
+vin.1: unspendable.(vout.0 from buyoffer) buyTx.vout[0]
+vout.0: vin.1 value to original pubkey buyTx.vout[0].nValue -> [origpubkey]
+vout.1: normal output for change (if any)
+vout.n-1: opreturn [EVAL_ASSETS] ['o'] [assetid]
+
+fillbuy:
+vin.0: normal input
+vin.1: unspendable.(vout.0 from buyoffer) buyTx.vout[0]
+vin.2+: valid CC output satisfies buyoffer (*tx.vin[2])->nValue
+vout.0: remaining amount of bid to unspendable
+vout.1: vin.1 value to signer of vin.2
+vout.2: vin.2 assetoshis to original pubkey
+vout.3: CC output for assetoshis change (if any)
+vout.4: normal output for change (if any)
+vout.n-1: opreturn [EVAL_ASSETS] ['B'] [assetid] [remaining asset required] [origpubkey]
+
+selloffer:
+vin.0: normal input
+vin.1+: valid CC output for sale
+vout.0: vin.1 assetoshis output to CC to unspendable
+vout.1: CC output for change (if any)
+vout.2: normal output for change (if any)
+vout.n-1: opreturn [EVAL_ASSETS] ['s'] [assetid] [amount of native coin required] [origpubkey]
+
+cancel:
+vin.0: normal input
+vin.1: unspendable.(vout.0 from exchange or selloffer) sellTx/exchangeTx.vout[0] inputTx
+vout.0: vin.1 assetoshis to original pubkey CC sellTx/exchangeTx.vout[0].nValue -> [origpubkey]
+vout.1: normal output for change (if any)
+vout.n-1: opreturn [EVAL_ASSETS] ['x'] [assetid]
+
+fillsell:
+vin.0: normal input
+vin.1: unspendable.(vout.0 assetoshis from selloffer) sellTx.vout[0]
+vin.2+: normal output that satisfies selloffer (*tx.vin[2])->nValue
+vout.0: remaining assetoshis -> unspendable
+vout.1: vin.1 assetoshis to signer of vin.2 sellTx.vout[0].nValue -> any
+vout.2: vin.2 value to original pubkey [origpubkey]
+vout.3: CC asset for change (if any)
+vout.4: CC asset2 for change (if any) 'E' only
+vout.5: normal output for change (if any)
+vout.n-1: opreturn [EVAL_ASSETS] ['S'] [assetid] [amount of coin still required] [origpubkey]
+
+Chapter 9 - dice example
+The dice CC contract is actually more complex in the sequences required than the assets/tokens CC. The reason is the need for realtime response by the dealer node, but also having a way to resolve bets if the dealer node is not online. The dice CC contract shows how to build in such a challenge/response mechanism, which likely will be very useful for many other realtime interactive CC contracts.
+
+First, let us describe the issues that the dice CC contract needs to solve. Foremost is that it needs to be random and fair. It should also have realtime response and a fallback timeout in case the realtime response doesnt happen. As with the rewards CC contract, multiple dice plans are supported. Each plan can be customized as to the following:  minbet, maxbet, maxodds, timeoutblocks
+
+This allows each plan to control the risk exposure and also advertises to everyone when dicebets expire and a timeout win can be claimed. In event the dealer node does not process a dicebet in time, in order to prevent dealer nodes from simply not responding to dicebets that they lose, a timeout must go to the dicebet player. A short timeframe means that the dealer would need to be running multiple redundant nodes to make sure they can respond in time. If the timeout is set to long, then many players would prefer to use a different dice plan with a shorter timeout.
+
+Now to describe how to ensure a proper random number that is fair. The method chosen was for the dealer node to create transactions with hash of their entropy in the OP_RETURN. Then the dicebet player would select a specific entropy tx and include their (unhashed) entropy to their OP_RETURN. This allows the dealer node to immediately determine if the dicebet won or lost. If the dicebet included the hash of the bettor entropy, then another step would be needed. However, doing so would allow some timeouts to end with a refund, rather than an automatic win for the dicebet player.
+
+One additional technique used to keep all required data on the blockchain is the dealer entropy value calculation. The vin0 txid is used as one of the privkeys to calculate a shared secret and then hashed to remove links to the original privkey. This method allows recreating the dealer's entropy value (by the dealer node) given the blockchain itself, which means there is no need for any local storage.
+
+This allows the dealer node to recreate the unhashed entropy value used and so when the dicebet transaction is seen (in the mempool!), the dealer node can immediately determine if it is a winner or a loser. This is done by creating a dealer hash vs. a bettor hash via:
+
+dealer hash: SHA256(dealer entropy + bettor entropy)
+bettor hash: SHA256(bettor entropy + dealer entropy)
+
+The same values are used, but in different order. The resulting hashes are compared arithmetically for 1:1 bets and the standard industry use is used for the higher odds: https://dicesites.com/provably-fair
+
+The dealer creates a dice plan and then also needs to create entropy transactions. Each win or loss that creates change also creates entropy transactions by the dealer, but timeout transactions wont as it needs to be created by the dealer node to prevent cheating. The dealer tx are locked into the global dice CC address, as is the dicebet transaction, which selects a specific entropy tx to "roll" against. Then the dicefinish process by the dealer will spend the dicebet outputs either all to itself for a loss, or the winning amount to th dice bettor's address. For dicebets that are not dicefinish'ed by the dealer, anybody is able to do a timeout completion.
+
+createfunding:
+vins.*: normal inputs
+vout.0: CC vout for funding
+vout.1: owner vout
+vout.2: dice marker address vout for easy searching
+vout.3: normal change
+vout.n-1: opreturn 'F' sbits minbet maxbet maxodds timeoutblocks
+
+addfunding (entropy):
+vins.*: normal inputs
+vout.0: CC vout for locked entropy funds
+vout.1: tag to owner address for entropy funds
+vout.2: normal change
+vout.n-1: opreturn 'E' sbits fundingtxid hentropy
+
+bet:
+vin.0: entropy txid from house (must validate vin0 of 'E')
+vins.1+: normal inputs
+vout.0: CC vout for locked entropy
+vout.1: CC vout for locked bet
+vout.2: tag for bettor's address (txfee + odds)
+vout.3: change
+vout.n-1: opreturn 'B' sbits fundingtxid entropy
+
+loser:
+vin.0: normal input
+vin.1: betTx CC vout.0 entropy from bet
+vin.2: betTx CC vout.1 bet amount from bet
+vin.3+: funding CC vout.0 from 'F', 'E', 'W', 'L' or 'T'
+vout.0: funding CC to entropy owner
+vout.1: tag to owner address for entropy funds
+vout.2: change to fundingpk
+vout.n-1: opreturn 'L' sbits fundingtxid hentropy proof
+
+winner:
+same as loser, but vout.2 is winnings
+vout.3: change to fundingpk
+vout.n-1: opreturn 'W' sbits fundingtxid hentropy proof
+
+timeout:
+same as winner, just without hentropy or proof
+
+WARNING: there is an attack vector that precludes betting any large amounts, it goes as follows:
+1. do dicebet to get the house entropy revealed
+2. calculate bettor entropy that would win against the house entropy
+3. reorg the chain and make a big bet using the winning entropy calculated in 2.
+
+In order to mitigate this, the disclosure of the house entropy needs to be delayed beyond a reasonable reorg depth (notarization). It is recommended for production dice game with significant amounts of money to use such a delayed disclosure method.
+
+
+Chapter 10 - lotto example
+
+Chapter 11 - oracles example
+Oracles CC is an example where it ended up being simpler than I first expected, but at the same time a lot more powerful. It is one of the smaller CC, but it enables creation of an arbitrary number of data markets, in a performant way.
+
+In order to gain the performance, some clever usage of special addresses was needed. It was a bit tricky to generate a special address to keep track of the latest data.
+
+Let's back up to the beginning. Just what is an oracle? In this context it is something that puts data that is not on the blockchain, onto the blockchain. Since everything other than the transactions and blocks are not in the blockchain, there is a very large universe of data that can be oracle-ized. It can be literally anything, from the obvious like prices to specific results relative to an arbitrary description.
+
+The most difficult issue about oracles is that they need to be trusted to various degree to provide accurate and timely data. The danger is that if a trusted node is used to write data to the blockchain, it creates a trust point and a single point of attack. Ultimately there is nothing that can ensure only valid data is written to the blockchain, so what is done is to reinforce good behavior via pay per datapoint. However, for critical data, higher level processing is needed that combines multiple data providers into a validated signal.
+
+At the oracles CC level, it is enough that there is financial incentive to provide good data. Also it is needed to allow multiple vendors for each data that is required and to enable efficient ways to update and query the data.
+
+The following are the rpc calls:
+oraclescreate name description format
+oracleslist
+oraclesinfo oracletxid
+oraclesregister oracletxid datafee
+oraclessubscribe oracletxid publisher amount
+oraclesdata oracletxid hexstr
+oraclessamples oracletxid batonutxo num
+
+The first step is to create a specific data description with oraclescreate, which also defines the format of the binary data. This creates an oracletxid, which is used in the other rpc calls. name and description are just arbitrary strings, with name preferably being a short name used to access the data. The format is a string comprised of a single character per data element:
+
+'s' -> <256 char string
+'S' -> <65536 char string
+'d' -> <256 binary data
+'D' -> <65536 binary data
+'c' -> 1 byte signed little endian number, 'C' unsigned
+'t' -> 2 byte signed little endian number, 'T' unsigned
+'i' -> 4 byte signed little endian number, 'I' unsigned
+'l' -> 8 byte signed little endian number, 'L' unsigned
+'h' -> 32 byte hash
+
+For example, if the datapoint is comprised of a 4byte timestamp and an 8byte number the format string would be: "IL"
+
+oracleslist displays a list of all the oraclestxid and oraclesinfo displays information about the specific oracletxid. Each oracletxid deterministically generates a marker address and a small amount is sent to that address to mark a transaction's relation to the oracltxid.
+
+{
+"result": "success",
+"txid": "4895f631316a649e216153aee7a574bd281686265dc4e8d37597f72353facac3",
+"name": "BTCUSD",
+"description": "coindeskpricedata",
+"format": "L",
+"marker": "RVqJCSrdBm1gYJZS1h7dgtHioA5TEYzNRk",
+"registered": [
+{
+"publisher": "02ebc786cb83de8dc3922ab83c21f3f8a2f3216940c3bf9da43ce39e2a3a882c92",
+"baton": "RKY4zmHJZ5mNtf6tfKE5VMsKoV71Euej3i",
+"batontxid": "4de10b01242ce1a5e29d5fbb03098b4519976879e05ad0458ef7174ed9127f18",
+"lifetime": "1.50000000",
+"funds": "0.01000000",
+"datafee": "0.01000000"
+}
+]
+}
+
+A data publisher needs to register a datafee and their pubkey for a specific oracletxid. datafee needs to be at least as big as a txfee. Using oraclesregister the current datafee can be updated so a publisher can adapt to market conditions. Once registered, subscribers can prepay for some number of datapoints to a specific publisher using the oraclessubscribe rpc. At first, it is likely that the publisher would pay themselves to enable the posting of initial data points so the potential subscribers can evaluate the quality and consistency of the data.
+
+The one final rpc is oraclessamples, which returns the most recent samples of data from a specific publisher. In order to have a performant solution to track all the potential data streams from all the publishers for all the oracletxid, a baton utxo is used. This is an output sent to a specific address and expected to have just a single utxo at any given time to allow for direct lookup. oraclessamples requires a starting txid to use and with each datapoint having the prior batontxid, there is a reverse linked list to traverse the most recent data.
+
+In order to implement this, the following vin/vout contraints are used:
+
+create:
+vins.*: normal inputs
+vout.0: txfee tag to oracle normal address
+vout.1: change, if any
+vout.n-1: opreturn with name and description and format for data
+
+register:
+vins.*: normal inputs
+vout.0: txfee tag to normal marker address
+vout.1: baton CC utxo
+vout.2: change, if any
+vout.n-1: opreturn with oracletxid, pubkey and price per data point
+
+subscribe:
+vins.*: normal inputs
+vout.0: subscription fee to publishers CC address
+vout.1: change, if any
+vout.n-1: opreturn with oracletxid, registered provider's pubkey, amount
+
+data:
+vin.0: normal input
+vin.1: baton CC utxo (most of the time)
+vin.2+: subscription or data vout.0
+vout.0: change to publishers CC address
+vout.1: baton CC utxo
+vout.2: payment for dataprovider
+vout.3: change, if any
+vout.n-1: opreturn with oracletxid, prevbatontxid and data in proper format
+
+The oraclesdata transaction is the most complex as it needs to find and spend the baton utxo, use the correct datafee and spend funds from the locked subscription funds. With the above, the oracles CC is complete and allows the creations of massively parallel data streams from multiple vendors that uses free market feedback via payments, ie. poorly performing providers wont get renewals.
+
+I expect that at first, the data providers will just be dapp developers deploying a working system including the required data, but its structure allows open market competition. Of course, specific dapps could restrict themselves to using only publishers from a whitelist of pubkeys. The potential usecases for oracles CC is quite varied and limited only by the imagination.
+
+Chapter 12 - limitless possibilities
+As can be seen, CC contracts can do a wide range of things and since they are Turing complete, we know that this is true. However, what is more important is the added security gained from using a utxo based system. While in some ways it is more complex to have to deal with utxo, as can be seen by the above examples, it is either solved and made invisible at the rpc level, or actually used as part of the solution.
+
+Being utxo based, automatically builds in a rate limit to how many tx per block a specific CC contract can do. The state advancing by one transaction at a time is another means that rate limits. Since more utxo can be made available to increase capacity, it actually offers a way for managing load.
+
+I believe I have made one of the first operational utxo smart contracts, CC or otherwise and hope that there will be many more developers joining forces to create more foundational CC contracts. Feel free to contact me for feedback on the type of CC contract you want to make. I have not documented all my notes and it could well be I already sort of know how to implement what your want your CC contract to do. Just only so many I can actually make time to code and debug.
+
+Our testing cycle went a lot faster than expected as the bugs found were few and far between. Considering the scope of the assets CC and the realtime response aspects of dice CC, this was quite unexpected. I can only attribute it to the fact that CC validation is just the final validation on top of all the standard bitcoin protocol validations. Not having to worry about double spends is sure a nice luxury, though dont get too complacent about chain rewrites! It is possible to wait for information to be divulged and then reorg the chain to take advantage of this knowledge in a chain which is rewound.
+
+Yes, blockchains are complicated.
+
+Chapter 13 - different languages
+The current codebase is integrated into the komodod codebase, which is C/C++. However, it is possible to use different languages and integrate into the C/C++ as zcash has shown by using the rust language for some parts of the zcashd.
+
+I think any language that is compiled and can create a linkable library while being able to call and be called by C/C++ functions can be used. If you are able to make such a language binding for a simple CC contract like faucet, this will be good for a 777 KMD bounty. Of course, you need to be the first to submit a properly working pull request.
+
+
+Chapter 14 - runtime bindings
+Once build time linking works, then it is one step away from being able to do runtime linking, ie. dynamically linked libraries. There will be some work required to prevent duplication of eval codes and making sure it is a valid version of the CC contract plugin, but these are issues that have been solved before and I dont see any reason they cant be solved for CC contracts.
+
+This would open up the door for quite an interesting ecosystem of CC plugins that blockchains can subscribe to.
+
+Chapter 15 - rpc based dapps
+Ultimately, I expect there to be so many new rpc calls (one set from each CC contract), that virtually any dapp can be made with rpc calls. We are just at the beginning now, but it is just a matter of time when we get there.
+
+For now, we just need to keep listening to what the market wants as far as dapps go. Then make a new CC contract that enables doing as many of those as possible.
+
+Repeat...
+
+Imagine the scope that will exist after a year or two of continuous new CC contracts being created, along with all the rpc based dapps. I have seen some automatic GUI generators and it could be that for most cases, there can be a special GUI that not only create the dapp's GUI, but also all the rpc calls that are needed to make it work the way it is customized.
+
+This codebase and tools in between the GUI and the rpc level will be a very good area for new initiatives.
+
+##########
+
+Conclusion
+I hope this document has helped you understand what a Komodo utxo based CC contract is and how it is different from the other smart contracts. If you are now able to dive into the cc directory and start making your own CC contract, then I am very happy!
+
+
+
+
+
+
+
diff --git a/src/cc/CCGateways.h b/src/cc/CCGateways.h
new file mode 100644
index 000000000..1b7852725
--- /dev/null
+++ b/src/cc/CCGateways.h
@@ -0,0 +1,27 @@
+/******************************************************************************
+ * Copyright © 2014-2018 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+
+
+#ifndef CC_GATEWAYS_H
+#define CC_GATEWAYS_H
+
+#include "CCinclude.h"
+
+bool GatewaysValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx);
+
+// CCcustom
+UniValue GatewaysInfo();
+
+#endif
diff --git a/src/cc/CCMofN.h b/src/cc/CCMofN.h
new file mode 100644
index 000000000..170200d77
--- /dev/null
+++ b/src/cc/CCMofN.h
@@ -0,0 +1,29 @@
+/******************************************************************************
+ * Copyright © 2014-2018 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+
+
+#ifndef CC_MOFN_H
+#define CC_MOFN_H
+
+#include "CCinclude.h"
+
+#define EVAL_MOFN 0xea
+
+bool MofNValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx);
+
+// CCcustom
+UniValue MofNInfo();
+
+#endif
diff --git a/src/cc/CCOracles.h b/src/cc/CCOracles.h
new file mode 100644
index 000000000..bddb9b15b
--- /dev/null
+++ b/src/cc/CCOracles.h
@@ -0,0 +1,35 @@
+/******************************************************************************
+ * Copyright © 2014-2018 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+
+
+#ifndef CC_ORACLES_H
+#define CC_ORACLES_H
+
+#include "CCinclude.h"
+
+#define ORACLES_MAXPROVIDERS 64
+
+bool OraclesValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx);
+std::string OracleCreate(int64_t txfee,std::string name,std::string description,std::string format);
+std::string OracleRegister(int64_t txfee,uint256 oracletxid,int64_t datafee);
+std::string OracleSubscribe(int64_t txfee,uint256 oracletxid,CPubKey publisher,int64_t amount);
+std::string OracleData(int64_t txfee,uint256 oracletxid,std::vector <uint8_t> data);
+
+// CCcustom
+UniValue OracleDataSamples(uint256 reforacletxid,uint256 batontxid,int32_t num);
+UniValue OracleInfo(uint256 origtxid);
+UniValue OraclesList();
+
+#endif
diff --git a/src/cc/CCPayments.h b/src/cc/CCPayments.h
new file mode 100644
index 000000000..7e7a0e681
--- /dev/null
+++ b/src/cc/CCPayments.h
@@ -0,0 +1,27 @@
+/******************************************************************************
+ * Copyright © 2014-2018 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+
+
+#ifndef CC_PAYMENTS_H
+#define CC_PAYMENTS_H
+
+#include "CCinclude.h"
+
+bool PaymentsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx);
+
+// CCcustom
+UniValue PaymentsInfo();
+
+#endif
diff --git a/src/cc/CCPegs.h b/src/cc/CCPegs.h
new file mode 100644
index 000000000..296e0c272
--- /dev/null
+++ b/src/cc/CCPegs.h
@@ -0,0 +1,27 @@
+/******************************************************************************
+ * Copyright © 2014-2018 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+
+
+#ifndef CC_PEGS_H
+#define CC_PEGS_H
+
+#include "CCinclude.h"
+
+bool PegsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx);
+
+// CCcustom
+UniValue PegsInfo();
+
+#endif
diff --git a/src/cc/CCPrices.h b/src/cc/CCPrices.h
new file mode 100644
index 000000000..8b09e9267
--- /dev/null
+++ b/src/cc/CCPrices.h
@@ -0,0 +1,27 @@
+/******************************************************************************
+ * Copyright © 2014-2018 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+
+
+#ifndef CC_PRICES_H
+#define CC_PRICES_H
+
+#include "CCinclude.h"
+
+bool PricesValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx);
+
+// CCcustom
+UniValue PricesInfo();
+
+#endif
diff --git a/src/cc/CCTriggers.h b/src/cc/CCTriggers.h
new file mode 100644
index 000000000..4e9881c52
--- /dev/null
+++ b/src/cc/CCTriggers.h
@@ -0,0 +1,27 @@
+/******************************************************************************
+ * Copyright © 2014-2018 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+
+
+#ifndef CC_TRIGGERS_H
+#define CC_TRIGGERS_H
+
+#include "CCinclude.h"
+
+bool TriggersValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx);
+
+// CCcustom
+UniValue TriggersInfo();
+
+#endif
diff --git a/src/cc/CCassetsCore.cpp b/src/cc/CCassetsCore.cpp
index 9ef08348e..a9361ede4 100644
--- a/src/cc/CCassetsCore.cpp
+++ b/src/cc/CCassetsCore.cpp
@@ -68,10 +68,10 @@ bool ValidateBidRemainder(int64_t remaining_units,int64_t remaining_nValue,int64
             newunitprice = (remaining_nValue / remaining_units);
         if ( recvunitprice < unitprice )
         {
-            fprintf(stderr,"error recvunitprice %.16f < %.16f unitprice, new unitprice %.16f\n",(double)recvunitprice/(COIN),(double)unitprice/(COIN),(double)newunitprice/(COIN));
+            fprintf(stderr,"error recvunitprice %.8f < %.8f unitprice, new unitprice %.8f\n",(double)recvunitprice/(COIN),(double)unitprice/(COIN),(double)newunitprice/(COIN));
             return(false);
         }
-        fprintf(stderr,"orig %llu total %llu, recv %llu paid %llu,recvunitprice %.16f >= %.16f unitprice, new unitprice %.16f\n",(long long)orig_nValue,(long long)totalunits,(long long)received_nValue,(long long)paidunits,(double)recvunitprice/(COIN),(double)unitprice/(COIN),(double)newunitprice/(COIN));
+        fprintf(stderr,"orig %llu total %llu, recv %llu paid %llu,recvunitprice %.8f >= %.8f unitprice, new unitprice %.8f\n",(long long)orig_nValue,(long long)totalunits,(long long)received_nValue,(long long)paidunits,(double)recvunitprice/(COIN),(double)unitprice/(COIN),(double)newunitprice/(COIN));
     }
     return(true);
 }
@@ -222,10 +222,10 @@ bool ValidateSwapRemainder(int64_t remaining_price,int64_t remaining_nValue,int6
             newunitprice = (remaining_nValue * COIN) / remaining_price;
         if ( recvunitprice < unitprice )
         {
-            fprintf(stderr,"error recvunitprice %.16f < %.16f unitprice, new unitprice %.16f\n",(double)recvunitprice/(COIN*COIN),(double)unitprice/(COIN*COIN),(double)newunitprice/(COIN*COIN));
+            fprintf(stderr,"error recvunitprice %.8f < %.8f unitprice, new unitprice %.8f\n",(double)recvunitprice/(COIN*COIN),(double)unitprice/(COIN*COIN),(double)newunitprice/(COIN*COIN));
             return(false);
         }
-        fprintf(stderr,"recvunitprice %.16f >= %.16f unitprice, new unitprice %.16f\n",(double)recvunitprice/(COIN*COIN),(double)unitprice/(COIN*COIN),(double)newunitprice/(COIN*COIN));
+        fprintf(stderr,"recvunitprice %.8f >= %.8f unitprice, new unitprice %.8f\n",(double)recvunitprice/(COIN*COIN),(double)unitprice/(COIN*COIN),(double)newunitprice/(COIN*COIN));
     }
     return(true);
 }
diff --git a/src/cc/CCassetstx.cpp b/src/cc/CCassetstx.cpp
index 74ef9fb58..45b9d7d6e 100644
--- a/src/cc/CCassetstx.cpp
+++ b/src/cc/CCassetstx.cpp
@@ -14,7 +14,6 @@
  ******************************************************************************/
 
 #include "CCassets.h"
-extern std::string CCerror;
 
 int64_t AddAssetInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPubKey pk,uint256 assetid,int64_t total,int32_t maxinputs)
 {
diff --git a/src/cc/CCchannels.h b/src/cc/CCchannels.h
new file mode 100644
index 000000000..26057457f
--- /dev/null
+++ b/src/cc/CCchannels.h
@@ -0,0 +1,33 @@
+/******************************************************************************
+ * Copyright © 2014-2018 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+
+
+#ifndef CC_CHANNELS_H
+#define CC_CHANNELS_H
+
+#include "CCinclude.h"
+#define CHANNELS_MAXPAYMENTS 1000
+
+bool ChannelsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx);
+std::string ChannelOpen(uint64_t txfee,CPubKey destpub,int32_t numpayments,int64_t payment);
+std::string ChannelStop(uint64_t txfee,CPubKey destpub,uint256 origtxid);
+std::string ChannelPayment(uint64_t txfee,uint256 prevtxid,uint256 origtxid,int32_t n,int64_t amount);
+std::string ChannelCollect(uint64_t txfee,uint256 paytxid,uint256 origtxid,int32_t n,int64_t amount);
+std::string ChannelRefund(uint64_t txfee,uint256 stoptxid,uint256 origtxid);
+
+// CCcustom
+UniValue ChannelsInfo();
+
+#endif
diff --git a/src/cc/CCcustom.cpp b/src/cc/CCcustom.cpp
index 9bf1d5449..d9a793ddd 100644
--- a/src/cc/CCcustom.cpp
+++ b/src/cc/CCcustom.cpp
@@ -21,6 +21,14 @@
 #include "CCauction.h"
 #include "CClotto.h"
 #include "CCfsm.h"
+#include "CCMofN.h"
+#include "CCchannels.h"
+#include "CCOracles.h"
+#include "CCPrices.h"
+#include "CCPegs.h"
+#include "CCTriggers.h"
+#include "CCPayments.h"
+#include "CCGateways.h"
 
 /*
  CCcustom has most of the functions that need to be extended to create a new CC contract.
@@ -44,10 +52,7 @@
  Make sure both the CC coins and normal coins are preserved and follow the rules that make sense. It is a good idea to define specific roles for specific vins and vouts to reduce the complexity of validation.
  */
 
-//BTCD Address: RAssetsAtGnvwgK9gVHBbAU4sVTah1hAm5
-//BTCD Privkey: UvtvQVgVScXEYm4J3r4nE4nbFuGXSVM5pKec8VWXwgG9dmpWBuDh
-//BTCD Address: RSavingsEYcivt2DFsxsKeCjqArV6oVtVZ
-//BTCD Privkey: Ux6XQekTxokko6gZHz24B7PUsmUQtWFzG2W9nUA8jba7UoVbPBF4
+// to create a new CCaddr, add to rpcwallet the CCaddress and start with -pubkey= with the pubkey of the new address, with its wif already imported. set normaladdr and CChexstr. run CCaddress and it will print the privkey along with autocorrect the CCaddress. which should then update the CCaddr here
 
 // Assets, aka Tokens
 #define FUNCNAME IsAssetsInput
@@ -128,6 +133,94 @@ uint8_t AuctionCCpriv[32] = { 0x8c, 0x1b, 0xb7, 0x8c, 0x02, 0xa3, 0x9d, 0x21, 0x
 #undef FUNCNAME
 #undef EVALCODE
 
+// MofN
+#define FUNCNAME IsMofNInput
+#define EVALCODE EVAL_MOFN
+const char *MofNCCaddr = "RDVHcSekmXgeYBqRupNTmqo3Rn8QRXNduy";
+const char *MofNNormaladdr = "RTPwUjKYECcGn6Y4KYChLhgaht1RSU4jwf";
+char MofNCChexstr[67] = { "03c91bef3d7cc59c3a89286833a3446b29e52a5e773f738a1ad2b09785e5f4179e" };
+uint8_t MofNCCpriv[32] = { 0x9d, 0xa1, 0xf8, 0xf7, 0xba, 0x0a, 0x91, 0x36, 0x89, 0x9a, 0x86, 0x30, 0x63, 0x20, 0xd7, 0xdf, 0xaa, 0x35, 0xe3, 0x99, 0x32, 0x2b, 0x63, 0xc0, 0x66, 0x9c, 0x93, 0xc4, 0x5e, 0x9d, 0xb9, 0xce };
+#include "CCcustom.inc"
+#undef FUNCNAME
+#undef EVALCODE
+
+// Channels
+#define FUNCNAME IsChannelsInput
+#define EVALCODE EVAL_CHANNELS
+const char *ChannelsCCaddr = "RQy3rwX8sP9oDm3c39vGKA6H315cgtPLfr";
+const char *ChannelsNormaladdr = "RQUuT8zmkvDfXqECH4m3VD3SsHZAfnoh1v";
+char ChannelsCChexstr[67] = { "035debdb19b1c98c615259339500511d6216a3ffbeb28ff5655a7ef5790a12ab0b" };
+uint8_t ChannelsCCpriv[32] = { 0xec, 0x91, 0x36, 0x15, 0x2d, 0xd4, 0x48, 0x73, 0x22, 0x36, 0x4f, 0x6a, 0x34, 0x5c, 0x61, 0x0f, 0x01, 0xb4, 0x79, 0xe8, 0x1c, 0x2f, 0xa1, 0x1d, 0x4a, 0x0a, 0x21, 0x16, 0xea, 0x82, 0x84, 0x60 };
+#include "CCcustom.inc"
+#undef FUNCNAME
+#undef EVALCODE
+
+// Oracles
+#define FUNCNAME IsOraclesInput
+#define EVALCODE EVAL_ORACLES
+const char *OraclesCCaddr = "REt2C4ZMnX8YYX1DRpffNA4hECZTFm39e3";
+const char *OraclesNormaladdr = "RHkFKzn1csxA3fWzAsxsLWohoCgBbirXb5";
+char OraclesCChexstr[67] = { "038c1d42db6a45a57eccb8981b078fb7857b9b496293fe299d2b8d120ac5b5691a" };
+uint8_t OraclesCCpriv[32] = { 0xf7, 0x4b, 0x5b, 0xa2, 0x7a, 0x5e, 0x9c, 0xda, 0x89, 0xb1, 0xcb, 0xb9, 0xe6, 0x9c, 0x2c, 0x70, 0x85, 0x37, 0xdd, 0x00, 0x7a, 0x67, 0xff, 0x7c, 0x62, 0x1b, 0xe2, 0xfb, 0x04, 0x8f, 0x85, 0xbf };
+#include "CCcustom.inc"
+#undef FUNCNAME
+#undef EVALCODE
+
+// Prices
+#define FUNCNAME IsPricesInput
+#define EVALCODE EVAL_PRICES
+const char *PricesCCaddr = "RAL5Vh8NXmFqEKJRKrk1KjKaUckK7mM1iS";
+const char *PricesNormaladdr = "RBunXCsMHk5NPd6q8SQfmpgre3x133rSwZ";
+char PricesCChexstr[67] = { "039894cb054c0032e99e65e715b03799607aa91212a16648d391b6fa2cc52ed0cf" };
+uint8_t PricesCCpriv[32] = { 0x0a, 0x3b, 0xe7, 0x5d, 0xce, 0x06, 0xed, 0xb7, 0xc0, 0xb1, 0xbe, 0xe8, 0x7b, 0x5a, 0xd4, 0x99, 0xb8, 0x8d, 0xde, 0xac, 0xb2, 0x7e, 0x7a, 0x52, 0x96, 0x15, 0xd2, 0xa0, 0xc6, 0xb9, 0x89, 0x61 };
+#include "CCcustom.inc"
+#undef FUNCNAME
+#undef EVALCODE
+
+// Pegs
+#define FUNCNAME IsPegsInput
+#define EVALCODE EVAL_PEGS
+const char *PegsCCaddr = "RHnkVb7vHuHnjEjhkCF1bS6xxLLNZPv5fd";
+const char *PegsNormaladdr = "RMcCZtX6dHf1fz3gpLQhUEMQ8cVZ6Rzaro";
+char PegsCChexstr[67] = { "03c75c1de29a35e41606363b430c08be1c2dd93cf7a468229a082cc79c7b77eece" };
+uint8_t PegsCCpriv[32] = { 0x52, 0x56, 0x4c, 0x78, 0x87, 0xf7, 0xa2, 0x39, 0xb0, 0x90, 0xb7, 0xb8, 0x62, 0x80, 0x0f, 0x83, 0x18, 0x9d, 0xf4, 0xf4, 0xbd, 0x28, 0x09, 0xa9, 0x9b, 0x85, 0x54, 0x16, 0x0f, 0x3f, 0xfb, 0x65 };
+#include "CCcustom.inc"
+#undef FUNCNAME
+#undef EVALCODE
+
+// Triggers
+#define FUNCNAME IsTriggersInput
+#define EVALCODE EVAL_TRIGGERS
+const char *TriggersCCaddr = "RGLSRDnUqTB43bYtRtNVgmwSSd1sun2te8";
+const char *TriggersNormaladdr = "RMN25Tn8NNzcyQDiQNuMp8UmwLMFd9thYc";
+char TriggersCChexstr[67] = { "03afc5be570d0ff419425cfcc580cc762ab82baad88c148f5b028d7db7bfeee61d" };
+uint8_t TriggersCCpriv[32] = { 0x7c, 0x0b, 0x54, 0x9b, 0x65, 0xd4, 0x89, 0x57, 0xdf, 0x05, 0xfe, 0xa2, 0x62, 0x41, 0xa9, 0x09, 0x0f, 0x2a, 0x6b, 0x11, 0x2c, 0xbe, 0xbd, 0x06, 0x31, 0x8d, 0xc0, 0xb9, 0x96, 0x76, 0x3f, 0x24 };
+#include "CCcustom.inc"
+#undef FUNCNAME
+#undef EVALCODE
+
+// Payments
+#define FUNCNAME IsPaymentsInput
+#define EVALCODE EVAL_PAYMENTS
+const char *PaymentsCCaddr = "REpyKi7avsVduqZ3eimncK4uKqSArLTGGK";
+const char *PaymentsNormaladdr = "RHRX8RTMAh2STWe9DHqsvJbzS7ty6aZy3d";
+char PaymentsCChexstr[67] = { "0358f1764f82c63abc7c7455555fd1d3184905e30e819e97667e247e5792b46856" };
+uint8_t PaymentsCCpriv[32] = { 0x03, 0xc9, 0x73, 0xc2, 0xb8, 0x30, 0x3d, 0xbd, 0xc8, 0xd9, 0xbf, 0x02, 0x49, 0xd9, 0x65, 0x61, 0x45, 0xed, 0x9e, 0x93, 0x51, 0xab, 0x8b, 0x2e, 0xe7, 0xc7, 0x40, 0xf1, 0xc4, 0xd2, 0xc0, 0x5b };
+#include "CCcustom.inc"
+#undef FUNCNAME
+#undef EVALCODE
+
+// Gateways
+#define FUNCNAME IsGatewaysInput
+#define EVALCODE EVAL_GATEWAYS
+const char *GatewaysCCaddr = "RKWpoK6vTRtq5b9qrRBodLkCzeURHeEk33";
+const char *GatewaysNormaladdr = "RGJKV97ZN1wBfunuMt1tebiiHENNEq73Yh";
+char GatewaysCChexstr[67] = { "03ea9c062b9652d8eff34879b504eda0717895d27597aaeb60347d65eed96ccb40" };
+uint8_t GatewaysCCpriv[32] = { 0xf7, 0x4b, 0x5b, 0xa2, 0x7a, 0x5e, 0x9c, 0xda, 0x89, 0xb1, 0xcb, 0xb9, 0xe6, 0x9c, 0x2c, 0x70, 0x85, 0x37, 0xdd, 0x00, 0x7a, 0x67, 0xff, 0x7c, 0x62, 0x1b, 0xe2, 0xfb, 0x04, 0x8f, 0x85, 0xbf };
+#include "CCcustom.inc"
+#undef FUNCNAME
+#undef EVALCODE
+
 struct CCcontract_info *CCinit(struct CCcontract_info *cp,uint8_t evalcode)
 {
     cp->evalcode = evalcode;
@@ -189,6 +282,70 @@ struct CCcontract_info *CCinit(struct CCcontract_info *cp,uint8_t evalcode)
             cp->validate = AuctionValidate;
             cp->ismyvin = IsAuctionInput;
             break;
+        case EVAL_MOFN:
+            strcpy(cp->unspendableCCaddr,MofNCCaddr);
+            strcpy(cp->normaladdr,MofNNormaladdr);
+            strcpy(cp->CChexstr,MofNCChexstr);
+            memcpy(cp->CCpriv,MofNCCpriv,32);
+            cp->validate = MofNValidate;
+            cp->ismyvin = IsMofNInput;
+            break;
+        case EVAL_CHANNELS:
+            strcpy(cp->unspendableCCaddr,ChannelsCCaddr);
+            strcpy(cp->normaladdr,ChannelsNormaladdr);
+            strcpy(cp->CChexstr,ChannelsCChexstr);
+            memcpy(cp->CCpriv,ChannelsCCpriv,32);
+            cp->validate = ChannelsValidate;
+            cp->ismyvin = IsChannelsInput;
+            break;
+        case EVAL_ORACLES:
+            strcpy(cp->unspendableCCaddr,OraclesCCaddr);
+            strcpy(cp->normaladdr,OraclesNormaladdr);
+            strcpy(cp->CChexstr,OraclesCChexstr);
+            memcpy(cp->CCpriv,OraclesCCpriv,32);
+            cp->validate = OraclesValidate;
+            cp->ismyvin = IsOraclesInput;
+            break;
+        case EVAL_PRICES:
+            strcpy(cp->unspendableCCaddr,PricesCCaddr);
+            strcpy(cp->normaladdr,PricesNormaladdr);
+            strcpy(cp->CChexstr,PricesCChexstr);
+            memcpy(cp->CCpriv,PricesCCpriv,32);
+            cp->validate = PricesValidate;
+            cp->ismyvin = IsPricesInput;
+            break;
+        case EVAL_PEGS:
+            strcpy(cp->unspendableCCaddr,PegsCCaddr);
+            strcpy(cp->normaladdr,PegsNormaladdr);
+            strcpy(cp->CChexstr,PegsCChexstr);
+            memcpy(cp->CCpriv,PegsCCpriv,32);
+            cp->validate = PegsValidate;
+            cp->ismyvin = IsPegsInput;
+            break;
+        case EVAL_TRIGGERS:
+            strcpy(cp->unspendableCCaddr,TriggersCCaddr);
+            strcpy(cp->normaladdr,TriggersNormaladdr);
+            strcpy(cp->CChexstr,TriggersCChexstr);
+            memcpy(cp->CCpriv,TriggersCCpriv,32);
+            cp->validate = TriggersValidate;
+            cp->ismyvin = IsTriggersInput;
+            break;
+        case EVAL_PAYMENTS:
+            strcpy(cp->unspendableCCaddr,PaymentsCCaddr);
+            strcpy(cp->normaladdr,PaymentsNormaladdr);
+            strcpy(cp->CChexstr,PaymentsCChexstr);
+            memcpy(cp->CCpriv,PaymentsCCpriv,32);
+            cp->validate = PaymentsValidate;
+            cp->ismyvin = IsPaymentsInput;
+            break;
+        case EVAL_GATEWAYS:
+            strcpy(cp->unspendableCCaddr,GatewaysCCaddr);
+            strcpy(cp->normaladdr,GatewaysNormaladdr);
+            strcpy(cp->CChexstr,GatewaysCChexstr);
+            memcpy(cp->CCpriv,GatewaysCCpriv,32);
+            cp->validate = GatewaysValidate;
+            cp->ismyvin = IsGatewaysInput;
+            break;
     }
     return(cp);
 }
diff --git a/src/cc/CCinclude.h b/src/cc/CCinclude.h
index 4795ead3c..6cf32b1c5 100644
--- a/src/cc/CCinclude.h
+++ b/src/cc/CCinclude.h
@@ -16,6 +16,26 @@
 #ifndef CC_INCLUDE_H
 #define CC_INCLUDE_H
 
+/*
+there are only a very few types in bitcoin. pay to pubkey, pay to pubkey hash and pay to script hash
+p2pk, p2pkh, p2sh
+there are actually more that are possible, but those three are 99%+ of bitcoin transactions
+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.
+all of the above are the standard bitcoin vout types and there should be plenty of materials about it
+Encrypted by a verified device
+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.
+ 
+but it gets more interesting
+each CC script has an evalcode
+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
+
+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!
+and this allows efficient segregation of one CC contracts transactions from another
+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
+
+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
+*/
+
 #include <cc/eval.h>
 #include <script/cc.h>
 #include <script/script.h>
@@ -27,8 +47,11 @@
 #include "../wallet/wallet.h"
 #include <univalue.h>
 #include <exception>
+#include "../komodo_defs.h"
 
 extern int32_t KOMODO_CONNECTING,KOMODO_CCACTIVATE;
+extern uint32_t ASSETCHAINS_CC;
+extern std::string CCerror;
 
 #define SMALLVAL 0.000000000000001
 union _bits256 { uint8_t bytes[32]; uint16_t ushorts[16]; uint32_t uints[8]; uint64_t ulongs[4]; uint64_t txid; };
@@ -44,8 +67,9 @@ struct CC_utxo
 struct CCcontract_info
 {
     uint256 prevtxid;
-    char unspendableCCaddr[64],CChexstr[72],normaladdr[64];
-    uint8_t CCpriv[32];
+    char unspendableCCaddr[64],CChexstr[72],normaladdr[64],unspendableaddr2[64];
+    uint8_t CCpriv[32],unspendablepriv2[32];
+    CPubKey unspendablepk2;
     bool (*validate)(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx);
     bool (*ismyvin)(CScript const& scriptSig);
     uint8_t evalcode,didinit;
@@ -66,12 +90,20 @@ bool myIsutxo_spentinmempool(uint256 txid,int32_t vout);
 int32_t myIsutxo_spent(uint256 &spenttxid,uint256 txid,int32_t vout);
 bool mySendrawtransaction(std::string res);
 int32_t decode_hex(uint8_t *bytes,int32_t n,char *hex);
+int32_t iguana_rwnum(int32_t rwflag,uint8_t *serialized,int32_t len,void *endianedp);
+int32_t iguana_rwbignum(int32_t rwflag,uint8_t *serialized,int32_t len,uint8_t *endianedp);
+
+int64_t OraclePrice(int32_t height,uint256 reforacletxid,char *markeraddr,char *format);
 
 // CCcustom
 CPubKey GetUnspendable(struct CCcontract_info *cp,uint8_t *unspendablepriv);
 
 // CCutils
+CPubKey buf2pk(uint8_t *buf33);
+void endiancpy(uint8_t *dest,uint8_t *src,int32_t len);
+uint256 DiceHashEntropy(uint256 &entropy,uint256 _txidpriv);
 CTxOut MakeCC1vout(uint8_t evalcode,CAmount nValue,CPubKey pk);
+CTxOut MakeCC1of2vout(uint8_t evalcode,CAmount nValue,CPubKey pk,CPubKey pk2);
 CC *MakeCCcond1(uint8_t evalcode,CPubKey pk);
 CC* GetCryptoCondition(CScript const& scriptSig);
 bool IsCCInput(CScript const& scriptSig);
@@ -83,6 +115,7 @@ char *pubkey33_str(char *dest,uint8_t *pubkey33);
 uint256 Parseuint256(char *hexstr);
 CPubKey pubkey2pk(std::vector<uint8_t> pubkey);
 bool GetCCaddress(struct CCcontract_info *cp,char *destaddr,CPubKey pk);
+bool GetCCaddress1of2(struct CCcontract_info *cp,char *destaddr,CPubKey pk,CPubKey pk2);
 bool ConstrainVout(CTxOut vout,int32_t CCflag,char *cmpaddr,int64_t nValue);
 bool PreventCC(Eval* eval,const CTransaction &tx,int32_t preventCCvins,int32_t numvins,int32_t preventCCvouts,int32_t numvouts);
 bool Getscriptaddress(char *destaddr,const CScript &scriptPubKey);
diff --git a/src/cc/CClotto.h b/src/cc/CClotto.h
index 41e3cb5b1..784441c57 100644
--- a/src/cc/CClotto.h
+++ b/src/cc/CClotto.h
@@ -23,6 +23,8 @@
 
 bool LottoValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx);
 
+UniValue LottoInfo(uint256 lottoid);
+UniValue LottoList();
 std::string LottoTicket(uint64_t txfee,int64_t numtickets);
 std::string LottoWinner(uint64_t txfee);
 
diff --git a/src/cc/CCtx.cpp b/src/cc/CCtx.cpp
index 2c3001c10..4764f4ff6 100644
--- a/src/cc/CCtx.cpp
+++ b/src/cc/CCtx.cpp
@@ -41,7 +41,7 @@ bool SignTx(CMutableTransaction &mtx,int32_t vini,int64_t utxovalue,const CScrip
 std::string FinalizeCCTx(uint64_t CCmask,struct CCcontract_info *cp,CMutableTransaction &mtx,CPubKey mypk,uint64_t txfee,CScript opret)
 {
     auto consensusBranchId = CurrentEpochBranchId(chainActive.Height() + 1, Params().GetConsensus());
-    CTransaction vintx; std::string hex; uint256 hashBlock; uint64_t mask=0,nmask=0,vinimask=0; int64_t utxovalues[64],change,normalinputs=0,totaloutputs=0,normaloutputs=0,totalinputs=0; int32_t i,utxovout,n,err = 0; char myaddr[64],destaddr[64],unspendable[64]; uint8_t *privkey,myprivkey[32],unspendablepriv[32],*msg32 = 0; CC *mycond=0,*othercond=0,*cond; CPubKey unspendablepk;
+    CTransaction vintx; std::string hex; uint256 hashBlock; uint64_t mask=0,nmask=0,vinimask=0; int64_t utxovalues[64],change,normalinputs=0,totaloutputs=0,normaloutputs=0,totalinputs=0; int32_t i,utxovout,n,err = 0; char myaddr[64],destaddr[64],unspendable[64]; uint8_t *privkey,myprivkey[32],unspendablepriv[32],*msg32 = 0; CC *mycond=0,*othercond=0,*othercond2=0,*cond; CPubKey unspendablepk;
     n = mtx.vout.size();
     for (i=0; i<n; i++)
     {
@@ -119,6 +119,14 @@ std::string FinalizeCCTx(uint64_t CCmask,struct CCcontract_info *cp,CMutableTran
                     cond = othercond;
                     //fprintf(stderr,"unspendable CC addr.(%s)\n",unspendable);
                 }
+                else if ( strcmp(destaddr,cp->unspendableaddr2) == 0 )
+                {
+                    //fprintf(stderr,"matched %s unspendable2!\n",cp->unspendableaddr2);
+                    privkey = cp->unspendablepriv2;
+                    if ( othercond2 == 0 )
+                        othercond2 = MakeCCcond1(cp->evalcode,cp->unspendablepk2);
+                    cond = othercond2;
+                }
                 else
                 {
                     fprintf(stderr,"vini.%d has unknown CC address.(%s)\n",i,destaddr);
@@ -136,7 +144,10 @@ std::string FinalizeCCTx(uint64_t CCmask,struct CCcontract_info *cp,CMutableTran
                     //fprintf(stderr," signed with privkey\n");
                     mtx.vin[i].scriptSig = CCSig(cond);
                 }
-                else fprintf(stderr,"vini.%d has CC signing error address.(%s)\n",i,destaddr);
+                else
+                {
+                    fprintf(stderr,"vini.%d has CC signing error address.(%s)\n",i,destaddr);
+                }
             }
         } else fprintf(stderr,"FinalizeCCTx couldnt find %s\n",mtx.vin[i].prevout.hash.ToString().c_str());
     }
diff --git a/src/cc/CCutils.cpp b/src/cc/CCutils.cpp
index 3c38d04b3..fea8e0ddf 100644
--- a/src/cc/CCutils.cpp
+++ b/src/cc/CCutils.cpp
@@ -19,13 +19,25 @@
  CCutils has low level functions that are universally useful for all contracts.
  */
 
-CTxOut MakeCC1vout(uint8_t evalcode,CAmount nValue,CPubKey pk)
+void endiancpy(uint8_t *dest,uint8_t *src,int32_t len)
 {
-    CTxOut vout;
-    CC *payoutCond = MakeCCcond1(evalcode,pk);
-    vout = CTxOut(nValue,CCPubKey(payoutCond));
-    cc_free(payoutCond);
-    return(vout);
+    int32_t i,j=0;
+#if defined(WORDS_BIGENDIAN)
+    for (i=31; i>=0; i--)
+        dest[j++] = src[i];
+#else
+    memcpy(dest,src,len);
+#endif
+}
+
+CC *MakeCCcond1of2(uint8_t evalcode,CPubKey pk1,CPubKey pk2)
+{
+    std::vector<CC*> pks;
+    pks.push_back(CCNewSecp256k1(pk1));
+    pks.push_back(CCNewSecp256k1(pk2));
+    CC *condCC = CCNewEval(E_MARSHAL(ss << evalcode));
+    CC *Sig = CCNewThreshold(1, pks);
+    return CCNewThreshold(2, {condCC, Sig});
 }
 
 CC *MakeCCcond1(uint8_t evalcode,CPubKey pk)
@@ -37,6 +49,24 @@ CC *MakeCCcond1(uint8_t evalcode,CPubKey pk)
     return CCNewThreshold(2, {condCC, Sig});
 }
 
+CTxOut MakeCC1vout(uint8_t evalcode,CAmount nValue,CPubKey pk)
+{
+    CTxOut vout;
+    CC *payoutCond = MakeCCcond1(evalcode,pk);
+    vout = CTxOut(nValue,CCPubKey(payoutCond));
+    cc_free(payoutCond);
+    return(vout);
+}
+
+CTxOut MakeCC1of2vout(uint8_t evalcode,CAmount nValue,CPubKey pk1,CPubKey pk2)
+{
+    CTxOut vout;
+    CC *payoutCond = MakeCCcond1of2(evalcode,pk1,pk2);
+    vout = CTxOut(nValue,CCPubKey(payoutCond));
+    cc_free(payoutCond);
+    return(vout);
+}
+
 CC* GetCryptoCondition(CScript const& scriptSig)
 {
     auto pc = scriptSig.begin();
@@ -119,6 +149,15 @@ uint256 Parseuint256(char *hexstr)
     return(txid);
 }
 
+CPubKey buf2pk(uint8_t *buf33)
+{
+    CPubKey pk; int32_t i; uint8_t *dest;
+    dest = (uint8_t *)pk.begin();
+    for (i=0; i<33; i++)
+        dest[i] = buf33[i];
+    return(pk);
+}
+
 CPubKey pubkey2pk(std::vector<uint8_t> pubkey)
 {
     CPubKey pk; int32_t i,n; uint8_t *dest,*pubkey33;
@@ -156,6 +195,18 @@ bool GetCCaddress(struct CCcontract_info *cp,char *destaddr,CPubKey pk)
     return(destaddr[0] != 0);
 }
 
+bool GetCCaddress1of2(struct CCcontract_info *cp,char *destaddr,CPubKey pk,CPubKey pk2)
+{
+    CC *payoutCond;
+    destaddr[0] = 0;
+    if ( (payoutCond= MakeCCcond1of2(cp->evalcode,pk,pk2)) != 0 )
+    {
+        Getscriptaddress(destaddr,CCPubKey(payoutCond));
+        cc_free(payoutCond);
+    }
+    return(destaddr[0] != 0);
+}
+
 bool ConstrainVout(CTxOut vout,int32_t CCflag,char *cmpaddr,int64_t nValue)
 {
     char destaddr[64];
@@ -235,7 +286,7 @@ bool Myprivkey(uint8_t myprivkey[])
                 {
                     for (i=0; i<32; i++)
                         fprintf(stderr,"0x%02x, ",myprivkey[i]);
-                    fprintf(stderr," found privkey!\n");
+                    fprintf(stderr," found privkey for %s!\n",dest);
                 }
                 return(true);
             }
@@ -266,7 +317,7 @@ bool ProcessCC(struct CCcontract_info *cp,Eval* eval, std::vector<uint8_t> param
         from_mempool = 1;
         height &= ((1<<30) - 1);
     }
-    fprintf(stderr,"KOMODO_CONNECTING.%d mempool.%d vs CCactive.%d\n",height,from_mempool,KOMODO_CCACTIVATE);
+    //fprintf(stderr,"KOMODO_CONNECTING.%d mempool.%d vs CCactive.%d\n",height,from_mempool,KOMODO_CCACTIVATE);
     // there is a chance CC tx is valid in mempool, but invalid when in block, so we cant filter duplicate requests. if any of the vins are spent, for example
     //txid = ctx.GetHash();
     //if ( txid == cp->prevtxid )
diff --git a/src/cc/MofN.cpp b/src/cc/MofN.cpp
new file mode 100644
index 000000000..84952176f
--- /dev/null
+++ b/src/cc/MofN.cpp
@@ -0,0 +1,226 @@
+/******************************************************************************
+ * Copyright © 2014-2018 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+
+#include "CCMofN.h"
+
+/*
+ The idea of MofN CC is to allow non-interactive multisig, preferably in a cross chain compatible way, ie. for actual bitcoin multisig.
+ 
+ full redeemscript in an initial tx with opreturn
+ ability to post partial signatures and construct a full transaction from M such partial signatures
+ a new transaction would refer to the initialtx and other partial would refer to both
+ 
+ There is no need for a CC contract to use it for normal multisig as normal multisig transactions are already supported.
+ 
+ In order to take advantage of CC powers, we can create a more powerful multisig using shamir's secret MofN (up to 255) algo to allow spends. Using the same non-interactive partial signing is possible. also, in addition to spending, data payload can have additional data that is also revealed when the funds are spent.
+ 
+ rpc calls needed:
+ 1) create msig address (normal or shamir)
+ 2) post payment with partial sig
+ 3) add partial sig to 2)
+ 4) combine and submit M partial sigs
+ 
+*/
+
+// start of consensus code
+
+int64_t IsMofNvout(struct CCcontract_info *cp,const CTransaction& tx,int32_t v)
+{
+    char destaddr[64];
+    if ( tx.vout[v].scriptPubKey.IsPayToCryptoCondition() != 0 )
+    {
+        if ( Getscriptaddress(destaddr,tx.vout[v].scriptPubKey) > 0 && strcmp(destaddr,cp->unspendableCCaddr) == 0 )
+            return(tx.vout[v].nValue);
+    }
+    return(0);
+}
+
+bool MofNExactAmounts(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx,int32_t minage,uint64_t txfee)
+{
+    static uint256 zerohash;
+    CTransaction vinTx; uint256 hashBlock,activehash; int32_t i,numvins,numvouts; int64_t inputs=0,outputs=0,assetoshis;
+    numvins = tx.vin.size();
+    numvouts = tx.vout.size();
+    for (i=0; i<numvins; i++)
+    {
+        //fprintf(stderr,"vini.%d\n",i);
+        if ( (*cp->ismyvin)(tx.vin[i].scriptSig) != 0 )
+        {
+            //fprintf(stderr,"vini.%d check mempool\n",i);
+            if ( eval->GetTxUnconfirmed(tx.vin[i].prevout.hash,vinTx,hashBlock) == 0 )
+                return eval->Invalid("cant find vinTx");
+            else
+            {
+                //fprintf(stderr,"vini.%d check hash and vout\n",i);
+                if ( hashBlock == zerohash )
+                    return eval->Invalid("cant MofN from mempool");
+                if ( (assetoshis= IsMofNvout(cp,vinTx,tx.vin[i].prevout.n)) != 0 )
+                    inputs += assetoshis;
+            }
+        }
+    }
+    for (i=0; i<numvouts; i++)
+    {
+        //fprintf(stderr,"i.%d of numvouts.%d\n",i,numvouts);
+        if ( (assetoshis= IsMofNvout(cp,tx,i)) != 0 )
+            outputs += assetoshis;
+    }
+    if ( inputs != outputs+txfee )
+    {
+        fprintf(stderr,"inputs %llu vs outputs %llu\n",(long long)inputs,(long long)outputs);
+        return eval->Invalid("mismatched inputs != outputs + txfee");
+    }
+    else return(true);
+}
+
+bool MofNValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx)
+{
+    int32_t numvins,numvouts,preventCCvins,preventCCvouts,i,numblocks; bool retval; uint256 txid; uint8_t hash[32]; char str[65],destaddr[64];
+    return(false);
+    std::vector<std::pair<CAddressIndexKey, CAmount> > txids;
+    numvins = tx.vin.size();
+    numvouts = tx.vout.size();
+    preventCCvins = preventCCvouts = -1;
+    if ( numvouts < 1 )
+        return eval->Invalid("no vouts");
+    else
+    {
+        for (i=0; i<numvins; i++)
+        {
+            if ( IsCCInput(tx.vin[0].scriptSig) == 0 )
+            {
+                return eval->Invalid("illegal normal vini");
+            }
+        }
+        //fprintf(stderr,"check amounts\n");
+        if ( MofNExactAmounts(cp,eval,tx,1,10000) == false )
+        {
+            fprintf(stderr,"mofnget invalid amount\n");
+            return false;
+        }
+        else
+        {
+            txid = tx.GetHash();
+            memcpy(hash,&txid,sizeof(hash));
+            retval = PreventCC(eval,tx,preventCCvins,numvins,preventCCvouts,numvouts);
+            if ( retval != 0 )
+                fprintf(stderr,"mofnget validated\n");
+            else fprintf(stderr,"mofnget invalid\n");
+            return(retval);
+        }
+    }
+}
+// end of consensus code
+
+// helper functions for rpc calls in rpcwallet.cpp
+
+int64_t AddMofNInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPubKey pk,int64_t total,int32_t maxinputs)
+{
+    char coinaddr[64]; int64_t nValue,price,totalinputs = 0; uint256 txid,hashBlock; std::vector<uint8_t> origpubkey; CTransaction vintx; int32_t vout,n = 0;
+    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
+    GetCCaddress(cp,coinaddr,pk);
+    SetCCunspents(unspentOutputs,coinaddr);
+    for (std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> >::const_iterator it=unspentOutputs.begin(); it!=unspentOutputs.end(); it++)
+    {
+        txid = it->first.txhash;
+        vout = (int32_t)it->first.index;
+        // no need to prevent dup
+        if ( GetTransaction(txid,vintx,hashBlock,false) != 0 )
+        {
+            if ( (nValue= IsMofNvout(cp,vintx,vout)) > 1000000 && myIsutxo_spentinmempool(txid,vout) == 0 )
+            {
+                if ( total != 0 && maxinputs != 0 )
+                    mtx.vin.push_back(CTxIn(txid,vout,CScript()));
+                nValue = it->second.satoshis;
+                totalinputs += nValue;
+                n++;
+                if ( (total > 0 && totalinputs >= total) || (maxinputs > 0 && n >= maxinputs) )
+                    break;
+            }
+        }
+    }
+    return(totalinputs);
+}
+
+std::string MofNGet(uint64_t txfee,int64_t nValue)
+{
+    CMutableTransaction mtx,tmpmtx; CPubKey mypk,mofnpk; int64_t inputs,CCchange=0; struct CCcontract_info *cp,C; std::string rawhex; uint32_t j; int32_t i,len; uint8_t buf[32768]; bits256 hash;
+    cp = CCinit(&C,EVAL_MOFN);
+    if ( txfee == 0 )
+        txfee = 10000;
+    mofnpk = GetUnspendable(cp,0);
+    mypk = pubkey2pk(Mypubkey());
+    if ( (inputs= AddMofNInputs(cp,mtx,mofnpk,nValue+txfee,60)) > 0 )
+    {
+        if ( inputs > nValue )
+            CCchange = (inputs - nValue - txfee);
+        if ( CCchange != 0 )
+            mtx.vout.push_back(MakeCC1vout(EVAL_MOFN,CCchange,mofnpk));
+        mtx.vout.push_back(CTxOut(nValue,CScript() << ParseHex(HexStr(mypk)) << OP_CHECKSIG));
+        fprintf(stderr,"start at %u\n",(uint32_t)time(NULL));
+        j = rand() & 0xfffffff;
+        for (i=0; i<1000000; i++,j++)
+        {
+            tmpmtx = mtx;
+            rawhex = FinalizeCCTx(-1LL,cp,tmpmtx,mypk,txfee,CScript() << OP_RETURN << E_MARSHAL(ss << (uint8_t)EVAL_MOFN << (uint8_t)'G' << j));
+            if ( (len= (int32_t)rawhex.size()) > 0 && len < 65536 )
+            {
+                len >>= 1;
+                decode_hex(buf,len,(char *)rawhex.c_str());
+                hash = bits256_doublesha256(0,buf,len);
+                if ( (hash.bytes[0] & 0xff) == 0 && (hash.bytes[31] & 0xff) == 0 )
+                {
+                    fprintf(stderr,"found valid txid after %d iterations %u\n",i,(uint32_t)time(NULL));
+                    return(rawhex);
+                }
+                //fprintf(stderr,"%02x%02x ",hash.bytes[0],hash.bytes[31]);
+            }
+        }
+        fprintf(stderr,"couldnt generate valid txid %u\n",(uint32_t)time(NULL));
+        return("");
+    } else fprintf(stderr,"cant find mofn inputs\n");
+    return("");
+}
+
+std::string MofNFund(uint64_t txfee,int64_t funds)
+{
+    CMutableTransaction mtx; CPubKey mypk,mofnpk; CScript opret; struct CCcontract_info *cp,C;
+    cp = CCinit(&C,EVAL_MOFN);
+    if ( txfee == 0 )
+        txfee = 10000;
+    mypk = pubkey2pk(Mypubkey());
+    mofnpk = GetUnspendable(cp,0);
+    if ( AddNormalinputs(mtx,mypk,funds+txfee,64) > 0 )
+    {
+        mtx.vout.push_back(MakeCC1vout(EVAL_MOFN,funds,mofnpk));
+        return(FinalizeCCTx(0,cp,mtx,mypk,txfee,opret));
+    }
+    return("");
+}
+
+UniValue MofNInfo()
+{
+    UniValue result(UniValue::VOBJ); char numstr[64];
+    CMutableTransaction mtx; CPubKey mofnpk; struct CCcontract_info *cp,C; int64_t funding;
+    result.push_back(Pair("result","success"));
+    result.push_back(Pair("name","MofN"));
+    cp = CCinit(&C,EVAL_MOFN);
+    mofnpk = GetUnspendable(cp,0);
+    funding = AddMofNInputs(cp,mtx,mofnpk,0,0);
+    sprintf(numstr,"%.8f",(double)funding/COIN);
+    result.push_back(Pair("funding",numstr));
+    return(result);
+}
+
diff --git a/src/cc/channels.cpp b/src/cc/channels.cpp
new file mode 100644
index 000000000..dc1a3f291
--- /dev/null
+++ b/src/cc/channels.cpp
@@ -0,0 +1,337 @@
+/******************************************************************************
+ * Copyright © 2014-2018 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+
+#include "CCchannels.h"
+
+/*
+ The idea here is to allow instant (mempool) payments that are secured by dPoW. In order to simplify things, channels CC will require creating reserves for each payee locked in the destination user's CC address. This will look like the payment is already made, but it is locked until further released. The dPoW protection comes from the cancel channel having a delayed effect until the next notarization. This way, if a payment release is made and the chain reorged, the same payment release will still be valid when it is re-broadcast into the mempool.
+ 
+ In order to achieve this effect, the payment release needs to be in a special form where its input cannot be spent only by the sender.
+
+ Given sender's payment to dest CC address, only the destination is able to spend, so we need to constrain that spending with a release mechanism. One idea is a 2of2 multisig, but that has the issue of needing confirmation and since a sender utxo is involved, subject to doublespend and we lose the speed. Another idea is release on secrets! since once revealed, the secret remains valid, this method is immune from double spend. Also, there is no worry about an MITM attack as the funds are only spendable by the destination pubkey and only with the secret. The secrets can be sent via any means, including OP_RETURN of normal transaction in the mempool.
+ 
+ Now the only remaining issue for sending is how to allocate funds to the secrets. This needs to be sent as hashes of secrets when the channel is created. A bruteforce method would be one secret per COIN, but for large amount channels this is cumbersome. A more practical approach is to have a set of secrets for each order of magnitude:
+ 
+ 123.45 channel funds -> 1x secret100, 2x secret10, 3x secret1, 4x secret.1, 5x secret.01
+ 15 secrets achieves the 123.45 channel funding.
+ 
+ In order to avoid networking issues, the convention can be to send tx to normal address of destination with just an OP_RETURN, for the cost of txfee. For micropayments, a separate method of secret release needs to be established, but that is beyond the scope of this CC.
+ 
+ There is now the dPoW security that needs to be ensured. In order to close the channel, a tx needs to be confirmed that cancels the channel. As soon as this tx is seen, the destination will know that the channel will be closing soon, if the node is online. If not, the payments cant be credited anyway, so it seems no harm. Even after the channel is closed, it is possible for secrets to be releasing funds, but depending on when the notarization happens, it could invalidate the spends, so it is safest that as soon as the channel cancel tx is confirmed to invalidate any further payments released.
+ 
+ Given a channelclose and notarization confirmation (or enough blocks), the remaining funds needs to be able to come back to the sender. this means the funds need to be in a 1of2 CC multisig to allow either party to spend. Cheating is prevented by the additional rules of spending, ie. denomination secrets, or channelclose.
+ 
+ For efficiency we want to allow batch spend with multiple secrets to claim a single total
+ 
+ Second iteration:
+ As implementing it, some efficieny gains to be made with a slightly different approach.
+ Instead of separate secrets for each amount, a hashchain will be used, each releasing the same amount
+ 
+ To spend, the prior value in the hash chain is published, or can publish N deep. validation takes N hashes.
+ 
+ Also, in order to be able to track open channels, a tag is needed to be sent and better to send to a normal CC address for a pubkey to isolate the transactions for channel opens.
+ 
+Possible third iteration:
+ Let us try to setup a single "hot wallet" address to have all the channel funds and use it for payments to any destination. If there are no problems with reorgs and double spends, this would allow everyone to be "connected" to everyone else via the single special address.
+ 
+ So funds -> user's CC address along with hashchain, but likely best to have several utxo to span order of magnitudes.
+ 
+ a micropayment would then spend a utxo and attach a shared secret encoded unhashed link from the hashchain. That makes the receiver the only one that can decode the actual hashchain's prior value.
+ 
+ however, since this spend is only spendable by the sender, it is subject to a double spend attack. It seems it is a dead end. Alternative is to use the global CC address, but that commingles all funds from all users and any accounting error puts all funds at risk.
+ 
+ So, back to the second iteration, which is the only one so far that is immune from doublespend attack as the funds are already in the destination's CC address. One complication is that due to CC sorting of pubkeys, the address for sending and receiving is the same, so the destination pubkey needs to be attached to each opreturn.
+ 
+ Now when the prior hashchain value is sent via payment, it allows the receiver to spend the utxo, so the only protection needed is to prevent channel close from invalidating already made payments.
+ 
+ In order to allow multiple payments included in a single transaction, presentation of the N prior hashchain value can be used to get N payments and all the spends create a spending chain in sequential order of the hashchain.
+ 
+*/
+
+// start of consensus code
+
+int64_t IsChannelsvout(struct CCcontract_info *cp,const CTransaction& tx,int32_t v)
+{
+    char destaddr[64];
+    if ( tx.vout[v].scriptPubKey.IsPayToCryptoCondition() != 0 )
+    {
+        if ( Getscriptaddress(destaddr,tx.vout[v].scriptPubKey) > 0 && strcmp(destaddr,cp->unspendableCCaddr) == 0 )
+            return(tx.vout[v].nValue);
+    }
+    return(0);
+}
+
+bool ChannelsExactAmounts(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx,int32_t minage,uint64_t txfee)
+{
+    static uint256 zerohash;
+    CTransaction vinTx; uint256 hashBlock,activehash; int32_t i,numvins,numvouts; int64_t inputs=0,outputs=0,assetoshis;
+    numvins = tx.vin.size();
+    numvouts = tx.vout.size();
+    for (i=0; i<numvins; i++)
+    {
+        //fprintf(stderr,"vini.%d\n",i);
+        if ( (*cp->ismyvin)(tx.vin[i].scriptSig) != 0 )
+        {
+            //fprintf(stderr,"vini.%d check mempool\n",i);
+            if ( eval->GetTxUnconfirmed(tx.vin[i].prevout.hash,vinTx,hashBlock) == 0 )
+                return eval->Invalid("cant find vinTx");
+            else
+            {
+                //fprintf(stderr,"vini.%d check hash and vout\n",i);
+                if ( hashBlock == zerohash )
+                    return eval->Invalid("cant Channels from mempool");
+                if ( (assetoshis= IsChannelsvout(cp,vinTx,tx.vin[i].prevout.n)) != 0 )
+                    inputs += assetoshis;
+            }
+        }
+    }
+    for (i=0; i<numvouts; i++)
+    {
+        //fprintf(stderr,"i.%d of numvouts.%d\n",i,numvouts);
+        if ( (assetoshis= IsChannelsvout(cp,tx,i)) != 0 )
+            outputs += assetoshis;
+    }
+    if ( inputs != outputs+txfee )
+    {
+        fprintf(stderr,"inputs %llu vs outputs %llu\n",(long long)inputs,(long long)outputs);
+        return eval->Invalid("mismatched inputs != outputs + txfee");
+    }
+    else return(true);
+}
+
+bool ChannelsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx)
+{
+    int32_t numvins,numvouts,preventCCvins,preventCCvouts,i,numblocks; bool retval; uint256 txid; uint8_t hash[32]; char str[65],destaddr[64];
+    return(false);
+    std::vector<std::pair<CAddressIndexKey, CAmount> > txids;
+    numvins = tx.vin.size();
+    numvouts = tx.vout.size();
+    preventCCvins = preventCCvouts = -1;
+    if ( numvouts < 1 )
+        return eval->Invalid("no vouts");
+    else
+    {
+        for (i=0; i<numvins; i++)
+        {
+            if ( IsCCInput(tx.vin[0].scriptSig) == 0 )
+            {
+                return eval->Invalid("illegal normal vini");
+            }
+        }
+        //fprintf(stderr,"check amounts\n");
+        if ( ChannelsExactAmounts(cp,eval,tx,1,10000) == false )
+        {
+            fprintf(stderr,"Channelsget invalid amount\n");
+            return false;
+        }
+        else
+        {
+            txid = tx.GetHash();
+            memcpy(hash,&txid,sizeof(hash));
+            retval = PreventCC(eval,tx,preventCCvins,numvins,preventCCvouts,numvouts);
+            if ( retval != 0 )
+                fprintf(stderr,"Channelsget validated\n");
+            else fprintf(stderr,"Channelsget invalid\n");
+            return(retval);
+        }
+    }
+}
+// end of consensus code
+
+// helper functions for rpc calls in rpcwallet.cpp
+
+CScript EncodeChannelsOpRet(uint8_t funcid,CPubKey srcpub,CPubKey destpub,int32_t numpayments,int64_t payment,uint256 hashchain)
+{
+    CScript opret; uint8_t evalcode = EVAL_CHANNELS;
+    opret << OP_RETURN << E_MARSHAL(ss << evalcode << funcid << srcpub << destpub << numpayments << payment << hashchain);
+    return(opret);
+}
+
+uint8_t DecodeChannelsOpRet(uint256 txid,const CScript &scriptPubKey,CPubKey &srcpub,CPubKey &destpub,int32_t &numpayments,int64_t &payment,uint256 &hashchain)
+{
+    std::vector<uint8_t> vopret; uint8_t *script,e,f,funcid;
+    GetOpReturnData(scriptPubKey, vopret);
+    if ( vopret.size() > 2 )
+    {
+        script = (uint8_t *)vopret.data();
+        if ( script[0] == EVAL_CHANNELS )
+        {
+            if ( E_UNMARSHAL(vopret,ss >> e; ss >> f; ss >> srcpub; ss >> destpub; ss >> numpayments; ss >> payment; ss >> hashchain) != 0 )
+            {
+                return(f);
+            }
+        } else fprintf(stderr,"script[0] %02x != EVAL_CHANNELS\n",script[0]);
+    } else fprintf(stderr,"not enough opret.[%d]\n",(int32_t)vopret.size());
+    return(0);
+}
+
+int64_t AddChannelsInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPubKey pk,int64_t total,int32_t maxinputs)
+{
+    char coinaddr[64]; int64_t nValue,price,totalinputs = 0; uint256 txid,hashBlock; std::vector<uint8_t> origpubkey; CTransaction vintx; int32_t vout,n = 0;
+    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
+    GetCCaddress(cp,coinaddr,pk);
+    SetCCunspents(unspentOutputs,coinaddr);
+    for (std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> >::const_iterator it=unspentOutputs.begin(); it!=unspentOutputs.end(); it++)
+    {
+        txid = it->first.txhash;
+        vout = (int32_t)it->first.index;
+        // no need to prevent dup
+        if ( GetTransaction(txid,vintx,hashBlock,false) != 0 )
+        {
+            if ( (nValue= IsChannelsvout(cp,vintx,vout)) > 0 && myIsutxo_spentinmempool(txid,vout) == 0 )
+            {
+                if ( total != 0 && maxinputs != 0 )
+                    mtx.vin.push_back(CTxIn(txid,vout,CScript()));
+                nValue = it->second.satoshis;
+                totalinputs += nValue;
+                n++;
+                if ( (total > 0 && totalinputs >= total) || (maxinputs > 0 && n >= maxinputs) )
+                    break;
+            }
+        }
+    }
+    return(totalinputs);
+}
+
+std::string ChannelOpen(uint64_t txfee,CPubKey destpub,int32_t numpayments,int64_t payment)
+{
+    CMutableTransaction mtx; uint8_t hash[32],hashdest[32]; uint64_t funds; int32_t i; uint256 hashchain,entropy,hentropy; CPubKey mypk; struct CCcontract_info *cp,C;
+    if ( numpayments <= 0 || payment <= 0 || numpayments > CHANNELS_MAXPAYMENTS )
+    {
+        CCerror = strprintf("invalid ChannelsFund param numpayments.%d max.%d payment.%lld\n",numpayments,CHANNELS_MAXPAYMENTS,(long long)payment);
+        fprintf(stderr,"%s\n",CCerror.c_str());
+        return("");
+    }
+    cp = CCinit(&C,EVAL_CHANNELS);
+    if ( txfee == 0 )
+        txfee = 10000;
+    mypk = pubkey2pk(Mypubkey());
+    funds = numpayments * payment;
+    if ( AddNormalinputs(mtx,mypk,funds+3*txfee,64) > 0 )
+    {
+        hentropy = DiceHashEntropy(entropy,mtx.vin[0].prevout.hash);
+        endiancpy(hash,(uint8_t *)&hentropy,32);
+        for (i=0; i<numpayments; i++)
+        {
+            vcalc_sha256(0,hashdest,hash,32);
+            memcpy(hash,hashdest,32);
+        }
+        endiancpy((uint8_t *)&hashchain,hashdest,32);
+        mtx.vout.push_back(MakeCC1of2vout(EVAL_CHANNELS,funds,mypk,destpub));
+        mtx.vout.push_back(MakeCC1vout(EVAL_CHANNELS,txfee,mypk));
+        mtx.vout.push_back(MakeCC1vout(EVAL_CHANNELS,txfee,destpub));
+        return(FinalizeCCTx(0,cp,mtx,mypk,txfee,EncodeChannelsOpRet('O',mypk,destpub,numpayments,payment,hashchain)));
+    }
+    return("");
+}
+
+std::string ChannelStop(uint64_t txfee,CPubKey destpub,uint256 origtxid)
+{
+    CMutableTransaction mtx; CPubKey mypk; struct CCcontract_info *cp,C;
+    // verify this is one of our outbound channels
+    cp = CCinit(&C,EVAL_CHANNELS);
+    if ( txfee == 0 )
+        txfee = 10000;
+    mypk = pubkey2pk(Mypubkey());
+    if ( AddNormalinputs(mtx,mypk,2*txfee,1) > 0 )
+    {
+        mtx.vout.push_back(MakeCC1vout(EVAL_CHANNELS,txfee,mypk));
+        return(FinalizeCCTx(0,cp,mtx,mypk,txfee,EncodeChannelsOpRet('S',mypk,destpub,0,0,zeroid)));
+    }
+    return("");
+}
+
+std::string ChannelPayment(uint64_t txfee,uint256 prevtxid,uint256 origtxid,int32_t n,int64_t amount)
+{
+    CMutableTransaction mtx; CPubKey mypk,destpub; uint256 secret; struct CCcontract_info *cp,C; int32_t prevdepth;
+    // verify lasttxid and origtxid match and src is me
+    // also verify hashchain depth and amount, set prevdepth
+    cp = CCinit(&C,EVAL_CHANNELS);
+    if ( txfee == 0 )
+        txfee = 10000;
+    mypk = pubkey2pk(Mypubkey());
+    if ( AddNormalinputs(mtx,mypk,2*txfee,1) > 0 )
+    {
+        // add locked funds inputs
+        mtx.vout.push_back(MakeCC1vout(EVAL_CHANNELS,txfee,mypk));
+        return(FinalizeCCTx(0,cp,mtx,mypk,txfee,EncodeChannelsOpRet('P',mypk,destpub,prevdepth-n,amount,secret)));
+    }
+    return("");
+}
+
+std::string ChannelCollect(uint64_t txfee,uint256 paytxid,uint256 origtxid,int32_t n,int64_t amount)
+{
+    CMutableTransaction mtx; CPubKey mypk,senderpub; struct CCcontract_info *cp,C; int32_t prevdepth;
+    // verify paytxid and origtxid match and dest is me
+    // also verify hashchain depth and amount
+    cp = CCinit(&C,EVAL_CHANNELS);
+    if ( txfee == 0 )
+        txfee = 10000;
+    mypk = pubkey2pk(Mypubkey());
+    if ( AddNormalinputs(mtx,mypk,2*txfee,1) > 0 )
+    {
+        // add locked funds inputs
+        mtx.vout.push_back(MakeCC1vout(EVAL_CHANNELS,txfee,mypk));
+        mtx.vout.push_back(CTxOut(amount,CScript() << ParseHex(HexStr(mypk)) << OP_CHECKSIG));
+        return(FinalizeCCTx(0,cp,mtx,mypk,txfee,EncodeChannelsOpRet('C',senderpub,mypk,prevdepth-n,amount,paytxid)));
+    }
+    return("");
+}
+
+std::string ChannelRefund(uint64_t txfee,uint256 stoptxid,uint256 origtxid)
+{
+    CMutableTransaction mtx; CPubKey mypk; struct CCcontract_info *cp,C; int64_t amount;
+    // verify stoptxid and origtxid match and are mine
+    cp = CCinit(&C,EVAL_CHANNELS);
+    if ( txfee == 0 )
+        txfee = 10000;
+    mypk = pubkey2pk(Mypubkey());
+    if ( AddNormalinputs(mtx,mypk,2*txfee,1) > 0 )
+    {
+        mtx.vout.push_back(MakeCC1vout(EVAL_CHANNELS,txfee,mypk));
+        mtx.vout.push_back(CTxOut(amount,CScript() << ParseHex(HexStr(mypk)) << OP_CHECKSIG));
+        return(FinalizeCCTx(0,cp,mtx,mypk,txfee,EncodeChannelsOpRet('R',mypk,mypk,0,0,stoptxid)));
+    }
+    return("");
+}
+
+UniValue ChannelsInfo()
+{
+    UniValue result(UniValue::VOBJ); CTransaction tx; uint256 txid,hashBlock,hashchain; struct CCcontract_info *cp,C; uint8_t funcid; char myCCaddr[64]; int32_t vout,numvouts,numpayments; int64_t nValue,payment; CPubKey srcpub,destpub,mypk;
+    std::vector<std::pair<CAddressIndexKey, CAmount> > txids;
+    result.push_back(Pair("result","success"));
+    result.push_back(Pair("name","Channels"));
+    cp = CCinit(&C,EVAL_CHANNELS);
+    mypk = pubkey2pk(Mypubkey());
+    GetCCaddress(cp,myCCaddr,mypk);
+    SetCCtxids(txids,myCCaddr);
+    for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=txids.begin(); it!=txids.end(); it++)
+    {
+        //int height = it->first.blockHeight;
+        txid = it->first.txhash;
+        vout = (int32_t)it->first.index;
+        nValue = (int64_t)it->second;
+        if ( (vout == 1 || vout == 2) && nValue == 10000 && GetTransaction(txid,tx,hashBlock,false) != 0 && (numvouts= tx.vout.size()) > 0 )
+        {
+            if ( DecodeChannelsOpRet(txid,tx.vout[numvouts-1].scriptPubKey,srcpub,destpub,numpayments,payment,hashchain) == 'O' || funcid == 'P' )
+            {
+                char str[67],str2[67];
+                fprintf(stderr,"%s func.%c %s -> %s %.8f num.%d of %.8f\n",mypk == srcpub ? "send" : "recv",funcid,pubkey33_str(str,(uint8_t *)&srcpub),pubkey33_str(str2,(uint8_t *)&destpub),(double)tx.vout[0].nValue/COIN,numpayments,(double)payment/COIN);
+            }
+        }
+    }
+    return(result);
+}
+
diff --git a/src/cc/crypto777/OS_portable.h b/src/cc/crypto777/OS_portable.h
new file mode 100755
index 000000000..9da753811
--- /dev/null
+++ b/src/cc/crypto777/OS_portable.h
@@ -0,0 +1,436 @@
+/******************************************************************************
+ * Copyright © 2014-2018 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+#ifndef OS_PORTABLEH
+#define OS_PORTABLEH
+
+// iguana_OS has functions that invoke system calls. Whenever possible stdio and similar functions are use and most functions are fully portable and in this file. For things that require OS specific, the call is routed to iguana_OS_portable_*  Usually, all but one OS can be handled with the same code, so iguana_OS_portable.c has most of this shared logic and an #ifdef iguana_OS_nonportable.c
+
+#ifdef __APPLE__
+//#define LIQUIDITY_PROVIDER 1
+#endif
+
+#ifdef NATIVE_WINDOWS
+//#define uint64_t unsigned __int64
+#define PACKED
+#else
+#define PACKED __attribute__((packed))
+#endif
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdint.h>
+#define HAVE_STRUCT_TIMESPEC
+#include <ctype.h>
+#include <fcntl.h>
+#include <math.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <time.h>
+
+#ifdef _WIN32
+#define sleep(x) Sleep(1000*(x))
+#include "../OSlibs/win/mingw.h"
+#include "../OSlibs/win/mman.h"
+#define PTW32_STATIC_LIB
+#include "../OSlibs/win/pthread.h"
+
+#ifndef NATIVE_WINDOWS
+#define EADDRINUSE WSAEADDRINUSE
+#endif
+
+#else
+#include <sys/time.h>
+#include <time.h>
+#include <poll.h>
+#include <netdb.h>
+#define HAVE_STRUCT_TIMESPEC
+#include <pthread.h>
+#include <sys/mman.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#define closesocket close
+#endif
+
+#ifndef MIN
+#define MIN(x, y) ( ((x)<(y))?(x):(y) )
+#endif
+
+#include "../includes/libgfshare.h"
+#include "../includes/utlist.h"
+#include "../includes/uthash.h"
+#include "../includes/curve25519.h"
+#include "../includes/cJSON.h"
+#include "../includes/tweetnacl.h"
+
+#ifndef MAP_FILE
+#define MAP_FILE        0
+#endif
+
+//#define fopen myfopen
+//#define fclose myfclose
+//FILE *myfopen(char *fname,char *mode);
+//int32_t myfclose(FILE *fp);
+
+struct huffstream { uint8_t *ptr,*buf; uint32_t bitoffset,maski,endpos; uint32_t allocsize:31,allocated:1; };
+typedef struct huffstream HUFF;
+
+struct ramcoder
+{
+    uint32_t cumulativeProb;
+    uint16_t lower,upper,code,underflowBits,lastsymbol,upper_lastsymbol,counter;
+    uint64_t *histo;
+    uint16_t ranges[];
+};
+
+#define hrewind(hp) hseek(hp,0,SEEK_SET)
+int32_t ramcoder_decoder(struct ramcoder *coder,int32_t updateprobs,uint8_t *buf,int32_t maxlen,HUFF *hp,bits256 *seed);
+int32_t ramcoder_encoder(struct ramcoder *coder,int32_t updateprobs,uint8_t *buf,int32_t len,HUFF *hp,uint64_t *histo,bits256 *seed);
+//int32_t init_ramcoder(struct ramcoder *coder,HUFF *hp,bits256 *seed);
+int32_t ramcoder_decompress(uint8_t *data,int32_t maxlen,uint8_t *bits,uint32_t numbits,bits256 seed);
+int32_t ramcoder_compress(uint8_t *bits,int32_t maxlen,uint8_t *data,int32_t datalen,bits256 seed);
+uint64_t hconv_bitlen(uint64_t bitlen);
+void _init_HUFF(HUFF *hp,int32_t allocsize,void *buf);
+int32_t hgetbit(HUFF *hp);
+int32_t hputbit(HUFF *hp,int32_t bit);
+uint64_t hconv_bitlen(uint64_t bitlen);
+int32_t hseek(HUFF *hp,int32_t offset,int32_t mode);
+
+#define SCRIPT_OPRETURN 0x6a
+#define GENESIS_ACCT "1739068987193023818"  // NXT-MRCC-2YLS-8M54-3CMAJ
+#define GENESIS_PUBKEYSTR "1259ec21d31a30898d7cd1609f80d9668b4778e3d97e941044b39f0c44d2e51b"
+#define GENESIS_PRIVKEYSTR "88a71671a6edd987ad9e9097428fc3f169decba3ac8f10da7b24e0ca16803b70"
+#define GENESIS_SECRET "It was a bright cold day in April, and the clocks were striking thirteen."
+
+#define SATOSHIDEN ((uint64_t)100000000L)
+#define dstr(x) ((double)(x) / SATOSHIDEN)
+
+#define SMALLVAL 0.000000000000001
+
+#define SETBIT(bits,bitoffset) (((uint8_t *)bits)[(bitoffset) >> 3] |= (1 << ((bitoffset) & 7)))
+#define GETBIT(bits,bitoffset) (((uint8_t *)bits)[(bitoffset) >> 3] & (1 << ((bitoffset) & 7)))
+#define CLEARBIT(bits,bitoffset) (((uint8_t *)bits)[(bitoffset) >> 3] &= ~(1 << ((bitoffset) & 7)))
+
+#define portable_mutex_t pthread_mutex_t
+#define portable_mutex_init(ptr) pthread_mutex_init(ptr,NULL)
+#define portable_mutex_lock pthread_mutex_lock
+#define portable_mutex_unlock pthread_mutex_unlock
+#define OS_thread_create pthread_create
+
+#define issue_curl(cmdstr) bitcoind_RPC(0,"curl",cmdstr,0,0,0,0)
+#define issue_curlt(cmdstr,timeout) bitcoind_RPC(0,"curl",cmdstr,0,0,0,timeout)
+
+struct allocitem { uint32_t allocsize,type; } PACKED;
+struct queueitem { struct queueitem *next,*prev; uint32_t allocsize,type;  } PACKED;
+struct stritem { struct queueitem DL; void **retptrp; uint32_t expiration; char str[]; };
+
+typedef struct queue
+{
+	struct queueitem *list;
+	portable_mutex_t mutex;
+    char name[64],initflag;
+} queue_t;
+
+struct rpcrequest_info
+{
+    struct rpcrequest_info *next,*prev;
+    pthread_t T;
+    int32_t sock;
+    uint32_t ipbits;
+    uint16_t port,pad;
+};
+
+struct OS_mappedptr
+{
+	char fname[512];
+	void *fileptr,*pending;
+	long allocsize,changedsize;
+	int32_t rwflag,dirty,actually_allocated;
+    uint32_t closetime,opentime;
+};
+
+struct OS_memspace
+{
+    portable_mutex_t mutex; long used,totalsize; struct OS_mappedptr M; char name[64]; void *ptr;
+    int32_t alignflag,counter,maxheight,openfiles,lastcounter,threadsafe,allocated:1,mapped:1,external:1;
+#ifdef IGUANA_PEERALLOC
+    int32_t outofptrs,numptrs,availptrs;
+    void *ptrs[4096]; int32_t allocsizes[4096],maxsizes[4096];
+#endif
+};
+
+struct tai { uint64_t x; double millis; };
+struct taidate { int32_t year,month,day; };
+struct taitime { struct taidate date; int32_t hour,minute,second; uint32_t offset; double millis; };
+int32_t leapsecs_sub(struct tai *);
+
+struct tai tai_now(void);
+uint32_t tai2utc(struct tai t);
+struct taidate taidate_frommjd(int32_t day,int32_t *pwday,int32_t *pyday);
+struct taitime tai2time(struct tai t,int32_t *pwday,int32_t *pyday);
+struct taidate tai2date(struct tai t);
+int32_t taidate_str(char *s,struct taidate cd);
+char *taitime_str(char *s,struct taitime ct);
+int32_t taidate_mjd(struct taidate cd);
+uint64_t tai2utime(struct tai t);
+struct tai taitime2tai(struct taitime ct);
+char *tai_str(char *str,struct tai t);
+char *utc_str(char *str,uint32_t utc);
+double tai_diff(struct tai reftai,struct tai cmptai);
+uint32_t OS_conv_utime(char *utime);
+
+//int32_t msync(void *addr,size_t len,int32_t flags);
+
+#ifdef __PNACL
+int32_t OS_nonportable_syncmap(struct OS_mappedptr *mp,long len);
+void *OS_nonportable_tmpalloc(char *dirname,char *name,struct OS_memspace *mem,long origsize);
+
+#elif _WIN32
+char *OS_portable_path(char *str);
+int32_t OS_nonportable_renamefile(char *fname,char *newfname);
+int32_t  OS_nonportable_launch(char *args[]);
+void OS_nonportable_randombytes(uint8_t *x,long xlen);
+int32_t OS_nonportable_init();
+#endif
+
+void OS_portable_init();
+void OS_init();
+int32_t sortds(double *buf,uint32_t num,int32_t size);
+int32_t revsortds(double *buf,uint32_t num,int32_t size);
+
+double OS_portable_milliseconds();
+void OS_portable_randombytes(uint8_t *x,long xlen);
+int32_t OS_portable_truncate(char *fname,long filesize);
+char *OS_portable_path(char *str);
+void OS_remove_directory(char *dirname);
+int32_t OS_portable_renamefile(char *fname,char *newfname);
+int32_t OS_portable_removefile(char *fname);
+void *OS_portable_mapfile(char *fname,long *filesizep,int32_t enablewrite);
+//int32_t OS_portable_syncmap(struct OS_mappedptr *mp,long len);
+//void *OS_portable_tmpalloc(char *dirname,char *name,struct OS_memspace *mem,long origsize);
+
+int32_t is_DST(int32_t datenum);
+int32_t extract_datenum(int32_t *yearp,int32_t *monthp,int32_t *dayp,int32_t datenum);
+int32_t expand_datenum(char *date,int32_t datenum);
+int32_t calc_datenum(int32_t year,int32_t month,int32_t day);
+int32_t ecb_decrdate(int32_t *yearp,int32_t *monthp,int32_t *dayp,char *date,int32_t datenum);
+int32_t conv_date(int32_t *secondsp,char *buf);
+uint32_t OS_conv_datenum(int32_t datenum,int32_t hour,int32_t minute,int32_t second);
+int32_t OS_conv_unixtime(struct tai *t,int32_t *secondsp,time_t timestamp);
+
+char *OS_compatible_path(char *str);
+FILE *OS_appendfile(char *origfname);
+
+int32_t OS_compare_files(char *fname,char *fname2);
+int64_t OS_copyfile(char *src,char *dest,int32_t cmpflag);
+void _OS_closemap(struct OS_mappedptr *mp);
+void *OS_loadfile(char *fname,char **bufp,long *lenp,long *allocsizep);
+void *OS_filestr(long *allocsizep,char *fname);
+void OS_closemap(struct OS_mappedptr *mp);
+int32_t OS_openmap(struct OS_mappedptr *mp);
+void *OS_mappedptr(void **ptrp,struct OS_mappedptr *mp,unsigned long allocsize,int32_t rwflag,char *fname);
+void *OS_filealloc(struct OS_mappedptr *M,char *fname,struct OS_memspace *mem,long size);
+void *OS_nonportable_mapfile(char *fname,long *filesizep,int32_t enablewrite);
+int32_t OS_nonportable_removefile(char *fname);
+
+unsigned long OS_filesize(char *fname);
+void OS_ensure_directory(char *dirname);
+long OS_ensurefilesize(char *fname,long filesize,int32_t truncateflag);
+int32_t OS_truncate(char *fname,long filesize);
+int32_t OS_renamefile(char *fname,char *newfname);
+int32_t OS_removefile(char *fname,int32_t scrubflag);
+
+void *OS_mapfile(char *fname,long *filesizep,int32_t enablewrite);
+int32_t OS_releasemap(void *ptr,unsigned long filesize);
+
+double OS_milliseconds();
+void OS_randombytes(uint8_t *x,long xlen);
+
+//int32_t OS_syncmap(struct OS_mappedptr *mp,long len);
+//void *OS_tmpalloc(char *dirname,char *name,struct OS_memspace *mem,long origsize);
+
+long myallocated(uint8_t type,long change);
+void *mycalloc(uint8_t type,int32_t n,long itemsize);
+void myfree(void *_ptr,long allocsize);
+//void free_queueitem(void *itemdata);
+void *myrealloc(uint8_t type,void *oldptr,long oldsize,long newsize);
+void *myaligned_alloc(uint64_t allocsize);
+int32_t myaligned_free(void *ptr,long size);
+
+struct queueitem *queueitem(char *str);
+void queue_enqueue(char *name,queue_t *queue,struct queueitem *origitem);//,int32_t offsetflag);
+void *queue_dequeue(queue_t *queue);//,int32_t offsetflag);
+void *queue_delete(queue_t *queue,struct queueitem *copy,int32_t copysize,int32_t freeitem);
+void *queue_free(queue_t *queue);
+void *queue_clone(queue_t *clone,queue_t *queue,int32_t size);
+int32_t queue_size(queue_t *queue);
+char *mbstr(char *str,double n);
+
+void iguana_memreset(struct OS_memspace *mem);
+void iguana_mempurge(struct OS_memspace *mem);
+void *iguana_meminit(struct OS_memspace *mem,char *name,void *ptr,int64_t totalsize,int32_t threadsafe);
+void *iguana_memalloc(struct OS_memspace *mem,long size,int32_t clearflag);
+int64_t iguana_memfree(struct OS_memspace *mem,void *ptr,int32_t size);
+
+// generic functions
+bits256 iguana_merkle(char *symbol,bits256 *tree,int32_t txn_count);
+bits256 bits256_calctxid(char *symbol,uint8_t *serialized,int32_t len);
+int32_t unhex(char c);
+void touppercase(char *str);
+uint32_t is_ipaddr(char *str);
+void iguana_bitmap(char *space,int32_t max,char *name);
+double _pairaved(double valA,double valB);
+int32_t unstringbits(char *buf,uint64_t bits);
+uint64_t stringbits(char *str);
+int32_t is_decimalstr(char *str);
+void tolowercase(char *str);
+char *clonestr(char *str);
+int32_t is_hexstr(char *str,int32_t n);
+int32_t decode_hex(uint8_t *bytes,int32_t n,char *hex);
+void reverse_hexstr(char *str);
+int32_t init_hexbytes_noT(char *hexbytes,uint8_t *message,long len);
+uint16_t parse_ipaddr(char *ipaddr,char *ip_port);
+int32_t bitweight(uint64_t x);
+uint8_t _decode_hex(char *hex);
+char *uppercase_str(char *buf,char *str);
+char *lowercase_str(char *buf,char *str);
+int32_t strsearch(char *strs[],int32_t num,char *name);
+int32_t OS_getline(int32_t waitflag,char *line,int32_t max,char *dispstr);
+int32_t sort64s(uint64_t *buf,uint32_t num,int32_t size);
+int32_t revsort64s(uint64_t *buf,uint32_t num,int32_t size);
+int decode_base32(uint8_t *token,uint8_t *tokenstr,int32_t len);
+int init_base32(char *tokenstr,uint8_t *token,int32_t len);
+char *OS_mvstr();
+
+long _stripwhite(char *buf,int accept);
+int32_t is_DST(int32_t datenum);
+int32_t extract_datenum(int32_t *yearp,int32_t *monthp,int32_t *dayp,int32_t datenum);
+int32_t expand_datenum(char *date,int32_t datenum);
+int32_t calc_datenum(int32_t year,int32_t month,int32_t day);
+int32_t ecb_decrdate(int32_t *yearp,int32_t *monthp,int32_t *dayp,char *date,int32_t datenum);
+int32_t conv_date(int32_t *secondsp,char *buf);
+uint32_t OS_conv_datenum(int32_t datenum,int32_t hour,int32_t minute,int32_t second);
+int32_t OS_conv_unixtime(struct tai *t,int32_t *secondsp,time_t timestamp);
+int32_t btc_coinaddr(char *coinaddr,uint8_t addrtype,char *pubkeystr);
+int32_t btc_convaddr(char *hexaddr,char *addr58);
+
+uint64_t RS_decode(char *rs);
+int32_t RS_encode(char *rsaddr,uint64_t id);
+char *cmc_ticker(char *base);
+
+void calc_sha1(char *hexstr,uint8_t *buf,uint8_t *msg,int32_t len);
+void calc_md2(char *hexstr,uint8_t *buf,uint8_t *msg,int32_t len);
+void calc_md4(char *hexstr,uint8_t *buf,uint8_t *msg,int32_t len);
+void calc_md4str(char *hexstr,uint8_t *buf,uint8_t *msg,int32_t len);
+void calc_md2str(char *hexstr,uint8_t *buf,uint8_t *msg,int32_t len);
+void calc_md5str(char *hexstr,uint8_t *buf,uint8_t *msg,int32_t len);
+void calc_sha224(char *hexstr,uint8_t *buf,uint8_t *msg,int32_t len);
+void calc_sha384(char *hexstr,uint8_t *buf,uint8_t *msg,int32_t len);
+void calc_sha512(char *hexstr,uint8_t *buf,uint8_t *msg,int32_t len);
+void calc_sha224(char *hexstr,uint8_t *buf,uint8_t *msg,int32_t len);
+void calc_rmd160(char *hexstr,uint8_t *buf,uint8_t *msg,int32_t len);
+void calc_rmd128(char *hexstr,uint8_t *buf,uint8_t *msg,int32_t len);
+void calc_rmd256(char *hexstr,uint8_t *buf,uint8_t *msg,int32_t len);
+void calc_rmd320(char *hexstr,uint8_t *buf,uint8_t *msg,int32_t len);
+void calc_tiger(char *hexstr,uint8_t *buf,uint8_t *msg,int32_t len);
+void calc_whirlpool(char *hexstr,uint8_t *buf,uint8_t *msg,int32_t len);
+
+char *hmac_sha1_str(char *dest,char *key,int32_t key_size,char *message);
+char *hmac_md2_str(char *dest,char *key,int32_t key_size,char *message);
+char *hmac_md4_str(char *dest,char *key,int32_t key_size,char *message);
+char *hmac_md5_str(char *dest,char *key,int32_t key_size,char *message);
+char *hmac_sha224_str(char *dest,char *key,int32_t key_size,char *message);
+char *hmac_sha256_str(char *dest,char *key,int32_t key_size,char *message);
+char *hmac_sha384_str(char *dest,char *key,int32_t key_size,char *message);
+char *hmac_sha512_str(char *dest,char *key,int32_t key_size,char *message);
+char *hmac_rmd128_str(char *dest,char *key,int32_t key_size,char *message);
+char *hmac_rmd160_str(char *dest,char *key,int32_t key_size,char *message);
+char *hmac_rmd256_str(char *dest,char *key,int32_t key_size,char *message);
+char *hmac_rmd320_str(char *dest,char *key,int32_t key_size,char *message);
+char *hmac_tiger_str(char *dest,char *key,int32_t key_size,char *message);
+char *hmac_whirlpool_str(char *dest,char *key,int32_t key_size,char *message);
+int nn_base64_encode(const uint8_t *in,size_t in_len,char *out,size_t out_len);
+int nn_base64_decode(const char *in,size_t in_len,uint8_t *out,size_t out_len);
+void calc_rmd160_sha256(uint8_t rmd160[20],uint8_t *data,int32_t datalen);
+void sha256_sha256(char *hexstr,uint8_t *buf,uint8_t *msg,int32_t len);
+void rmd160ofsha256(char *hexstr,uint8_t *buf,uint8_t *msg,int32_t len);
+void calc_md5str(char *hexstr,uint8_t *buf,uint8_t *msg,int32_t len);
+void calc_crc32str(char *hexstr,uint8_t *buf,uint8_t *msg,int32_t len);
+void calc_NXTaddr(char *hexstr,uint8_t *buf,uint8_t *msg,int32_t len);
+void calc_curve25519_str(char *hexstr,uint8_t *buf,uint8_t *msg,int32_t len);
+void calc_base64_encodestr(char *hexstr,uint8_t *buf,uint8_t *msg,int32_t len);
+void calc_base64_decodestr(char *hexstr,uint8_t *buf,uint8_t *msg,int32_t len);
+void calc_hexstr(char *hexstr,uint8_t *buf,uint8_t *msg,int32_t len);
+void calc_unhexstr(char *hexstr,uint8_t *buf,uint8_t *msg,int32_t len);
+int32_t safecopy(char *dest,char *src,long len);
+double dxblend(double *destp,double val,double decay);
+
+uint64_t calc_ipbits(char *ip_port);
+void expand_ipbits(char *ipaddr,uint64_t ipbits);
+void escape_code(char *escaped,char *str);
+void SaM_PrepareIndices();
+
+// iguana_serdes.c
+#ifndef IGUANA_LOG2PACKETSIZE
+#define IGUANA_LOG2PACKETSIZE 22
+#endif
+#ifndef IGUANA_MAXPACKETSIZE
+#define IGUANA_MAXPACKETSIZE (1 << IGUANA_LOG2PACKETSIZE)
+#endif
+struct iguana_msghdr { uint8_t netmagic[4]; char command[12]; uint8_t serdatalen[4],hash[4]; } PACKED;
+
+int32_t iguana_rwnum(int32_t rwflag,uint8_t *serialized,int32_t len,void *endianedp);
+int32_t iguana_validatehdr(char *symbol,struct iguana_msghdr *H);
+int32_t iguana_rwbignum(int32_t rwflag,uint8_t *serialized,int32_t len,uint8_t *endianedp);
+int32_t iguana_sethdr(struct iguana_msghdr *H,const uint8_t netmagic[4],char *command,uint8_t *data,int32_t datalen);
+uint8_t *iguana_varint16(int32_t rwflag,uint8_t *serialized,uint16_t *varint16p);
+uint8_t *iguana_varint32(int32_t rwflag,uint8_t *serialized,uint16_t *varint16p);
+uint8_t *iguana_varint64(int32_t rwflag,uint8_t *serialized,uint32_t *varint32p);
+int32_t iguana_rwvarint(int32_t rwflag,uint8_t *serialized,uint64_t *varint64p);
+int32_t iguana_rwvarint32(int32_t rwflag,uint8_t *serialized,uint32_t *int32p);
+int32_t iguana_rwvarstr(int32_t rwflag,uint8_t *serialized,int32_t maxlen,char *endianedp);
+int32_t iguana_rwmem(int32_t rwflag,uint8_t *serialized,int32_t len,void *endianedp);
+#define bits256_nonz(a) (((a).ulongs[0] | (a).ulongs[1] | (a).ulongs[2] | (a).ulongs[3]) != 0)
+
+bits256 bits256_ave(bits256 a,bits256 b);
+bits256 bits256_doublesha256(char *hashstr,uint8_t *data,int32_t datalen);
+char *bits256_str(char hexstr[65],bits256 x);
+char *bits256_lstr(char hexstr[65],bits256 x);
+bits256 bits256_add(bits256 a,bits256 b);
+int32_t bits256_cmp(bits256 a,bits256 b);
+bits256 bits256_lshift(bits256 x);
+bits256 bits256_rshift(bits256 x);
+bits256 bits256_from_compact(uint32_t c);
+uint32_t bits256_to_compact(bits256 x);
+bits256 bits256_conv(char *hexstr);
+int32_t btc_priv2pub(uint8_t pubkey[33],uint8_t privkey[32]);
+int32_t OS_portable_rmdir(char *dirname,int32_t diralso);
+void calc_hmac_sha256(uint8_t *mac,int32_t maclen,uint8_t *key,int32_t key_size,uint8_t *message,int32_t len);
+int32_t revsort32(uint32_t *buf,uint32_t num,int32_t size);
+
+bits256 bits256_sha256(bits256 data);
+void bits256_rmd160(uint8_t rmd160[20],bits256 data);
+void bits256_rmd160_sha256(uint8_t rmd160[20],bits256 data);
+double get_theoretical(double *avebidp,double *aveaskp,double *highbidp,double *lowaskp,double *CMC_averagep,double changes[3],char *name,char *base,char *rel,double *USD_averagep);
+char *bitcoind_RPCnew(void *curl_handle,char **retstrp,char *debugstr,char *url,char *userpass,char *command,char *params,int32_t timeout);
+
+extern char *Iguana_validcommands[];
+extern bits256 GENESIS_PUBKEY,GENESIS_PRIVKEY;
+extern char NXTAPIURL[];
+extern int32_t smallprimes[168],Debuglevel;
+
+#endif
+
diff --git a/src/cc/dapps/cJSON.c b/src/cc/dapps/cJSON.c
new file mode 100755
index 000000000..e0665e378
--- /dev/null
+++ b/src/cc/dapps/cJSON.c
@@ -0,0 +1,1196 @@
+
+/*
+ Copyright (c) 2009 Dave Gamble
+ 
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+ 
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ */
+
+/* cJSON */
+/* JSON parser in C. */
+#include <math.h>
+
+#include "../includes/cJSON.h"
+
+#ifndef DBL_EPSILON
+#define DBL_EPSILON 2.2204460492503131E-16
+#endif
+
+static const char *ep;
+
+long stripquotes(char *str)
+{
+    long len,offset;
+    if ( str == 0 )
+        return(0);
+    len = strlen(str);
+    if ( str[0] == '"' && str[len-1] == '"' )
+        str[len-1] = 0, offset = 1;
+    else offset = 0;
+    return(offset);
+}
+
+const char *cJSON_GetErrorPtr(void) {return ep;}
+
+static int32_t cJSON_strcasecmp(const char *s1,const char *s2)
+{
+	if (!s1) return (s1==s2)?0:1;if (!s2) return 1;
+	for(; tolower((int32_t)(*s1)) == tolower((int32_t)(*s2)); ++s1, ++s2)	if(*s1 == 0)	return 0;
+	return tolower((int32_t)(*(const unsigned char *)s1)) - tolower((int32_t)(*(const unsigned char *)s2));
+}
+
+void *LP_alloc(uint64_t len);
+void LP_free(void *ptr);
+static void *(*cJSON_malloc)(size_t sz) = (void *)malloc;//LP_alloc;
+static void (*cJSON_free)(void *ptr) = free;//LP_free;
+
+static void *cJSON_mallocstr(int32_t len)
+{
+    return(cJSON_malloc(len));
+}
+
+static char **cJSON_mallocptrs(int32_t num,char **space,int32_t max)
+{
+    if ( num < max )
+        return(space);
+    else return(cJSON_malloc(num * sizeof(char *)));
+}
+
+static void *cJSON_mallocnode()
+{
+    return(cJSON_malloc(sizeof(cJSON)));
+}
+
+static void cJSON_freeptrs(char **ptrs,int32_t num,char **space)
+{
+    if ( ptrs != space )
+        cJSON_free(ptrs);
+}
+
+static void cJSON_freestr(char *str)
+{
+    cJSON_free(str);
+}
+
+static void cJSON_freenode(cJSON *item)
+{
+    cJSON_free(item);
+}
+
+static char* cJSON_strdup(const char* str)
+{
+    size_t len;
+    char* copy;
+    
+    len = strlen(str) + 1;
+    if (!(copy = (char*)cJSON_mallocstr((int32_t)len+1))) return 0;
+    memcpy(copy,str,len);
+    return copy;
+}
+
+void cJSON_InitHooks(cJSON_Hooks* hooks)
+{
+    if (!hooks) { /* Reset hooks */
+        cJSON_malloc = malloc;
+        cJSON_free = free;
+        return;
+    }
+    
+    cJSON_malloc = (hooks->malloc_fn)?hooks->malloc_fn:malloc;
+    cJSON_free	 = (hooks->free_fn)?hooks->free_fn:free;
+}
+
+/* Internal constructor. */
+static cJSON *cJSON_New_Item(void)
+{
+	cJSON* node = (cJSON*)cJSON_mallocnode();
+	if (node) memset(node,0,sizeof(cJSON));
+	return node;
+}
+
+/* Delete a cJSON structure. */
+void cJSON_Delete(cJSON *c)
+{
+	cJSON *next;
+	while (c)
+	{
+		next=c->next;
+		if (!(c->type&cJSON_IsReference) && c->child) cJSON_Delete(c->child);
+		if (!(c->type&cJSON_IsReference) && c->valuestring) cJSON_freestr(c->valuestring);
+		if (c->string) cJSON_freestr(c->string);
+		cJSON_freenode(c);
+		c=next;
+	}
+}
+
+/* Parse the input text to generate a number, and populate the result into item. */
+static const char *parse_number(cJSON *item,const char *num)
+{
+	double n=0,sign=1,scale=0;int32_t subscale=0,signsubscale=1;
+    
+	if (*num=='-') sign=-1,num++;	/* Has sign? */
+	if (*num=='0') num++;			/* is zero */
+	if (*num>='1' && *num<='9')	do	n=(n*10.0)+(*num++ -'0');	while (*num>='0' && *num<='9');	/* Number? */
+	if (*num=='.' && num[1]>='0' && num[1]<='9') {num++;		do	n=(n*10.0)+(*num++ -'0'),scale--; while (*num>='0' && *num<='9');}	/* Fractional part? */
+	if (*num=='e' || *num=='E')		/* Exponent? */
+	{	num++;if (*num=='+') num++;	else if (*num=='-') signsubscale=-1,num++;		/* With sign? */
+		while (*num>='0' && *num<='9') subscale=(subscale*10)+(*num++ - '0');	/* Number? */
+	}
+    
+	n=sign*n*pow(10.0,(scale+subscale*signsubscale));	/* number = +/- number.fraction * 10^+/- exponent */
+	
+	item->valuedouble=n;
+	item->valueint=(int64_t)n;
+	item->type=cJSON_Number;
+	return num;
+}
+
+/* Render the number nicely from the given item into a string. */
+static char *print_number(cJSON *item)
+{
+	char *str;
+	double d = item->valuedouble;
+        if ( fabs(((double)item->valueint) - d) <= DBL_EPSILON && d >= (1. - DBL_EPSILON) && d < (1LL << 62) )//d <= INT_MAX && d >= INT_MIN )
+        {
+		str = (char *)cJSON_mallocstr(24);	/* 2^64+1 can be represented in 21 chars + sign. */
+		if ( str != 0 )
+            sprintf(str,"%lld",(long long)item->valueint);
+	}
+	else
+	{
+		str = (char *)cJSON_mallocstr(66);	/* This is a nice tradeoff. */
+		if ( str != 0 )
+		{
+			if ( fabs(floor(d) - d) <= DBL_EPSILON && fabs(d) < 1.0e60 )
+                sprintf(str,"%.0f",d);
+			//else if (fabs(d)<1.0e-6 || fabs(d)>1.0e9)			sprintf(str,"%e",d);
+			else
+                sprintf(str,"%.8f",d);
+		}
+	}
+	return str;
+}
+
+static unsigned parse_hex4(const char *str)
+{
+	unsigned h=0;
+	if (*str>='0' && *str<='9') h+=(*str)-'0'; else if (*str>='A' && *str<='F') h+=10+(*str)-'A'; else if (*str>='a' && *str<='f') h+=10+(*str)-'a'; else return 0;
+	h=h<<4;str++;
+	if (*str>='0' && *str<='9') h+=(*str)-'0'; else if (*str>='A' && *str<='F') h+=10+(*str)-'A'; else if (*str>='a' && *str<='f') h+=10+(*str)-'a'; else return 0;
+	h=h<<4;str++;
+	if (*str>='0' && *str<='9') h+=(*str)-'0'; else if (*str>='A' && *str<='F') h+=10+(*str)-'A'; else if (*str>='a' && *str<='f') h+=10+(*str)-'a'; else return 0;
+	h=h<<4;str++;
+	if (*str>='0' && *str<='9') h+=(*str)-'0'; else if (*str>='A' && *str<='F') h+=10+(*str)-'A'; else if (*str>='a' && *str<='f') h+=10+(*str)-'a'; else return 0;
+	return h;
+}
+
+/* Parse the input text into an unescaped cstring, and populate item. */
+static const unsigned char firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
+static const char *parse_string(cJSON *item,const char *str)
+{
+	const char *ptr=str+1;char *ptr2;char *out;int32_t len=0;unsigned uc,uc2;
+	if (*str!='\"') {ep=str;return 0;}	/* not a string! */
+	
+	while (*ptr!='\"' && *ptr && ++len) if (*ptr++ == '\\') ptr++;	// Skip escaped quotes
+	
+	out=(char*)cJSON_mallocstr(len+2);	/* This is how long we need for the string, roughly. */
+	if (!out) return 0;
+	
+	ptr=str+1;ptr2=out;
+	while (*ptr!='\"' && *ptr)
+	{
+		if (*ptr!='\\')
+        {
+            if ( *ptr == '%' && is_hexstr((char *)&ptr[1],2) && isprint(_decode_hex((char *)&ptr[1])) != 0 )
+                *ptr2++ = _decode_hex((char *)&ptr[1]), ptr += 3;
+            else *ptr2++ = *ptr++;
+        }
+		else
+		{
+			ptr++;
+			switch (*ptr)
+			{
+				case 'b': *ptr2++='\b';	break;
+				case 'f': *ptr2++='\f';	break;
+				case 'n': *ptr2++='\n';	break;
+				case 'r': *ptr2++='\r';	break;
+				case 't': *ptr2++='\t';	break;
+				case 'u':	 // transcode utf16 to utf8
+					uc=parse_hex4(ptr+1);ptr+=4;	// get the unicode char
+                    
+					if ((uc>=0xDC00 && uc<=0xDFFF) || uc==0)	break;	// check for invalid
+                    
+					if (uc>=0xD800 && uc<=0xDBFF)	// UTF16 surrogate pairs
+					{
+						if (ptr[1]!='\\' || ptr[2]!='u')	break;	// missing second-half of surrogate.
+						uc2=parse_hex4(ptr+3);ptr+=6;
+						if (uc2<0xDC00 || uc2>0xDFFF)		break;	// invalid second-half of surrogate
+						uc=0x10000 + (((uc&0x3FF)<<10) | (uc2&0x3FF));
+					}
+                    
+					len=4;if (uc<0x80) len=1;else if (uc<0x800) len=2;else if (uc<0x10000) len=3; ptr2+=len;
+					
+					switch (len) {
+						case 4: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6;
+						case 3: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6;
+						case 2: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6;
+						case 1: *--ptr2 =(uc | firstByteMark[len]);
+					}
+					ptr2+=len;
+					break;
+				default:  *ptr2++=*ptr; break;
+			}
+			ptr++;
+		}
+	}
+	*ptr2=0;
+	if (*ptr=='\"') ptr++;
+	item->valuestring=out;
+	item->type=cJSON_String;
+	return ptr;
+}
+
+/* Render the cstring provided to an escaped version that can be printed. */
+static char *print_string_ptr(const char *str)
+{
+	const char *ptr;char *ptr2,*out;int32_t len=0;unsigned char token;
+	
+	if (!str) return cJSON_strdup("");
+	ptr=str;while ((token=*ptr) && ++len) {if (strchr("\"\\\b\f\n\r\t",token)) len++; else if (token<32) len+=5;ptr++;}
+	
+	out=(char*)cJSON_mallocstr(len+3+1);
+	if (!out) return 0;
+    
+	ptr2=out;ptr=str;
+	*ptr2++='\"';
+	while (*ptr)
+	{
+		if ((unsigned char)*ptr>31 && *ptr!='\"' && *ptr!='\\') *ptr2++=*ptr++;
+		else
+		{
+			*ptr2++='\\';
+			switch (token=*ptr++)
+			{
+				case '\\':	*ptr2++='\\';	break;
+				case '\"':	*ptr2++='\"';	break;
+				case '\b':	*ptr2++='b';	break;
+				case '\f':	*ptr2++='f';	break;
+				case '\n':	*ptr2++='n';	break;
+				case '\r':	*ptr2++='r';	break;
+				case '\t':	*ptr2++='t';	break;
+				default: sprintf(ptr2,"u%04x",token);ptr2+=5;	break;	/* escape and print */
+			}
+		}
+	}
+	*ptr2++='\"';*ptr2++=0;
+	return out;
+}
+/* Invote print_string_ptr (which is useful) on an item. */
+static char *print_string(cJSON *item)	{return print_string_ptr(item->valuestring);}
+
+/* Predeclare these prototypes. */
+static const char *parse_value(cJSON *item,const char *value);
+static char *print_value(cJSON *item,int32_t depth,int32_t fmt);
+static const char *parse_array(cJSON *item,const char *value);
+static char *print_array(cJSON *item,int32_t depth,int32_t fmt);
+static const char *parse_object(cJSON *item,const char *value);
+static char *print_object(cJSON *item,int32_t depth,int32_t fmt);
+
+/* Utility to jump whitespace and cr/lf */
+static const char *skip(const char *in) {while (in && *in && (unsigned char)*in<=32) in++; return in;}
+
+/* Parse an object - create a new root, and populate. */
+cJSON *cJSON_ParseWithOpts(const char *value,const char **return_parse_end,int32_t require_null_terminated)
+{
+	const char *end=0;
+	cJSON *c=cJSON_New_Item();
+	ep=0;
+	if (!c) return 0;       /* memory fail */
+    
+	end=parse_value(c,skip(value));
+	if (!end)	{cJSON_Delete(c);return 0;}	/* parse failure. ep is set. */
+    
+	/* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */
+	if (require_null_terminated) {end=skip(end);if (*end) {cJSON_Delete(c);ep=end;return 0;}}
+	if (return_parse_end) *return_parse_end=end;
+	return c;
+}
+/* Default options for cJSON_Parse */
+cJSON *cJSON_Parse(const char *value)
+{
+    return(cJSON_ParseWithOpts(value,0,0));
+}
+
+/* Render a cJSON item/entity/structure to text. */
+char *cJSON_Print(cJSON *item)
+{
+    return(print_value(item,0,1));
+}
+char *cJSON_PrintUnformatted(cJSON *item)	{return print_value(item,0,0);}
+
+/* Parser core - when encountering text, process appropriately. */
+static const char *parse_value(cJSON *item,const char *value)
+{
+	if (!value)						return 0;	/* Fail on null. */
+	if (!strncmp(value,"null",4))	{ item->type=cJSON_NULL;  return value+4; }
+	if (!strncmp(value,"false",5))	{ item->type=cJSON_False; return value+5; }
+	if (!strncmp(value,"true",4))	{ item->type=cJSON_True; item->valueint=1;	return value+4; }
+	if (*value=='\"')				{ return parse_string(item,value); }
+	if (*value=='-' || (*value>='0' && *value<='9'))	{ return parse_number(item,value); }
+	if (*value=='[')				{ return parse_array(item,value); }
+	if (*value=='{')				{ return parse_object(item,value); }
+    
+	ep=value;return 0;	/* failure. */
+}
+
+/* Render a value to text. */
+static char *print_value(cJSON *item,int32_t depth,int32_t fmt)
+{
+	char *out=0;
+	if (!item) return 0;
+	switch ((item->type)&255)
+	{
+		case cJSON_NULL:	out=cJSON_strdup("null");	break;
+		case cJSON_False:	out=cJSON_strdup("false");break;
+		case cJSON_True:	out=cJSON_strdup("true"); break;
+		case cJSON_Number:	out=print_number(item);break;
+		case cJSON_String:	out=print_string(item);break;
+		case cJSON_Array:	out=print_array(item,depth,fmt);break;
+		case cJSON_Object:	out=print_object(item,depth,fmt);break;
+	}
+	return out;
+}
+
+/* Build an array from input text. */
+static const char *parse_array(cJSON *item,const char *value)
+{
+	cJSON *child;
+	if (*value!='[')	{ep=value;return 0;}	/* not an array! */
+    
+	item->type=cJSON_Array;
+	value=skip(value+1);
+	if (*value==']') return value+1;	/* empty array. */
+    
+	item->child=child=cJSON_New_Item();
+	if (!item->child) return 0;		 /* memory fail */
+	value=skip(parse_value(child,skip(value)));	/* skip any spacing, get the value. */
+	if (!value) return 0;
+    
+	while (*value==',')
+	{
+		cJSON *new_item;
+		if (!(new_item=cJSON_New_Item())) return 0; 	/* memory fail */
+		child->next=new_item;new_item->prev=child;child=new_item;
+		value=skip(parse_value(child,skip(value+1)));
+		if (!value) return 0;	/* memory fail */
+	}
+    
+	if (*value==']') return value+1;	/* end of array */
+	ep=value;return 0;	/* malformed. */
+}
+
+/* Render an array to text */
+static char *print_array(cJSON *item,int32_t depth,int32_t fmt)
+{
+	char **entries,*space_entries[512];
+	char *out=0,*ptr,*ret;int32_t len=5;
+	cJSON *child=item->child;
+	int32_t numentries=0,i=0,fail=0;
+	
+	/* How many entries in the array? */
+	while (child) numentries++,child=child->next;
+	/* Explicitly handle numentries==0 */
+	if (!numentries)
+	{
+		out=(char*)cJSON_mallocstr(3+1);
+		if (out) strcpy(out,"[]");
+		return out;
+	}
+	/* Allocate an array to hold the values for each */
+	entries=cJSON_mallocptrs(1+numentries,space_entries,sizeof(space_entries)/sizeof(*space_entries));
+	if (!entries) return 0;
+	memset(entries,0,numentries*sizeof(char*));
+	/* Retrieve all the results: */
+	child=item->child;
+	while (child && !fail)
+	{
+		ret=print_value(child,depth+1,fmt);
+		entries[i++]=ret;
+		if (ret) len+=strlen(ret)+2+(fmt?1:0); else fail=1;
+		child=child->next;
+	}
+	
+	/* If we didn't fail, try to malloc the output string */
+	if (!fail) out=(char*)cJSON_mallocstr(len+1);
+	/* If that fails, we fail. */
+	if (!out) fail=1;
+    
+	/* Handle failure. */
+	if (fail)
+	{
+		for (i=0;i<numentries;i++) if (entries[i]) cJSON_freestr(entries[i]);
+		cJSON_freeptrs(entries,numentries,space_entries);
+		return 0;
+	}
+	
+	/* Compose the output array. */
+	*out='[';
+	ptr=out+1;*ptr=0;
+	for (i=0;i<numentries;i++)
+	{
+		strcpy(ptr,entries[i]);ptr+=strlen(entries[i]);
+		if (i!=numentries-1) {*ptr++=',';if(fmt)*ptr++=' ';*ptr=0;}
+		cJSON_freestr(entries[i]);
+	}
+	cJSON_freeptrs(entries,numentries,space_entries);
+	*ptr++=']';*ptr++=0;
+	return out;
+}
+
+/* Build an object from the text. */
+static const char *parse_object(cJSON *item,const char *value)
+{
+	cJSON *child;
+	if (*value!='{')	{ep=value;return 0;}	/* not an object! */
+	
+	item->type=cJSON_Object;
+	value=skip(value+1);
+	if (*value=='}') return value+1;	/* empty array. */
+	
+	item->child=child=cJSON_New_Item();
+	if (!item->child) return 0;
+	value=skip(parse_string(child,skip(value)));
+	if (!value) return 0;
+	child->string=child->valuestring;child->valuestring=0;
+	if (*value!=':') {ep=value;return 0;}	/* fail! */
+	value=skip(parse_value(child,skip(value+1)));	/* skip any spacing, get the value. */
+	if (!value) return 0;
+	
+	while (*value==',')
+	{
+		cJSON *new_item;
+		if (!(new_item=cJSON_New_Item()))	return 0; /* memory fail */
+		child->next=new_item;new_item->prev=child;child=new_item;
+		value=skip(parse_string(child,skip(value+1)));
+		if (!value) return 0;
+		child->string=child->valuestring;child->valuestring=0;
+		if (*value!=':') {ep=value;return 0;}	/* fail! */
+		value=skip(parse_value(child,skip(value+1)));	/* skip any spacing, get the value. */
+		if (!value) return 0;
+	}
+	
+	if (*value=='}') return value+1;	/* end of array */
+	ep=value;return 0;	/* malformed. */
+}
+
+/* Render an object to text. */
+static char *print_object(cJSON *item,int32_t depth,int32_t fmt)
+{
+    char **entries=0,**names=0,*space_entries[512],*space_names[512];
+	char *out=0,*ptr,*ret,*str;int32_t len=7,i=0,j;
+	cJSON *child=item->child,*firstchild;
+	int32_t numentries=0,fail=0;
+	// Count the number of entries
+    firstchild = child;
+	while ( child )
+    {
+        numentries++;
+        child = child->next;
+        if ( child == firstchild )
+        {
+            printf("cJSON infinite loop detected\n");
+            break;
+        }
+    }
+	/* Explicitly handle empty object case */
+	if (!numentries)
+	{
+		out=(char*)cJSON_mallocstr(fmt?depth+4+1:3+1);
+		if (!out)	return 0;
+		ptr=out;*ptr++='{';
+		if (fmt) {*ptr++='\n';for (i=0;i<depth-1;i++) *ptr++='\t';}
+		*ptr++='}';*ptr++=0;
+		return out;
+	}
+	/* Allocate space for the names and the objects */
+	entries=(char**)cJSON_mallocptrs(numentries,space_entries,sizeof(space_entries)/sizeof(*space_entries));
+	if (!entries) return 0;
+	names=(char**)cJSON_mallocptrs(numentries,space_names,sizeof(space_names)/sizeof(*space_names));
+	if (!names) {cJSON_freeptrs(entries,numentries,space_entries);return 0;}
+	memset(entries,0,sizeof(char*)*numentries);
+	memset(names,0,sizeof(char*)*numentries);
+    
+	/* Collect all the results into our arrays: */
+	child=item->child;depth++;if (fmt) len+=depth;
+	while ( child )
+	{
+		names[i]=str=print_string_ptr(child->string);
+		entries[i++]=ret=print_value(child,depth,fmt);
+		if (str && ret) len+=strlen(ret)+strlen(str)+2+(fmt?2+depth:0); else fail=1;
+		child=child->next;
+        if ( child == firstchild )
+            break;
+	}
+	
+	/* Try to allocate the output string */
+	if (!fail) out=(char*)cJSON_mallocstr(len+1);
+	if (!out) fail=1;
+    
+	/* Handle failure */
+	if (fail)
+	{
+		for (i=0;i<numentries;i++) {if (names[i]) cJSON_freestr(names[i]);if (entries[i]) cJSON_freestr(entries[i]);}
+		cJSON_freeptrs(names,numentries,space_names);
+        cJSON_freeptrs(entries,numentries,space_entries);
+		return 0;
+	}
+	
+	/* Compose the output: */
+	*out='{';ptr=out+1;if (fmt)*ptr++='\n';*ptr=0;
+	for (i=0;i<numentries;i++)
+	{
+		if (fmt) for (j=0;j<depth;j++) *ptr++='\t';
+		strcpy(ptr,names[i]);ptr+=strlen(names[i]);
+		*ptr++=':';if (fmt) *ptr++='\t';
+		strcpy(ptr,entries[i]);ptr+=strlen(entries[i]);
+		if (i!=numentries-1) *ptr++=',';
+		if (fmt) *ptr++='\n';*ptr=0;
+		cJSON_freestr(names[i]);cJSON_freestr(entries[i]);
+	}
+	
+	cJSON_freeptrs(names,numentries,space_names);
+    cJSON_freeptrs(entries,numentries,space_entries);
+	if (fmt) for (i=0;i<depth-1;i++) *ptr++='\t';
+	*ptr++='}';*ptr++=0;
+	return out;
+}
+
+/* Get Array size/item / object item. */
+int32_t    cJSON_GetArraySize(cJSON *array)							{cJSON *c; if ( array == 0 ) return(0); c=array->child;int32_t i=0;while(c)i++,c=c->next;return i;}
+cJSON *cJSON_GetArrayItem(cJSON *array,int32_t item)				{cJSON *c=array->child;  while (c && item>0) item--,c=c->next; return c;}
+cJSON *cJSON_GetObjectItem(cJSON *object,const char *string)	{ if ( object == 0 ) return(0); cJSON *c=object->child; while (c && cJSON_strcasecmp(c->string,string)) c=c->next; return c;}
+
+/* Utility for array list handling. */
+static void suffix_object(cJSON *prev,cJSON *item) {prev->next=item;item->prev=prev;}
+/* Utility for handling references. */
+static cJSON *create_reference(cJSON *item) {cJSON *ref=cJSON_New_Item();if (!ref) return 0;memcpy(ref,item,sizeof(cJSON));ref->string=0;ref->type|=cJSON_IsReference;ref->next=ref->prev=0;return ref;}
+
+/* Add item to array/object. */
+void   cJSON_AddItemToArray(cJSON *array, cJSON *item)						{cJSON *c=array->child;if (!item) return; if (!c) {array->child=item;} else {while (c && c->next) c=c->next; suffix_object(c,item);}}
+void   cJSON_AddItemToObject(cJSON *object,const char *string,cJSON *item)	{if (!item) return; if (item->string) cJSON_free(item->string);item->string=cJSON_strdup(string);cJSON_AddItemToArray(object,item);}
+void	cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item)						{cJSON_AddItemToArray(array,create_reference(item));}
+void	cJSON_AddItemReferenceToObject(cJSON *object,const char *string,cJSON *item)	{cJSON_AddItemToObject(object,string,create_reference(item));}
+
+cJSON *cJSON_DetachItemFromArray(cJSON *array,int32_t which)			{cJSON *c=array->child;while (c && which>0) c=c->next,which--;if (!c) return 0;
+	if (c->prev) c->prev->next=c->next;if (c->next) c->next->prev=c->prev;if (c==array->child) array->child=c->next;c->prev=c->next=0;return c;}
+void   cJSON_DeleteItemFromArray(cJSON *array,int32_t which)			{cJSON_Delete(cJSON_DetachItemFromArray(array,which));}
+cJSON *cJSON_DetachItemFromObject(cJSON *object,const char *string) {int32_t i=0;cJSON *c=object->child;while (c && cJSON_strcasecmp(c->string,string)) i++,c=c->next;if (c) return cJSON_DetachItemFromArray(object,i);return 0;}
+void   cJSON_DeleteItemFromObject(cJSON *object,const char *string) {cJSON_Delete(cJSON_DetachItemFromObject(object,string));}
+
+/* Replace array/object items with new ones. */
+void   cJSON_ReplaceItemInArray(cJSON *array,int32_t which,cJSON *newitem)		{cJSON *c=array->child;while (c && which>0) c=c->next,which--;if (!c) return;
+	newitem->next=c->next;newitem->prev=c->prev;if (newitem->next) newitem->next->prev=newitem;
+	if (c==array->child) array->child=newitem; else newitem->prev->next=newitem;c->next=c->prev=0;cJSON_Delete(c);}
+void   cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem){int32_t i=0;cJSON *c=object->child;while(c && cJSON_strcasecmp(c->string,string))i++,c=c->next;if(c){newitem->string=cJSON_strdup(string);cJSON_ReplaceItemInArray(object,i,newitem);}}
+
+/* Create basic types: */
+cJSON *cJSON_CreateNull(void)					{cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_NULL;return item;}
+cJSON *cJSON_CreateTrue(void)					{cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_True;return item;}
+cJSON *cJSON_CreateFalse(void)					{cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_False;return item;}
+cJSON *cJSON_CreateBool(int32_t b)					{cJSON *item=cJSON_New_Item();if(item)item->type=b?cJSON_True:cJSON_False;return item;}
+cJSON *cJSON_CreateNumber(double num)			{cJSON *item=cJSON_New_Item();if(item){item->type=cJSON_Number;item->valuedouble=num;item->valueint=(int64_t)num;}return item;}
+cJSON *cJSON_CreateString(const char *string)	{cJSON *item=cJSON_New_Item();if(item){item->type=cJSON_String;item->valuestring=cJSON_strdup(string);}return item;}
+
+/* Create Arrays: */
+cJSON *cJSON_CreateIntArray(int64_t *numbers,int32_t count)		{int32_t i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;a && i<count;i++){n=cJSON_CreateNumber((double)numbers[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;}
+cJSON *cJSON_CreateFloatArray(float *numbers,int32_t count)	{int32_t i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;a && i<count;i++){n=cJSON_CreateNumber(numbers[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;}
+cJSON *cJSON_CreateDoubleArray(double *numbers,int32_t count)	{int32_t i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;a && i<count;i++){n=cJSON_CreateNumber(numbers[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;}
+cJSON *cJSON_CreateStringArray(char **strings,int32_t count)	{int32_t i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;a && i<count;i++){n=cJSON_CreateString(strings[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;}
+
+/* Duplication */
+cJSON *cJSON_Duplicate(cJSON *item,int32_t recurse)
+{
+	cJSON *newitem,*cptr,*nptr=0,*newchild;
+	/* Bail on bad ptr */
+	if (!item) return 0;
+	/* Create new item */
+	newitem=cJSON_New_Item();
+	if (!newitem) return 0;
+	/* Copy over all vars */
+	newitem->type=item->type&(~cJSON_IsReference),newitem->valueint=item->valueint,newitem->valuedouble=item->valuedouble;
+	if (item->valuestring)	{newitem->valuestring=cJSON_strdup(item->valuestring);	if (!newitem->valuestring)	{cJSON_Delete(newitem);return 0;}}
+	if (item->string)		{newitem->string=cJSON_strdup(item->string);			if (!newitem->string)		{cJSON_Delete(newitem);return 0;}}
+	/* If non-recursive, then we're done! */
+	if (!recurse) return newitem;
+	/* Walk the ->next chain for the child. */
+	cptr=item->child;
+	while (cptr)
+	{
+		newchild=cJSON_Duplicate(cptr,1);		/* Duplicate (with recurse) each item in the ->next chain */
+		if (!newchild) {cJSON_Delete(newitem);return 0;}
+		if (nptr)	{nptr->next=newchild,newchild->prev=nptr;nptr=newchild;}	/* If newitem->child already set, then crosswire ->prev and ->next and move on */
+		else		{newitem->child=newchild;nptr=newchild;}					/* Set newitem->child and move to it */
+		cptr=cptr->next;
+	}
+	return newitem;
+}
+
+void cJSON_Minify(char *json)
+{
+	char *into=json;
+	while (*json)
+	{
+		if (*json==' ') json++;
+		else if (*json=='\t') json++;	// Whitespace characters.
+		else if (*json=='\r') json++;
+		else if (*json=='\n') json++;
+		else if (*json=='/' && json[1]=='/')  while (*json && *json!='\n') json++;	// double-slash comments, to end of line.
+		else if (*json=='/' && json[1]=='*') {while (*json && !(*json=='*' && json[1]=='/')) json++;json+=2;}	// multiline comments.
+		else if (*json=='\"'){*into++=*json++;while (*json && *json!='\"'){if (*json=='\\') *into++=*json++;*into++=*json++;}*into++=*json++;} // string literals, which are \" sensitive.
+		else *into++=*json++;			// All other characters.
+	}
+	*into=0;	// and null-terminate.
+}
+
+// the following written by jl777
+/******************************************************************************
+ * Copyright © 2014-2018 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+
+void copy_cJSON(struct destbuf *dest,cJSON *obj)
+{
+    char *str;
+    int i;
+    long offset;
+    dest->buf[0] = 0;
+    if ( obj != 0 )
+    {
+        str = cJSON_Print(obj);
+        if ( str != 0 )
+        {
+            offset = stripquotes(str);
+            //strcpy(dest,str+offset);
+            for (i=0; i<MAX_JSON_FIELD-1; i++)
+                if ( (dest->buf[i]= str[offset+i]) == 0 )
+                    break;
+            dest->buf[i] = 0;
+            free(str);
+        }
+    }
+}
+
+void copy_cJSON2(char *dest,int32_t maxlen,cJSON *obj)
+{
+    struct destbuf tmp;
+    maxlen--;
+    dest[0] = 0;
+    if ( maxlen > sizeof(tmp.buf) )
+        maxlen = sizeof(tmp.buf);
+    copy_cJSON(&tmp,obj);
+    if ( strlen(tmp.buf) < maxlen )
+        strcpy(dest,tmp.buf);
+    else dest[0] = 0;
+}
+
+int64_t _get_cJSON_int(cJSON *json)
+{
+    struct destbuf tmp;
+    if ( json != 0 )
+    {
+        copy_cJSON(&tmp,json);
+        if ( tmp.buf[0] != 0 )
+            return(calc_nxt64bits(tmp.buf));
+    }
+    return(0);
+}
+
+int64_t get_cJSON_int(cJSON *json,char *field)
+{
+    cJSON *numjson;
+    if ( json != 0 )
+    {
+        numjson = cJSON_GetObjectItem(json,field);
+        if ( numjson != 0 )
+            return(_get_cJSON_int(numjson));
+    }
+    return(0);
+}
+
+int64_t _conv_cJSON_float(cJSON *json)
+{
+    int64_t conv_floatstr(char *);
+    struct destbuf tmp;
+    if ( json != 0 )
+    {
+        copy_cJSON(&tmp,json);
+        return(conv_floatstr(tmp.buf));
+    }
+    return(0);
+}
+
+int64_t conv_cJSON_float(cJSON *json,char *field)
+{
+    if ( json != 0 )
+        return(_conv_cJSON_float(cJSON_GetObjectItem(json,field)));
+    return(0);
+}
+
+int32_t extract_cJSON_str(char *dest,int32_t max,cJSON *json,char *field)
+{
+    int32_t safecopy(char *dest,char *src,long len);
+    char *str;
+    cJSON *obj;
+    int32_t len;
+    long offset;
+    dest[0] = 0;
+    obj = cJSON_GetObjectItem(json,field);
+    if ( obj != 0 )
+    {
+        str = cJSON_Print(obj);
+        offset = stripquotes(str);
+        len = safecopy(dest,str+offset,max);
+        free(str);
+        return(len);
+    }
+    return(0);
+}
+
+cJSON *gen_list_json(char **list)
+{
+    cJSON *array,*item;
+    array = cJSON_CreateArray();
+    while ( list != 0 && *list != 0 && *list[0] != 0 )
+    {
+        item = cJSON_CreateString(*list++);
+        cJSON_AddItemToArray(array,item);
+    }
+    return(array);
+}
+
+uint64_t get_API_nxt64bits(cJSON *obj)
+{
+    uint64_t nxt64bits = 0;
+    struct destbuf tmp;
+    if ( obj != 0 )
+    {
+        if ( is_cJSON_Number(obj) != 0 )
+            return((uint64_t)obj->valuedouble);
+        copy_cJSON(&tmp,obj);
+        nxt64bits = calc_nxt64bits(tmp.buf);
+    }
+    return(nxt64bits);
+}
+uint64_t j64bits(cJSON *json,char *field) { if ( field == 0 ) return(get_API_nxt64bits(json)); return(get_API_nxt64bits(cJSON_GetObjectItem(json,field))); }
+uint64_t j64bitsi(cJSON *json,int32_t i) { return(get_API_nxt64bits(cJSON_GetArrayItem(json,i))); }
+
+uint64_t get_satoshi_obj(cJSON *json,char *field)
+{
+    int32_t i,n;
+    uint64_t prev,satoshis,mult = 1;
+    struct destbuf numstr,checkstr;
+    cJSON *numjson;
+    numjson = cJSON_GetObjectItem(json,field);
+    copy_cJSON(&numstr,numjson);
+    satoshis = prev = 0; mult = 1; n = (int32_t)strlen(numstr.buf);
+    for (i=n-1; i>=0; i--,mult*=10)
+    {
+        satoshis += (mult * (numstr.buf[i] - '0'));
+        if ( satoshis < prev )
+            printf("get_satoshi_obj numstr.(%s) i.%d prev.%llu vs satoshis.%llu\n",numstr.buf,i,(unsigned long long)prev,(unsigned long long)satoshis);
+        prev = satoshis;
+    }
+    sprintf(checkstr.buf,"%llu",(long long)satoshis);
+    if ( strcmp(checkstr.buf,numstr.buf) != 0 )
+    {
+        printf("SATOSHI GREMLIN?? numstr.(%s) -> %.8f -> (%s)\n",numstr.buf,dstr(satoshis),checkstr.buf);
+    }
+    return(satoshis);
+}
+
+void add_satoshis_json(cJSON *json,char *field,uint64_t satoshis)
+{
+    cJSON *obj;
+    char numstr[64];
+    sprintf(numstr,"%lld",(long long)satoshis);
+    obj = cJSON_CreateString(numstr);
+    cJSON_AddItemToObject(json,field,obj);
+    if ( satoshis != get_satoshi_obj(json,field) )
+        printf("error adding satoshi obj %ld -> %ld\n",(unsigned long)satoshis,(unsigned long)get_satoshi_obj(json,field));
+}
+
+char *cJSON_str(cJSON *json)
+{
+    if ( json != 0 && is_cJSON_String(json) != 0 )
+        return(json->valuestring);
+    return(0);
+}
+
+void jadd(cJSON *json,char *field,cJSON *item) { if ( json != 0 )cJSON_AddItemToObject(json,field,item); }
+void jaddstr(cJSON *json,char *field,char *str) { if ( json != 0 && str != 0 ) cJSON_AddItemToObject(json,field,cJSON_CreateString(str)); }
+void jaddnum(cJSON *json,char *field,double num) { if ( json != 0 )cJSON_AddItemToObject(json,field,cJSON_CreateNumber(num)); }
+void jadd64bits(cJSON *json,char *field,uint64_t nxt64bits) { char numstr[64]; sprintf(numstr,"%llu",(long long)nxt64bits), jaddstr(json,field,numstr); }
+void jaddi(cJSON *json,cJSON *item) { if ( json != 0 ) cJSON_AddItemToArray(json,item); }
+void jaddistr(cJSON *json,char *str) { if ( json != 0 ) cJSON_AddItemToArray(json,cJSON_CreateString(str)); }
+void jaddinum(cJSON *json,double num) { if ( json != 0 ) cJSON_AddItemToArray(json,cJSON_CreateNumber(num)); }
+void jaddi64bits(cJSON *json,uint64_t nxt64bits) { char numstr[64]; sprintf(numstr,"%llu",(long long)nxt64bits), jaddistr(json,numstr); }
+char *jstr(cJSON *json,char *field) { if ( json == 0 ) return(0); if ( field == 0 ) return(cJSON_str(json)); return(cJSON_str(cJSON_GetObjectItem(json,field))); }
+
+char *jstri(cJSON *json,int32_t i) { return(cJSON_str(cJSON_GetArrayItem(json,i))); }
+char *jprint(cJSON *json,int32_t freeflag)
+{
+    char *str;
+    /*static portable_mutex_t mutex; static int32_t initflag;
+    if ( initflag == 0 )
+    {
+        portable_mutex_init(&mutex);
+        initflag = 1;
+    }*/
+    if ( json == 0 )
+        return(clonestr((char *)"{}"));
+    //portable_mutex_lock(&mutex);
+    //usleep(5000);
+    str = cJSON_Print(json), _stripwhite(str,' ');
+    if ( freeflag != 0 )
+        free_json(json);
+    //portable_mutex_unlock(&mutex);
+    return(str);
+}
+
+bits256 get_API_bits256(cJSON *obj)
+{
+    bits256 hash; char *str;
+    memset(hash.bytes,0,sizeof(hash));
+    if ( obj != 0 )
+    {
+        if ( is_cJSON_String(obj) != 0 && (str= obj->valuestring) != 0 && strlen(str) == 64 )
+            decode_hex(hash.bytes,sizeof(hash),str);
+    }
+    return(hash);
+}
+bits256 jbits256(cJSON *json,char *field) { if ( field == 0 ) return(get_API_bits256(json)); return(get_API_bits256(json != 0 ? cJSON_GetObjectItem(json,field) : 0)); }
+bits256 jbits256i(cJSON *json,int32_t i) { return(get_API_bits256(cJSON_GetArrayItem(json,i))); }
+void jaddbits256(cJSON *json,char *field,bits256 hash) { char str[65]; bits256_str(str,hash), jaddstr(json,field,str); }
+void jaddibits256(cJSON *json,bits256 hash) { char str[65]; bits256_str(str,hash), jaddistr(json,str); }
+
+char *get_cJSON_fieldname(cJSON *obj)
+{
+    if ( obj != 0 )
+    {
+        if ( obj->string != 0 )
+            return(obj->string);
+		if ( obj->child != 0 && obj->child->string != 0 )
+			return(obj->child->string);
+    }
+    return((char *)"<no cJSON string field>");
+}
+
+int32_t jnum(cJSON *obj,char *field)
+{
+    char *str; int32_t polarity = 1;
+    if ( field != 0 )
+        obj = jobj(obj,field);
+    if ( obj != 0 )
+    {
+        if ( is_cJSON_Number(obj) != 0 )
+            return(obj->valuedouble);
+        else if ( is_cJSON_String(obj) != 0 && (str= jstr(obj,0)) != 0 )
+        {
+            if ( str[0] == '-' )
+                polarity = -1, str++;
+            return(polarity * (int32_t)calc_nxt64bits(str));
+        }
+    }
+    return(0);
+}
+
+void ensure_jsonitem(cJSON *json,char *field,char *value)
+{
+    cJSON *obj;
+    if ( json != 0 )
+    {
+        obj = cJSON_GetObjectItem(json,field);
+        if ( obj == 0 )
+            cJSON_AddItemToObject(json,field,cJSON_CreateString(value));
+        else cJSON_ReplaceItemInObject(json,field,cJSON_CreateString(value));
+    }
+}
+
+int32_t in_jsonarray(cJSON *array,char *value)
+{
+    int32_t i,n;
+    struct destbuf remote;
+    if ( array != 0 && is_cJSON_Array(array) != 0 )
+    {
+        n = cJSON_GetArraySize(array);
+        for (i=0; i<n; i++)
+        {
+            if ( array == 0 || n == 0 )
+                break;
+            copy_cJSON(&remote,cJSON_GetArrayItem(array,i));
+            if ( strcmp(remote.buf,value) == 0 )
+                return(1);
+        }
+    }
+    return(0);
+}
+
+int32_t myatoi(char *str,int32_t range)
+{
+    long x; char *ptr;
+    x = strtol(str,&ptr,10);
+    if ( range != 0 && x >= range )
+        x = (range - 1);
+    return((int32_t)x);
+}
+
+int32_t get_API_int(cJSON *obj,int32_t val)
+{
+    struct destbuf buf;
+    if ( obj != 0 )
+    {
+        if ( is_cJSON_Number(obj) != 0 )
+            return((int32_t)obj->valuedouble);
+        copy_cJSON(&buf,obj);
+        val = myatoi(buf.buf,0);
+        if ( val < 0 )
+            val = 0;
+    }
+    return(val);
+}
+int32_t jint(cJSON *json,char *field) { if ( json == 0 ) return(0); if ( field == 0 ) return(get_API_int(json,0)); return(get_API_int(cJSON_GetObjectItem(json,field),0)); }
+int32_t jinti(cJSON *json,int32_t i) { if ( json == 0 ) return(0); return(get_API_int(cJSON_GetArrayItem(json,i),0)); }
+
+uint32_t get_API_uint(cJSON *obj,uint32_t val)
+{
+    struct destbuf buf;
+    if ( obj != 0 )
+    {
+        if ( is_cJSON_Number(obj) != 0 )
+            return((uint32_t)obj->valuedouble);
+        copy_cJSON(&buf,obj);
+        val = myatoi(buf.buf,0);
+    }
+    return(val);
+}
+uint32_t juint(cJSON *json,char *field) { if ( json == 0 ) return(0); if ( field == 0 ) return(get_API_uint(json,0)); return(get_API_uint(cJSON_GetObjectItem(json,field),0)); }
+uint32_t juinti(cJSON *json,int32_t i) { if ( json == 0 ) return(0); return(get_API_uint(cJSON_GetArrayItem(json,i),0)); }
+
+double get_API_float(cJSON *obj)
+{
+    double val = 0.;
+    struct destbuf buf;
+    if ( obj != 0 )
+    {
+        if ( is_cJSON_Number(obj) != 0 )
+            return(obj->valuedouble);
+        copy_cJSON(&buf,obj);
+        val = atof(buf.buf);
+    }
+    return(val);
+}
+
+double jdouble(cJSON *json,char *field)
+{
+    if ( json != 0 )
+    {
+        if ( field == 0 )
+            return(get_API_float(json));
+        else return(get_API_float(cJSON_GetObjectItem(json,field)));
+    } else return(0.);
+}
+
+double jdoublei(cJSON *json,int32_t i)
+{
+    if ( json != 0 )
+        return(get_API_float(cJSON_GetArrayItem(json,i)));
+    else return(0.);
+}
+
+cJSON *jobj(cJSON *json,char *field) { if ( json != 0 ) return(cJSON_GetObjectItem(json,field)); return(0); }
+
+void jdelete(cJSON *json,char *field)
+{
+    if ( jobj(json,field) != 0 )
+        cJSON_DeleteItemFromObject(json,field);
+}
+
+cJSON *jduplicate(cJSON *json) { return(cJSON_Duplicate(json,1)); }
+
+cJSON *jitem(cJSON *array,int32_t i) { if ( array != 0 && is_cJSON_Array(array) != 0 && cJSON_GetArraySize(array) > i ) return(cJSON_GetArrayItem(array,i)); return(0); }
+cJSON *jarray(int32_t *nump,cJSON *json,char *field)
+{
+    cJSON *array;
+    if ( json != 0 )
+    {
+        if ( field == 0 )
+            array = json;
+        else array = cJSON_GetObjectItem(json,field);
+        if ( array != 0 && is_cJSON_Array(array) != 0 && (*nump= cJSON_GetArraySize(array)) > 0 )
+            return(array);
+    }
+    *nump = 0;
+    return(0);
+}
+
+int32_t expand_nxt64bits(char *NXTaddr,uint64_t nxt64bits)
+{
+    int32_t i,n;
+    uint64_t modval;
+    char rev[64];
+    for (i=0; nxt64bits!=0; i++)
+    {
+        modval = nxt64bits % 10;
+        rev[i] = (char)(modval + '0');
+        nxt64bits /= 10;
+    }
+    n = i;
+    for (i=0; i<n; i++)
+        NXTaddr[i] = rev[n-1-i];
+    NXTaddr[i] = 0;
+    return(n);
+}
+
+char *nxt64str(uint64_t nxt64bits)
+{
+    static char NXTaddr[64];
+    expand_nxt64bits(NXTaddr,nxt64bits);
+    return(NXTaddr);
+}
+
+char *nxt64str2(uint64_t nxt64bits)
+{
+    static char NXTaddr[64];
+    expand_nxt64bits(NXTaddr,nxt64bits);
+    return(NXTaddr);
+}
+
+int32_t cmp_nxt64bits(const char *str,uint64_t nxt64bits)
+{
+    char expanded[64];
+    if ( str == 0 )//|| str[0] == 0 || nxt64bits == 0 )
+        return(-1);
+    if ( nxt64bits == 0 && str[0] == 0 )
+        return(0);
+    expand_nxt64bits(expanded,nxt64bits);
+    return(strcmp(str,expanded));
+}
+
+uint64_t calc_nxt64bits(const char *NXTaddr)
+{
+    int32_t c;
+    int64_t n,i,polarity = 1;
+    uint64_t lastval,mult,nxt64bits = 0;
+    if ( NXTaddr == 0 )
+    {
+        printf("calling calc_nxt64bits with null ptr!\n");
+        return(0);
+    }
+    n = strlen(NXTaddr);
+    if ( n >= 22 )
+    {
+        printf("calc_nxt64bits: illegal NXTaddr.(%s) too long\n",NXTaddr);
+        return(0);
+    }
+    else if ( strcmp(NXTaddr,"0") == 0 || strcmp(NXTaddr,"false") == 0 )
+    {
+        // printf("zero address?\n"); getchar();
+        return(0);
+    }
+    if ( NXTaddr[0] == '-' )
+        polarity = -1, NXTaddr++, n--;
+    mult = 1;
+    lastval = 0;
+    for (i=n-1; i>=0; i--,mult*=10)
+    {
+        c = NXTaddr[i];
+        if ( c < '0' || c > '9' )
+        {
+            //printf("calc_nxt64bits: illegal char.(%c %d) in (%s).%d\n",c,c,NXTaddr,(int32_t)i);
+#ifdef __APPLE__
+            //while ( 1 )
+            {
+                //sleep(60);
+                //printf("calc_nxt64bits: illegal char.(%c %d) in (%s).%d\n",c,c,NXTaddr,(int32_t)i);
+            }
+#endif
+            return(0);
+        }
+        nxt64bits += mult * (c - '0');
+        if ( nxt64bits < lastval )
+            printf("calc_nxt64bits: warning: 64bit overflow %llx < %llx\n",(long long)nxt64bits,(long long)lastval);
+        lastval = nxt64bits;
+    }
+    while ( *NXTaddr == '0' && *NXTaddr != 0 )
+        NXTaddr++;
+    if ( cmp_nxt64bits(NXTaddr,nxt64bits) != 0 )
+        printf("error calculating nxt64bits: %s -> %llx -> %s\n",NXTaddr,(long long)nxt64bits,nxt64str(nxt64bits));
+    if ( polarity < 0 )
+        return(-(int64_t)nxt64bits);
+    return(nxt64bits);
+}
+
+cJSON *addrs_jsonarray(uint64_t *addrs,int32_t num)
+{
+    int32_t j; cJSON *array;
+    array = cJSON_CreateArray();
+    for (j=0; j<num; j++)
+        jaddi64bits(array,addrs[j]);
+    return(array);
+}
+
+cJSON *cJSON_CreateArray(void)
+{
+    cJSON *item = cJSON_New_Item();
+    if ( item )
+        item->type = cJSON_Array;
+//#ifdef CJSON_GARBAGECOLLECTION
+//    cJSON_register(item);
+//#endif
+    return(item);
+}
+
+cJSON *cJSON_CreateObject(void)
+{
+    cJSON *item = cJSON_New_Item();
+    if ( item )
+        item->type = cJSON_Object;
+//#ifdef CJSON_GARBAGECOLLECTION
+//    cJSON_register(item);
+//#endif
+    return item;
+}
+
+void free_json(cJSON *item)
+{
+//#ifdef CJSON_GARBAGECOLLECTION
+//    cJSON_unregister(item);
+//#endif
+   if ( item != 0 )
+        cJSON_Delete(item);
+}
diff --git a/src/cc/dapps/oracle_dapp.sh b/src/cc/dapps/oracle_dapp.sh
new file mode 100755
index 000000000..f6efd6a2b
--- /dev/null
+++ b/src/cc/dapps/oracle_dapp.sh
@@ -0,0 +1,24 @@
+#!/bin/bash
+
+# SET AC
+read -p "Enter AC name you use : " acname
+sed -i "/#define ACNAME */c\#define ACNAME \"$acname\"" oraclefeed.c
+# Set ORACLETXID
+read -p "Enter your oracle TXID (Oracle should have L data type) : " oracletxid
+sed -i "/#define ORACLETXID */c\#define ORACLETXID \"$oracletxid\"" oraclefeed.c
+# SET PUBKEY
+read -p "Enter your pubkey : " pubkey
+sed -i "/#define MYPUBKEY */c\#define MYPUBKEY \"$pubkey\"" oraclefeed.c
+# COMPILATION
+echo "Great, compiling !"
+gcc oraclefeed.c -lm -o oracle_dapp
+mv oracle_dapp ../../oracle_dapp
+echo "Oracle is ready to use !"
+while true; do
+    read -p "Would you like to run BTCUSD oracle app? [Y/N]" yn
+    case $yn in
+        [Yy]* ) cd ../..; ./oracle_dapp; break;;
+        [Nn]* ) exit;;
+        * ) echo "Please answer yes or no.";;
+    esac
+done
diff --git a/src/cc/dapps/oraclefeed.c b/src/cc/dapps/oraclefeed.c
new file mode 100644
index 000000000..f32ef3f73
--- /dev/null
+++ b/src/cc/dapps/oraclefeed.c
@@ -0,0 +1,441 @@
+/******************************************************************************
+ * Copyright © 2014-2018 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <memory.h>
+#include "cJSON.c"
+
+
+char hexbyte(int32_t c)
+{
+    c &= 0xf;
+    if ( c < 10 )
+        return('0'+c);
+    else if ( c < 16 )
+        return('a'+c-10);
+    else return(0);
+}
+
+int32_t _unhex(char c)
+{
+    if ( c >= '0' && c <= '9' )
+        return(c - '0');
+    else if ( c >= 'a' && c <= 'f' )
+        return(c - 'a' + 10);
+    else if ( c >= 'A' && c <= 'F' )
+        return(c - 'A' + 10);
+    return(-1);
+}
+
+int32_t is_hexstr(char *str,int32_t n)
+{
+    int32_t i;
+    if ( str == 0 || str[0] == 0 )
+        return(0);
+    for (i=0; str[i]!=0; i++)
+    {
+        if ( n > 0 && i >= n )
+            break;
+        if ( _unhex(str[i]) < 0 )
+            break;
+    }
+    if ( n == 0 )
+        return(i);
+    return(i == n);
+}
+
+int32_t unhex(char c)
+{
+    int32_t hex;
+    if ( (hex= _unhex(c)) < 0 )
+    {
+        //printf("unhex: illegal hexchar.(%c)\n",c);
+    }
+    return(hex);
+}
+
+unsigned char _decode_hex(char *hex) { return((unhex(hex[0])<<4) | unhex(hex[1])); }
+
+int32_t decode_hex(unsigned char *bytes,int32_t n,char *hex)
+{
+    int32_t adjust,i = 0;
+    //printf("decode.(%s)\n",hex);
+    if ( is_hexstr(hex,n) <= 0 )
+    {
+        memset(bytes,0,n);
+        return(n);
+    }
+    if ( hex[n-1] == '\n' || hex[n-1] == '\r' )
+        hex[--n] = 0;
+    if ( hex[n-1] == '\n' || hex[n-1] == '\r' )
+        hex[--n] = 0;
+    if ( n == 0 || (hex[n*2+1] == 0 && hex[n*2] != 0) )
+    {
+        if ( n > 0 )
+        {
+            bytes[0] = unhex(hex[0]);
+            printf("decode_hex n.%d hex[0] (%c) -> %d hex.(%s) [n*2+1: %d] [n*2: %d %c] len.%ld\n",n,hex[0],bytes[0],hex,hex[n*2+1],hex[n*2],hex[n*2],(long)strlen(hex));
+        }
+        bytes++;
+        hex++;
+        adjust = 1;
+    } else adjust = 0;
+    if ( n > 0 )
+    {
+        for (i=0; i<n; i++)
+            bytes[i] = _decode_hex(&hex[i*2]);
+    }
+    //bytes[i] = 0;
+    return(n + adjust);
+}
+
+int32_t init_hexbytes_noT(char *hexbytes,unsigned char *message,long len)
+{
+    int32_t i;
+    if ( len <= 0 )
+    {
+        hexbytes[0] = 0;
+        return(1);
+    }
+    for (i=0; i<len; i++)
+    {
+        hexbytes[i*2] = hexbyte((message[i]>>4) & 0xf);
+        hexbytes[i*2 + 1] = hexbyte(message[i] & 0xf);
+        //printf("i.%d (%02x) [%c%c]\n",i,message[i],hexbytes[i*2],hexbytes[i*2+1]);
+    }
+    hexbytes[len*2] = 0;
+    //printf("len.%ld\n",len*2+1);
+    return((int32_t)len*2+1);
+}
+
+long _stripwhite(char *buf,int accept)
+{
+    int32_t i,j,c;
+    if ( buf == 0 || buf[0] == 0 )
+        return(0);
+    for (i=j=0; buf[i]!=0; i++)
+    {
+        buf[j] = c = buf[i];
+        if ( c == accept || (c != ' ' && c != '\n' && c != '\r' && c != '\t' && c != '\b') )
+            j++;
+    }
+    buf[j] = 0;
+    return(j);
+}
+
+char *clonestr(char *str)
+{
+    char *clone;
+    if ( str == 0 || str[0] == 0 )
+    {
+        printf("warning cloning nullstr.%p\n",str);
+        //#ifdef __APPLE__
+        //        while ( 1 ) sleep(1);
+        //#endif
+        str = (char *)"<nullstr>";
+    }
+    clone = (char *)malloc(strlen(str)+16);
+    strcpy(clone,str);
+    return(clone);
+}
+
+int32_t safecopy(char *dest,char *src,long len)
+{
+    int32_t i = -1;
+    if ( src != 0 && dest != 0 && src != dest )
+    {
+        if ( dest != 0 )
+            memset(dest,0,len);
+        for (i=0; i<len&&src[i]!=0; i++)
+            dest[i] = src[i];
+        if ( i == len )
+        {
+            printf("safecopy: %s too long %ld\n",src,len);
+            //printf("divide by zero! %d\n",1/zeroval());
+#ifdef __APPLE__
+            //getchar();
+#endif
+            return(-1);
+        }
+        dest[i] = 0;
+    }
+    return(i);
+}
+
+char *bits256_str(char hexstr[65],bits256 x)
+{
+    init_hexbytes_noT(hexstr,x.bytes,sizeof(x));
+    return(hexstr);
+}
+
+int64_t conv_floatstr(char *numstr)
+{
+    double val,corr;
+    val = atof(numstr);
+    corr = (val < 0.) ? -0.50000000001 : 0.50000000001;
+    return((int64_t)(val * SATOSHIDEN + corr));
+}
+
+char *nonportable_path(char *str)
+{
+    int32_t i;
+    for (i=0; str[i]!=0; i++)
+        if ( str[i] == '/' )
+            str[i] = '\\';
+    return(str);
+}
+
+char *portable_path(char *str)
+{
+#ifdef _WIN32
+    return(nonportable_path(str));
+#else
+#ifdef __PNACL
+    /*int32_t i,n;
+     if ( str[0] == '/' )
+     return(str);
+     else
+     {
+     n = (int32_t)strlen(str);
+     for (i=n; i>0; i--)
+     str[i] = str[i-1];
+     str[0] = '/';
+     str[n+1] = 0;
+     }*/
+#endif
+    return(str);
+#endif
+}
+
+void *loadfile(char *fname,uint8_t **bufp,long *lenp,long *allocsizep)
+{
+    FILE *fp;
+    long  filesize,buflen = *allocsizep;
+    uint8_t *buf = *bufp;
+    *lenp = 0;
+    if ( (fp= fopen(portable_path(fname),"rb")) != 0 )
+    {
+        fseek(fp,0,SEEK_END);
+        filesize = ftell(fp);
+        if ( filesize == 0 )
+        {
+            fclose(fp);
+            *lenp = 0;
+            printf("loadfile null size.(%s)\n",fname);
+            return(0);
+        }
+        if ( filesize > buflen )
+        {
+            *allocsizep = filesize;
+            *bufp = buf = (uint8_t *)realloc(buf,(long)*allocsizep+64);
+        }
+        rewind(fp);
+        if ( buf == 0 )
+            printf("Null buf ???\n");
+        else
+        {
+            if ( fread(buf,1,(long)filesize,fp) != (unsigned long)filesize )
+                printf("error reading filesize.%ld\n",(long)filesize);
+            buf[filesize] = 0;
+        }
+        fclose(fp);
+        *lenp = filesize;
+        //printf("loaded.(%s)\n",buf);
+    } //else printf("OS_loadfile couldnt load.(%s)\n",fname);
+    return(buf);
+}
+
+void *filestr(long *allocsizep,char *_fname)
+{
+    long filesize = 0; char *fname,*buf = 0; void *retptr;
+    *allocsizep = 0;
+    fname = malloc(strlen(_fname)+1);
+    strcpy(fname,_fname);
+    retptr = loadfile(fname,(uint8_t **)&buf,&filesize,allocsizep);
+    free(fname);
+    return(retptr);
+}
+
+char *send_curl(char *url,char *fname)
+{
+    long fsize; char curlstr[1024];
+    sprintf(curlstr,"curl --url \"%s\" > %s",url,fname);
+    system(curlstr);
+    return(filestr(&fsize,fname));
+}
+
+cJSON *get_urljson(char *url,char *fname)
+{
+    char *jsonstr; cJSON *json = 0;
+    if ( (jsonstr= send_curl(url,fname)) != 0 )
+    {
+        //printf("(%s) -> (%s)\n",url,jsonstr);
+        json = cJSON_Parse(jsonstr);
+        free(jsonstr);
+    }
+    return(json);
+}
+
+//////////////////////////////////////////////
+// start of dapp
+//////////////////////////////////////////////
+
+uint64_t get_btcusd()
+{
+    cJSON *pjson,*bpi,*usd; uint64_t btcusd = 0;
+    if ( (pjson= get_urljson("http://api.coindesk.com/v1/bpi/currentprice.json","/tmp/oraclefeed.json")) != 0 )
+    {
+        if ( (bpi= jobj(pjson,"bpi")) != 0 && (usd= jobj(bpi,"USD")) != 0 )
+        {
+            btcusd = jdouble(usd,"rate_float") * SATOSHIDEN;
+            printf("BTC/USD %.4f\n",dstr(btcusd));
+        }
+        free_json(pjson);
+    }
+    return(btcusd);
+}
+
+cJSON *get_komodocli(char **retstrp,char *acname,char *method,char *arg0,char *arg1,char *arg2)
+{
+    long fsize; cJSON *retjson = 0; char cmdstr[32768],*jsonstr,*fname = "/tmp/komodocli";
+    sprintf(cmdstr,"./komodo-cli -ac_name=%s %s %s %s %s > %s\n",acname,method,arg0,arg1,arg2,fname);
+    system(cmdstr);
+    *retstrp = 0;
+    if ( (jsonstr= filestr(&fsize,fname)) != 0 )
+    {
+        //fprintf(stderr,"%s -> jsonstr.(%s)\n",cmdstr,jsonstr);
+        if ( (retjson= cJSON_Parse(jsonstr)) == 0 )
+            *retstrp = jsonstr;
+        else free(jsonstr);
+    }
+    return(retjson);
+}
+
+void bntn()
+{
+    long fsize; int32_t i,n; cJSON *item,*retjson = 0; char cmdstr[32768],*jsonstr,*addr; double val;
+    if ( (jsonstr= filestr(&fsize,"bntn")) != 0 )
+    {
+        if ( (retjson= cJSON_Parse(jsonstr)) != 0 )
+        {
+            if ( (n= cJSON_GetArraySize(retjson)) > 0 )
+            {
+                for (i=0; i<n; i++)
+                {
+                    item = jitem(retjson,i);
+                    if ( (addr= jstr(item,"KMD Address")) != 0 && (val= jdouble(item,"(BNTN)")) > 0 )
+                    {
+                        val = 1387;
+                        if ( addr[0] == 'z' )
+                            printf("./komodo-cli -ac_name=BNTN sendtoaddress %s %.8f\n",addr,val);
+                    }
+                }
+            }
+            free_json(retjson);
+        }
+    }
+}
+
+void komodobroadcast(char *acname,cJSON *hexjson)
+{
+    char *hexstr,*retstr; cJSON *retjson;
+    if ( (hexstr= jstr(hexjson,"hex")) != 0 )
+    {
+        if ( (retjson= get_komodocli(&retstr,acname,"sendrawtransaction",hexstr,"","")) != 0 )
+        {
+            //fprintf(stderr,"broadcast.(%s)\n",jprint(retjson,0));
+            free_json(retjson);
+        }
+        else if ( retstr != 0 )
+        {
+            fprintf(stderr,"txid.(%s)\n",retstr);
+            free(retstr);
+        }
+    }
+}
+
+/*
+ oraclescreate "BTCUSD" "coindeskpricedata" "L" -> 4895f631316a649e216153aee7a574bd281686265dc4e8d37597f72353facac3
+ oraclesregister 4895f631316a649e216153aee7a574bd281686265dc4e8d37597f72353facac3 1000000 -> 11c54d4ab17293217276396e27d86f714576ff55a3300dac34417047825edf93
+ oraclessubscribe 4895f631316a649e216153aee7a574bd281686265dc4e8d37597f72353facac3 02ebc786cb83de8dc3922ab83c21f3f8a2f3216940c3bf9da43ce39e2a3a882c92 1.5 -> ce4e4afa53765b11a74543dacbd3174a93f33f12bb94cdc080c2c023726b5838
+ oraclesdata 4895f631316a649e216153aee7a574bd281686265dc4e8d37597f72353facac3 000000ff00000000 -> e8a8c897e97389dcac31d81b617ab73a829110bd5c6f99f9f533b9c0e22700d0
+ oraclessamples 4895f631316a649e216153aee7a574bd281686265dc4e8d37597f72353facac3 90ff8813a93b5b2615ec43974ff4fc91e4373dfd672d995676c43ff2dcda1010 10 ->
+{
+"result": "success",
+"samples": [
+            [
+             "4278190080"
+             ]
+            ]
+}
+ 
+oraclescreate test testsformat s -> 17a841a919c284cea8a676f34e793da002e606f19a9258a3190bed12d5aaa3ff
+oraclesregister -> 7825ad75ba854ab12868f7d2e06b4061903687fe93f41a2a99202a6b9ca3c029
+oraclessubscribe 17a841a919c284cea8a676f34e793da002e606f19a9258a3190bed12d5aaa3ff 02ebc786cb83de8dc3922ab83c21f3f8a2f3216940c3bf9da43ce39e2a3a882c92 1.5 -> faf8a6676f6389abad9e7f397015d200395c9f8a24c4ded291d83e6265b2f4d1
+oraclesdata 17a841a919c284cea8a676f34e793da002e606f19a9258a3190bed12d5aaa3ff 03404040 -> e8a8c897e97389dcac31d81b617ab73a829110bd5c6f99f9f533b9c0e22700d0
+
+*/
+
+#define ORACLETXID "4895f631316a649e216153aee7a574bd281686265dc4e8d37597f72353facac3"
+#define MYPUBKEY "02ebc786cb83de8dc3922ab83c21f3f8a2f3216940c3bf9da43ce39e2a3a882c92"
+#define ACNAME "ORCL"
+
+int32_t main(int32_t argc,char **argv)
+{
+    cJSON *clijson,*clijson2,*regjson,*item; int32_t i,j,n; char *retstr,*retstr2,*pkstr,hexstr[64]; uint64_t price;
+    printf("Powered by CoinDesk (%s) %.8f\n","https://www.coindesk.com/price/",dstr(get_btcusd()));
+    while ( 1 )
+    {
+        retstr = 0;
+        if ( (price= get_btcusd()) != 0 && (clijson= get_komodocli(&retstr,ACNAME,"oraclesinfo",ORACLETXID,"","")) != 0 )
+        {
+            if ( (regjson= jarray(&n,clijson,"registered")) != 0 )
+            {
+                for (i=0; i<n; i++)
+                {
+                    item = jitem(regjson,i);
+                    if ( (pkstr= jstr(item,"publisher")) != 0 && strcmp(pkstr,MYPUBKEY) == 0 )
+                    {
+                        for (j=0; j<8; j++)
+                            sprintf(&hexstr[j*2],"%02x",(uint8_t)((price >> (j*8)) & 0xff));
+                        hexstr[16] = 0;
+                        if ( (clijson2= get_komodocli(&retstr2,ACNAME,"oraclesdata",ORACLETXID,hexstr,"")) != 0 )
+                        {
+                            //printf("data.(%s)\n",jprint(clijson2,0));
+                            komodobroadcast(ACNAME,clijson2);
+                            free_json(clijson2);
+                        }
+                        else if ( retstr2 != 0 )
+                        {
+                            printf("error parsing oraclesdata.(%s)\n",retstr2);
+                            free(retstr2);
+                        }
+                        break;
+                    }
+                }
+            }
+            free_json(clijson);
+        }
+        if ( retstr != 0 )
+        {
+            printf("got json parse error.(%s)\n",retstr);
+            free(retstr);
+        }
+        sleep(60);
+    }
+    return(0);
+}
diff --git a/src/cc/dice.cpp b/src/cc/dice.cpp
index 4d2675d8b..4271186da 100644
--- a/src/cc/dice.cpp
+++ b/src/cc/dice.cpp
@@ -15,8 +15,6 @@
 
 #include "CCdice.h"
 
-extern std::string CCerror;
-
 // timeout
 
 /*
@@ -167,17 +165,6 @@ void DiceQueue(int32_t iswin,uint64_t sbits,uint256 fundingtxid,uint256 bettxid)
     } // small memory leak per DiceQueue
 }
 
-void endiancpy(uint8_t *dest,uint8_t *src,int32_t len)
-{
-    int32_t i,j=0;
-#if defined(WORDS_BIGENDIAN)
-    for (i=31; i>=0; i--)
-        dest[j++] = src[i];
-#else
-    memcpy(dest,src,len);
-#endif
-}
-
 CPubKey DiceFundingPk(CScript scriptPubKey)
 {
     CPubKey pk; uint8_t *ptr,*dest; int32_t i;
@@ -1142,7 +1129,7 @@ double DiceStatus(uint64_t txfee,char *planstr,uint256 fundingtxid,uint256 bettx
                 }
             }
         }
-        if ( scriptPubKey == fundingPubKey )
+        if ( 0 && scriptPubKey == fundingPubKey )
         {
             for (i=0; i<=n; i++)
             {
@@ -1168,7 +1155,7 @@ double DiceStatus(uint64_t txfee,char *planstr,uint256 fundingtxid,uint256 bettx
             }
             CCerror = "couldnt find bettx or spenttx %s\n",uint256_str(str,spenttxid);
             fprintf(stderr,"%s\n", CCerror.c_str());
-            return(0.);
+            return(-1.);
         }
         else if ( scriptPubKey == fundingPubKey )
             res = DiceBetFinish(&result,txfee,planstr,fundingtxid,bettxid,1);
diff --git a/src/cc/eval.h b/src/cc/eval.h
index 77c592a16..9ff0ca623 100644
--- a/src/cc/eval.h
+++ b/src/cc/eval.h
@@ -46,7 +46,15 @@
         EVAL(EVAL_DICE, 0xe6) \
         EVAL(EVAL_FSM, 0xe7) \
         EVAL(EVAL_AUCTION, 0xe8) \
-        EVAL(EVAL_LOTTO, 0xe9)
+        EVAL(EVAL_LOTTO, 0xe9) \
+        EVAL(EVAL_MOFN, 0xea) \
+        EVAL(EVAL_CHANNELS, 0xeb) \
+        EVAL(EVAL_ORACLES, 0xec) \
+        EVAL(EVAL_PRICES, 0xed) \
+        EVAL(EVAL_PEGS, 0xee) \
+        EVAL(EVAL_TRIGGERS, 0xef) \
+        EVAL(EVAL_PAYMENTS, 0xf0) \
+        EVAL(EVAL_GATEWAYS, 0xf1)
 
 
 typedef uint8_t EvalCode;
diff --git a/src/cc/faucet.cpp b/src/cc/faucet.cpp
index 1ac601e64..676cb152c 100644
--- a/src/cc/faucet.cpp
+++ b/src/cc/faucet.cpp
@@ -150,6 +150,7 @@ int64_t AddFaucetInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPub
     {
         txid = it->first.txhash;
         vout = (int32_t)it->first.index;
+        //char str[65]; fprintf(stderr,"check %s/v%d %.8f`\n",uint256_str(str,txid),vout,(double)it->second.satoshis/COIN);
         // no need to prevent dup
         if ( GetTransaction(txid,vintx,hashBlock,false) != 0 )
         {
@@ -162,8 +163,8 @@ int64_t AddFaucetInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPub
                 n++;
                 if ( (total > 0 && totalinputs >= total) || (maxinputs > 0 && n >= maxinputs) )
                     break;
-            }
-        }
+            } else fprintf(stderr,"nValue too small or already spent in mempool\n");
+        } else fprintf(stderr,"couldnt get tx\n");
     }
     return(totalinputs);
 }
diff --git a/src/cc/fsm.cpp b/src/cc/fsm.cpp
index 04c620e99..41601b437 100644
--- a/src/cc/fsm.cpp
+++ b/src/cc/fsm.cpp
@@ -17,6 +17,8 @@
 #include "../txmempool.h"
 
 /*
+ FSM CC is a highlevel CC contract that mostly uses other CC contracts. A finite state machine is defined, which combines triggers, payments and whatever other events/actions into a state machine
+ 
 */
 
 // start of consensus code
diff --git a/src/cc/gateways.cpp b/src/cc/gateways.cpp
new file mode 100644
index 000000000..8f5d00f26
--- /dev/null
+++ b/src/cc/gateways.cpp
@@ -0,0 +1,215 @@
+/******************************************************************************
+ * Copyright © 2014-2018 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+
+#include "CCGateways.h"
+
+/*
+ Uses MofN CC's normal msig handling to create automated deposits -> token issuing. And partial signing by the selected pubkeys for releasing the funds. A user would be able to select which pubkeys to use to construct the automated deposit/redeem multisigs.
+ 
+ the potential pubkeys to be used would be based on active oracle data providers with recent activity.
+ 
+ 
+*/
+
+// start of consensus code
+
+int64_t IsGatewaysvout(struct CCcontract_info *cp,const CTransaction& tx,int32_t v)
+{
+    char destaddr[64];
+    if ( tx.vout[v].scriptPubKey.IsPayToCryptoCondition() != 0 )
+    {
+        if ( Getscriptaddress(destaddr,tx.vout[v].scriptPubKey) > 0 && strcmp(destaddr,cp->unspendableCCaddr) == 0 )
+            return(tx.vout[v].nValue);
+    }
+    return(0);
+}
+
+bool GatewaysExactAmounts(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx,int32_t minage,uint64_t txfee)
+{
+    static uint256 zerohash;
+    CTransaction vinTx; uint256 hashBlock,activehash; int32_t i,numvins,numvouts; int64_t inputs=0,outputs=0,assetoshis;
+    numvins = tx.vin.size();
+    numvouts = tx.vout.size();
+    for (i=0; i<numvins; i++)
+    {
+        //fprintf(stderr,"vini.%d\n",i);
+        if ( (*cp->ismyvin)(tx.vin[i].scriptSig) != 0 )
+        {
+            //fprintf(stderr,"vini.%d check mempool\n",i);
+            if ( eval->GetTxUnconfirmed(tx.vin[i].prevout.hash,vinTx,hashBlock) == 0 )
+                return eval->Invalid("cant find vinTx");
+            else
+            {
+                //fprintf(stderr,"vini.%d check hash and vout\n",i);
+                if ( hashBlock == zerohash )
+                    return eval->Invalid("cant Gateways from mempool");
+                if ( (assetoshis= IsGatewaysvout(cp,vinTx,tx.vin[i].prevout.n)) != 0 )
+                    inputs += assetoshis;
+            }
+        }
+    }
+    for (i=0; i<numvouts; i++)
+    {
+        //fprintf(stderr,"i.%d of numvouts.%d\n",i,numvouts);
+        if ( (assetoshis= IsGatewaysvout(cp,tx,i)) != 0 )
+            outputs += assetoshis;
+    }
+    if ( inputs != outputs+txfee )
+    {
+        fprintf(stderr,"inputs %llu vs outputs %llu\n",(long long)inputs,(long long)outputs);
+        return eval->Invalid("mismatched inputs != outputs + txfee");
+    }
+    else return(true);
+}
+
+bool GatewaysValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx)
+{
+    int32_t numvins,numvouts,preventCCvins,preventCCvouts,i,numblocks; bool retval; uint256 txid; uint8_t hash[32]; char str[65],destaddr[64];
+    return(false);
+    std::vector<std::pair<CAddressIndexKey, CAmount> > txids;
+    numvins = tx.vin.size();
+    numvouts = tx.vout.size();
+    preventCCvins = preventCCvouts = -1;
+    if ( numvouts < 1 )
+        return eval->Invalid("no vouts");
+    else
+    {
+        for (i=0; i<numvins; i++)
+        {
+            if ( IsCCInput(tx.vin[0].scriptSig) == 0 )
+            {
+                return eval->Invalid("illegal normal vini");
+            }
+        }
+        //fprintf(stderr,"check amounts\n");
+        if ( GatewaysExactAmounts(cp,eval,tx,1,10000) == false )
+        {
+            fprintf(stderr,"Gatewaysget invalid amount\n");
+            return false;
+        }
+        else
+        {
+            txid = tx.GetHash();
+            memcpy(hash,&txid,sizeof(hash));
+            retval = PreventCC(eval,tx,preventCCvins,numvins,preventCCvouts,numvouts);
+            if ( retval != 0 )
+                fprintf(stderr,"Gatewaysget validated\n");
+            else fprintf(stderr,"Gatewaysget invalid\n");
+            return(retval);
+        }
+    }
+}
+// end of consensus code
+
+// helper functions for rpc calls in rpcwallet.cpp
+
+int64_t AddGatewaysInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPubKey pk,int64_t total,int32_t maxinputs)
+{
+    char coinaddr[64]; int64_t nValue,price,totalinputs = 0; uint256 txid,hashBlock; std::vector<uint8_t> origpubkey; CTransaction vintx; int32_t vout,n = 0;
+    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
+    GetCCaddress(cp,coinaddr,pk);
+    SetCCunspents(unspentOutputs,coinaddr);
+    for (std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> >::const_iterator it=unspentOutputs.begin(); it!=unspentOutputs.end(); it++)
+    {
+        txid = it->first.txhash;
+        vout = (int32_t)it->first.index;
+        // no need to prevent dup
+        if ( GetTransaction(txid,vintx,hashBlock,false) != 0 )
+        {
+            if ( (nValue= IsGatewaysvout(cp,vintx,vout)) > 1000000 && myIsutxo_spentinmempool(txid,vout) == 0 )
+            {
+                if ( total != 0 && maxinputs != 0 )
+                    mtx.vin.push_back(CTxIn(txid,vout,CScript()));
+                nValue = it->second.satoshis;
+                totalinputs += nValue;
+                n++;
+                if ( (total > 0 && totalinputs >= total) || (maxinputs > 0 && n >= maxinputs) )
+                    break;
+            }
+        }
+    }
+    return(totalinputs);
+}
+
+std::string GatewaysGet(uint64_t txfee,int64_t nValue)
+{
+    CMutableTransaction mtx,tmpmtx; CPubKey mypk,Gatewayspk; int64_t inputs,CCchange=0; struct CCcontract_info *cp,C; std::string rawhex; uint32_t j; int32_t i,len; uint8_t buf[32768]; bits256 hash;
+    cp = CCinit(&C,EVAL_GATEWAYS);
+    if ( txfee == 0 )
+        txfee = 10000;
+    Gatewayspk = GetUnspendable(cp,0);
+    mypk = pubkey2pk(Mypubkey());
+    if ( (inputs= AddGatewaysInputs(cp,mtx,Gatewayspk,nValue+txfee,60)) > 0 )
+    {
+        if ( inputs > nValue )
+            CCchange = (inputs - nValue - txfee);
+        if ( CCchange != 0 )
+            mtx.vout.push_back(MakeCC1vout(EVAL_GATEWAYS,CCchange,Gatewayspk));
+        mtx.vout.push_back(CTxOut(nValue,CScript() << ParseHex(HexStr(mypk)) << OP_CHECKSIG));
+        fprintf(stderr,"start at %u\n",(uint32_t)time(NULL));
+        j = rand() & 0xfffffff;
+        for (i=0; i<1000000; i++,j++)
+        {
+            tmpmtx = mtx;
+            rawhex = FinalizeCCTx(-1LL,cp,tmpmtx,mypk,txfee,CScript() << OP_RETURN << E_MARSHAL(ss << (uint8_t)EVAL_GATEWAYS << (uint8_t)'G' << j));
+            if ( (len= (int32_t)rawhex.size()) > 0 && len < 65536 )
+            {
+                len >>= 1;
+                decode_hex(buf,len,(char *)rawhex.c_str());
+                hash = bits256_doublesha256(0,buf,len);
+                if ( (hash.bytes[0] & 0xff) == 0 && (hash.bytes[31] & 0xff) == 0 )
+                {
+                    fprintf(stderr,"found valid txid after %d iterations %u\n",i,(uint32_t)time(NULL));
+                    return(rawhex);
+                }
+                //fprintf(stderr,"%02x%02x ",hash.bytes[0],hash.bytes[31]);
+            }
+        }
+        fprintf(stderr,"couldnt generate valid txid %u\n",(uint32_t)time(NULL));
+        return("");
+    } else fprintf(stderr,"cant find Gateways inputs\n");
+    return("");
+}
+
+std::string GatewaysFund(uint64_t txfee,int64_t funds)
+{
+    CMutableTransaction mtx; CPubKey mypk,Gatewayspk; CScript opret; struct CCcontract_info *cp,C;
+    cp = CCinit(&C,EVAL_GATEWAYS);
+    if ( txfee == 0 )
+        txfee = 10000;
+    mypk = pubkey2pk(Mypubkey());
+    Gatewayspk = GetUnspendable(cp,0);
+    if ( AddNormalinputs(mtx,mypk,funds+txfee,64) > 0 )
+    {
+        mtx.vout.push_back(MakeCC1vout(EVAL_GATEWAYS,funds,Gatewayspk));
+        return(FinalizeCCTx(0,cp,mtx,mypk,txfee,opret));
+    }
+    return("");
+}
+
+UniValue GatewaysInfo()
+{
+    UniValue result(UniValue::VOBJ); char numstr[64];
+    CMutableTransaction mtx; CPubKey Gatewayspk; struct CCcontract_info *cp,C; int64_t funding;
+    result.push_back(Pair("result","success"));
+    result.push_back(Pair("name","Gateways"));
+    cp = CCinit(&C,EVAL_GATEWAYS);
+    Gatewayspk = GetUnspendable(cp,0);
+    funding = AddGatewaysInputs(cp,mtx,Gatewayspk,0,0);
+    sprintf(numstr,"%.8f",(double)funding/COIN);
+    result.push_back(Pair("funding",numstr));
+    return(result);
+}
+
diff --git a/src/cc/includes/cJSON.h b/src/cc/includes/cJSON.h
new file mode 100755
index 000000000..3ecdadc69
--- /dev/null
+++ b/src/cc/includes/cJSON.h
@@ -0,0 +1,237 @@
+/*
+ Copyright (c) 2009 Dave Gamble
+ 
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+ 
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ */
+
+#ifndef cJSON__h
+#define cJSON__h
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <math.h>
+#include <ctype.h>
+#include <float.h>
+#include <memory.h>
+
+#include "../crypto777/OS_portable.h"
+
+#define SATOSHIDEN ((uint64_t)100000000L)
+#define dstr(x) ((double)(x) / SATOSHIDEN)
+#define MAX_JSON_FIELD 4096 // on the big side
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+    
+    /* cJSON Types: */
+#define cJSON_False 0
+#define cJSON_True 1
+#define cJSON_NULL 2
+#define cJSON_Number 3
+#define cJSON_String 4
+#define cJSON_Array 5
+#define cJSON_Object 6
+	
+#define is_cJSON_Null(json) ((json) != 0 && ((json)->type & 0xff) == cJSON_NULL)
+#define is_cJSON_Array(json) ((json) != 0 && ((json)->type & 0xff) == cJSON_Array)
+#define is_cJSON_String(json) ((json) != 0 && ((json)->type & 0xff) == cJSON_String)
+#define is_cJSON_Number(json) ((json) != 0 && ((json)->type & 0xff) == cJSON_Number)
+#define is_cJSON_Object(json) ((json) != 0 && ((json)->type & 0xff) == cJSON_Object)
+#define is_cJSON_True(json) ((json) != 0 && ((json)->type & 0xff) == cJSON_True)
+#define is_cJSON_False(json) ((json) != 0 && ((json)->type & 0xff) == cJSON_False)
+    
+#define cJSON_IsReference 256
+    
+    /* The cJSON structure: */
+    typedef struct cJSON {
+        struct cJSON *next,*prev;	/* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */
+        struct cJSON *child;		/* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */
+        
+        int32_t type;					/* The type of the item, as above. */
+        
+        char *valuestring;			/* The item's string, if type==cJSON_String */
+        int64_t valueint;				/* The item's number, if type==cJSON_Number */
+        double valuedouble;			/* The item's number, if type==cJSON_Number */
+        
+        char *string;				/* The item's name string, if this item is the child of, or is in the list of subitems of an object. */
+        uint32_t cjsonid;
+    } cJSON;
+    
+    typedef struct cJSON_Hooks {
+        void *(*malloc_fn)(size_t sz);
+        void (*free_fn)(void *ptr);
+    } cJSON_Hooks;
+    
+    /* Supply malloc, realloc and free functions to cJSON */
+    extern void cJSON_InitHooks(cJSON_Hooks* hooks);
+    
+    
+    /* Supply a block of JSON, and this returns a cJSON object you can interrogate. Call cJSON_Delete when finished. */
+    extern cJSON *cJSON_Parse(const char *value);
+    /* Render a cJSON entity to text for transfer/storage. Free the char* when finished. */
+    extern char  *cJSON_Print(cJSON *item);
+    /* Render a cJSON entity to text for transfer/storage without any formatting. Free the char* when finished. */
+    extern char  *cJSON_PrintUnformatted(cJSON *item);
+    /* Delete a cJSON entity and all subentities. */
+    extern void   cJSON_Delete(cJSON *c);
+    
+    /* Returns the number of items in an array (or object). */
+    extern int	  cJSON_GetArraySize(cJSON *array);
+    /* Retrieve item number "item" from array "array". Returns NULL if unsuccessful. */
+    extern cJSON *cJSON_GetArrayItem(cJSON *array,int32_t item);
+    /* Get item "string" from object. Case insensitive. */
+    extern cJSON *cJSON_GetObjectItem(cJSON *object,const char *string);
+    
+    /* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */
+    extern const char *cJSON_GetErrorPtr(void);
+	
+    /* These calls create a cJSON item of the appropriate type. */
+    extern cJSON *cJSON_CreateNull(void);
+    extern cJSON *cJSON_CreateTrue(void);
+    extern cJSON *cJSON_CreateFalse(void);
+    extern cJSON *cJSON_CreateBool(int32_t b);
+    extern cJSON *cJSON_CreateNumber(double num);
+    extern cJSON *cJSON_CreateString(const char *string);
+    extern cJSON *cJSON_CreateArray(void);
+    extern cJSON *cJSON_CreateObject(void);
+    
+    /* These utilities create an Array of count items. */
+    extern cJSON *cJSON_CreateIntArray(int64_t *numbers,int32_t count);
+    extern cJSON *cJSON_CreateFloatArray(float *numbers,int32_t count);
+    extern cJSON *cJSON_CreateDoubleArray(double *numbers,int32_t count);
+    extern cJSON *cJSON_CreateStringArray(char **strings,int32_t count);
+    
+    /* Append item to the specified array/object. */
+    extern void cJSON_AddItemToArray(cJSON *array, cJSON *item);
+    extern void	cJSON_AddItemToObject(cJSON *object,const char *string,cJSON *item);
+    /* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON. */
+    extern void cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item);
+    extern void	cJSON_AddItemReferenceToObject(cJSON *object,const char *string,cJSON *item);
+    
+    /* Remove/Detatch items from Arrays/Objects. */
+    extern cJSON *cJSON_DetachItemFromArray(cJSON *array,int32_t which);
+    extern void   cJSON_DeleteItemFromArray(cJSON *array,int32_t which);
+    extern cJSON *cJSON_DetachItemFromObject(cJSON *object,const char *string);
+    extern void   cJSON_DeleteItemFromObject(cJSON *object,const char *string);
+	
+    /* Update array items. */
+    extern void cJSON_ReplaceItemInArray(cJSON *array,int32_t which,cJSON *newitem);
+    extern void cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem);
+    
+    /* Duplicate a cJSON item */
+    extern cJSON *cJSON_Duplicate(cJSON *item,int32_t recurse);
+    /* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will
+     need to be released. With recurse!=0, it will duplicate any children connected to the item.
+     The item->next and ->prev pointers are always zero on return from Duplicate. */
+    
+    /* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */
+    extern cJSON *cJSON_ParseWithOpts(const char *value,const char **return_parse_end,int32_t require_null_terminated);
+    
+    extern void cJSON_Minify(char *json);
+    
+    /* Macros for creating things quickly. */
+#define cJSON_AddNullToObject(object,name)		cJSON_AddItemToObject(object, name, cJSON_CreateNull())
+#define cJSON_AddTrueToObject(object,name)		cJSON_AddItemToObject(object, name, cJSON_CreateTrue())
+#define cJSON_AddFalseToObject(object,name)		cJSON_AddItemToObject(object, name, cJSON_CreateFalse())
+#define cJSON_AddBoolToObject(object,name,b)	cJSON_AddItemToObject(object, name, cJSON_CreateBool(b))
+#define cJSON_AddNumberToObject(object,name,n)	cJSON_AddItemToObject(object, name, cJSON_CreateNumber(n))
+#define cJSON_AddStringToObject(object,name,s)	cJSON_AddItemToObject(object, name, cJSON_CreateString(s))
+    
+    struct destbuf { char buf[MAX_JSON_FIELD]; };
+    
+    /* When assigning an integer value, it needs to be propagated to valuedouble too. */
+#define cJSON_SetIntValue(object,val)			((object)?(object)->valueint=(object)->valuedouble=(val):(val))
+#define jfieldstr get_cJSON_fieldname
+    
+    char *cJSON_str(cJSON *json);
+    char *jstr(cJSON *json,char *field);
+    char *jprint(cJSON *json,int32_t freeflag);
+    int32_t jint(cJSON *json,char *field);
+    uint32_t juint(cJSON *json,char *field);
+    char *jstri(cJSON *json,int32_t i);
+    int32_t jinti(cJSON *json,int32_t i);
+    uint32_t juinti(cJSON *json,int32_t i);
+    uint64_t j64bitsi(cJSON *json,int32_t i);
+    double jdoublei(cJSON *json,int32_t i);
+    double jdouble(cJSON *json,char *field);
+    cJSON *jobj(cJSON *json,char *field);
+    cJSON *jarray(int32_t *nump,cJSON *json,char *field);
+    cJSON *jitem(cJSON *array,int32_t i);
+    uint64_t j64bits(cJSON *json,char *field);
+    void jadd(cJSON *json,char *field,cJSON *item);
+    void jaddstr(cJSON *json,char *field,char *str);
+    void jaddnum(cJSON *json,char *field,double num);
+    void jadd64bits(cJSON *json,char *field,uint64_t nxt64bits);
+    void jaddi(cJSON *json,cJSON *item);
+    void jaddistr(cJSON *json,char *str);
+    void jaddinum(cJSON *json,double num);
+    void jaddi64bits(cJSON *json,uint64_t nxt64bits);
+    void jdelete(cJSON *object,char *string);
+    cJSON *jduplicate(cJSON *json);
+    int32_t jnum(cJSON *obj,char *field);
+ 
+    bits256 jbits256(cJSON *json,char *field);
+    bits256 jbits256i(cJSON *json,int32_t i);
+    void jaddbits256(cJSON *json,char *field,bits256 hash);
+    void jaddibits256(cJSON *json,bits256 hash);
+    void copy_cJSON(struct destbuf *dest,cJSON *obj);
+    void copy_cJSON2(char *dest,int32_t maxlen,cJSON *obj);
+    cJSON *gen_list_json(char **list);
+    int32_t extract_cJSON_str(char *dest,int32_t max,cJSON *json,char *field);
+
+    void free_json(cJSON *json);
+    int64_t _conv_cJSON_float(cJSON *json);
+    int64_t conv_cJSON_float(cJSON *json,char *field);
+    int64_t get_cJSON_int(cJSON *json,char *field);
+    void add_satoshis_json(cJSON *json,char *field,uint64_t satoshis);
+    uint64_t get_satoshi_obj(cJSON *json,char *field);
+    
+    int32_t get_API_int(cJSON *obj,int32_t val);
+    uint32_t get_API_uint(cJSON *obj,uint32_t val);
+    uint64_t get_API_nxt64bits(cJSON *obj);
+    double get_API_float(cJSON *obj);
+    char *get_cJSON_fieldname(cJSON *obj);
+    void ensure_jsonitem(cJSON *json,char *field,char *value);
+    int32_t in_jsonarray(cJSON *array,char *value);
+    char *bitcoind_RPC(char **retstrp,char *debugstr,char *url,char *userpass,char *command,char *params,int32_t timeout);
+    uint64_t calc_nxt64bits(const char *str);
+    int32_t expand_nxt64bits(char *str,uint64_t nxt64bits);
+    char *nxt64str(uint64_t nxt64bits);
+    char *nxt64str2(uint64_t nxt64bits);
+    cJSON *addrs_jsonarray(uint64_t *addrs,int32_t num);
+    int32_t myatoi(char *str,int32_t range);
+    void cJSON_register(cJSON *item);
+    void cJSON_unregister(cJSON *item);
+
+    char *stringifyM(char *str);
+#define replace_backslashquotes unstringify
+    char *unstringify(char *str);
+#define jtrue cJSON_CreateTrue
+#define jfalse cJSON_CreateFalse
+
+#define jfieldname get_cJSON_fieldname
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/cc/includes/curve25519.h b/src/cc/includes/curve25519.h
new file mode 100755
index 000000000..9f8c9ba16
--- /dev/null
+++ b/src/cc/includes/curve25519.h
@@ -0,0 +1,87 @@
+/******************************************************************************
+ * Copyright © 2014-2015 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+// derived from curve25519_donna
+
+#ifndef dcnet_curve25519_h
+#define dcnet_curve25519_h
+#include <stdint.h>
+#include <memory.h>
+#include <string.h>
+
+union _bits128 { uint8_t bytes[16]; uint16_t ushorts[8]; uint32_t uints[4]; uint64_t ulongs[2]; uint64_t txid; };
+typedef union _bits128 bits128;
+union _bits256 { uint8_t bytes[32]; uint16_t ushorts[16]; uint32_t uints[8]; uint64_t ulongs[4]; uint64_t txid; };
+typedef union _bits256 bits256;
+
+union _bits320 { uint8_t bytes[40]; uint16_t ushorts[20]; uint32_t uints[10]; uint64_t ulongs[5]; uint64_t txid; };
+typedef union _bits320 bits320;
+
+union _bits384 { bits256 sig; uint8_t bytes[48]; uint16_t ushorts[24]; uint32_t uints[12]; uint64_t ulongs[6]; uint64_t txid; };
+typedef union _bits384 bits384;
+
+struct sha256_vstate { uint64_t length; uint32_t state[8],curlen; uint8_t buf[64]; };
+struct rmd160_vstate { uint64_t length; uint8_t buf[64]; uint32_t curlen, state[5]; };
+
+struct acct777_sig { bits256 sigbits,pubkey; uint64_t signer64bits; uint32_t timestamp,allocsize; };
+
+//#undef force_inline
+//#define force_inline __attribute__((always_inline))
+
+
+bits320 fmul(const bits320 in2,const bits320 in);
+bits320 fexpand(bits256 basepoint);
+bits256 fcontract(const bits320 input);
+void cmult(bits320 *resultx,bits320 *resultz,bits256 secret,const bits320 q);
+bits320 crecip(const bits320 z);
+bits256 curve25519(bits256 mysecret,bits256 basepoint);
+void OS_randombytes(unsigned char *x,long xlen);
+bits256 rand256(int32_t privkeyflag);
+bits256 curve25519_basepoint9();
+bits256 curve25519_keypair(bits256 *pubkeyp);
+
+void vcalc_sha256(char hashstr[(256 >> 3) * 2 + 1],uint8_t hash[256 >> 3],uint8_t *src,int32_t len);
+void vcalc_sha256cat(uint8_t hash[256 >> 3],uint8_t *src,int32_t len,uint8_t *src2,int32_t len2);
+void vupdate_sha256(uint8_t hash[256 >> 3],struct sha256_vstate *state,uint8_t *src,int32_t len);
+bits256 curve25519_shared(bits256 privkey,bits256 otherpub);
+int32_t iguana_rwnum(int32_t rwflag,uint8_t *serialized,int32_t len,void *endianedp);
+int32_t iguana_rwbignum(int32_t rwflag,uint8_t *serialized,int32_t len,uint8_t *endianedp);
+
+uint32_t calc_crc32(uint32_t crc,const void *buf,size_t size);
+uint64_t conv_NXTpassword(unsigned char *mysecret,unsigned char *mypublic,uint8_t *pass,int32_t passlen);
+bits128 calc_md5(char digeststr[33],void *buf,int32_t len);
+
+bits256 acct777_msgprivkey(uint8_t *data,int32_t datalen);
+bits256 acct777_msgpubkey(uint8_t *data,int32_t datalen);
+void acct777_rwsig(int32_t rwflag,uint8_t *serialized,struct acct777_sig *sig);
+int32_t acct777_sigcheck(struct acct777_sig *sig);
+
+bits256 acct777_pubkey(bits256 privkey);
+uint64_t acct777_nxt64bits(bits256 pubkey);
+bits256 acct777_hashiter(bits256 privkey,bits256 pubkey,int32_t lockdays,uint8_t chainlen);
+bits256 acct777_lockhash(bits256 pubkey,int32_t lockdays,uint8_t chainlen);
+bits256 acct777_invoicehash(bits256 *invoicehash,uint16_t lockdays,uint8_t chainlen);
+uint64_t acct777_sign(struct acct777_sig *sig,bits256 privkey,bits256 otherpubkey,uint32_t timestamp,uint8_t *serialized,int32_t datalen);
+uint64_t acct777_validate(struct acct777_sig *sig,bits256 privkey,bits256 pubkey);
+uint64_t acct777_signtx(struct acct777_sig *sig,bits256 privkey,uint32_t timestamp,uint8_t *data,int32_t datalen);
+uint64_t acct777_swaptx(bits256 privkey,struct acct777_sig *sig,uint32_t timestamp,uint8_t *data,int32_t datalen);
+void calc_hmac_sha256(uint8_t *mac,int32_t maclen,uint8_t *key,int32_t key_size,uint8_t *message,int32_t len);
+
+#include "../includes/tweetnacl.h"
+int32_t _SuperNET_cipher(uint8_t nonce[crypto_box_NONCEBYTES],uint8_t *cipher,uint8_t *message,int32_t len,bits256 destpub,bits256 srcpriv,uint8_t *buf);
+uint8_t *_SuperNET_decipher(uint8_t nonce[crypto_box_NONCEBYTES],uint8_t *cipher,uint8_t *message,int32_t len,bits256 srcpub,bits256 mypriv);
+void *SuperNET_deciphercalc(void **ptrp,int32_t *msglenp,bits256 privkey,bits256 srcpubkey,uint8_t *cipher,int32_t cipherlen,uint8_t *buf,int32_t bufsize);
+uint8_t *SuperNET_ciphercalc(void **ptrp,int32_t *cipherlenp,bits256 *privkeyp,bits256 *destpubkeyp,uint8_t *data,int32_t datalen,uint8_t *space2,int32_t space2size);
+
+#endif
diff --git a/src/cc/includes/libgfshare.h b/src/cc/includes/libgfshare.h
new file mode 100755
index 000000000..a4d494aff
--- /dev/null
+++ b/src/cc/includes/libgfshare.h
@@ -0,0 +1,91 @@
+/*
+ * This file is Copyright Daniel Silverstone <dsilvers@digital-scurf.org> 2006
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy,
+ * modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#ifndef LIBGFSHARE_H
+#define LIBGFSHARE_H
+#include <stdint.h>
+
+typedef struct _gfshare_ctx gfshare_ctx;
+
+typedef void (*gfshare_rand_func_t)(unsigned char*,long);
+
+/* This will, by default, use random(). It's not very good so you should
+ * replace it (perhaps with a function which reads from /dev/urandom).
+ * If you can't be bothered, be sure to srandom() before you use any
+ * of the gfshare_ctx_enc_* functions
+ */
+extern gfshare_rand_func_t gfshare_fill_rand;
+
+/* ------------------------------------------------------[ Preparation ]---- */
+
+/* Initialise a gfshare context for producing shares */
+gfshare_ctx* gfshare_ctx_init_enc(unsigned char* /* sharenrs */,
+                                  uint32_t /* sharecount */,
+                                  unsigned char /* threshold */,
+                                  uint32_t /* size */);
+
+/* Initialise a gfshare context for recombining shares */
+gfshare_ctx* gfshare_ctx_init_dec(unsigned char* /* sharenrs */,
+                                  uint32_t /* sharecount */,
+                                  uint32_t /* size */);
+
+/* Free a share context's memory. */
+void gfshare_ctx_free(gfshare_ctx* /* ctx */);
+
+/* --------------------------------------------------------[ Splitting ]---- */
+
+/* Provide a secret to the encoder. (this re-scrambles the coefficients) */
+void gfshare_ctx_enc_setsecret(gfshare_ctx* /* ctx */,
+                               unsigned char* /* secret */);
+
+/* Extract a share from the context. 
+ * 'share' must be preallocated and at least 'size' bytes long.
+ * 'sharenr' is the index into the 'sharenrs' array of the share you want.
+ */
+void gfshare_ctx_encgetshare(uint8_t *logs,uint8_t *exps,gfshare_ctx* /* ctx */, unsigned char /* sharenr */, unsigned char* /* share */);
+void gfshare_ctx_enc_getshare(gfshare_ctx* /* ctx */, unsigned char /* sharenr */, unsigned char* /* share */);
+
+/* ----------------------------------------------------[ Recombination ]---- */
+
+/* Inform a recombination context of a change in share indexes */
+void gfshare_ctx_dec_newshares(gfshare_ctx* /* ctx */,
+                               unsigned char* /* sharenrs */);
+
+/* Provide a share context with one of the shares.
+ * The 'sharenr' is the index into the 'sharenrs' array
+ */
+void gfshare_ctx_dec_giveshare(gfshare_ctx* /* ctx */,
+                               unsigned char /* sharenr */,
+                               unsigned char* /* share */);
+
+/* Extract the secret by interpolation of the shares.
+ * secretbuf must be allocated and at least 'size' bytes long
+ */
+
+void gfshare_ctx_decextract(uint8_t *logs,uint8_t *exps,gfshare_ctx* /* ctx */, unsigned char* /* secretbuf */);
+void gfshare_ctx_dec_extract(gfshare_ctx* /* ctx */, unsigned char* /* secretbuf */);
+
+#endif /* LIBGFSHARE_H */
+
diff --git a/src/cc/includes/tweetnacl.h b/src/cc/includes/tweetnacl.h
new file mode 100755
index 000000000..ce0fa9bcb
--- /dev/null
+++ b/src/cc/includes/tweetnacl.h
@@ -0,0 +1,275 @@
+#ifndef TWEETNACL_H
+#define TWEETNACL_H 
+#define crypto_auth_PRIMITIVE "hmacsha512256"
+#define crypto_auth crypto_auth_hmacsha512256
+#define crypto_auth_verify crypto_auth_hmacsha512256_verify
+#define crypto_auth_BYTES crypto_auth_hmacsha512256_BYTES
+#define crypto_auth_KEYBYTES crypto_auth_hmacsha512256_KEYBYTES
+#define crypto_auth_IMPLEMENTATION crypto_auth_hmacsha512256_IMPLEMENTATION
+#define crypto_auth_VERSION crypto_auth_hmacsha512256_VERSION
+#define crypto_auth_hmacsha512256_tweet_BYTES 32
+#define crypto_auth_hmacsha512256_tweet_KEYBYTES 32
+extern int crypto_auth_hmacsha512256_tweet(unsigned char *,const unsigned char *,unsigned long long,const unsigned char *);
+extern int crypto_auth_hmacsha512256_tweet_verify(const unsigned char *,const unsigned char *,unsigned long long,const unsigned char *);
+#define crypto_auth_hmacsha512256_tweet_VERSION "-"
+#define crypto_auth_hmacsha512256 crypto_auth_hmacsha512256_tweet
+#define crypto_auth_hmacsha512256_verify crypto_auth_hmacsha512256_tweet_verify
+#define crypto_auth_hmacsha512256_BYTES crypto_auth_hmacsha512256_tweet_BYTES
+#define crypto_auth_hmacsha512256_KEYBYTES crypto_auth_hmacsha512256_tweet_KEYBYTES
+#define crypto_auth_hmacsha512256_VERSION crypto_auth_hmacsha512256_tweet_VERSION
+#define crypto_auth_hmacsha512256_IMPLEMENTATION "crypto_auth/hmacsha512256/tweet"
+#define crypto_box_PRIMITIVE "curve25519xsalsa20poly1305"
+#define crypto_box crypto_box_curve25519xsalsa20poly1305
+#define crypto_box_open crypto_box_curve25519xsalsa20poly1305_open
+#define crypto_box_keypair crypto_box_curve25519xsalsa20poly1305_keypair
+#define crypto_box_priv2pub crypto_box_curve25519xsalsa20poly1305_priv2pub
+#define crypto_box_beforenm crypto_box_curve25519xsalsa20poly1305_beforenm
+#define crypto_box_afternm crypto_box_curve25519xsalsa20poly1305_afternm
+#define crypto_box_open_afternm crypto_box_curve25519xsalsa20poly1305_open_afternm
+#define crypto_box_PUBLICKEYBYTES crypto_box_curve25519xsalsa20poly1305_PUBLICKEYBYTES
+#define crypto_box_SECRETKEYBYTES crypto_box_curve25519xsalsa20poly1305_SECRETKEYBYTES
+#define crypto_box_BEFORENMBYTES crypto_box_curve25519xsalsa20poly1305_BEFORENMBYTES
+#define crypto_box_NONCEBYTES crypto_box_curve25519xsalsa20poly1305_NONCEBYTES
+#define crypto_box_ZEROBYTES crypto_box_curve25519xsalsa20poly1305_ZEROBYTES
+#define crypto_box_BOXZEROBYTES crypto_box_curve25519xsalsa20poly1305_BOXZEROBYTES
+#define crypto_box_IMPLEMENTATION crypto_box_curve25519xsalsa20poly1305_IMPLEMENTATION
+#define crypto_box_VERSION crypto_box_curve25519xsalsa20poly1305_VERSION
+#define crypto_box_curve25519xsalsa20poly1305_tweet_PUBLICKEYBYTES 32
+#define crypto_box_curve25519xsalsa20poly1305_tweet_SECRETKEYBYTES 32
+#define crypto_box_curve25519xsalsa20poly1305_tweet_BEFORENMBYTES 32
+#define crypto_box_curve25519xsalsa20poly1305_tweet_NONCEBYTES 24
+#define crypto_box_curve25519xsalsa20poly1305_tweet_ZEROBYTES 32
+#define crypto_box_curve25519xsalsa20poly1305_tweet_BOXZEROBYTES 16
+extern int crypto_box_curve25519xsalsa20poly1305_tweet(unsigned char *,const unsigned char *,unsigned long long,const unsigned char *,const unsigned char *,const unsigned char *);
+extern int crypto_box_curve25519xsalsa20poly1305_tweet_open(unsigned char *,const unsigned char *,unsigned long long,const unsigned char *,const unsigned char *,const unsigned char *);
+extern int crypto_box_curve25519xsalsa20poly1305_tweet_keypair(unsigned char *,unsigned char *);
+extern int crypto_box_curve25519xsalsa20poly1305_tweet_priv2pub(unsigned char *,unsigned char *);
+extern int crypto_box_curve25519xsalsa20poly1305_tweet_beforenm(unsigned char *,const unsigned char *,const unsigned char *);
+extern int crypto_box_curve25519xsalsa20poly1305_tweet_afternm(unsigned char *,const unsigned char *,unsigned long long,const unsigned char *,const unsigned char *);
+extern int crypto_box_curve25519xsalsa20poly1305_tweet_open_afternm(unsigned char *,const unsigned char *,unsigned long long,const unsigned char *,const unsigned char *);
+#define crypto_box_curve25519xsalsa20poly1305_tweet_VERSION "-"
+#define crypto_box_curve25519xsalsa20poly1305 crypto_box_curve25519xsalsa20poly1305_tweet
+#define crypto_box_curve25519xsalsa20poly1305_open crypto_box_curve25519xsalsa20poly1305_tweet_open
+#define crypto_box_curve25519xsalsa20poly1305_keypair crypto_box_curve25519xsalsa20poly1305_tweet_keypair
+#define crypto_box_curve25519xsalsa20poly1305_priv2pub crypto_box_curve25519xsalsa20poly1305_tweet_priv2pub
+#define crypto_box_curve25519xsalsa20poly1305_beforenm crypto_box_curve25519xsalsa20poly1305_tweet_beforenm
+#define crypto_box_curve25519xsalsa20poly1305_afternm crypto_box_curve25519xsalsa20poly1305_tweet_afternm
+#define crypto_box_curve25519xsalsa20poly1305_open_afternm crypto_box_curve25519xsalsa20poly1305_tweet_open_afternm
+#define crypto_box_curve25519xsalsa20poly1305_PUBLICKEYBYTES crypto_box_curve25519xsalsa20poly1305_tweet_PUBLICKEYBYTES
+#define crypto_box_curve25519xsalsa20poly1305_SECRETKEYBYTES crypto_box_curve25519xsalsa20poly1305_tweet_SECRETKEYBYTES
+#define crypto_box_curve25519xsalsa20poly1305_BEFORENMBYTES crypto_box_curve25519xsalsa20poly1305_tweet_BEFORENMBYTES
+#define crypto_box_curve25519xsalsa20poly1305_NONCEBYTES crypto_box_curve25519xsalsa20poly1305_tweet_NONCEBYTES
+#define crypto_box_curve25519xsalsa20poly1305_ZEROBYTES crypto_box_curve25519xsalsa20poly1305_tweet_ZEROBYTES
+#define crypto_box_curve25519xsalsa20poly1305_BOXZEROBYTES crypto_box_curve25519xsalsa20poly1305_tweet_BOXZEROBYTES
+#define crypto_box_curve25519xsalsa20poly1305_VERSION crypto_box_curve25519xsalsa20poly1305_tweet_VERSION
+#define crypto_box_curve25519xsalsa20poly1305_IMPLEMENTATION "crypto_box/curve25519xsalsa20poly1305/tweet"
+#define crypto_core_PRIMITIVE "salsa20"
+#define crypto_core crypto_core_salsa20
+#define crypto_core_OUTPUTBYTES crypto_core_salsa20_OUTPUTBYTES
+#define crypto_core_INPUTBYTES crypto_core_salsa20_INPUTBYTES
+#define crypto_core_KEYBYTES crypto_core_salsa20_KEYBYTES
+#define crypto_core_CONSTBYTES crypto_core_salsa20_CONSTBYTES
+#define crypto_core_IMPLEMENTATION crypto_core_salsa20_IMPLEMENTATION
+#define crypto_core_VERSION crypto_core_salsa20_VERSION
+#define crypto_core_salsa20_tweet_OUTPUTBYTES 64
+#define crypto_core_salsa20_tweet_INPUTBYTES 16
+#define crypto_core_salsa20_tweet_KEYBYTES 32
+#define crypto_core_salsa20_tweet_CONSTBYTES 16
+extern int crypto_core_salsa20_tweet(unsigned char *,const unsigned char *,const unsigned char *,const unsigned char *);
+#define crypto_core_salsa20_tweet_VERSION "-"
+#define crypto_core_salsa20 crypto_core_salsa20_tweet
+#define crypto_core_salsa20_OUTPUTBYTES crypto_core_salsa20_tweet_OUTPUTBYTES
+#define crypto_core_salsa20_INPUTBYTES crypto_core_salsa20_tweet_INPUTBYTES
+#define crypto_core_salsa20_KEYBYTES crypto_core_salsa20_tweet_KEYBYTES
+#define crypto_core_salsa20_CONSTBYTES crypto_core_salsa20_tweet_CONSTBYTES
+#define crypto_core_salsa20_VERSION crypto_core_salsa20_tweet_VERSION
+#define crypto_core_salsa20_IMPLEMENTATION "crypto_core/salsa20/tweet"
+#define crypto_core_hsalsa20_tweet_OUTPUTBYTES 32
+#define crypto_core_hsalsa20_tweet_INPUTBYTES 16
+#define crypto_core_hsalsa20_tweet_KEYBYTES 32
+#define crypto_core_hsalsa20_tweet_CONSTBYTES 16
+extern int crypto_core_hsalsa20_tweet(unsigned char *,const unsigned char *,const unsigned char *,const unsigned char *);
+#define crypto_core_hsalsa20_tweet_VERSION "-"
+#define crypto_core_hsalsa20 crypto_core_hsalsa20_tweet
+#define crypto_core_hsalsa20_OUTPUTBYTES crypto_core_hsalsa20_tweet_OUTPUTBYTES
+#define crypto_core_hsalsa20_INPUTBYTES crypto_core_hsalsa20_tweet_INPUTBYTES
+#define crypto_core_hsalsa20_KEYBYTES crypto_core_hsalsa20_tweet_KEYBYTES
+#define crypto_core_hsalsa20_CONSTBYTES crypto_core_hsalsa20_tweet_CONSTBYTES
+#define crypto_core_hsalsa20_VERSION crypto_core_hsalsa20_tweet_VERSION
+#define crypto_core_hsalsa20_IMPLEMENTATION "crypto_core/hsalsa20/tweet"
+#define crypto_hashblocks_PRIMITIVE "sha512"
+#define crypto_hashblocks crypto_hashblocks_sha512
+#define crypto_hashblocks_STATEBYTES crypto_hashblocks_sha512_STATEBYTES
+#define crypto_hashblocks_BLOCKBYTES crypto_hashblocks_sha512_BLOCKBYTES
+#define crypto_hashblocks_IMPLEMENTATION crypto_hashblocks_sha512_IMPLEMENTATION
+#define crypto_hashblocks_VERSION crypto_hashblocks_sha512_VERSION
+#define crypto_hashblocks_sha512_tweet_STATEBYTES 64
+#define crypto_hashblocks_sha512_tweet_BLOCKBYTES 128
+extern int crypto_hashblocks_sha512_tweet(unsigned char *,const unsigned char *,unsigned long long);
+#define crypto_hashblocks_sha512_tweet_VERSION "-"
+#define crypto_hashblocks_sha512 crypto_hashblocks_sha512_tweet
+#define crypto_hashblocks_sha512_STATEBYTES crypto_hashblocks_sha512_tweet_STATEBYTES
+#define crypto_hashblocks_sha512_BLOCKBYTES crypto_hashblocks_sha512_tweet_BLOCKBYTES
+#define crypto_hashblocks_sha512_VERSION crypto_hashblocks_sha512_tweet_VERSION
+#define crypto_hashblocks_sha512_IMPLEMENTATION "crypto_hashblocks/sha512/tweet"
+#define crypto_hashblocks_sha256_tweet_STATEBYTES 32
+#define crypto_hashblocks_sha256_tweet_BLOCKBYTES 64
+extern int crypto_hashblocks_sha256_tweet(unsigned char *,const unsigned char *,unsigned long long);
+#define crypto_hashblocks_sha256_tweet_VERSION "-"
+#define crypto_hashblocks_sha256 crypto_hashblocks_sha256_tweet
+#define crypto_hashblocks_sha256_STATEBYTES crypto_hashblocks_sha256_tweet_STATEBYTES
+#define crypto_hashblocks_sha256_BLOCKBYTES crypto_hashblocks_sha256_tweet_BLOCKBYTES
+#define crypto_hashblocks_sha256_VERSION crypto_hashblocks_sha256_tweet_VERSION
+#define crypto_hashblocks_sha256_IMPLEMENTATION "crypto_hashblocks/sha256/tweet"
+#define crypto_hash_PRIMITIVE "sha512"
+#define crypto_hash crypto_hash_sha512
+#define crypto_hash_BYTES crypto_hash_sha512_BYTES
+#define crypto_hash_IMPLEMENTATION crypto_hash_sha512_IMPLEMENTATION
+#define crypto_hash_VERSION crypto_hash_sha512_VERSION
+#define crypto_hash_sha512_tweet_BYTES 64
+extern int crypto_hash_sha512_tweet(unsigned char *,const unsigned char *,unsigned long long);
+#define crypto_hash_sha512_tweet_VERSION "-"
+#define crypto_hash_sha512 crypto_hash_sha512_tweet
+#define crypto_hash_sha512_BYTES crypto_hash_sha512_tweet_BYTES
+#define crypto_hash_sha512_VERSION crypto_hash_sha512_tweet_VERSION
+#define crypto_hash_sha512_IMPLEMENTATION "crypto_hash/sha512/tweet"
+#define crypto_hash_sha256_tweet_BYTES 32
+extern int crypto_hash_sha256_tweet(unsigned char *,const unsigned char *,unsigned long long);
+#define crypto_hash_sha256_tweet_VERSION "-"
+#define crypto_hash_sha256 crypto_hash_sha256_tweet
+#define crypto_hash_sha256_BYTES crypto_hash_sha256_tweet_BYTES
+#define crypto_hash_sha256_VERSION crypto_hash_sha256_tweet_VERSION
+#define crypto_hash_sha256_IMPLEMENTATION "crypto_hash/sha256/tweet"
+#define crypto_onetimeauth_PRIMITIVE "poly1305"
+#define crypto_onetimeauth crypto_onetimeauth_poly1305
+#define crypto_onetimeauth_verify crypto_onetimeauth_poly1305_verify
+#define crypto_onetimeauth_BYTES crypto_onetimeauth_poly1305_BYTES
+#define crypto_onetimeauth_KEYBYTES crypto_onetimeauth_poly1305_KEYBYTES
+#define crypto_onetimeauth_IMPLEMENTATION crypto_onetimeauth_poly1305_IMPLEMENTATION
+#define crypto_onetimeauth_VERSION crypto_onetimeauth_poly1305_VERSION
+#define crypto_onetimeauth_poly1305_tweet_BYTES 16
+#define crypto_onetimeauth_poly1305_tweet_KEYBYTES 32
+extern int crypto_onetimeauth_poly1305_tweet(unsigned char *,const unsigned char *,unsigned long long,const unsigned char *);
+extern int crypto_onetimeauth_poly1305_tweet_verify(const unsigned char *,const unsigned char *,unsigned long long,const unsigned char *);
+#define crypto_onetimeauth_poly1305_tweet_VERSION "-"
+#define crypto_onetimeauth_poly1305 crypto_onetimeauth_poly1305_tweet
+#define crypto_onetimeauth_poly1305_verify crypto_onetimeauth_poly1305_tweet_verify
+#define crypto_onetimeauth_poly1305_BYTES crypto_onetimeauth_poly1305_tweet_BYTES
+#define crypto_onetimeauth_poly1305_KEYBYTES crypto_onetimeauth_poly1305_tweet_KEYBYTES
+#define crypto_onetimeauth_poly1305_VERSION crypto_onetimeauth_poly1305_tweet_VERSION
+#define crypto_onetimeauth_poly1305_IMPLEMENTATION "crypto_onetimeauth/poly1305/tweet"
+#define crypto_scalarmult_PRIMITIVE "curve25519"
+#define crypto_scalarmult crypto_scalarmult_curve25519
+#define crypto_scalarmult_base crypto_scalarmult_curve25519_base
+#define crypto_scalarmult_BYTES crypto_scalarmult_curve25519_BYTES
+#define crypto_scalarmult_SCALARBYTES crypto_scalarmult_curve25519_SCALARBYTES
+#define crypto_scalarmult_IMPLEMENTATION crypto_scalarmult_curve25519_IMPLEMENTATION
+#define crypto_scalarmult_VERSION crypto_scalarmult_curve25519_VERSION
+#define crypto_scalarmult_curve25519_tweet_BYTES 32
+#define crypto_scalarmult_curve25519_tweet_SCALARBYTES 32
+extern int crypto_scalarmult_curve25519_tweet(unsigned char *,const unsigned char *,const unsigned char *);
+extern int crypto_scalarmult_curve25519_tweet_base(unsigned char *,const unsigned char *);
+#define crypto_scalarmult_curve25519_tweet_VERSION "-"
+#define crypto_scalarmult_curve25519 crypto_scalarmult_curve25519_tweet
+#define crypto_scalarmult_curve25519_base crypto_scalarmult_curve25519_tweet_base
+#define crypto_scalarmult_curve25519_BYTES crypto_scalarmult_curve25519_tweet_BYTES
+#define crypto_scalarmult_curve25519_SCALARBYTES crypto_scalarmult_curve25519_tweet_SCALARBYTES
+#define crypto_scalarmult_curve25519_VERSION crypto_scalarmult_curve25519_tweet_VERSION
+#define crypto_scalarmult_curve25519_IMPLEMENTATION "crypto_scalarmult/curve25519/tweet"
+#define crypto_secretbox_PRIMITIVE "xsalsa20poly1305"
+#define crypto_secretbox crypto_secretbox_xsalsa20poly1305
+#define crypto_secretbox_open crypto_secretbox_xsalsa20poly1305_open
+#define crypto_secretbox_KEYBYTES crypto_secretbox_xsalsa20poly1305_KEYBYTES
+#define crypto_secretbox_NONCEBYTES crypto_secretbox_xsalsa20poly1305_NONCEBYTES
+#define crypto_secretbox_ZEROBYTES crypto_secretbox_xsalsa20poly1305_ZEROBYTES
+#define crypto_secretbox_BOXZEROBYTES crypto_secretbox_xsalsa20poly1305_BOXZEROBYTES
+#define crypto_secretbox_IMPLEMENTATION crypto_secretbox_xsalsa20poly1305_IMPLEMENTATION
+#define crypto_secretbox_VERSION crypto_secretbox_xsalsa20poly1305_VERSION
+#define crypto_secretbox_xsalsa20poly1305_tweet_KEYBYTES 32
+#define crypto_secretbox_xsalsa20poly1305_tweet_NONCEBYTES 24
+#define crypto_secretbox_xsalsa20poly1305_tweet_ZEROBYTES 32
+#define crypto_secretbox_xsalsa20poly1305_tweet_BOXZEROBYTES 16
+extern int crypto_secretbox_xsalsa20poly1305_tweet(unsigned char *,const unsigned char *,unsigned long long,const unsigned char *,const unsigned char *);
+extern int crypto_secretbox_xsalsa20poly1305_tweet_open(unsigned char *,const unsigned char *,unsigned long long,const unsigned char *,const unsigned char *);
+#define crypto_secretbox_xsalsa20poly1305_tweet_VERSION "-"
+#define crypto_secretbox_xsalsa20poly1305 crypto_secretbox_xsalsa20poly1305_tweet
+#define crypto_secretbox_xsalsa20poly1305_open crypto_secretbox_xsalsa20poly1305_tweet_open
+#define crypto_secretbox_xsalsa20poly1305_KEYBYTES crypto_secretbox_xsalsa20poly1305_tweet_KEYBYTES
+#define crypto_secretbox_xsalsa20poly1305_NONCEBYTES crypto_secretbox_xsalsa20poly1305_tweet_NONCEBYTES
+#define crypto_secretbox_xsalsa20poly1305_ZEROBYTES crypto_secretbox_xsalsa20poly1305_tweet_ZEROBYTES
+#define crypto_secretbox_xsalsa20poly1305_BOXZEROBYTES crypto_secretbox_xsalsa20poly1305_tweet_BOXZEROBYTES
+#define crypto_secretbox_xsalsa20poly1305_VERSION crypto_secretbox_xsalsa20poly1305_tweet_VERSION
+#define crypto_secretbox_xsalsa20poly1305_IMPLEMENTATION "crypto_secretbox/xsalsa20poly1305/tweet"
+#define crypto_sign_PRIMITIVE "ed25519"
+#define crypto_sign crypto_sign_ed25519
+#define crypto_sign_open crypto_sign_ed25519_open
+#define crypto_sign_keypair crypto_sign_ed25519_keypair
+#define crypto_sign_BYTES crypto_sign_ed25519_BYTES
+#define crypto_sign_PUBLICKEYBYTES crypto_sign_ed25519_PUBLICKEYBYTES
+#define crypto_sign_SECRETKEYBYTES crypto_sign_ed25519_SECRETKEYBYTES
+#define crypto_sign_IMPLEMENTATION crypto_sign_ed25519_IMPLEMENTATION
+#define crypto_sign_VERSION crypto_sign_ed25519_VERSION
+#define crypto_sign_ed25519_tweet_BYTES 64
+#define crypto_sign_ed25519_tweet_PUBLICKEYBYTES 32
+#define crypto_sign_ed25519_tweet_SECRETKEYBYTES 64
+extern int crypto_sign_ed25519_tweet(unsigned char *,unsigned long long *,const unsigned char *,unsigned long long,const unsigned char *);
+extern int crypto_sign_ed25519_tweet_open(unsigned char *,unsigned long long *,const unsigned char *,unsigned long long,const unsigned char *);
+extern int crypto_sign_ed25519_tweet_keypair(unsigned char *,unsigned char *);
+#define crypto_sign_ed25519_tweet_VERSION "-"
+#define crypto_sign_ed25519 crypto_sign_ed25519_tweet
+#define crypto_sign_ed25519_open crypto_sign_ed25519_tweet_open
+#define crypto_sign_ed25519_keypair crypto_sign_ed25519_tweet_keypair
+#define crypto_sign_ed25519_BYTES crypto_sign_ed25519_tweet_BYTES
+#define crypto_sign_ed25519_PUBLICKEYBYTES crypto_sign_ed25519_tweet_PUBLICKEYBYTES
+#define crypto_sign_ed25519_SECRETKEYBYTES crypto_sign_ed25519_tweet_SECRETKEYBYTES
+#define crypto_sign_ed25519_VERSION crypto_sign_ed25519_tweet_VERSION
+#define crypto_sign_ed25519_IMPLEMENTATION "crypto_sign/ed25519/tweet"
+#define crypto_stream_PRIMITIVE "xsalsa20"
+#define crypto_stream crypto_stream_xsalsa20
+#define crypto_stream_xor crypto_stream_xsalsa20_xor
+#define crypto_stream_KEYBYTES crypto_stream_xsalsa20_KEYBYTES
+#define crypto_stream_NONCEBYTES crypto_stream_xsalsa20_NONCEBYTES
+#define crypto_stream_IMPLEMENTATION crypto_stream_xsalsa20_IMPLEMENTATION
+#define crypto_stream_VERSION crypto_stream_xsalsa20_VERSION
+#define crypto_stream_xsalsa20_tweet_KEYBYTES 32
+#define crypto_stream_xsalsa20_tweet_NONCEBYTES 24
+extern int crypto_stream_xsalsa20_tweet(unsigned char *,unsigned long long,const unsigned char *,const unsigned char *);
+extern int crypto_stream_xsalsa20_tweet_xor(unsigned char *,const unsigned char *,unsigned long long,const unsigned char *,const unsigned char *);
+#define crypto_stream_xsalsa20_tweet_VERSION "-"
+#define crypto_stream_xsalsa20 crypto_stream_xsalsa20_tweet
+#define crypto_stream_xsalsa20_xor crypto_stream_xsalsa20_tweet_xor
+#define crypto_stream_xsalsa20_KEYBYTES crypto_stream_xsalsa20_tweet_KEYBYTES
+#define crypto_stream_xsalsa20_NONCEBYTES crypto_stream_xsalsa20_tweet_NONCEBYTES
+#define crypto_stream_xsalsa20_VERSION crypto_stream_xsalsa20_tweet_VERSION
+#define crypto_stream_xsalsa20_IMPLEMENTATION "crypto_stream/xsalsa20/tweet"
+#define crypto_stream_salsa20_tweet_KEYBYTES 32
+#define crypto_stream_salsa20_tweet_NONCEBYTES 8
+extern int crypto_stream_salsa20_tweet(unsigned char *,unsigned long long,const unsigned char *,const unsigned char *);
+extern int crypto_stream_salsa20_tweet_xor(unsigned char *,const unsigned char *,unsigned long long,const unsigned char *,const unsigned char *);
+#define crypto_stream_salsa20_tweet_VERSION "-"
+#define crypto_stream_salsa20 crypto_stream_salsa20_tweet
+#define crypto_stream_salsa20_xor crypto_stream_salsa20_tweet_xor
+#define crypto_stream_salsa20_KEYBYTES crypto_stream_salsa20_tweet_KEYBYTES
+#define crypto_stream_salsa20_NONCEBYTES crypto_stream_salsa20_tweet_NONCEBYTES
+#define crypto_stream_salsa20_VERSION crypto_stream_salsa20_tweet_VERSION
+#define crypto_stream_salsa20_IMPLEMENTATION "crypto_stream/salsa20/tweet"
+#define crypto_verify_PRIMITIVE "16"
+#define crypto_verify crypto_verify_16
+#define crypto_verify_BYTES crypto_verify_16_BYTES
+#define crypto_verify_IMPLEMENTATION crypto_verify_16_IMPLEMENTATION
+#define crypto_verify_VERSION crypto_verify_16_VERSION
+#define crypto_verify_16_tweet_BYTES 16
+extern int crypto_verify_16_tweet(const unsigned char *,const unsigned char *);
+#define crypto_verify_16_tweet_VERSION "-"
+#define crypto_verify_16 crypto_verify_16_tweet
+#define crypto_verify_16_BYTES crypto_verify_16_tweet_BYTES
+#define crypto_verify_16_VERSION crypto_verify_16_tweet_VERSION
+#define crypto_verify_16_IMPLEMENTATION "crypto_verify/16/tweet"
+#define crypto_verify_32_tweet_BYTES 32
+extern int crypto_verify_32_tweet(const unsigned char *,const unsigned char *);
+#define crypto_verify_32_tweet_VERSION "-"
+#define crypto_verify_32 crypto_verify_32_tweet
+#define crypto_verify_32_BYTES crypto_verify_32_tweet_BYTES
+#define crypto_verify_32_VERSION crypto_verify_32_tweet_VERSION
+#define crypto_verify_32_IMPLEMENTATION "crypto_verify/32/tweet"
+#endif
diff --git a/src/cc/includes/uthash.h b/src/cc/includes/uthash.h
new file mode 100755
index 000000000..7b99c0133
--- /dev/null
+++ b/src/cc/includes/uthash.h
@@ -0,0 +1,963 @@
+ 
+/*
+ Copyright (c) 2003-2014, Troy D. Hanson     http://troydhanson.github.com/uthash/
+ All rights reserved.
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UTHASH_H
+#define UTHASH_H
+
+//#define HASH_BLOOM 16
+
+#include <string.h>   /* memcmp,strlen */
+#include <stddef.h>   /* ptrdiff_t */
+#include <stdlib.h>   /* exit() */
+
+/* These macros use decltype or the earlier __typeof GNU extension.
+ As decltype is only available in newer compilers (VS2010 or gcc 4.3+
+ when compiling c++ source) this code uses whatever method is needed
+ or, for VS2008 where neither is available, uses casting workarounds. */
+#if defined(_MSC_VER)   /* MS compiler */
+#if _MSC_VER >= 1600 && defined(__cplusplus)  /* VS2010 or newer in C++ mode */
+#define DECLTYPE(x) (decltype(x))
+#else                   /* VS2008 or older (or VS2010 in C mode) */
+#define NO_DECLTYPE
+#define DECLTYPE(x)
+#endif
+#elif defined(__BORLANDC__) || defined(__LCC__) || defined(__WATCOMC__)
+#define NO_DECLTYPE
+#define DECLTYPE(x)
+#else                   /* GNU, Sun and other compilers */
+#define DECLTYPE(x) (__typeof(x))
+#endif
+
+#ifdef NO_DECLTYPE
+#define DECLTYPE_ASSIGN(dst,src)                                                 \
+do {                                                                             \
+char **_da_dst = (char**)(&(dst));                                             \
+*_da_dst = (char*)(src);                                                       \
+} while(0)
+#else
+#define DECLTYPE_ASSIGN(dst,src)                                                 \
+do {                                                                             \
+(dst) = DECLTYPE(dst)(src);                                                    \
+} while(0)
+#endif
+
+/* a number of the hash function use uint32_t which isn't defined on Pre VS2010 */
+#if defined (_WIN32)
+#if defined(_MSC_VER) && _MSC_VER >= 1600
+#include <stdint.h>
+#elif defined(__WATCOMC__)
+#include <stdint.h>
+#else
+//typedef unsigned int uint32_t;
+//typedef unsigned char uint8_t;
+#endif
+#else
+#include <stdint.h>
+#endif
+
+#define UTHASH_VERSION 1.9.9
+
+#ifndef uthash_fatal
+#define uthash_fatal(msg) exit(-1)        /* fatal error (out of memory,etc) */
+#endif
+#ifndef uthash_malloc
+#define uthash_malloc(sz) malloc(sz)      /* malloc fcn                      */
+#endif
+#ifndef uthash_free
+#define uthash_free(ptr,sz) free(ptr)     /* free fcn                        */
+#endif
+
+#ifndef uthash_noexpand_fyi
+#define uthash_noexpand_fyi(tbl)          /* can be defined to log noexpand  */
+#endif
+#ifndef uthash_expand_fyi
+#define uthash_expand_fyi(tbl)            /* can be defined to log expands   */
+#endif
+
+/* initial number of buckets */
+#ifndef HASH_INITIAL_NUM_BUCKETS_LOG2
+#define HASH_INITIAL_NUM_BUCKETS_LOG2 5  /* lg2 of initial number of buckets */
+#endif
+#define HASH_INITIAL_NUM_BUCKETS (1<<HASH_INITIAL_NUM_BUCKETS_LOG2)      /* initial number of buckets        */
+#define HASH_BKT_CAPACITY_THRESH 10      /* expand when bucket count reaches */
+
+/* calculate the element whose hash handle address is hhe */
+#define ELMT_FROM_HH(tbl,hhp) ((void*)(((char*)(hhp)) - ((tbl)->hho)))
+
+#define HASH_FIND(hh,head,keyptr,keylen,out)                                     \
+do {                                                                             \
+out=NULL;                                                                      \
+if (head) {                                                                    \
+uint32_t _hf_bkt,_hf_hashv;                                                 \
+HASH_FCN(keyptr,keylen, (head)->hh.tbl->num_buckets, _hf_hashv, _hf_bkt);   \
+if (HASH_BLOOM_TEST((head)->hh.tbl, _hf_hashv)) {                           \
+HASH_FIND_IN_BKT((head)->hh.tbl, hh, (head)->hh.tbl->buckets[ _hf_bkt ],  \
+keyptr,keylen,out);                                      \
+}                                                                           \
+}                                                                              \
+} while (0)
+
+#ifdef HASH_BLOOM
+#define HASH_BLOOM_BITLEN (1ULL << HASH_BLOOM)
+#define HASH_BLOOM_BYTELEN (HASH_BLOOM_BITLEN/8) + ((HASH_BLOOM_BITLEN%8) ? 1:0)
+#define HASH_BLOOM_MAKE(tbl)                                                     \
+do {                                                                             \
+(tbl)->bloom_nbits = HASH_BLOOM;                                               \
+(tbl)->bloom_bv = (uint8_t*)uthash_malloc(HASH_BLOOM_BYTELEN);                 \
+if (!((tbl)->bloom_bv))  { uthash_fatal( "out of memory"); }                   \
+memset((tbl)->bloom_bv, 0, HASH_BLOOM_BYTELEN);                                \
+(tbl)->bloom_sig = HASH_BLOOM_SIGNATURE;                                       \
+} while (0)
+
+#define HASH_BLOOM_FREE(tbl)                                                     \
+do {                                                                             \
+uthash_free((tbl)->bloom_bv, HASH_BLOOM_BYTELEN);                              \
+} while (0)
+
+#define HASH_BLOOM_BITSET(bv,idx) (bv[(idx)/8] |= (1U << ((idx)%8)))
+#define HASH_BLOOM_BITTEST(bv,idx) (bv[(idx)/8] & (1U << ((idx)%8)))
+
+#define HASH_BLOOM_ADD(tbl,hashv)                                                \
+HASH_BLOOM_BITSET((tbl)->bloom_bv, (hashv & (uint32_t)((1ULL << (tbl)->bloom_nbits) - 1)))
+
+#define HASH_BLOOM_TEST(tbl,hashv)                                               \
+HASH_BLOOM_BITTEST((tbl)->bloom_bv, (hashv & (uint32_t)((1ULL << (tbl)->bloom_nbits) - 1)))
+
+#else
+#define HASH_BLOOM_MAKE(tbl)
+#define HASH_BLOOM_FREE(tbl)
+#define HASH_BLOOM_ADD(tbl,hashv)
+#define HASH_BLOOM_TEST(tbl,hashv) (1)
+#define HASH_BLOOM_BYTELEN 0
+#endif
+
+#define HASH_MAKE_TABLE(hh,head)                                                 \
+do {                                                                             \
+(head)->hh.tbl = (UT_hash_table*)uthash_malloc(                                \
+sizeof(UT_hash_table));                                        \
+if (!((head)->hh.tbl))  { uthash_fatal( "out of memory"); }                    \
+memset((head)->hh.tbl, 0, sizeof(UT_hash_table));                              \
+(head)->hh.tbl->tail = &((head)->hh);                                          \
+(head)->hh.tbl->num_buckets = HASH_INITIAL_NUM_BUCKETS;                        \
+(head)->hh.tbl->log2_num_buckets = HASH_INITIAL_NUM_BUCKETS_LOG2;              \
+(head)->hh.tbl->hho = (char*)(&(head)->hh) - (char*)(head);                    \
+(head)->hh.tbl->buckets = (UT_hash_bucket*)uthash_malloc(                      \
+HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket));               \
+if (! (head)->hh.tbl->buckets) { uthash_fatal( "out of memory"); }             \
+memset((head)->hh.tbl->buckets, 0,                                             \
+HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket));               \
+HASH_BLOOM_MAKE((head)->hh.tbl);                                               \
+(head)->hh.tbl->signature = HASH_SIGNATURE;                                    \
+} while(0)
+
+#define HASH_ADD(hh,head,fieldname,keylen_in,add)                                \
+HASH_ADD_KEYPTR(hh,head,&((add)->fieldname),keylen_in,add)
+
+#define HASH_REPLACE(hh,head,fieldname,keylen_in,add,replaced)                   \
+do {                                                                             \
+replaced=NULL;                                                                 \
+HASH_FIND(hh,head,&((add)->fieldname),keylen_in,replaced);                     \
+if (replaced!=NULL) {                                                          \
+HASH_DELETE(hh,head,replaced);                                              \
+};                                                                             \
+HASH_ADD(hh,head,fieldname,keylen_in,add);                                     \
+} while(0)
+
+#define HASH_ADD_KEYPTR(hh,head,keyptr,keylen_in,add)                            \
+do {                                                                             \
+uint32_t _ha_bkt;                                                               \
+(add)->hh.next = NULL;                                                          \
+(add)->hh.key = (char*)(keyptr);                                                \
+(add)->hh.keylen = (uint32_t)(keylen_in);                                       \
+if (!(head)) {                                                                  \
+head = (add);                                                                \
+(head)->hh.prev = NULL;                                                      \
+HASH_MAKE_TABLE(hh,head);                                                    \
+} else {                                                                        \
+(head)->hh.tbl->tail->next = (add);                                          \
+(add)->hh.prev = ELMT_FROM_HH((head)->hh.tbl, (head)->hh.tbl->tail);         \
+(head)->hh.tbl->tail = &((add)->hh);                                         \
+}                                                                               \
+(head)->hh.tbl->num_items++;                                                    \
+(add)->hh.tbl = (head)->hh.tbl;                                                 \
+HASH_FCN(keyptr,keylen_in, (head)->hh.tbl->num_buckets,                         \
+(add)->hh.hashv, _ha_bkt);                                              \
+HASH_ADD_TO_BKT((head)->hh.tbl->buckets[_ha_bkt],&(add)->hh);                   \
+HASH_BLOOM_ADD((head)->hh.tbl,(add)->hh.hashv);                                 \
+HASH_EMIT_KEY(hh,head,keyptr,keylen_in);                                        \
+HASH_FSCK(hh,head);                                                             \
+} while(0)
+
+#define HASH_TO_BKT( hashv, num_bkts, bkt )                                      \
+do {                                                                             \
+bkt = ((hashv) & ((num_bkts) - 1));                                            \
+} while(0)
+
+/* delete "delptr" from the hash table.
+ * "the usual" patch-up process for the app-order doubly-linked-list.
+ * The use of _hd_hh_del below deserves special explanation.
+ * These used to be expressed using (delptr) but that led to a bug
+ * if someone used the same symbol for the head and deletee, like
+ *  HASH_DELETE(hh,users,users);
+ * We want that to work, but by changing the head (users) below
+ * we were forfeiting our ability to further refer to the deletee (users)
+ * in the patch-up process. Solution: use scratch space to
+ * copy the deletee pointer, then the latter references are via that
+ * scratch pointer rather than through the repointed (users) symbol.
+ */
+#define HASH_DELETE(hh,head,delptr)                                              \
+do {                                                                             \
+struct UT_hash_handle *_hd_hh_del;                                           \
+if ( ((delptr)->hh.prev == NULL) && ((delptr)->hh.next == NULL) )  {         \
+uthash_free((head)->hh.tbl->buckets,                                     \
+(head)->hh.tbl->num_buckets*sizeof(struct UT_hash_bucket) ); \
+HASH_BLOOM_FREE((head)->hh.tbl);                                         \
+uthash_free((head)->hh.tbl, sizeof(UT_hash_table));                      \
+head = NULL;                                                             \
+} else {                                                                     \
+uint32_t _hd_bkt;                                                        \
+_hd_hh_del = &((delptr)->hh);                                            \
+if ((delptr) == ELMT_FROM_HH((head)->hh.tbl,(head)->hh.tbl->tail)) {     \
+(head)->hh.tbl->tail =                                               \
+(UT_hash_handle*)((ptrdiff_t)((delptr)->hh.prev) +               \
+(head)->hh.tbl->hho);                                            \
+}                                                                        \
+if ((delptr)->hh.prev) {                                                 \
+((UT_hash_handle*)((ptrdiff_t)((delptr)->hh.prev) +                  \
+(head)->hh.tbl->hho))->next = (delptr)->hh.next;             \
+} else {                                                                 \
+DECLTYPE_ASSIGN(head,(delptr)->hh.next);                             \
+}                                                                        \
+if (_hd_hh_del->next) {                                                  \
+((UT_hash_handle*)((ptrdiff_t)_hd_hh_del->next +                     \
+(head)->hh.tbl->hho))->prev =                                \
+_hd_hh_del->prev;                                            \
+}                                                                        \
+HASH_TO_BKT( _hd_hh_del->hashv, (head)->hh.tbl->num_buckets, _hd_bkt);   \
+HASH_DEL_IN_BKT(hh,(head)->hh.tbl->buckets[_hd_bkt], _hd_hh_del);        \
+(head)->hh.tbl->num_items--;                                             \
+}                                                                            \
+HASH_FSCK(hh,head);                                                          \
+} while (0)
+
+
+/* convenience forms of HASH_FIND/HASH_ADD/HASH_DEL */
+#define HASH_FIND_STR(head,findstr,out)                                          \
+HASH_FIND(hh,head,findstr,(uint32_t)strlen(findstr),out)
+#define HASH_ADD_STR(head,strfield,add)                                          \
+HASH_ADD(hh,head,strfield[0],strlen(add->strfield),add)
+#define HASH_REPLACE_STR(head,strfield,add,replaced)                             \
+HASH_REPLACE(hh,head,strfield[0],(uint32_t)strlen(add->strfield),add,replaced)
+#define HASH_FIND_INT(head,findint,out)                                          \
+HASH_FIND(hh,head,findint,sizeof(int),out)
+#define HASH_ADD_INT(head,intfield,add)                                          \
+HASH_ADD(hh,head,intfield,sizeof(int),add)
+#define HASH_REPLACE_INT(head,intfield,add,replaced)                             \
+HASH_REPLACE(hh,head,intfield,sizeof(int),add,replaced)
+#define HASH_FIND_PTR(head,findptr,out)                                          \
+HASH_FIND(hh,head,findptr,sizeof(void *),out)
+#define HASH_ADD_PTR(head,ptrfield,add)                                          \
+HASH_ADD(hh,head,ptrfield,sizeof(void *),add)
+#define HASH_REPLACE_PTR(head,ptrfield,add,replaced)                             \
+HASH_REPLACE(hh,head,ptrfield,sizeof(void *),add,replaced)
+#define HASH_DEL(head,delptr)                                                    \
+HASH_DELETE(hh,head,delptr)
+
+/* HASH_FSCK checks hash integrity on every add/delete when HASH_DEBUG is defined.
+ * This is for uthash developer only; it compiles away if HASH_DEBUG isn't defined.
+ */
+#ifdef HASH_DEBUG
+#define HASH_OOPS(...) do { fprintf(stderr,__VA_ARGS__); exit(-1); } while (0)
+#define HASH_FSCK(hh,head)                                                       \
+do {                                                                             \
+struct UT_hash_handle *_thh;                                                 \
+if (head) {                                                                  \
+uint32_t _bkt_i;                                                         \
+uint32_t _count;                                                         \
+char *_prev;                                                             \
+_count = 0;                                                              \
+for( _bkt_i = 0; _bkt_i < (head)->hh.tbl->num_buckets; _bkt_i++) {       \
+uint32_t _bkt_count = 0;                                             \
+_thh = (head)->hh.tbl->buckets[_bkt_i].hh_head;                      \
+_prev = NULL;                                                        \
+while (_thh) {                                                       \
+if (_prev != (char*)(_thh->hh_prev)) {                            \
+HASH_OOPS("invalid hh_prev %p, actual %p\n",                  \
+_thh->hh_prev, _prev );                                      \
+}                                                                 \
+_bkt_count++;                                                     \
+_prev = (char*)(_thh);                                            \
+_thh = _thh->hh_next;                                             \
+}                                                                    \
+_count += _bkt_count;                                                \
+if ((head)->hh.tbl->buckets[_bkt_i].count !=  _bkt_count) {          \
+HASH_OOPS("invalid bucket count %u, actual %u\n",                 \
+(head)->hh.tbl->buckets[_bkt_i].count, _bkt_count);              \
+}                                                                    \
+}                                                                        \
+if (_count != (head)->hh.tbl->num_items) {                               \
+HASH_OOPS("invalid hh item count %u, actual %u\n",                   \
+(head)->hh.tbl->num_items, _count );                             \
+}                                                                        \
+/* traverse hh in app order; check next/prev integrity, count */         \
+_count = 0;                                                              \
+_prev = NULL;                                                            \
+_thh =  &(head)->hh;                                                     \
+while (_thh) {                                                           \
+_count++;                                                             \
+if (_prev !=(char*)(_thh->prev)) {                                    \
+HASH_OOPS("invalid prev %p, actual %p\n",                          \
+_thh->prev, _prev );                                         \
+}                                                                     \
+_prev = (char*)ELMT_FROM_HH((head)->hh.tbl, _thh);                    \
+_thh = ( _thh->next ?  (UT_hash_handle*)((char*)(_thh->next) +        \
+(head)->hh.tbl->hho) : NULL );                 \
+}                                                                        \
+if (_count != (head)->hh.tbl->num_items) {                               \
+HASH_OOPS("invalid app item count %u, actual %u\n",                  \
+(head)->hh.tbl->num_items, _count );                             \
+}                                                                        \
+}                                                                            \
+} while (0)
+#else
+#define HASH_FSCK(hh,head)
+#endif
+
+/* When compiled with -DHASH_EMIT_KEYS, length-prefixed keys are emitted to
+ * the descriptor to which this macro is defined for tuning the hash function.
+ * The app can #include <unistd.h> to get the prototype for write(2). */
+#ifdef HASH_EMIT_KEYS
+#define HASH_EMIT_KEY(hh,head,keyptr,fieldlen)                                   \
+do {                                                                             \
+uint32_t _klen = fieldlen;                                                   \
+write(HASH_EMIT_KEYS, &_klen, sizeof(_klen));                                \
+write(HASH_EMIT_KEYS, keyptr, fieldlen);                                     \
+} while (0)
+#else
+#define HASH_EMIT_KEY(hh,head,keyptr,fieldlen)
+#endif
+
+/* default to Jenkin's hash unless overridden e.g. DHASH_FUNCTION=HASH_SAX */
+#ifdef HASH_FUNCTION
+#define HASH_FCN HASH_FUNCTION
+#else
+#define HASH_FCN HASH_JEN
+#endif
+
+/* The Bernstein hash function, used in Perl prior to v5.6. Note (x<<5+x)=x*33. */
+#define HASH_BER(key,keylen,num_bkts,hashv,bkt)                                  \
+do {                                                                             \
+uint32_t _hb_keylen=keylen;                                                    \
+char *_hb_key=(char*)(key);                                                    \
+(hashv) = 0;                                                                   \
+while (_hb_keylen--)  { (hashv) = (((hashv) << 5) + (hashv)) + *_hb_key++; }   \
+bkt = (hashv) & (num_bkts-1);                                                  \
+} while (0)
+
+
+/* SAX/FNV/OAT/JEN hash functions are macro variants of those listed at
+ * http://eternallyconfuzzled.com/tuts/algorithms/jsw_tut_hashing.aspx */
+#define HASH_SAX(key,keylen,num_bkts,hashv,bkt)                                  \
+do {                                                                             \
+uint32_t _sx_i;                                                                \
+char *_hs_key=(char*)(key);                                                    \
+hashv = 0;                                                                     \
+for(_sx_i=0; _sx_i < keylen; _sx_i++)                                          \
+hashv ^= (hashv << 5) + (hashv >> 2) + _hs_key[_sx_i];                     \
+bkt = hashv & (num_bkts-1);                                                    \
+} while (0)
+/* FNV-1a variation */
+#define HASH_FNV(key,keylen,num_bkts,hashv,bkt)                                  \
+do {                                                                             \
+uint32_t _fn_i;                                                                \
+char *_hf_key=(char*)(key);                                                    \
+hashv = 2166136261UL;                                                          \
+for(_fn_i=0; _fn_i < keylen; _fn_i++) {                                        \
+hashv = hashv ^ _hf_key[_fn_i];                                            \
+hashv = hashv * 16777619;                                                  \
+}                                                                              \
+bkt = hashv & (num_bkts-1);                                                    \
+} while(0)
+
+#define HASH_OAT(key,keylen,num_bkts,hashv,bkt)                                  \
+do {                                                                             \
+uint32_t _ho_i;                                                                \
+char *_ho_key=(char*)(key);                                                    \
+hashv = 0;                                                                     \
+for(_ho_i=0; _ho_i < keylen; _ho_i++) {                                        \
+hashv += _ho_key[_ho_i];                                                   \
+hashv += (hashv << 10);                                                    \
+hashv ^= (hashv >> 6);                                                     \
+}                                                                              \
+hashv += (hashv << 3);                                                         \
+hashv ^= (hashv >> 11);                                                        \
+hashv += (hashv << 15);                                                        \
+bkt = hashv & (num_bkts-1);                                                    \
+} while(0)
+
+#define HASH_JEN_MIX(a,b,c)                                                      \
+do {                                                                             \
+a -= b; a -= c; a ^= ( c >> 13 );                                              \
+b -= c; b -= a; b ^= ( a << 8 );                                               \
+c -= a; c -= b; c ^= ( b >> 13 );                                              \
+a -= b; a -= c; a ^= ( c >> 12 );                                              \
+b -= c; b -= a; b ^= ( a << 16 );                                              \
+c -= a; c -= b; c ^= ( b >> 5 );                                               \
+a -= b; a -= c; a ^= ( c >> 3 );                                               \
+b -= c; b -= a; b ^= ( a << 10 );                                              \
+c -= a; c -= b; c ^= ( b >> 15 );                                              \
+} while (0)
+
+#define HASH_JEN(key,keylen,num_bkts,hashv,bkt)                                  \
+do {                                                                             \
+uint32_t _hj_i,_hj_j,_hj_k;                                                    \
+unsigned char *_hj_key=(unsigned char*)(key);                                  \
+hashv = 0xfeedbeef;                                                            \
+_hj_i = _hj_j = 0x9e3779b9;                                                    \
+_hj_k = (uint32_t)(keylen);                                                    \
+while (_hj_k >= 12) {                                                          \
+_hj_i +=    (_hj_key[0] + ( (uint32_t)_hj_key[1] << 8 )                      \
++ ( (uint32_t)_hj_key[2] << 16 )                                         \
++ ( (uint32_t)_hj_key[3] << 24 ) );                                      \
+_hj_j +=    (_hj_key[4] + ( (uint32_t)_hj_key[5] << 8 )                      \
++ ( (uint32_t)_hj_key[6] << 16 )                                         \
++ ( (uint32_t)_hj_key[7] << 24 ) );                                      \
+hashv += (_hj_key[8] + ( (uint32_t)_hj_key[9] << 8 )                         \
++ ( (uint32_t)_hj_key[10] << 16 )                                        \
++ ( (uint32_t)_hj_key[11] << 24 ) );                                     \
+\
+HASH_JEN_MIX(_hj_i, _hj_j, hashv);                                          \
+\
+_hj_key += 12;                                                              \
+_hj_k -= 12;                                                                \
+}                                                                              \
+hashv += keylen;                                                               \
+switch ( _hj_k ) {                                                             \
+case 11: hashv += ( (uint32_t)_hj_key[10] << 24 );                          \
+case 10: hashv += ( (uint32_t)_hj_key[9] << 16 );                           \
+case 9:  hashv += ( (uint32_t)_hj_key[8] << 8 );                            \
+case 8:  _hj_j += ( (uint32_t)_hj_key[7] << 24 );                           \
+case 7:  _hj_j += ( (uint32_t)_hj_key[6] << 16 );                           \
+case 6:  _hj_j += ( (uint32_t)_hj_key[5] << 8 );                            \
+case 5:  _hj_j += _hj_key[4];                                               \
+case 4:  _hj_i += ( (uint32_t)_hj_key[3] << 24 );                           \
+case 3:  _hj_i += ( (uint32_t)_hj_key[2] << 16 );                           \
+case 2:  _hj_i += ( (uint32_t)_hj_key[1] << 8 );                            \
+case 1:  _hj_i += _hj_key[0];                                               \
+}                                                                              \
+HASH_JEN_MIX(_hj_i, _hj_j, hashv);                                             \
+bkt = hashv & (num_bkts-1);                                                    \
+} while(0)
+
+/* The Paul Hsieh hash function */
+#undef get16bits
+#if (defined(__GNUC__) && defined(__i386__)) || defined(__WATCOMC__)             \
+|| defined(_MSC_VER) || defined (__BORLANDC__) || defined (__TURBOC__)
+#define get16bits(d) (*((const uint16_t *) (d)))
+#endif
+
+#if !defined (get16bits)
+#define get16bits(d) ((((uint32_t)(((const uint8_t *)(d))[1])) << 8)             \
++(uint32_t)(((const uint8_t *)(d))[0]) )
+#endif
+#define HASH_SFH(key,keylen,num_bkts,hashv,bkt)                                  \
+do {                                                                             \
+unsigned char *_sfh_key=(unsigned char*)(key);                                 \
+uint32_t _sfh_tmp, _sfh_len = keylen;                                          \
+\
+int _sfh_rem = _sfh_len & 3;                                                   \
+_sfh_len >>= 2;                                                                \
+hashv = 0xcafebabe;                                                            \
+\
+/* Main loop */                                                                \
+for (;_sfh_len > 0; _sfh_len--) {                                              \
+hashv    += get16bits (_sfh_key);                                            \
+_sfh_tmp       = (uint32_t)(get16bits (_sfh_key+2)) << 11  ^ hashv;          \
+hashv     = (hashv << 16) ^ _sfh_tmp;                                        \
+_sfh_key += 2*sizeof (uint16_t);                                             \
+hashv    += hashv >> 11;                                                     \
+}                                                                              \
+\
+/* Handle end cases */                                                         \
+switch (_sfh_rem) {                                                            \
+case 3: hashv += get16bits (_sfh_key);                                       \
+hashv ^= hashv << 16;                                                \
+hashv ^= (uint32_t)(_sfh_key[sizeof (uint16_t)] << 18);              \
+hashv += hashv >> 11;                                                \
+break;                                                               \
+case 2: hashv += get16bits (_sfh_key);                                       \
+hashv ^= hashv << 11;                                                \
+hashv += hashv >> 17;                                                \
+break;                                                               \
+case 1: hashv += *_sfh_key;                                                  \
+hashv ^= hashv << 10;                                                \
+hashv += hashv >> 1;                                                 \
+}                                                                              \
+\
+/* Force "avalanching" of final 127 bits */                                  \
+hashv ^= hashv << 3;                                                         \
+hashv += hashv >> 5;                                                         \
+hashv ^= hashv << 4;                                                         \
+hashv += hashv >> 17;                                                        \
+hashv ^= hashv << 25;                                                        \
+hashv += hashv >> 6;                                                         \
+bkt = hashv & (num_bkts-1);                                                  \
+} while(0)
+
+#ifdef HASH_USING_NO_STRICT_ALIASING
+/* The MurmurHash exploits some CPU's (x86,x86_64) tolerance for unaligned reads.
+ * For other types of CPU's (e.g. Sparc) an unaligned read causes a bus error.
+ * MurmurHash uses the faster approach only on CPU's where we know it's safe.
+ *
+ * Note the preprocessor built-in defines can be emitted using:
+ *
+ *   gcc -m64 -dM -E - < /dev/null                  (on gcc)
+ *   cc -## a.c (where a.c is a simple test file)   (Sun Studio)
+ */
+#if (defined(__i386__) || defined(__x86_64__)  || defined(_M_IX86))
+#define MUR_GETBLOCK(p,i) p[i]
+#else /* non intel */
+#define MUR_PLUS0_ALIGNED(p) (((uint64_t)p & 0x3) == 0)
+#define MUR_PLUS1_ALIGNED(p) (((uint64_t)p & 0x3) == 1)
+#define MUR_PLUS2_ALIGNED(p) (((uint64_t)p & 0x3) == 2)
+#define MUR_PLUS3_ALIGNED(p) (((uint64_t)p & 0x3) == 3)
+#define WP(p) ((uint32_t*)((uint64_t)(p) & ~3UL))
+#if (defined(__BIG_ENDIAN__) || defined(SPARC) || defined(__ppc__) || defined(__ppc64__))
+#define MUR_THREE_ONE(p) ((((*WP(p))&0x00ffffff) << 8) | (((*(WP(p)+1))&0xff000000) >> 24))
+#define MUR_TWO_TWO(p)   ((((*WP(p))&0x0000ffff) <<16) | (((*(WP(p)+1))&0xffff0000) >> 16))
+#define MUR_ONE_THREE(p) ((((*WP(p))&0x000000ff) <<24) | (((*(WP(p)+1))&0xffffff00) >>  8))
+#else /* assume little endian non-intel */
+#define MUR_THREE_ONE(p) ((((*WP(p))&0xffffff00) >> 8) | (((*(WP(p)+1))&0x000000ff) << 24))
+#define MUR_TWO_TWO(p)   ((((*WP(p))&0xffff0000) >>16) | (((*(WP(p)+1))&0x0000ffff) << 16))
+#define MUR_ONE_THREE(p) ((((*WP(p))&0xff000000) >>24) | (((*(WP(p)+1))&0x00ffffff) <<  8))
+#endif
+#define MUR_GETBLOCK(p,i) (MUR_PLUS0_ALIGNED(p) ? ((p)[i]) :           \
+(MUR_PLUS1_ALIGNED(p) ? MUR_THREE_ONE(p) : \
+(MUR_PLUS2_ALIGNED(p) ? MUR_TWO_TWO(p) :  \
+MUR_ONE_THREE(p))))
+#endif
+#define MUR_ROTL32(x,r) (((x) << (r)) | ((x) >> (32 - (r))))
+#define MUR_FMIX(_h) \
+do {                 \
+_h ^= _h >> 16;    \
+_h *= 0x85ebca6b;  \
+_h ^= _h >> 13;    \
+_h *= 0xc2b2ae35l; \
+_h ^= _h >> 16;    \
+} while(0)
+
+#define HASH_MUR(key,keylen,num_bkts,hashv,bkt)                        \
+do {                                                                   \
+const uint8_t *_mur_data = (const uint8_t*)(key);                    \
+const int _mur_nblocks = (keylen) / 4;                               \
+uint32_t _mur_h1 = 0xf88D5353;                                       \
+uint32_t _mur_c1 = 0xcc9e2d51;                                       \
+uint32_t _mur_c2 = 0x1b873593;                                       \
+uint32_t _mur_k1 = 0;                                                \
+const uint8_t *_mur_tail;                                            \
+const uint32_t *_mur_blocks = (const uint32_t*)(_mur_data+_mur_nblocks*4); \
+int _mur_i;                                                          \
+for(_mur_i = -_mur_nblocks; _mur_i; _mur_i++) {                      \
+_mur_k1 = MUR_GETBLOCK(_mur_blocks,_mur_i);                        \
+_mur_k1 *= _mur_c1;                                                \
+_mur_k1 = MUR_ROTL32(_mur_k1,15);                                  \
+_mur_k1 *= _mur_c2;                                                \
+\
+_mur_h1 ^= _mur_k1;                                                \
+_mur_h1 = MUR_ROTL32(_mur_h1,13);                                  \
+_mur_h1 = _mur_h1*5+0xe6546b64;                                    \
+}                                                                    \
+_mur_tail = (const uint8_t*)(_mur_data + _mur_nblocks*4);            \
+_mur_k1=0;                                                           \
+switch((keylen) & 3) {                                               \
+case 3: _mur_k1 ^= _mur_tail[2] << 16;                             \
+case 2: _mur_k1 ^= _mur_tail[1] << 8;                              \
+case 1: _mur_k1 ^= _mur_tail[0];                                   \
+_mur_k1 *= _mur_c1;                                                \
+_mur_k1 = MUR_ROTL32(_mur_k1,15);                                  \
+_mur_k1 *= _mur_c2;                                                \
+_mur_h1 ^= _mur_k1;                                                \
+}                                                                    \
+_mur_h1 ^= (keylen);                                                 \
+MUR_FMIX(_mur_h1);                                                   \
+hashv = _mur_h1;                                                     \
+bkt = hashv & (num_bkts-1);                                          \
+} while(0)
+#endif  /* HASH_USING_NO_STRICT_ALIASING */
+
+/* key comparison function; return 0 if keys equal */
+#define HASH_KEYCMP(a,b,len) memcmp(a,b,len)
+
+/* iterate over items in a known bucket to find desired item */
+#define HASH_FIND_IN_BKT(tbl,hh,head,keyptr,keylen_in,out)                       \
+do {                                                                             \
+if (head.hh_head) DECLTYPE_ASSIGN(out,ELMT_FROM_HH(tbl,head.hh_head));          \
+else out=NULL;                                                                  \
+while (out) {                                                                   \
+if ((out)->hh.keylen == keylen_in) {                                           \
+if ((HASH_KEYCMP((out)->hh.key,keyptr,keylen_in)) == 0) break;             \
+}                                                                            \
+if ((out)->hh.hh_next) DECLTYPE_ASSIGN(out,ELMT_FROM_HH(tbl,(out)->hh.hh_next)); \
+else out = NULL;                                                             \
+}                                                                               \
+} while(0)
+
+/* add an item to a bucket  */
+#define HASH_ADD_TO_BKT(head,addhh)                                              \
+do {                                                                             \
+head.count++;                                                                   \
+(addhh)->hh_next = head.hh_head;                                                \
+(addhh)->hh_prev = NULL;                                                        \
+if (head.hh_head) { (head).hh_head->hh_prev = (addhh); }                        \
+(head).hh_head=addhh;                                                           \
+if (head.count >= ((head.expand_mult+1) * HASH_BKT_CAPACITY_THRESH)             \
+&& (addhh)->tbl->noexpand != 1) {                                           \
+HASH_EXPAND_BUCKETS((addhh)->tbl);                                        \
+}                                                                               \
+} while(0)
+
+/* remove an item from a given bucket */
+#define HASH_DEL_IN_BKT(hh,head,hh_del)                                          \
+(head).count--;                                                              \
+if ((head).hh_head == hh_del) {                                              \
+(head).hh_head = hh_del->hh_next;                                          \
+}                                                                            \
+if (hh_del->hh_prev) {                                                       \
+hh_del->hh_prev->hh_next = hh_del->hh_next;                              \
+}                                                                            \
+if (hh_del->hh_next) {                                                       \
+hh_del->hh_next->hh_prev = hh_del->hh_prev;                              \
+}
+
+/* Bucket expansion has the effect of doubling the number of buckets
+ * and redistributing the items into the new buckets. Ideally the
+ * items will distribute more or less evenly into the new buckets
+ * (the extent to which this is true is a measure of the quality of
+ * the hash function as it applies to the key domain).
+ *
+ * With the items distributed into more buckets, the chain length
+ * (item count) in each bucket is reduced. Thus by expanding buckets
+ * the hash keeps a bound on the chain length. This bounded chain
+ * length is the essence of how a hash provides constant time lookup.
+ *
+ * The calculation of tbl->ideal_chain_maxlen below deserves some
+ * explanation. First, keep in mind that we're calculating the ideal
+ * maximum chain length based on the *new* (doubled) bucket count.
+ * In fractions this is just n/b (n=number of items,b=new num buckets).
+ * Since the ideal chain length is an integer, we want to calculate
+ * ceil(n/b). We don't depend on floating point arithmetic in this
+ * hash, so to calculate ceil(n/b) with integers we could write
+ *
+ *      ceil(n/b) = (n/b) + ((n%b)?1:0)
+ *
+ * and in fact a previous version of this hash did just that.
+ * But now we have improved things a bit by recognizing that b is
+ * always a power of two. We keep its base 2 log handy (call it lb),
+ * so now we can write this with a bit shift and logical AND:
+ *
+ *      ceil(n/b) = (n>>lb) + ( (n & (b-1)) ? 1:0)
+ *
+ */
+#define HASH_EXPAND_BUCKETS(tbl)                                                 \
+do {                                                                             \
+uint32_t _he_bkt;                                                            \
+uint32_t _he_bkt_i;                                                          \
+struct UT_hash_handle *_he_thh, *_he_hh_nxt;                                 \
+UT_hash_bucket *_he_new_buckets, *_he_newbkt;                                \
+_he_new_buckets = (UT_hash_bucket*)uthash_malloc(                            \
+2 * tbl->num_buckets * sizeof(struct UT_hash_bucket));              \
+if (!_he_new_buckets) { uthash_fatal( "out of memory"); }                    \
+memset(_he_new_buckets, 0,                                                   \
+2 * tbl->num_buckets * sizeof(struct UT_hash_bucket));               \
+tbl->ideal_chain_maxlen =                                                    \
+(tbl->num_items >> (tbl->log2_num_buckets+1)) +                           \
+((tbl->num_items & ((tbl->num_buckets*2)-1)) ? 1 : 0);                    \
+tbl->nonideal_items = 0;                                                     \
+for(_he_bkt_i = 0; _he_bkt_i < tbl->num_buckets; _he_bkt_i++)                \
+{                                                                            \
+_he_thh = tbl->buckets[ _he_bkt_i ].hh_head;                             \
+while (_he_thh) {                                                        \
+_he_hh_nxt = _he_thh->hh_next;                                        \
+HASH_TO_BKT( _he_thh->hashv, tbl->num_buckets*2, _he_bkt);            \
+_he_newbkt = &(_he_new_buckets[ _he_bkt ]);                           \
+if (++(_he_newbkt->count) > tbl->ideal_chain_maxlen) {                \
+tbl->nonideal_items++;                                              \
+_he_newbkt->expand_mult = _he_newbkt->count /                       \
+tbl->ideal_chain_maxlen;                 \
+}                                                                     \
+_he_thh->hh_prev = NULL;                                              \
+_he_thh->hh_next = _he_newbkt->hh_head;                               \
+if (_he_newbkt->hh_head) _he_newbkt->hh_head->hh_prev =               \
+_he_thh;                                                         \
+_he_newbkt->hh_head = _he_thh;                                        \
+_he_thh = _he_hh_nxt;                                                 \
+}                                                                        \
+}                                                                            \
+uthash_free( tbl->buckets, tbl->num_buckets*sizeof(struct UT_hash_bucket) ); \
+tbl->num_buckets *= 2;                                                       \
+tbl->log2_num_buckets++;                                                     \
+tbl->buckets = _he_new_buckets;                                              \
+tbl->ineff_expands = (tbl->nonideal_items > (tbl->num_items >> 1)) ?         \
+(tbl->ineff_expands+1) : 0;                                              \
+if (tbl->ineff_expands > 1) {                                                \
+tbl->noexpand=1;                                                         \
+uthash_noexpand_fyi(tbl);                                                \
+}                                                                            \
+uthash_expand_fyi(tbl);                                                      \
+} while(0)
+
+
+/* This is an adaptation of Simon Tatham's O(n log(n)) mergesort */
+/* Note that HASH_SORT assumes the hash handle name to be hh.
+ * HASH_SRT was added to allow the hash handle name to be passed in. */
+#define HASH_SORT(head,cmpfcn) HASH_SRT(hh,head,cmpfcn)
+#define HASH_SRT(hh,head,cmpfcn)                                                 \
+do {                                                                             \
+uint32_t _hs_i;                                                                \
+uint32_t _hs_looping,_hs_nmerges,_hs_insize,_hs_psize,_hs_qsize;               \
+struct UT_hash_handle *_hs_p, *_hs_q, *_hs_e, *_hs_list, *_hs_tail;            \
+if (head) {                                                                    \
+_hs_insize = 1;                                                            \
+_hs_looping = 1;                                                           \
+_hs_list = &((head)->hh);                                                  \
+while (_hs_looping) {                                                      \
+_hs_p = _hs_list;                                                      \
+_hs_list = NULL;                                                       \
+_hs_tail = NULL;                                                       \
+_hs_nmerges = 0;                                                       \
+while (_hs_p) {                                                        \
+_hs_nmerges++;                                                     \
+_hs_q = _hs_p;                                                     \
+_hs_psize = 0;                                                     \
+for ( _hs_i = 0; _hs_i  < _hs_insize; _hs_i++ ) {                  \
+_hs_psize++;                                                   \
+_hs_q = (UT_hash_handle*)((_hs_q->next) ?                      \
+((void*)((char*)(_hs_q->next) +                        \
+(head)->hh.tbl->hho)) : NULL);                         \
+if (! (_hs_q) ) break;                                         \
+}                                                                  \
+_hs_qsize = _hs_insize;                                            \
+while ((_hs_psize > 0) || ((_hs_qsize > 0) && _hs_q )) {           \
+if (_hs_psize == 0) {                                          \
+_hs_e = _hs_q;                                             \
+_hs_q = (UT_hash_handle*)((_hs_q->next) ?                  \
+((void*)((char*)(_hs_q->next) +                    \
+(head)->hh.tbl->hho)) : NULL);                     \
+_hs_qsize--;                                               \
+} else if ( (_hs_qsize == 0) || !(_hs_q) ) {                   \
+_hs_e = _hs_p;                                             \
+if (_hs_p){                                                \
+_hs_p = (UT_hash_handle*)((_hs_p->next) ?                \
+((void*)((char*)(_hs_p->next) +                  \
+(head)->hh.tbl->hho)) : NULL);                   \
+}                                                         \
+_hs_psize--;                                               \
+} else if ((                                                   \
+cmpfcn(DECLTYPE(head)(ELMT_FROM_HH((head)->hh.tbl,_hs_p)), \
+DECLTYPE(head)(ELMT_FROM_HH((head)->hh.tbl,_hs_q))) \
+) <= 0) {                                           \
+_hs_e = _hs_p;                                             \
+if (_hs_p){                                                \
+_hs_p = (UT_hash_handle*)((_hs_p->next) ?                \
+((void*)((char*)(_hs_p->next) +                   \
+(head)->hh.tbl->hho)) : NULL);                    \
+}                                                         \
+_hs_psize--;                                               \
+} else {                                                       \
+_hs_e = _hs_q;                                             \
+_hs_q = (UT_hash_handle*)((_hs_q->next) ?                  \
+((void*)((char*)(_hs_q->next) +                    \
+(head)->hh.tbl->hho)) : NULL);                     \
+_hs_qsize--;                                               \
+}                                                              \
+if ( _hs_tail ) {                                              \
+_hs_tail->next = ((_hs_e) ?                                \
+ELMT_FROM_HH((head)->hh.tbl,_hs_e) : NULL);          \
+} else {                                                       \
+_hs_list = _hs_e;                                          \
+}                                                              \
+if (_hs_e) {                                                   \
+_hs_e->prev = ((_hs_tail) ?                                    \
+ELMT_FROM_HH((head)->hh.tbl,_hs_tail) : NULL);              \
+}                                                              \
+_hs_tail = _hs_e;                                              \
+}                                                                  \
+_hs_p = _hs_q;                                                     \
+}                                                                      \
+if (_hs_tail){                                                         \
+_hs_tail->next = NULL;                                               \
+}                                                                      \
+if ( _hs_nmerges <= 1 ) {                                              \
+_hs_looping=0;                                                     \
+(head)->hh.tbl->tail = _hs_tail;                                   \
+DECLTYPE_ASSIGN(head,ELMT_FROM_HH((head)->hh.tbl, _hs_list));      \
+}                                                                      \
+_hs_insize *= 2;                                                       \
+}                                                                          \
+HASH_FSCK(hh,head);                                                        \
+}                                                                               \
+} while (0)
+
+/* This function selects items from one hash into another hash.
+ * The end result is that the selected items have dual presence
+ * in both hashes. There is no copy of the items made; rather
+ * they are added into the new hash through a secondary hash
+ * hash handle that must be present in the structure. */
+#define HASH_SELECT(hh_dst, dst, hh_src, src, cond)                              \
+do {                                                                             \
+uint32_t _src_bkt, _dst_bkt;                                                   \
+void *_last_elt=NULL, *_elt;                                                   \
+UT_hash_handle *_src_hh, *_dst_hh, *_last_elt_hh=NULL;                         \
+ptrdiff_t _dst_hho = ((char*)(&(dst)->hh_dst) - (char*)(dst));                 \
+if (src) {                                                                     \
+for(_src_bkt=0; _src_bkt < (src)->hh_src.tbl->num_buckets; _src_bkt++) {     \
+for(_src_hh = (src)->hh_src.tbl->buckets[_src_bkt].hh_head;                \
+_src_hh;                                                               \
+_src_hh = _src_hh->hh_next) {                                          \
+_elt = ELMT_FROM_HH((src)->hh_src.tbl, _src_hh);                       \
+if (cond(_elt)) {                                                      \
+_dst_hh = (UT_hash_handle*)(((char*)_elt) + _dst_hho);               \
+_dst_hh->key = _src_hh->key;                                         \
+_dst_hh->keylen = _src_hh->keylen;                                   \
+_dst_hh->hashv = _src_hh->hashv;                                     \
+_dst_hh->prev = _last_elt;                                           \
+_dst_hh->next = NULL;                                                \
+if (_last_elt_hh) { _last_elt_hh->next = _elt; }                     \
+if (!dst) {                                                          \
+DECLTYPE_ASSIGN(dst,_elt);                                         \
+HASH_MAKE_TABLE(hh_dst,dst);                                       \
+} else {                                                             \
+_dst_hh->tbl = (dst)->hh_dst.tbl;                                  \
+}                                                                    \
+HASH_TO_BKT(_dst_hh->hashv, _dst_hh->tbl->num_buckets, _dst_bkt);    \
+HASH_ADD_TO_BKT(_dst_hh->tbl->buckets[_dst_bkt],_dst_hh);            \
+(dst)->hh_dst.tbl->num_items++;                                      \
+_last_elt = _elt;                                                    \
+_last_elt_hh = _dst_hh;                                              \
+}                                                                      \
+}                                                                          \
+}                                                                            \
+}                                                                              \
+HASH_FSCK(hh_dst,dst);                                                         \
+} while (0)
+
+#define HASH_CLEAR(hh,head)                                                      \
+do {                                                                             \
+if (head) {                                                                    \
+uthash_free((head)->hh.tbl->buckets,                                         \
+(head)->hh.tbl->num_buckets*sizeof(struct UT_hash_bucket));      \
+HASH_BLOOM_FREE((head)->hh.tbl);                                             \
+uthash_free((head)->hh.tbl, sizeof(UT_hash_table));                          \
+(head)=NULL;                                                                 \
+}                                                                              \
+} while(0)
+
+#define HASH_OVERHEAD(hh,head)                                                   \
+(size_t)((((head)->hh.tbl->num_items   * sizeof(UT_hash_handle))   +            \
+((head)->hh.tbl->num_buckets * sizeof(UT_hash_bucket))   +            \
+(sizeof(UT_hash_table))                                 +            \
+(HASH_BLOOM_BYTELEN)))
+
+#ifdef NO_DECLTYPE
+#define HASH_ITER(hh,head,el,tmp)                                                \
+for((el)=(head), (*(char**)(&(tmp)))=(char*)((head)?(head)->hh.next:NULL);       \
+el; (el)=(tmp),(*(char**)(&(tmp)))=(char*)((tmp)?(tmp)->hh.next:NULL))
+#else
+#define HASH_ITER(hh,head,el,tmp)                                                \
+for((el)=(head),(tmp)=DECLTYPE(el)((head)?(head)->hh.next:NULL);                 \
+el; (el)=(tmp),(tmp)=DECLTYPE(el)((tmp)?(tmp)->hh.next:NULL))
+#endif
+
+/* obtain a count of items in the hash */
+#define HASH_COUNT(head) HASH_CNT(hh,head)
+#define HASH_CNT(hh,head) ((head)?((head)->hh.tbl->num_items):0)
+
+typedef struct UT_hash_bucket {
+    struct UT_hash_handle *hh_head;
+    uint32_t count;
+    
+    /* expand_mult is normally set to 0. In this situation, the max chain length
+     * threshold is enforced at its default value, HASH_BKT_CAPACITY_THRESH. (If
+     * the bucket's chain exceeds this length, bucket expansion is triggered).
+     * However, setting expand_mult to a non-zero value delays bucket expansion
+     * (that would be triggered by additions to this particular bucket)
+     * until its chain length reaches a *multiple* of HASH_BKT_CAPACITY_THRESH.
+     * (The multiplier is simply expand_mult+1). The whole idea of this
+     * multiplier is to reduce bucket expansions, since they are expensive, in
+     * situations where we know that a particular bucket tends to be overused.
+     * It is better to let its chain length grow to a longer yet-still-bounded
+     * value, than to do an O(n) bucket expansion too often.
+     */
+    uint32_t expand_mult;
+    
+} UT_hash_bucket;
+
+/* random signature used only to find hash tables in external analysis */
+#define HASH_SIGNATURE 0xa0111fe1
+#define HASH_BLOOM_SIGNATURE 0xb12220f2
+
+typedef struct UT_hash_table {
+    UT_hash_bucket *buckets;
+    uint32_t num_buckets, log2_num_buckets;
+    uint32_t num_items;
+    struct UT_hash_handle *tail; /* tail hh in app order, for fast append    */
+    ptrdiff_t hho; /* hash handle offset (byte pos of hash handle in element */
+    
+    /* in an ideal situation (all buckets used equally), no bucket would have
+     * more than ceil(#items/#buckets) items. that's the ideal chain length. */
+    uint32_t ideal_chain_maxlen;
+    
+    /* nonideal_items is the number of items in the hash whose chain position
+     * exceeds the ideal chain maxlen. these items pay the penalty for an uneven
+     * hash distribution; reaching them in a chain traversal takes >ideal steps */
+    uint32_t nonideal_items;
+    
+    /* ineffective expands occur when a bucket doubling was performed, but
+     * afterward, more than half the items in the hash had nonideal chain
+     * positions. If this happens on two consecutive expansions we inhibit any
+     * further expansion, as it's not helping; this happens when the hash
+     * function isn't a good fit for the key domain. When expansion is inhibited
+     * the hash will still work, albeit no longer in constant time. */
+    uint32_t ineff_expands, noexpand;
+    
+    uint32_t signature; /* used only to find hash tables in external analysis */
+#ifdef HASH_BLOOM
+    uint32_t bloom_sig; /* used only to test bloom exists in external analysis */
+    uint8_t *bloom_bv;
+    char bloom_nbits;
+#endif
+    
+} UT_hash_table;
+
+typedef struct UT_hash_handle {
+    struct UT_hash_table *tbl;
+    void *prev;                       /* prev element in app order      */
+    void *next;                       /* next element in app order      */
+    struct UT_hash_handle *hh_prev;   /* previous hh in bucket order    */
+    struct UT_hash_handle *hh_next;   /* next hh in bucket order        */
+    void *key;                        /* ptr to enclosing struct's key  */
+    uint32_t hashv;                   /* result of hash-fcn(key)        */
+    uint8_t keylen;                  /* enclosing struct's key len     */
+    uint32_t itemind;
+} UT_hash_handle;
+
+#endif /* UTHASH_H */
+
diff --git a/src/cc/includes/utlist.h b/src/cc/includes/utlist.h
new file mode 100755
index 000000000..93c7ceef0
--- /dev/null
+++ b/src/cc/includes/utlist.h
@@ -0,0 +1,753 @@
+/*
+ Copyright (c) 2007-2014, Troy D. Hanson   http://troydhanson.github.com/uthash/
+ All rights reserved.
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+ 
+#ifndef UTLIST_H
+#define UTLIST_H
+
+#define UTLIST_VERSION 1.9.9
+
+#include <assert.h>
+
+/*
+ * This file contains macros to manipulate singly and doubly-linked lists.
+ *
+ * 1. LL_ macros:  singly-linked lists.
+ * 2. DL_ macros:  doubly-linked lists.
+ * 3. CDL_ macros: circular doubly-linked lists.
+ *
+ * To use singly-linked lists, your structure must have a "next" pointer.
+ * To use doubly-linked lists, your structure must "prev" and "next" pointers.
+ * Either way, the pointer to the head of the list must be initialized to NULL.
+ *
+ * ----------------.EXAMPLE -------------------------
+ * struct item {
+ *      int id;
+ *      struct item *prev, *next;
+ * }
+ *
+ * struct item *list = NULL:
+ *
+ * int main() {
+ *      struct item *item;
+ *      ... allocate and populate item ...
+ *      DL_APPEND(list, item);
+ * }
+ * --------------------------------------------------
+ *
+ * For doubly-linked lists, the append and delete macros are O(1)
+ * For singly-linked lists, append and delete are O(n) but prepend is O(1)
+ * The sort macro is O(n log(n)) for all types of single/double/circular lists.
+ */
+
+/* These macros use decltype or the earlier __typeof GNU extension.
+ As decltype is only available in newer compilers (VS2010 or gcc 4.3+
+ when compiling c++ code), this code uses whatever method is needed
+ or, for VS2008 where neither is available, uses casting workarounds. */
+#ifdef _MSC_VER            /* MS compiler */
+#if _MSC_VER >= 1600 && defined(__cplusplus)  /* VS2010 or newer in C++ mode */
+#define LDECLTYPE(x) decltype(x)
+#else                     /* VS2008 or older (or VS2010 in C mode) */
+#define NO_DECLTYPE
+#define LDECLTYPE(x) char*
+#endif
+#elif defined(__ICCARM__)
+#define NO_DECLTYPE
+#define LDECLTYPE(x) char*
+#else                      /* GNU, Sun and other compilers */
+#define LDECLTYPE(x) __typeof(x)
+#endif
+
+/* for VS2008 we use some workarounds to get around the lack of decltype,
+ * namely, we always reassign our tmp variable to the list head if we need
+ * to dereference its prev/next pointers, and save/restore the real head.*/
+#ifdef NO_DECLTYPE
+#define _SV(elt,list) _tmp = (char*)(list); {char **_alias = (char**)&(list); *_alias = (elt); }
+#define _NEXT(elt,list,next) ((char*)((list)->next))
+#define _NEXTASGN(elt,list,to,next) { char **_alias = (char**)&((list)->next); *_alias=(char*)(to); }
+/* #define _PREV(elt,list,prev) ((char*)((list)->prev)) */
+#define _PREVASGN(elt,list,to,prev) { char **_alias = (char**)&((list)->prev); *_alias=(char*)(to); }
+#define _RS(list) { char **_alias = (char**)&(list); *_alias=_tmp; }
+#define _CASTASGN(a,b) { char **_alias = (char**)&(a); *_alias=(char*)(b); }
+#else
+#define _SV(elt,list)
+#define _NEXT(elt,list,next) ((elt)->next)
+#define _NEXTASGN(elt,list,to,next) ((elt)->next)=(to)
+/* #define _PREV(elt,list,prev) ((elt)->prev) */
+#define _PREVASGN(elt,list,to,prev) ((elt)->prev)=(to)
+#define _RS(list)
+#define _CASTASGN(a,b) (a)=(b)
+#endif
+
+/******************************************************************************
+ * The sort macro is an adaptation of Simon Tatham's O(n log(n)) mergesort    *
+ * Unwieldy variable names used here to avoid shadowing passed-in variables.  *
+ *****************************************************************************/
+#define LL_SORT(list, cmp)                                                                     \
+LL_SORT2(list, cmp, next)
+
+#define LL_SORT2(list, cmp, next)                                                              \
+do {                                                                                           \
+LDECLTYPE(list) _ls_p;                                                                       \
+LDECLTYPE(list) _ls_q;                                                                       \
+LDECLTYPE(list) _ls_e;                                                                       \
+LDECLTYPE(list) _ls_tail;                                                                    \
+int _ls_insize, _ls_nmerges, _ls_psize, _ls_qsize, _ls_i, _ls_looping;                       \
+if (list) {                                                                                  \
+_ls_insize = 1;                                                                            \
+_ls_looping = 1;                                                                           \
+while (_ls_looping) {                                                                      \
+_CASTASGN(_ls_p,list);                                                                   \
+list = NULL;                                                                             \
+_ls_tail = NULL;                                                                         \
+_ls_nmerges = 0;                                                                         \
+while (_ls_p) {                                                                          \
+_ls_nmerges++;                                                                         \
+_ls_q = _ls_p;                                                                         \
+_ls_psize = 0;                                                                         \
+for (_ls_i = 0; _ls_i < _ls_insize; _ls_i++) {                                         \
+_ls_psize++;                                                                         \
+_SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list,next); _RS(list);                          \
+if (!_ls_q) break;                                                                   \
+}                                                                                      \
+_ls_qsize = _ls_insize;                                                                \
+while (_ls_psize > 0 || (_ls_qsize > 0 && _ls_q)) {                                    \
+if (_ls_psize == 0) {                                                                \
+_ls_e = _ls_q; _SV(_ls_q,list); _ls_q =                                            \
+_NEXT(_ls_q,list,next); _RS(list); _ls_qsize--;                                  \
+} else if (_ls_qsize == 0 || !_ls_q) {                                               \
+_ls_e = _ls_p; _SV(_ls_p,list); _ls_p =                                            \
+_NEXT(_ls_p,list,next); _RS(list); _ls_psize--;                                  \
+} else if (cmp(_ls_p,_ls_q) <= 0) {                                                  \
+_ls_e = _ls_p; _SV(_ls_p,list); _ls_p =                                            \
+_NEXT(_ls_p,list,next); _RS(list); _ls_psize--;                                  \
+} else {                                                                             \
+_ls_e = _ls_q; _SV(_ls_q,list); _ls_q =                                            \
+_NEXT(_ls_q,list,next); _RS(list); _ls_qsize--;                                  \
+}                                                                                    \
+if (_ls_tail) {                                                                      \
+_SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,_ls_e,next); _RS(list);                \
+} else {                                                                             \
+_CASTASGN(list,_ls_e);                                                             \
+}                                                                                    \
+_ls_tail = _ls_e;                                                                    \
+}                                                                                      \
+_ls_p = _ls_q;                                                                         \
+}                                                                                        \
+if (_ls_tail) {                                                                          \
+_SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,NULL,next); _RS(list);                     \
+}                                                                                        \
+if (_ls_nmerges <= 1) {                                                                  \
+_ls_looping=0;                                                                         \
+}                                                                                        \
+_ls_insize *= 2;                                                                         \
+}                                                                                          \
+}                                                                                            \
+} while (0)
+
+
+#define DL_SORT(list, cmp)                                                                     \
+DL_SORT2(list, cmp, prev, next)
+
+#define DL_SORT2(list, cmp, prev, next)                                                        \
+do {                                                                                           \
+LDECLTYPE(list) _ls_p;                                                                       \
+LDECLTYPE(list) _ls_q;                                                                       \
+LDECLTYPE(list) _ls_e;                                                                       \
+LDECLTYPE(list) _ls_tail;                                                                    \
+int _ls_insize, _ls_nmerges, _ls_psize, _ls_qsize, _ls_i, _ls_looping;                       \
+if (list) {                                                                                  \
+_ls_insize = 1;                                                                            \
+_ls_looping = 1;                                                                           \
+while (_ls_looping) {                                                                      \
+_CASTASGN(_ls_p,list);                                                                   \
+list = NULL;                                                                             \
+_ls_tail = NULL;                                                                         \
+_ls_nmerges = 0;                                                                         \
+while (_ls_p) {                                                                          \
+_ls_nmerges++;                                                                         \
+_ls_q = _ls_p;                                                                         \
+_ls_psize = 0;                                                                         \
+for (_ls_i = 0; _ls_i < _ls_insize; _ls_i++) {                                         \
+_ls_psize++;                                                                         \
+_SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list,next); _RS(list);                          \
+if (!_ls_q) break;                                                                   \
+}                                                                                      \
+_ls_qsize = _ls_insize;                                                                \
+while (_ls_psize > 0 || (_ls_qsize > 0 && _ls_q)) {                                    \
+if (_ls_psize == 0) {                                                                \
+_ls_e = _ls_q; _SV(_ls_q,list); _ls_q =                                            \
+_NEXT(_ls_q,list,next); _RS(list); _ls_qsize--;                                  \
+} else if (_ls_qsize == 0 || !_ls_q) {                                               \
+_ls_e = _ls_p; _SV(_ls_p,list); _ls_p =                                            \
+_NEXT(_ls_p,list,next); _RS(list); _ls_psize--;                                  \
+} else if (cmp(_ls_p,_ls_q) <= 0) {                                                  \
+_ls_e = _ls_p; _SV(_ls_p,list); _ls_p =                                            \
+_NEXT(_ls_p,list,next); _RS(list); _ls_psize--;                                  \
+} else {                                                                             \
+_ls_e = _ls_q; _SV(_ls_q,list); _ls_q =                                            \
+_NEXT(_ls_q,list,next); _RS(list); _ls_qsize--;                                  \
+}                                                                                    \
+if (_ls_tail) {                                                                      \
+_SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,_ls_e,next); _RS(list);                \
+} else {                                                                             \
+_CASTASGN(list,_ls_e);                                                             \
+}                                                                                    \
+_SV(_ls_e,list); _PREVASGN(_ls_e,list,_ls_tail,prev); _RS(list);                     \
+_ls_tail = _ls_e;                                                                    \
+}                                                                                      \
+_ls_p = _ls_q;                                                                         \
+}                                                                                        \
+_CASTASGN(list->prev, _ls_tail);                                                         \
+_SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,NULL,next); _RS(list);                       \
+if (_ls_nmerges <= 1) {                                                                  \
+_ls_looping=0;                                                                         \
+}                                                                                        \
+_ls_insize *= 2;                                                                         \
+}                                                                                          \
+}                                                                                            \
+} while (0)
+
+#define CDL_SORT(list, cmp)                                                                    \
+CDL_SORT2(list, cmp, prev, next)
+
+#define CDL_SORT2(list, cmp, prev, next)                                                       \
+do {                                                                                           \
+LDECLTYPE(list) _ls_p;                                                                       \
+LDECLTYPE(list) _ls_q;                                                                       \
+LDECLTYPE(list) _ls_e;                                                                       \
+LDECLTYPE(list) _ls_tail;                                                                    \
+LDECLTYPE(list) _ls_oldhead;                                                                 \
+LDECLTYPE(list) _tmp;                                                                        \
+int _ls_insize, _ls_nmerges, _ls_psize, _ls_qsize, _ls_i, _ls_looping;                       \
+if (list) {                                                                                  \
+_ls_insize = 1;                                                                            \
+_ls_looping = 1;                                                                           \
+while (_ls_looping) {                                                                      \
+_CASTASGN(_ls_p,list);                                                                   \
+_CASTASGN(_ls_oldhead,list);                                                             \
+list = NULL;                                                                             \
+_ls_tail = NULL;                                                                         \
+_ls_nmerges = 0;                                                                         \
+while (_ls_p) {                                                                          \
+_ls_nmerges++;                                                                         \
+_ls_q = _ls_p;                                                                         \
+_ls_psize = 0;                                                                         \
+for (_ls_i = 0; _ls_i < _ls_insize; _ls_i++) {                                         \
+_ls_psize++;                                                                         \
+_SV(_ls_q,list);                                                                     \
+if (_NEXT(_ls_q,list,next) == _ls_oldhead) {                                         \
+_ls_q = NULL;                                                                      \
+} else {                                                                             \
+_ls_q = _NEXT(_ls_q,list,next);                                                    \
+}                                                                                    \
+_RS(list);                                                                           \
+if (!_ls_q) break;                                                                   \
+}                                                                                      \
+_ls_qsize = _ls_insize;                                                                \
+while (_ls_psize > 0 || (_ls_qsize > 0 && _ls_q)) {                                    \
+if (_ls_psize == 0) {                                                                \
+_ls_e = _ls_q; _SV(_ls_q,list); _ls_q =                                            \
+_NEXT(_ls_q,list,next); _RS(list); _ls_qsize--;                                  \
+if (_ls_q == _ls_oldhead) { _ls_q = NULL; }                                        \
+} else if (_ls_qsize == 0 || !_ls_q) {                                               \
+_ls_e = _ls_p; _SV(_ls_p,list); _ls_p =                                            \
+_NEXT(_ls_p,list,next); _RS(list); _ls_psize--;                                  \
+if (_ls_p == _ls_oldhead) { _ls_p = NULL; }                                        \
+} else if (cmp(_ls_p,_ls_q) <= 0) {                                                  \
+_ls_e = _ls_p; _SV(_ls_p,list); _ls_p =                                            \
+_NEXT(_ls_p,list,next); _RS(list); _ls_psize--;                                  \
+if (_ls_p == _ls_oldhead) { _ls_p = NULL; }                                        \
+} else {                                                                             \
+_ls_e = _ls_q; _SV(_ls_q,list); _ls_q =                                            \
+_NEXT(_ls_q,list,next); _RS(list); _ls_qsize--;                                  \
+if (_ls_q == _ls_oldhead) { _ls_q = NULL; }                                        \
+}                                                                                    \
+if (_ls_tail) {                                                                      \
+_SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,_ls_e,next); _RS(list);                \
+} else {                                                                             \
+_CASTASGN(list,_ls_e);                                                             \
+}                                                                                    \
+_SV(_ls_e,list); _PREVASGN(_ls_e,list,_ls_tail,prev); _RS(list);                     \
+_ls_tail = _ls_e;                                                                    \
+}                                                                                      \
+_ls_p = _ls_q;                                                                         \
+}                                                                                        \
+_CASTASGN(list->prev,_ls_tail);                                                          \
+_CASTASGN(_tmp,list);                                                                    \
+_SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,_tmp,next); _RS(list);                       \
+if (_ls_nmerges <= 1) {                                                                  \
+_ls_looping=0;                                                                         \
+}                                                                                        \
+_ls_insize *= 2;                                                                         \
+}                                                                                          \
+}                                                                                            \
+} while (0)
+
+/******************************************************************************
+ * singly linked list macros (non-circular)                                   *
+ *****************************************************************************/
+#define LL_PREPEND(head,add)                                                                   \
+LL_PREPEND2(head,add,next)
+
+#define LL_PREPEND2(head,add,next)                                                             \
+do {                                                                                           \
+(add)->next = head;                                                                          \
+head = add;                                                                                  \
+} while (0)
+
+#define LL_CONCAT(head1,head2)                                                                 \
+LL_CONCAT2(head1,head2,next)
+
+#define LL_CONCAT2(head1,head2,next)                                                           \
+do {                                                                                           \
+LDECLTYPE(head1) _tmp;                                                                       \
+if (head1) {                                                                                 \
+_tmp = head1;                                                                              \
+while (_tmp->next) { _tmp = _tmp->next; }                                                  \
+_tmp->next=(head2);                                                                        \
+} else {                                                                                     \
+(head1)=(head2);                                                                           \
+}                                                                                            \
+} while (0)
+
+#define LL_APPEND(head,add)                                                                    \
+LL_APPEND2(head,add,next)
+
+#define LL_APPEND2(head,add,next)                                                              \
+do {                                                                                           \
+LDECLTYPE(head) _tmp;                                                                        \
+(add)->next=NULL;                                                                            \
+if (head) {                                                                                  \
+_tmp = head;                                                                               \
+while (_tmp->next) { _tmp = _tmp->next; }                                                  \
+_tmp->next=(add);                                                                          \
+} else {                                                                                     \
+(head)=(add);                                                                              \
+}                                                                                            \
+} while (0)
+
+#define LL_DELETE(head,del)                                                                    \
+LL_DELETE2(head,del,next)
+
+#define LL_DELETE2(head,del,next)                                                              \
+do {                                                                                           \
+LDECLTYPE(head) _tmp;                                                                        \
+if ((head) == (del)) {                                                                       \
+(head)=(head)->next;                                                                       \
+} else {                                                                                     \
+_tmp = head;                                                                               \
+while (_tmp->next && (_tmp->next != (del))) {                                              \
+_tmp = _tmp->next;                                                                       \
+}                                                                                          \
+if (_tmp->next) {                                                                          \
+_tmp->next = ((del)->next);                                                              \
+}                                                                                          \
+}                                                                                            \
+} while (0)
+
+/* Here are VS2008 replacements for LL_APPEND and LL_DELETE */
+#define LL_APPEND_VS2008(head,add)                                                             \
+LL_APPEND2_VS2008(head,add,next)
+
+#define LL_APPEND2_VS2008(head,add,next)                                                       \
+do {                                                                                           \
+if (head) {                                                                                  \
+(add)->next = head;     /* use add->next as a temp variable */                             \
+while ((add)->next->next) { (add)->next = (add)->next->next; }                             \
+(add)->next->next=(add);                                                                   \
+} else {                                                                                     \
+(head)=(add);                                                                              \
+}                                                                                            \
+(add)->next=NULL;                                                                            \
+} while (0)
+
+#define LL_DELETE_VS2008(head,del)                                                             \
+LL_DELETE2_VS2008(head,del,next)
+
+#define LL_DELETE2_VS2008(head,del,next)                                                       \
+do {                                                                                           \
+if ((head) == (del)) {                                                                       \
+(head)=(head)->next;                                                                       \
+} else {                                                                                     \
+char *_tmp = (char*)(head);                                                                \
+while ((head)->next && ((head)->next != (del))) {                                          \
+head = (head)->next;                                                                     \
+}                                                                                          \
+if ((head)->next) {                                                                        \
+(head)->next = ((del)->next);                                                            \
+}                                                                                          \
+{                                                                                          \
+char **_head_alias = (char**)&(head);                                                    \
+*_head_alias = _tmp;                                                                     \
+}                                                                                          \
+}                                                                                            \
+} while (0)
+#ifdef NO_DECLTYPE
+#undef LL_APPEND
+#define LL_APPEND LL_APPEND_VS2008
+#undef LL_DELETE
+#define LL_DELETE LL_DELETE_VS2008
+#undef LL_DELETE2
+#define LL_DELETE2 LL_DELETE2_VS2008
+#undef LL_APPEND2
+#define LL_APPEND2 LL_APPEND2_VS2008
+#undef LL_CONCAT /* no LL_CONCAT_VS2008 */
+#undef DL_CONCAT /* no DL_CONCAT_VS2008 */
+#endif
+/* end VS2008 replacements */
+
+#define LL_COUNT(head,el,counter)                                                              \
+LL_COUNT2(head,el,counter,next)                                                            \
+
+#define LL_COUNT2(head,el,counter,next)                                                        \
+{                                                                                              \
+counter = 0;                                                                               \
+LL_FOREACH2(head,el,next){ ++counter; }                                                    \
+}
+
+#define LL_FOREACH(head,el)                                                                    \
+LL_FOREACH2(head,el,next)
+
+#define LL_FOREACH2(head,el,next)                                                              \
+for(el=head;el;el=(el)->next)
+
+#define LL_FOREACH_SAFE(head,el,tmp)                                                           \
+LL_FOREACH_SAFE2(head,el,tmp,next)
+
+#define LL_FOREACH_SAFE2(head,el,tmp,next)                                                     \
+for((el)=(head);(el) && (tmp = (el)->next, 1); (el) = tmp)
+
+#define LL_SEARCH_SCALAR(head,out,field,val)                                                   \
+LL_SEARCH_SCALAR2(head,out,field,val,next)
+
+#define LL_SEARCH_SCALAR2(head,out,field,val,next)                                             \
+do {                                                                                           \
+LL_FOREACH2(head,out,next) {                                                               \
+if ((out)->field == (val)) break;                                                        \
+}                                                                                          \
+} while(0)
+
+#define LL_SEARCH(head,out,elt,cmp)                                                            \
+LL_SEARCH2(head,out,elt,cmp,next)
+
+#define LL_SEARCH2(head,out,elt,cmp,next)                                                      \
+do {                                                                                           \
+LL_FOREACH2(head,out,next) {                                                               \
+if ((cmp(out,elt))==0) break;                                                            \
+}                                                                                          \
+} while(0)
+
+#define LL_REPLACE_ELEM(head, el, add)                                                         \
+do {                                                                                           \
+LDECLTYPE(head) _tmp;                                                                         \
+assert(head != NULL);                                                                         \
+assert(el != NULL);                                                                           \
+assert(add != NULL);                                                                          \
+(add)->next = (el)->next;                                                                     \
+if ((head) == (el)) {                                                                         \
+(head) = (add);                                                                              \
+} else {                                                                                      \
+_tmp = head;                                                                                 \
+while (_tmp->next && (_tmp->next != (el))) {                                                 \
+_tmp = _tmp->next;                                                                          \
+}                                                                                            \
+if (_tmp->next) {                                                                            \
+_tmp->next = (add);                                                                        \
+}                                                                                            \
+}                                                                                             \
+} while (0)
+
+#define LL_PREPEND_ELEM(head, el, add)                                                         \
+do {                                                                                           \
+LDECLTYPE(head) _tmp;                                                                         \
+assert(head != NULL);                                                                         \
+assert(el != NULL);                                                                           \
+assert(add != NULL);                                                                          \
+(add)->next = (el);                                                                           \
+if ((head) == (el)) {                                                                         \
+(head) = (add);                                                                              \
+} else {                                                                                      \
+_tmp = head;                                                                                 \
+while (_tmp->next && (_tmp->next != (el))) {                                                 \
+_tmp = _tmp->next;                                                                          \
+}                                                                                            \
+if (_tmp->next) {                                                                            \
+_tmp->next = (add);                                                                        \
+}                                                                                            \
+}                                                                                             \
+} while (0)                                                                                    \
+
+
+/******************************************************************************
+ * doubly linked list macros (non-circular)                                   *
+ *****************************************************************************/
+#define DL_PREPEND(head,add)                                                                   \
+DL_PREPEND2(head,add,prev,next)
+
+#define DL_PREPEND2(head,add,prev,next)                                                        \
+do {                                                                                           \
+(add)->next = head;                                                                           \
+if (head) {                                                                                   \
+(add)->prev = (head)->prev;                                                                 \
+(head)->prev = (add);                                                                       \
+} else {                                                                                      \
+(add)->prev = (add);                                                                        \
+}                                                                                             \
+(head) = (add);                                                                               \
+} while (0)
+
+#define DL_APPEND(head,add)                                                                    \
+DL_APPEND2(head,add,prev,next)
+
+#define DL_APPEND2(head,add,prev,next)                                                         \
+do {                                                                                           \
+if (head) {                                                                                  \
+(add)->prev = (head)->prev;                                                              \
+(head)->prev->next = (add);                                                              \
+(head)->prev = (add);                                                                    \
+(add)->next = NULL;                                                                      \
+} else {                                                                                     \
+(head)=(add);                                                                            \
+(head)->prev = (head);                                                                   \
+(head)->next = NULL;                                                                     \
+}                                                                                            \
+} while (0)
+
+#define DL_CONCAT(head1,head2)                                                                 \
+DL_CONCAT2(head1,head2,prev,next)
+
+#define DL_CONCAT2(head1,head2,prev,next)                                                      \
+do {                                                                                           \
+LDECLTYPE(head1) _tmp;                                                                       \
+if (head2) {                                                                                 \
+if (head1) {                                                                               \
+_tmp = (head2)->prev;                                                                  \
+(head2)->prev = (head1)->prev;                                                         \
+(head1)->prev->next = (head2);                                                         \
+(head1)->prev = _tmp;                                                                  \
+} else {                                                                                   \
+(head1)=(head2);                                                                       \
+}                                                                                          \
+}                                                                                            \
+} while (0)
+
+#define DL_DELETE(head,del)                                                                    \
+DL_DELETE2(head,del,prev,next)
+
+#define DL_DELETE2(head,del,prev,next)                                                         \
+do {                                                                                           \
+assert((del)->prev != NULL);                                                                 \
+if ((del)->prev == (del)) {                                                                  \
+(head)=NULL;                                                                             \
+} else if ((del)==(head)) {                                                                  \
+(del)->next->prev = (del)->prev;                                                         \
+(head) = (del)->next;                                                                    \
+} else {                                                                                     \
+(del)->prev->next = (del)->next;                                                         \
+if ((del)->next) {                                                                       \
+(del)->next->prev = (del)->prev;                                                     \
+} else {                                                                                 \
+(head)->prev = (del)->prev;                                                          \
+}                                                                                        \
+}                                                                                            \
+} while (0)
+
+#define DL_COUNT(head,el,counter)                                                              \
+DL_COUNT2(head,el,counter,next)                                                            \
+
+#define DL_COUNT2(head,el,counter,next)                                                        \
+{                                                                                              \
+counter = 0;                                                                               \
+DL_FOREACH2(head,el,next){ ++counter; }                                                    \
+}
+
+#define DL_FOREACH(head,el)                                                                    \
+DL_FOREACH2(head,el,next)
+
+#define DL_FOREACH2(head,el,next)                                                              \
+for(el=head;el;el=(el)->next)
+
+/* this version is safe for deleting the elements during iteration */
+#define DL_FOREACH_SAFE(head,el,tmp)                                                           \
+DL_FOREACH_SAFE2(head,el,tmp,next)
+
+#define DL_FOREACH_SAFE2(head,el,tmp,next)                                                     \
+for((el)=(head);(el) && (tmp = (el)->next, 1); (el) = tmp)
+
+/* these are identical to their singly-linked list counterparts */
+#define DL_SEARCH_SCALAR LL_SEARCH_SCALAR
+#define DL_SEARCH LL_SEARCH
+#define DL_SEARCH_SCALAR2 LL_SEARCH_SCALAR2
+#define DL_SEARCH2 LL_SEARCH2
+
+#define DL_REPLACE_ELEM(head, el, add)                                                         \
+do {                                                                                           \
+assert(head != NULL);                                                                         \
+assert(el != NULL);                                                                           \
+assert(add != NULL);                                                                          \
+if ((head) == (el)) {                                                                         \
+(head) = (add);                                                                              \
+(add)->next = (el)->next;                                                                    \
+if ((el)->next == NULL) {                                                                    \
+(add)->prev = (add);                                                                        \
+} else {                                                                                     \
+(add)->prev = (el)->prev;                                                                   \
+(add)->next->prev = (add);                                                                  \
+}                                                                                            \
+} else {                                                                                      \
+(add)->next = (el)->next;                                                                    \
+(add)->prev = (el)->prev;                                                                    \
+(add)->prev->next = (add);                                                                   \
+if ((el)->next == NULL) {                                                                    \
+(head)->prev = (add);                                                                       \
+} else {                                                                                     \
+(add)->next->prev = (add);                                                                  \
+}                                                                                            \
+}                                                                                             \
+} while (0)
+
+#define DL_PREPEND_ELEM(head, el, add)                                                         \
+do {                                                                                           \
+assert(head != NULL);                                                                         \
+assert(el != NULL);                                                                           \
+assert(add != NULL);                                                                          \
+(add)->next = (el);                                                                           \
+(add)->prev = (el)->prev;                                                                     \
+(el)->prev = (add);                                                                           \
+if ((head) == (el)) {                                                                         \
+(head) = (add);                                                                              \
+} else {                                                                                      \
+(add)->prev->next = (add);                                                                   \
+}                                                                                             \
+} while (0)                                                                                    \
+
+
+/******************************************************************************
+ * circular doubly linked list macros                                         *
+ *****************************************************************************/
+#define CDL_PREPEND(head,add)                                                                  \
+CDL_PREPEND2(head,add,prev,next)
+
+#define CDL_PREPEND2(head,add,prev,next)                                                       \
+do {                                                                                           \
+if (head) {                                                                                   \
+(add)->prev = (head)->prev;                                                                 \
+(add)->next = (head);                                                                       \
+(head)->prev = (add);                                                                       \
+(add)->prev->next = (add);                                                                  \
+} else {                                                                                      \
+(add)->prev = (add);                                                                        \
+(add)->next = (add);                                                                        \
+}                                                                                             \
+(head)=(add);                                                                                  \
+} while (0)
+
+#define CDL_DELETE(head,del)                                                                   \
+CDL_DELETE2(head,del,prev,next)
+
+#define CDL_DELETE2(head,del,prev,next)                                                        \
+do {                                                                                           \
+if ( ((head)==(del)) && ((head)->next == (head))) {                                          \
+(head) = 0L;                                                                             \
+} else {                                                                                     \
+(del)->next->prev = (del)->prev;                                                          \
+(del)->prev->next = (del)->next;                                                          \
+if ((del) == (head)) (head)=(del)->next;                                                  \
+}                                                                                            \
+} while (0)
+
+#define CDL_COUNT(head,el,counter)                                                             \
+CDL_COUNT2(head,el,counter,next)                                                           \
+
+#define CDL_COUNT2(head, el, counter,next)                                                     \
+{                                                                                              \
+counter = 0;                                                                               \
+CDL_FOREACH2(head,el,next){ ++counter; }                                                   \
+}
+
+#define CDL_FOREACH(head,el)                                                                   \
+CDL_FOREACH2(head,el,next)
+
+#define CDL_FOREACH2(head,el,next)                                                             \
+for(el=head;el;el=((el)->next==head ? 0L : (el)->next))
+
+#define CDL_FOREACH_SAFE(head,el,tmp1,tmp2)                                                    \
+CDL_FOREACH_SAFE2(head,el,tmp1,tmp2,prev,next)
+
+#define CDL_FOREACH_SAFE2(head,el,tmp1,tmp2,prev,next)                                         \
+for((el)=(head), ((tmp1)=(head)?((head)->prev):NULL);                                        \
+(el) && ((tmp2)=(el)->next, 1);                                                          \
+((el) = (((el)==(tmp1)) ? 0L : (tmp2))))
+
+#define CDL_SEARCH_SCALAR(head,out,field,val)                                                  \
+CDL_SEARCH_SCALAR2(head,out,field,val,next)
+
+#define CDL_SEARCH_SCALAR2(head,out,field,val,next)                                            \
+do {                                                                                           \
+CDL_FOREACH2(head,out,next) {                                                              \
+if ((out)->field == (val)) break;                                                        \
+}                                                                                          \
+} while(0)
+
+#define CDL_SEARCH(head,out,elt,cmp)                                                           \
+CDL_SEARCH2(head,out,elt,cmp,next)
+
+#define CDL_SEARCH2(head,out,elt,cmp,next)                                                     \
+do {                                                                                           \
+CDL_FOREACH2(head,out,next) {                                                              \
+if ((cmp(out,elt))==0) break;                                                            \
+}                                                                                          \
+} while(0)
+
+#define CDL_REPLACE_ELEM(head, el, add)                                                        \
+do {                                                                                           \
+assert(head != NULL);                                                                         \
+assert(el != NULL);                                                                           \
+assert(add != NULL);                                                                          \
+if ((el)->next == (el)) {                                                                     \
+(add)->next = (add);                                                                         \
+(add)->prev = (add);                                                                         \
+(head) = (add);                                                                              \
+} else {                                                                                      \
+(add)->next = (el)->next;                                                                    \
+(add)->prev = (el)->prev;                                                                    \
+(add)->next->prev = (add);                                                                   \
+(add)->prev->next = (add);                                                                   \
+if ((head) == (el)) {                                                                        \
+(head) = (add);                                                                             \
+}                                                                                            \
+}                                                                                             \
+} while (0)
+
+#define CDL_PREPEND_ELEM(head, el, add)                                                        \
+do {                                                                                           \
+assert(head != NULL);                                                                         \
+assert(el != NULL);                                                                           \
+assert(add != NULL);                                                                          \
+(add)->next = (el);                                                                           \
+(add)->prev = (el)->prev;                                                                     \
+(el)->prev = (add);                                                                           \
+(add)->prev->next = (add);                                                                    \
+if ((head) == (el)) {                                                                         \
+(head) = (add);                                                                              \
+}                                                                                             \
+} while (0)                                                                                    \
+
+#endif /* UTLIST_H */
diff --git a/src/cc/lotto.cpp b/src/cc/lotto.cpp
index e20cb3505..7129bfcd8 100644
--- a/src/cc/lotto.cpp
+++ b/src/cc/lotto.cpp
@@ -17,6 +17,48 @@
 #include "../txmempool.h"
 
 /*
+ A blockchain lotto has the problem of generating the deterministic random numbers needed to get a winner in a way that doesnt allow cheating. If we save the entropy for later publishing and display the hash of the entropy, it is true that the players wont know what the entropy value is, however the creator of the lotto funds will be able to know and simply create a winning ticket when the jackpot is large enough.
+ 
+ We also need to avoid chain reorgs from disclosing the entropy and then allowing people to submit a winning ticket calculated based on the disclosed entropy (see attack vector in dice.cpp)
+ 
+ As usual it needs to be provably fair and random
+ 
+ The solution is for everybody to post the hash of their entropy when purchasing tickets. Then at the time of the drawing, nodes would post their entropy over an N block period to avoid censorship attack. After the N block period, then we have valid entropy that we know was locked in prior to the start of the N blocks and that nobody would have been able to know ahead of time the final entropy value.
+ 
+ As long as one node submits a high entropy value, then just by combining all the submissions together, we get the drawing's entropy value. Given that, the usual process can determine if there was a winner at the specified odds. In fact, all the nodes are able to determine exactly how many winners there were and whether to validate 1/w payouts to the w winners or rollover the jackpot to the next drawing.
+ 
+ To remove the need for an autopayout, the winning node(s) would need to submit a 1/w payout tx, this would be able to be done at any time and the winner does not have to have submitted proof of hentropy. In order to prevent a player from opportunistically withholding their entropy, the lotto creator will post the original proof of hentropy after the N block player submission period. This masks to all the players the final value of entropy.
+ 
+ Attack vector: the lotto creator can have many player tickets in reserve all with their entropy ready to submit, but based on the actual submissions, find the one which gives him the best outcome. since all the player submissions will be known via mempool, along with the original hentropy. However the lotto creator would have to mine the final block in order to know the order of the player tickets.
+ 
+ Thinking about this evil miner attack, it seems pretty bad, so a totally new approach is needed. Preferably with a simple enough protocol. Let us remove any special knowledge by the lotto creator, so like the faucet, it seems just that there is a single lotto for a chain.
+ 
+ >>>>>>>>>>>> second iteration
+ 
+ What we need is something that gives each ticket an equal chance at the jackpot, without allowing miner or relayer to gain an advantage. ultimately the jackpot payout tx needs to be confirmed, so there needs to be some number of blocks to make a claim to avoid censorship attack. If onchain entropy is needed, then it should be reduced to 1 bit per block to reduce the grinding that is possible. This does mean a block miner for the last bit of entropy can double their chances at winning, but the alternative is to have an external source of entropy, which creates its own set of issues like what prevents the nodes getting the external entropy from cheating?
+ 
+ Conveniently the lotto mechanics are similar to a PoS staking, so it can be based on everybody trying to stake a single lotto jackpot.
+ 
+ The calculation would need to be based on the payout address and utxosize, so relayers cant intercept it to steal the jackpot.
+ 
+ each jackpot would effectively restart the lotto
+ 
+ the funds from new lotto tickets can be spent by the jackpot, but those tickets can still win the new jackpot
+ 
+ each set of tickets (utxo) would become eligible to claim the jackpot after some time is elapsed so the entropy for that utxo can be obtained. [6 bits * 32 + 1 bit * 16] 48 blocks
+ 
+It is possible to have a jackpot but miss out on it due to not claiming it. To minimize the effect from this, each ticket would have one chance to win, which can be calculated and a jackpot claim submitted just once.
+ 
+ in order to randomize the timing of claim, a txid PoW similar to faucetget will maximize the chance of only a single jackpot txid that can propagate throughout the mempools, which will prevent the second one broadcast. Granted the mining node can override this if they also have a winning ticket, but assuming the PoS lottery makes it unlikely for two winners in a single block, this is not a big issue.
+ 
+ In order to adapt the difficulty of winning the lotto, but not requiring recalculating all past tickets, as new lotto tickets are sold without a jackpot, it needs to become easier to win. Basically as the lotto jackpot gets bigger and bigger, it keeps getting easier to win! This convergence will avoid having unwinnable jackpots.
+ 
+ rpc calls
+ lottoinfo
+ lottotickets <numtickets>
+ lottostatus
+ lottowinner tickethash ticketid
+
 */
 
 // start of consensus code
@@ -62,10 +104,10 @@ bool LottoExactAmounts(struct CCcontract_info *cp,Eval* eval,const CTransaction
         if ( (assetoshis= IsLottovout(cp,tx,i)) != 0 )
             outputs += assetoshis;
     }
-    if ( inputs != outputs+COIN+txfee )
+    if ( inputs != outputs+txfee )
     {
         fprintf(stderr,"inputs %llu vs outputs %llu\n",(long long)inputs,(long long)outputs);
-        return eval->Invalid("mismatched inputs != outputs + COIN + txfee");
+        return eval->Invalid("mismatched inputs != outputs + txfee");
     }
     else return(true);
 }
@@ -128,7 +170,7 @@ int64_t AddLottoInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPubK
     {
         txid = it->first.txhash;
         // prevent dup
-        if ( it->second.satoshis < 1000000 )
+        if ( it->second.satoshis < COIN )
             continue;
         if ( GetTransaction(txid,vintx,hashBlock,false) != 0 )
         {
@@ -147,20 +189,128 @@ int64_t AddLottoInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPubK
     return(totalinputs);
 }
 
-std::string LottoTicket(uint64_t txfee,int64_t numtickets)
+uint8_t DecodeLottoFundingOpRet(const CScript &scriptPubKey,uint64_t &sbits,int32_t ticketsize,int32_t odds,int32_t firstheight,int32_t period,uint256 hentropy)
 {
-    CMutableTransaction mtx; CPubKey mypk,Lottopk; CScript opret; int64_t inputs,CCchange=0,nValue=COIN; struct CCcontract_info *cp,C;
+    std::vector<uint8_t> vopret; uint8_t *script,e,f;
+    GetOpReturnData(scriptPubKey, vopret);
+    script = (uint8_t *)vopret.data();
+    if ( vopret.size() > 2 && E_UNMARSHAL(vopret,ss >> e; ss >> f; ss >> sbits; ss >> ticketsize; ss >> odds; ss >> firstheight; ss >> period; ss >> hentropy) != 0 )
+    {
+        if ( e == EVAL_LOTTO && f == 'F' )
+            return(f);
+    }
+    return(0);
+}
+
+int64_t LottoPlanFunds(uint64_t refsbits,struct CCcontract_info *cp,CPubKey pk,uint256 reffundingtxid)
+{
+    char coinaddr[64]; uint64_t sbits; int64_t nValue,lockedfunds; uint256 txid,hashBlock,fundingtxid; CTransaction tx; int32_t vout; uint8_t funcid;
+    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
+    lockedfunds = 0;
+    GetCCaddress(cp,coinaddr,pk);
+    SetCCunspents(unspentOutputs,coinaddr);
+    for (std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> >::const_iterator it=unspentOutputs.begin(); it!=unspentOutputs.end(); it++)
+    {
+        txid = it->first.txhash;
+        vout = (int32_t)it->first.index;
+        if ( GetTransaction(txid,tx,hashBlock,false) != 0 && tx.vout[vout].scriptPubKey.IsPayToCryptoCondition() != 0 )
+        {
+            // need to implement this! if ( (funcid= DecodeLottoOpRet(txid,tx.vout[tx.vout.size()-1].scriptPubKey,sbits,fundingtxid)) == 'F' || funcid == 'T' )
+            {
+                if ( refsbits == sbits && (funcid == 'F' && reffundingtxid == txid) || reffundingtxid == fundingtxid )
+                {
+                    if ( (nValue= IsLottovout(cp,tx,vout)) > 0 )
+                        lockedfunds += nValue;
+                    else fprintf(stderr,"refsbits.%llx sbits.%llx nValue %.8f\n",(long long)refsbits,(long long)sbits,(double)nValue/COIN);
+                } //else fprintf(stderr,"else case\n");
+            } //else fprintf(stderr,"funcid.%d %c skipped %.8f\n",funcid,funcid,(double)tx.vout[vout].nValue/COIN);
+        }
+    }
+    return(lockedfunds);
+}
+
+UniValue LottoInfo(uint256 lottoid)
+{
+    UniValue result(UniValue::VOBJ); uint256 hashBlock,hentropy; CTransaction vintx; uint64_t lockedfunds,sbits; int32_t ticketsize,odds,firstheight,period; CPubKey lottopk; struct CCcontract_info *cp,C; char str[67],numstr[65];
+    if ( GetTransaction(lottoid,vintx,hashBlock,false) == 0 )
+    {
+        fprintf(stderr,"cant find lottoid\n");
+        result.push_back(Pair("result","error"));
+        result.push_back(Pair("error","cant find lottoid"));
+        return(result);
+    }
+    if ( vintx.vout.size() > 0 && DecodeLottoFundingOpRet(vintx.vout[vintx.vout.size()-1].scriptPubKey,sbits,ticketsize,odds,firstheight,period,hentropy) == 0 )
+    {
+        fprintf(stderr,"lottoid isnt lotto creation txid\n");
+        result.push_back(Pair("result","error"));
+        result.push_back(Pair("error","lottoid isnt lotto creation txid"));
+        return(result);
+    }
+    result.push_back(Pair("result","success"));
+    result.push_back(Pair("lottoid",uint256_str(str,lottoid)));
+    unstringbits(str,sbits);
+    result.push_back(Pair("name",str));
+    result.push_back(Pair("sbits",sbits));
+    result.push_back(Pair("ticketsize",ticketsize));
+    result.push_back(Pair("odds",odds));
+    cp = CCinit(&C,EVAL_LOTTO);
+    lottopk = GetUnspendable(cp,0);
+    lockedfunds = LottoPlanFunds(sbits,cp,lottopk,lottoid);
+    sprintf(numstr,"%.8f",(double)lockedfunds/COIN);
+    result.push_back(Pair("jackpot",numstr));
+    return(result);
+}
+
+UniValue LottoList()
+{
+    UniValue result(UniValue::VARR); std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex; struct CCcontract_info *cp,C; uint256 txid,hashBlock,hentropy; CTransaction vintx; uint64_t sbits; int32_t ticketsize,odds,firstheight,period; char str[65];
+    cp = CCinit(&C,EVAL_LOTTO);
+    SetCCtxids(addressIndex,cp->normaladdr);
+    for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=addressIndex.begin(); it!=addressIndex.end(); it++)
+    {
+        txid = it->first.txhash;
+        if ( GetTransaction(txid,vintx,hashBlock,false) != 0 )
+        {
+            if ( vintx.vout.size() > 0 && DecodeLottoFundingOpRet(vintx.vout[vintx.vout.size()-1].scriptPubKey,sbits,ticketsize,odds,firstheight,period,hentropy) == 'F' )
+            {
+                result.push_back(uint256_str(str,txid));
+            }
+        }
+    }
+    return(result);
+}
+
+std::string LottoCreate(uint64_t txfee,char *planstr,int64_t funding,int32_t ticketsize,int32_t odds,int32_t firstheight,int32_t period)
+{
+    CMutableTransaction mtx; uint256 entropy,hentropy; CPubKey mypk,lottopk; uint64_t sbits; int64_t inputs,CCchange=0,nValue=COIN; struct CCcontract_info *cp,C;
     cp = CCinit(&C,EVAL_LOTTO);
     if ( txfee == 0 )
         txfee = 10000;
-    Lottopk = GetUnspendable(cp,0);
+    lottopk = GetUnspendable(cp,0);
     mypk = pubkey2pk(Mypubkey());
-    if ( (inputs= AddLottoInputs(cp,mtx,Lottopk,nValue+txfee,60)) > 0 )
+    sbits = stringbits(planstr);
+    if ( AddNormalinputs(mtx,mypk,funding+txfee,60) > 0 )
+    {
+        hentropy = DiceHashEntropy(entropy,mtx.vin[0].prevout.hash);
+        mtx.vout.push_back(MakeCC1vout(EVAL_LOTTO,funding,lottopk));
+        return(FinalizeCCTx(0,cp,mtx,mypk,txfee,CScript() << OP_RETURN << E_MARSHAL(ss << (uint8_t)EVAL_LOTTO << (uint8_t)'F' << sbits << ticketsize << odds << firstheight << period << hentropy)));
+    }
+}
+
+std::string LottoTicket(uint64_t txfee,uint256 lottoid,int64_t numtickets)
+{
+    CMutableTransaction mtx; CPubKey mypk,lottopk; CScript opret; int64_t inputs,CCchange=0,nValue=COIN; struct CCcontract_info *cp,C;
+    cp = CCinit(&C,EVAL_LOTTO);
+    if ( txfee == 0 )
+        txfee = 10000;
+    lottopk = GetUnspendable(cp,0);
+    mypk = pubkey2pk(Mypubkey());
+    if ( (inputs= AddLottoInputs(cp,mtx,lottopk,nValue+txfee,60)) > 0 )
     {
         if ( inputs > nValue )
             CCchange = (inputs - nValue - txfee);
         if ( CCchange != 0 )
-            mtx.vout.push_back(MakeCC1vout(EVAL_LOTTO,CCchange,Lottopk));
+            mtx.vout.push_back(MakeCC1vout(EVAL_LOTTO,CCchange,lottopk));
         mtx.vout.push_back(CTxOut(nValue,CScript() << ParseHex(HexStr(mypk)) << OP_CHECKSIG));
         return(FinalizeCCTx(-1LL,cp,mtx,mypk,txfee,opret));
     } else fprintf(stderr,"cant find Lotto inputs\n");
@@ -169,15 +319,15 @@ std::string LottoTicket(uint64_t txfee,int64_t numtickets)
 
 std::string LottoWinner(uint64_t txfee)
 {
-    CMutableTransaction mtx; CPubKey mypk,Lottopk; int64_t winnings = 0; CScript opret; struct CCcontract_info *cp,C;
+    CMutableTransaction mtx; CPubKey mypk,lottopk; int64_t winnings = 0; CScript opret; struct CCcontract_info *cp,C;
     cp = CCinit(&C,EVAL_LOTTO);
     if ( txfee == 0 )
         txfee = 10000;
     mypk = pubkey2pk(Mypubkey());
-    Lottopk = GetUnspendable(cp,0);
+    lottopk = GetUnspendable(cp,0);
     if ( AddNormalinputs(mtx,mypk,txfee,64) > 0 )
     {
-        mtx.vout.push_back(MakeCC1vout(EVAL_LOTTO,winnings,Lottopk));
+        mtx.vout.push_back(MakeCC1vout(EVAL_LOTTO,winnings,lottopk));
         return(FinalizeCCTx(0,cp,mtx,mypk,txfee,opret));
     }
     return("");
diff --git a/src/cc/oracles.cpp b/src/cc/oracles.cpp
new file mode 100644
index 000000000..a9554b077
--- /dev/null
+++ b/src/cc/oracles.cpp
@@ -0,0 +1,858 @@
+/******************************************************************************
+ * Copyright © 2014-2018 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+
+#include "CCOracles.h"
+#include <secp256k1.h>
+
+/*
+ An oracles CC has the purpose of converting offchain data into onchain data
+ simplest would just be to have a pubkey(s) that are trusted to provide such data, but this wont need to have a CC involved at all and can just be done by convention
+ 
+ That begs the question, "what would an oracles CC do?"
+ A couple of things come to mind, ie. payments to oracles for future offchain data and maybe some sort of dispute/censoring ability
+ 
+ first step is to define the data that the oracle is providing. A simple name:description tx can be created to define the name and description of the oracle data.
+ linked to this txid would be two types of transactions:
+    a) oracle providers
+    b) oracle data users
+ 
+ In order to be resistant to sybil attacks, the feedback mechanism needs to have a cost. combining with the idea of payments for data, the oracle providers will be ranked by actual payments made to each oracle for each data type.
+ 
+ Implementation notes:
+  In order to maintain good performance even under heavy usage, special marker utxo are used. Actually a pair of them. When a provider registers to be a data provider, a special unspendable normal output is created to allow for quick scanning. Since the marker is based on the oracletxid, it becomes a single address where all the providers can be found. 
+ 
+  A convention is used so that the datafee can be changed by registering again. it is assumed that there wont be too many of these datafee changes. if more than one from the same provider happens in the same block, the lower price is used.
+ 
+  The other efficiency issue is finding the most recent data point. We want to create a linked list of all data points, going back to the first one. In order to make this efficient, a special and unique per provider/oracletxid baton utxo is used. This should have exactly one utxo, so the search would be a direct lookup and it is passed on from one data point to the next. There is some small chance that the baton utxo is spent in a non-data transaction, so provision is made to allow for recreating a baton utxo in case it isnt found. The baton utxo is a convenience and doesnt affect validation
+ 
+ Required transactions:
+ 0) create oracle description -> just needs to create txid for oracle data
+ 1) register as oracle data provider with price -> become a registered oracle data provider
+ 2) pay provider for N oracle data points -> lock funds for oracle provider
+ 3) publish oracle data point -> publish data and collect payment
+ 
+ The format string is a set of chars with the following meaning:
+  's' -> <256 char string
+  'S' -> <65536 char string
+  'd' -> <256 binary data
+  'D' -> <65536 binary data
+  'c' -> 1 byte signed little endian number, 'C' unsigned
+  't' -> 2 byte signed little endian number, 'T' unsigned
+  'i' -> 4 byte signed little endian number, 'I' unsigned
+  'l' -> 8 byte signed little endian number, 'L' unsigned
+  'h' -> 32 byte hash
+ 
+ create:
+ vins.*: normal inputs
+ vout.0: txfee tag to oracle normal address
+ vout.1: change, if any
+ vout.n-1: opreturn with name and description and format for data
+ 
+ register:
+ vins.*: normal inputs
+ vout.0: txfee tag to normal marker address
+ vout.1: baton CC utxo
+ vout.2: change, if any
+ vout.n-1: opreturn with oracletxid, pubkey and price per data point
+ 
+ subscribe:
+ vins.*: normal inputs
+ vout.0: subscription fee to publishers CC address
+ vout.1: change, if any
+ vout.n-1: opreturn with oracletxid, registered provider's pubkey, amount
+ 
+ data:
+ vin.0: normal input
+ vin.1: baton CC utxo (most of the time)
+ vin.2+: subscription or data vout.0
+ vout.0: change to publishers CC address
+ vout.1: baton CC utxo
+ vout.2: payment for dataprovider
+ vout.3: change, if any
+ vout.n-1: opreturn with oracletxid, prevbatontxid and data in proper format
+ 
+ data (without payment) this is not needed as publisher can pay themselves!
+ vin.0: normal input
+ vin.1: baton CC utxo
+ vout.0: txfee to publishers normal address
+ vout.1: baton CC utxo
+ vout.2: change, if any
+ vout.n-1: opreturn with oracletxid, prevbatontxid and data in proper format
+
+*/
+
+// start of consensus code
+
+
+CScript EncodeOraclesCreateOpRet(uint8_t funcid,std::string name,std::string description,std::string format)
+{
+    CScript opret; uint8_t evalcode = EVAL_ORACLES;
+    opret << OP_RETURN << E_MARSHAL(ss << evalcode << funcid << name << format << description);
+    return(opret);
+}
+
+uint8_t DecodeOraclesCreateOpRet(const CScript &scriptPubKey,std::string &name,std::string &description,std::string &format)
+{
+    std::vector<uint8_t> vopret; uint8_t *script,e,f,funcid;
+    GetOpReturnData(scriptPubKey,vopret);
+    script = (uint8_t *)vopret.data();
+    if ( script[0] == EVAL_ORACLES )
+    {
+        if ( script[1] == 'C' )
+        {
+            if ( E_UNMARSHAL(vopret,ss >> e; ss >> f; ss >> name; ss >> format; ss >> description) != 0 )
+            {
+                return(script[1]);
+            } else fprintf(stderr,"DecodeOraclesCreateOpRet unmarshal error for C\n");
+        }
+    }
+    return(0);
+}
+
+CScript EncodeOraclesOpRet(uint8_t funcid,uint256 oracletxid,CPubKey pk,int64_t num)
+{
+    CScript opret; uint8_t evalcode = EVAL_ORACLES;
+    opret << OP_RETURN << E_MARSHAL(ss << evalcode << funcid << oracletxid << pk << num);
+    return(opret);
+}
+
+uint8_t DecodeOraclesOpRet(const CScript &scriptPubKey,uint256 &oracletxid,CPubKey &pk,int64_t &num)
+{
+    std::vector<uint8_t> vopret; uint8_t *script,e,f;
+    GetOpReturnData(scriptPubKey,vopret);
+    script = (uint8_t *)vopret.data();
+    if ( vopret.size() > 1 && E_UNMARSHAL(vopret,ss >> e; ss >> f; ss >> oracletxid; ss >> pk; ss >> num) != 0 )
+    {
+        if ( e == EVAL_ORACLES && (f == 'R' || f == 'S') )
+            return(f);
+    }
+    return(0);
+}
+
+CScript EncodeOraclesData(uint8_t funcid,uint256 oracletxid,uint256 batontxid,CPubKey pk,std::vector <uint8_t>data)
+{
+    CScript opret; uint8_t evalcode = EVAL_ORACLES;
+    opret << OP_RETURN << E_MARSHAL(ss << evalcode << funcid << oracletxid << batontxid << pk << data);
+    return(opret);
+}
+
+uint8_t DecodeOraclesData(const CScript &scriptPubKey,uint256 &oracletxid,uint256 &batontxid,CPubKey &pk,std::vector <uint8_t>&data)
+{
+    std::vector<uint8_t> vopret; uint8_t *script,e,f;
+    GetOpReturnData(scriptPubKey,vopret);
+    script = (uint8_t *)vopret.data();
+    if ( vopret.size() > 1 && E_UNMARSHAL(vopret,ss >> e; ss >> f; ss >> oracletxid; ss >> batontxid; ss >> pk; ss >> data) != 0 )
+    {
+        if ( e == EVAL_ORACLES && f == 'D' )
+            return(f);
+    }
+    return(0);
+}
+
+CPubKey OracleBatonPk(char *batonaddr,struct CCcontract_info *cp)
+{
+    static secp256k1_context *ctx;
+    size_t clen = CPubKey::PUBLIC_KEY_SIZE;
+    secp256k1_pubkey pubkey; CPubKey batonpk; uint8_t priv[32]; int32_t i;
+    if ( ctx == 0 )
+        ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN);
+    Myprivkey(priv);
+    for (i=0; i<32; i++)
+        cp->unspendablepriv2[i] = (priv[i] ^ cp->CCpriv[i]);
+    while ( secp256k1_ec_seckey_verify(ctx,cp->unspendablepriv2) == 0 )
+    {
+        for (i=0; i<32; i++)
+            fprintf(stderr,"%02x",cp->unspendablepriv2[i]);
+        fprintf(stderr," invalid privkey\n");
+        if ( secp256k1_ec_privkey_tweak_add(ctx,cp->unspendablepriv2,priv) != 0 )
+            break;
+    }
+    if ( secp256k1_ec_pubkey_create(ctx,&pubkey,cp->unspendablepriv2) != 0 )
+    {
+        secp256k1_ec_pubkey_serialize(ctx,(unsigned char*)batonpk.begin(),&clen,&pubkey,SECP256K1_EC_COMPRESSED);
+        cp->unspendablepk2 = batonpk;
+        Getscriptaddress(batonaddr,MakeCC1vout(cp->evalcode,0,batonpk).scriptPubKey);
+        //fprintf(stderr,"batonpk.(%s) -> %s\n",(char *)HexStr(batonpk).c_str(),batonaddr);
+        strcpy(cp->unspendableaddr2,batonaddr);
+    } else fprintf(stderr,"error creating pubkey\n");
+    return(batonpk);
+}
+
+int64_t OracleCurrentDatafee(uint256 reforacletxid,char *markeraddr,CPubKey publisher)
+{
+    uint256 txid,oracletxid,hashBlock; int64_t datafee=0,dfee; int32_t dheight=0,vout,height,numvouts; CTransaction tx; CPubKey pk;
+    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
+    SetCCunspents(unspentOutputs,markeraddr);
+    for (std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> >::const_iterator it=unspentOutputs.begin(); it!=unspentOutputs.end(); it++)
+    {
+        txid = it->first.txhash;
+        vout = (int32_t)it->first.index;
+        height = (int32_t)it->second.blockHeight;
+        if ( myGetTransaction(txid,tx,hashBlock) != 0 && (numvouts= tx.vout.size()) > 0 )
+        {
+            if ( DecodeOraclesOpRet(tx.vout[numvouts-1].scriptPubKey,oracletxid,pk,dfee) == 'R' )
+            {
+                if ( oracletxid == reforacletxid && pk == publisher )
+                {
+                    if ( height > dheight || (height == dheight && dfee < datafee) )
+                    {
+                        dheight = height;
+                        datafee = dfee;
+                        if ( 0 && dheight != 0 )
+                            fprintf(stderr,"set datafee %.8f height.%d\n",(double)datafee/COIN,height);
+                    }
+                }
+            }
+        }
+    }
+    return(datafee);
+}
+
+int64_t OracleDatafee(CScript &scriptPubKey,uint256 oracletxid,CPubKey publisher)
+{
+    CTransaction oracletx; char markeraddr[64]; CPubKey markerpubkey; uint8_t buf33[33]; uint256 hashBlock; std::string name,description,format; int32_t numvouts; int64_t datafee = 0;
+    if ( myGetTransaction(oracletxid,oracletx,hashBlock) != 0 && (numvouts= oracletx.vout.size()) > 0 )
+    {
+        if ( DecodeOraclesCreateOpRet(oracletx.vout[numvouts-1].scriptPubKey,name,description,format) == 'C' )
+        {
+            buf33[0] = 0x02;
+            endiancpy(&buf33[1],(uint8_t *)&oracletxid,32);
+            markerpubkey = buf2pk(buf33);
+            scriptPubKey = CScript() << ParseHex(HexStr(markerpubkey)) << OP_CHECKSIG;
+            Getscriptaddress(markeraddr,scriptPubKey);
+            datafee = OracleCurrentDatafee(oracletxid,markeraddr,publisher);
+        }
+    }
+    return(datafee);
+}
+
+uint256 OracleBatonUtxo(uint64_t txfee,struct CCcontract_info *cp,uint256 reforacletxid,char *batonaddr,CPubKey publisher,std::vector <uint8_t> &dataarg)
+{
+    uint256 txid,oracletxid,hashBlock,btxid,batontxid = zeroid; int64_t dfee; int32_t dheight=0,vout,height,numvouts; CTransaction tx; CPubKey pk; uint8_t *ptr; std::vector<uint8_t> vopret,data;
+    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
+    SetCCunspents(unspentOutputs,batonaddr);
+    for (std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> >::const_iterator it=unspentOutputs.begin(); it!=unspentOutputs.end(); it++)
+    {
+        txid = it->first.txhash;
+        vout = (int32_t)it->first.index;
+        height = (int32_t)it->second.blockHeight;
+        if ( it->second.satoshis != txfee )
+        {
+            fprintf(stderr,"it->second.satoshis %llu != %llu txfee\n",(long long)it->second.satoshis,(long long)txfee);
+            continue;
+        }
+        if ( myGetTransaction(txid,tx,hashBlock) != 0 && (numvouts= tx.vout.size()) > 0 )
+        {
+            GetOpReturnData(tx.vout[numvouts-1].scriptPubKey,vopret);
+            if ( vopret.size() > 2 )
+            {
+                ptr = (uint8_t *)vopret.data();
+                if ( (ptr[1] == 'D' && DecodeOraclesData(tx.vout[numvouts-1].scriptPubKey,oracletxid,btxid,pk,data) == 'D') || (ptr[1] == 'R' && DecodeOraclesOpRet(tx.vout[numvouts-1].scriptPubKey,oracletxid,pk,dfee) == 'R') )
+                {
+                    if ( oracletxid == reforacletxid && pk == publisher )
+                    {
+                        if ( height > dheight )
+                        {
+                            dheight = height;
+                            batontxid = txid;
+                            if ( ptr[1] == 'D' )
+                                dataarg = data;
+                            //char str[65]; fprintf(stderr,"set batontxid %s height.%d\n",uint256_str(str,batontxid),height);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return(batontxid);
+}
+
+int32_t oracle_format(uint256 *hashp,int64_t *valp,char *str,uint8_t fmt,uint8_t *data,int32_t offset,int32_t datalen)
+{
+    char _str[65]; int32_t sflag = 0,i,val32,len = 0,slen = 0,dlen = 0; uint32_t uval32; uint16_t uval16; int16_t val16; int64_t val = 0; uint64_t uval = 0;
+    *valp = 0;
+    *hashp = zeroid;
+    if ( str != 0 )
+        str[0] = 0;
+    switch ( fmt )
+    {
+        case 's': slen = data[offset++]; break;
+        case 'S': slen = data[offset++]; slen |= ((int32_t)data[offset++] << 8); break;
+        case 'd': dlen = data[offset++]; break;
+        case 'D': dlen = data[offset++]; dlen |= ((int32_t)data[offset++] << 8); break;
+        case 'c': len = 1; sflag = 1; break;
+        case 'C': len = 1; break;
+        case 't': len = 2; sflag = 1; break;
+        case 'T': len = 2; break;
+        case 'i': len = 4; sflag = 1; break;
+        case 'I': len = 4; break;
+        case 'l': len = 8; sflag = 1; break;
+        case 'L': len = 8; break;
+        case 'h': len = 32; break;
+        default: return(-1); break;
+    }
+    if ( slen != 0 )
+    {
+        if ( str != 0 )
+        {
+            if ( slen < IGUANA_MAXSCRIPTSIZE && offset+slen <= datalen )
+            {
+                for (i=0; i<slen; i++)
+                    str[i] = data[offset++];
+                str[i] = 0;
+            } else return(-1);
+        }
+    }
+    else if ( dlen != 0 )
+    {
+        if ( str != 0 )
+        {
+            if ( dlen < IGUANA_MAXSCRIPTSIZE && offset+dlen <= datalen )
+            {
+                for (i=0; i<dlen; i++)
+                    sprintf(&str[i<<1],"%02x",data[offset++]);
+                str[i] = 0;
+            } else return(-1);
+        }
+    }
+    else if ( len != 0 && len+offset <= datalen )
+    {
+        if ( len == 32 )
+        {
+            iguana_rwbignum(0,&data[offset],len,(uint8_t *)hashp);
+            if ( str != 0 )
+                sprintf(str,"%s",uint256_str(_str,*hashp));
+        }
+        else
+        {
+            if ( sflag != 0 )
+            {
+                switch ( len )
+                {
+                    case 1: val = (int8_t)data[offset]; break;
+                    case 2: iguana_rwnum(0,&data[offset],len,(void *)&val16); val = val16; break;
+                    case 4: iguana_rwnum(0,&data[offset],len,(void *)&val32); val = val32; break;
+                    case 8: iguana_rwnum(0,&data[offset],len,(void *)&val); break;
+                }
+                if ( str != 0 )
+                    sprintf(str,"%lld",(long long)val);
+                *valp = val;
+            }
+            else
+            {
+                switch ( len )
+                {
+                    case 1: uval = data[offset]; break;
+                    case 2: iguana_rwnum(0,&data[offset],len,(void *)&uval16); uval = uval16; break;
+                    case 4: iguana_rwnum(0,&data[offset],len,(void *)&uval32); uval = uval32; break;
+                    case 8: iguana_rwnum(0,&data[offset],len,(void *)&uval); break;
+                }
+                if ( str != 0 )
+                    sprintf(str,"%llu",(long long)uval);
+                *valp = (int64_t)uval;
+            }
+        }
+        offset += len;
+    } else return(-1);
+    return(offset);
+}
+
+int64_t _correlate_price(int64_t *prices,int32_t n,int64_t price)
+{
+    int32_t i,count = 0; int64_t diff,threshold = (price >> 8);
+    for (i=0; i<n; i++)
+    {
+        if ( (diff= (price - prices[i])) < 0 )
+            diff = -diff;
+        if ( diff <= threshold )
+            count++;
+    }
+    if ( count < (n >> 1) )
+        return(0);
+    else return(price);
+}
+
+int64_t correlate_price(int32_t height,int64_t *prices,int32_t n)
+{
+    int32_t i,j; int64_t price = 0;
+    if ( n == 1 )
+        return(prices[0]);
+    // deterministic sort, like heapsort
+    for (i=0; i<n; i++)
+    {
+        j = (height + i) % n;
+        if ( prices[j] != 0 && (price= _correlate_price(prices,n,prices[j])) != 0 )
+            break;
+    }
+    for (i=0; i<n; i++)
+        fprintf(stderr,"%llu ",(long long)prices[i]);
+    fprintf(stderr,"-> %llu ht.%d\n",(long long)price,height);
+}
+
+int64_t OracleCorrelatedPrice(int32_t height,char *format,std::vector <uint8_t> datas[ORACLES_MAXPROVIDERS],int32_t n)
+{
+    int64_t prices[ORACLES_MAXPROVIDERS]; int32_t i,m=0; uint256 hash; int64_t val,price=0;
+    if ( format[0] == 'L' )
+    {
+        for (i=0; i<n; i++)
+        {
+            oracle_format(&hash,&val,0,'L',(uint8_t *)datas[i].data(),0,(int32_t)datas[i].size());
+            if ( val != 0 )
+                prices[m++] = val;
+        }
+    }
+    if ( m != 0 )
+        price = correlate_price(height,prices,m);
+    return(0);
+}
+
+int64_t OraclePrice(int32_t height,uint256 reforacletxid,char *markeraddr,char *format)
+{
+    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
+    CTransaction regtx,tx; uint256 hashBlock,txid,oracletxid,batontxid; CPubKey pk,providers[ORACLES_MAXPROVIDERS]; int32_t i,j,n=0; int64_t datafee; char batonaddr[64]; std::vector <uint8_t> data,datas[ORACLES_MAXPROVIDERS]; struct CCcontract_info *cp,C;
+    cp = CCinit(&C,EVAL_ORACLES);
+    SetCCunspents(unspentOutputs,markeraddr);
+    for (std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> >::const_iterator it=unspentOutputs.begin(); it!=unspentOutputs.end(); it++)
+    {
+        txid = it->first.txhash;
+        if ( myGetTransaction(txid,regtx,hashBlock) != 0 )
+        {
+            if ( regtx.vout.size() > 0 && DecodeOraclesOpRet(regtx.vout[regtx.vout.size()-1].scriptPubKey,oracletxid,pk,datafee) == 'R' && oracletxid == reforacletxid )
+            {
+                for (j=0; j<n; j++)
+                    if ( pk == providers[j] )
+                        break;
+                if ( j == n )
+                {
+                    Getscriptaddress(batonaddr,regtx.vout[1].scriptPubKey);
+                    batontxid = OracleBatonUtxo(10000,cp,oracletxid,batonaddr,pk,data);
+                    if ( batontxid != zeroid )
+                    {
+                        datas[n] = data;
+                        providers[n++] = pk;
+                        if ( n == ORACLES_MAXPROVIDERS )
+                            break;
+                    }
+                }
+            }
+        }
+    }
+    return(OracleCorrelatedPrice(height,format,datas,n));
+}
+
+int64_t IsOraclesvout(struct CCcontract_info *cp,const CTransaction& tx,int32_t v)
+{
+    char destaddr[64];
+    if ( tx.vout[v].scriptPubKey.IsPayToCryptoCondition() != 0 )
+    {
+        if ( Getscriptaddress(destaddr,tx.vout[v].scriptPubKey) > 0 )// && strcmp(destaddr,cp->unspendableCCaddr) == 0 )
+            return(tx.vout[v].nValue);
+    }
+    return(0);
+}
+
+bool OraclesDataValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx,uint256 oracletxid,CPubKey publisher,int64_t datafee)
+{
+    static uint256 zerohash;
+    CTransaction vinTx; uint256 hashBlock,activehash; int32_t i,numvins,numvouts; int64_t inputs=0,outputs=0,assetoshis; CScript scriptPubKey;
+    numvins = tx.vin.size();
+    numvouts = tx.vout.size();
+    if ( OracleDatafee(scriptPubKey,oracletxid,publisher) != datafee )
+        return eval->Invalid("mismatched datafee");
+    scriptPubKey = MakeCC1vout(cp->evalcode,0,publisher).scriptPubKey;
+    for (i=0; i<numvins; i++)
+    {
+        //fprintf(stderr,"vini.%d\n",i);
+        if ( (*cp->ismyvin)(tx.vin[i].scriptSig) != 0 )
+        {
+            if ( i == 0 )
+                return eval->Invalid("unexpected vin.0 is CC");
+            //fprintf(stderr,"vini.%d check mempool\n",i);
+            else if ( eval->GetTxUnconfirmed(tx.vin[i].prevout.hash,vinTx,hashBlock) == 0 )
+                return eval->Invalid("cant find vinTx");
+            else
+            {
+                //fprintf(stderr,"vini.%d check hash and vout\n",i);
+                if ( hashBlock == zerohash )
+                    return eval->Invalid("cant Oracles from mempool");
+                if ( (assetoshis= IsOraclesvout(cp,vinTx,tx.vin[i].prevout.n)) != 0 )
+                {
+                    if ( i == 1 && vinTx.vout[1].scriptPubKey != tx.vout[1].scriptPubKey )
+                        return eval->Invalid("baton violation");
+                    else if ( i != 1 && scriptPubKey == vinTx.vout[tx.vin[i].prevout.n].scriptPubKey )
+                        inputs += assetoshis;
+                }
+            }
+        }
+        else if ( i != 0 )
+            return eval->Invalid("vin0 not normal");
+     
+    }
+    for (i=0; i<numvouts; i++)
+    {
+        //fprintf(stderr,"i.%d of numvouts.%d\n",i,numvouts);
+        if ( (assetoshis= IsOraclesvout(cp,tx,i)) != 0 )
+        {
+            if ( i < 2 )
+            {
+                if ( i == 0 )
+                {
+                    if ( tx.vout[0].scriptPubKey == scriptPubKey )
+                        outputs += assetoshis;
+                    else return eval->Invalid("invalid CC vout CC destination");
+                }
+            }
+        }
+    }
+    if ( inputs != outputs+datafee )
+    {
+        fprintf(stderr,"inputs %llu vs outputs %llu + datafee %llu\n",(long long)inputs,(long long)outputs,(long long)datafee);
+        return eval->Invalid("mismatched inputs != outputs + datafee");
+    }
+    else return(true);
+}
+
+bool OraclesValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx)
+{
+    uint256 txid,oracletxid,batontxid; uint64_t txfee=10000; int32_t numvins,numvouts,preventCCvins,preventCCvouts; uint8_t *script; std::vector<uint8_t> vopret,data; CScript scriptPubKey; CPubKey publisher;
+    numvins = tx.vin.size();
+    numvouts = tx.vout.size();
+    preventCCvins = preventCCvouts = -1;
+    if ( numvouts < 1 )
+        return eval->Invalid("no vouts");
+    else
+    {
+        txid = tx.GetHash();
+        GetOpReturnData(tx.vout[numvouts-1].scriptPubKey,vopret);
+        if ( vopret.size() > 2 )
+        {
+            script = (uint8_t *)vopret.data();
+            switch ( script[1] )
+            {
+                case 'C': // create
+                    // vins.*: normal inputs
+                    // vout.0: txfee tag to oracle normal address
+                    // vout.1: change, if any
+                    // vout.n-1: opreturn with name and description and format for data
+                    return eval->Invalid("unexpected OraclesValidate for create");
+                    break;
+                case 'R': // register
+                    // vins.*: normal inputs
+                    // vout.0: txfee tag to normal marker address
+                    // vout.1: baton CC utxo
+                    // vout.2: change, if any
+                    // vout.n-1: opreturn with createtxid, pubkey and price per data point
+                    return eval->Invalid("unexpected OraclesValidate for register");
+                    break;
+                case 'S': // subscribe
+                    // vins.*: normal inputs
+                    // vout.0: subscription fee to publishers CC address
+                    // vout.1: change, if any
+                    // vout.n-1: opreturn with createtxid, registered provider's pubkey, amount
+                    return eval->Invalid("unexpected OraclesValidate for subscribe");
+                    break;
+                case 'D': // data
+                    // vin.0: normal input
+                    // vin.1: baton CC utxo (most of the time)
+                    // vin.2+: subscription vout.0
+                    // vout.0: change to publishers CC address
+                    // vout.1: baton CC utxo
+                    // vout.2: payment for dataprovider
+                    // vout.3: change, if any
+                    if ( numvins >= 2 && numvouts >= 3 && DecodeOraclesData(tx.vout[numvouts-1].scriptPubKey,oracletxid,batontxid,publisher,data) == 'D' )
+                    {
+                        if ( OraclesDataValidate(cp,eval,tx,oracletxid,publisher,tx.vout[2].nValue) != 0 )
+                        {
+                            return(true);
+                        } else return(false);
+                    }
+                    return eval->Invalid("unexpected OraclesValidate 'D' tx invalid");
+                    break;
+            }
+        }
+        return(PreventCC(eval,tx,preventCCvins,numvins,preventCCvouts,numvouts));
+    }
+    return(true);
+}
+// end of consensus code
+
+// helper functions for rpc calls in rpcwallet.cpp
+
+int64_t AddOracleInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPubKey pk,int64_t total,int32_t maxinputs)
+{
+    char coinaddr[64]; int64_t nValue,price,totalinputs = 0; uint256 txid,hashBlock; std::vector<uint8_t> origpubkey; CTransaction vintx; int32_t vout,n = 0;
+    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
+    GetCCaddress(cp,coinaddr,pk);
+    SetCCunspents(unspentOutputs,coinaddr);
+    for (std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> >::const_iterator it=unspentOutputs.begin(); it!=unspentOutputs.end(); it++)
+    {
+        txid = it->first.txhash;
+        vout = (int32_t)it->first.index;
+        if ( GetTransaction(txid,vintx,hashBlock,false) != 0 )
+        {
+            // get valid CC payments
+            if ( (nValue= IsOraclesvout(cp,vintx,vout)) >= 10000 && myIsutxo_spentinmempool(txid,vout) == 0 )
+            {
+                if ( total != 0 && maxinputs != 0 )
+                    mtx.vin.push_back(CTxIn(txid,vout,CScript()));
+                nValue = it->second.satoshis;
+                totalinputs += nValue;
+                n++;
+                if ( (total > 0 && totalinputs >= total) || (maxinputs > 0 && n >= maxinputs) )
+                    break;
+            }
+        }
+    }
+    return(totalinputs);
+}
+
+int64_t LifetimeOraclesFunds(struct CCcontract_info *cp,uint256 oracletxid,CPubKey publisher)
+{
+    char coinaddr[64]; CPubKey pk; int64_t total=0,num; uint256 txid,hashBlock,subtxid; CTransaction subtx;
+    std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex;
+    GetCCaddress(cp,coinaddr,publisher);
+    SetCCtxids(addressIndex,coinaddr);
+    //fprintf(stderr,"scan lifetime of %s\n",coinaddr);
+    for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=addressIndex.begin(); it!=addressIndex.end(); it++)
+    {
+        txid = it->first.txhash;
+        if ( GetTransaction(txid,subtx,hashBlock,false) != 0 )
+        {
+            if ( subtx.vout.size() > 0 && DecodeOraclesOpRet(subtx.vout[subtx.vout.size()-1].scriptPubKey,subtxid,pk,num) == 'S' && subtxid == oracletxid && pk == publisher )
+            {
+                total += subtx.vout[0].nValue;
+            }
+        }
+    }
+    return(total);
+}
+
+std::string OracleCreate(int64_t txfee,std::string name,std::string description,std::string format)
+{
+    CMutableTransaction mtx; CPubKey mypk,Oraclespk; struct CCcontract_info *cp,C;
+    cp = CCinit(&C,EVAL_ORACLES);
+    if ( name.size() > 32 || description.size() > 4096 || format.size() > 4096 )
+    {
+        fprintf(stderr,"name.%d or description.%d is too big\n",(int32_t)name.size(),(int32_t)description.size());
+        return("");
+    }
+    if ( txfee == 0 )
+        txfee = 10000;
+    mypk = pubkey2pk(Mypubkey());
+    Oraclespk = GetUnspendable(cp,0);
+    if ( AddNormalinputs(mtx,mypk,2*txfee,1) > 0 )
+    {
+        mtx.vout.push_back(CTxOut(txfee,CScript() << ParseHex(HexStr(Oraclespk)) << OP_CHECKSIG));
+        return(FinalizeCCTx(0,cp,mtx,mypk,txfee,EncodeOraclesCreateOpRet('C',name,description,format)));
+    }
+    return("");
+}
+
+std::string OracleRegister(int64_t txfee,uint256 oracletxid,int64_t datafee)
+{
+    CMutableTransaction mtx; CPubKey mypk,markerpubkey,batonpk; struct CCcontract_info *cp,C; uint8_t buf33[33]; char markeraddr[64],batonaddr[64];
+    cp = CCinit(&C,EVAL_ORACLES);
+    if ( txfee == 0 )
+        txfee = 10000;
+    if ( datafee < txfee )
+    {
+        fprintf(stderr,"datafee must be txfee or more\n");
+        return("");
+    }
+    mypk = pubkey2pk(Mypubkey());
+    buf33[0] = 0x02;
+    endiancpy(&buf33[1],(uint8_t *)&oracletxid,32);
+    markerpubkey = buf2pk(buf33);
+    Getscriptaddress(markeraddr,CScript() << ParseHex(HexStr(markerpubkey)) << OP_CHECKSIG);
+    batonpk = OracleBatonPk(batonaddr,cp);
+    if ( AddNormalinputs(mtx,mypk,3*txfee,4) > 0 )
+    {
+        mtx.vout.push_back(CTxOut(txfee,CScript() << ParseHex(HexStr(markerpubkey)) << OP_CHECKSIG));
+        mtx.vout.push_back(MakeCC1vout(cp->evalcode,txfee,batonpk));
+        return(FinalizeCCTx(0,cp,mtx,mypk,txfee,EncodeOraclesOpRet('R',oracletxid,mypk,datafee)));
+    }
+    return("");
+}
+
+std::string OracleSubscribe(int64_t txfee,uint256 oracletxid,CPubKey publisher,int64_t amount)
+{
+    CMutableTransaction mtx; CPubKey mypk,markerpubkey; struct CCcontract_info *cp,C; uint8_t buf33[33]; char markeraddr[64];
+    cp = CCinit(&C,EVAL_ORACLES);
+    if ( txfee == 0 )
+        txfee = 10000;
+    mypk = pubkey2pk(Mypubkey());
+    buf33[0] = 0x02;
+    endiancpy(&buf33[1],(uint8_t *)&oracletxid,32);
+    markerpubkey = buf2pk(buf33);
+    Getscriptaddress(markeraddr,CScript() << ParseHex(HexStr(markerpubkey)) << OP_CHECKSIG);
+    if ( AddNormalinputs(mtx,mypk,amount + 2*txfee,1) > 0 )
+    {
+        mtx.vout.push_back(MakeCC1vout(cp->evalcode,amount,publisher));
+        mtx.vout.push_back(CTxOut(txfee,CScript() << ParseHex(HexStr(markerpubkey)) << OP_CHECKSIG));
+        return(FinalizeCCTx(0,cp,mtx,mypk,txfee,EncodeOraclesOpRet('S',oracletxid,mypk,amount)));
+    }
+    return("");
+}
+
+std::string OracleData(int64_t txfee,uint256 oracletxid,std::vector <uint8_t> data)
+{
+    CMutableTransaction mtx; CScript pubKey; CPubKey mypk,batonpk; int64_t datafee,inputs,CCchange = 0; struct CCcontract_info *cp,C; uint256 batontxid; char coinaddr[64],batonaddr[64]; std::vector <uint8_t> prevdata;
+    cp = CCinit(&C,EVAL_ORACLES);
+    mypk = pubkey2pk(Mypubkey());
+    if ( data.size() > 8192 )
+    {
+        fprintf(stderr,"datasize %d is too big\n",(int32_t)data.size());
+        return("");
+    }
+    if ( (datafee= OracleDatafee(pubKey,oracletxid,mypk)) <= 0 )
+    {
+        fprintf(stderr,"datafee %.8f is illegal\n",(double)datafee/COIN);
+        return("");
+    }
+    if ( txfee == 0 )
+        txfee = 10000;
+    GetCCaddress(cp,coinaddr,mypk);
+    if ( AddNormalinputs(mtx,mypk,2*txfee,3) > 0 ) // have enough funds even if baton utxo not there
+    {
+        batonpk = OracleBatonPk(batonaddr,cp);
+        batontxid = OracleBatonUtxo(txfee,cp,oracletxid,batonaddr,mypk,prevdata);
+        if ( batontxid != zeroid ) // not impossible to fail, but hopefully a very rare event
+            mtx.vin.push_back(CTxIn(batontxid,1,CScript()));
+        else fprintf(stderr,"warning: couldnt find baton utxo %s\n",batonaddr);
+        if ( (inputs= AddOracleInputs(cp,mtx,mypk,datafee,60)) > 0 )
+        {
+            if ( inputs > datafee )
+                CCchange = (inputs - datafee);
+            mtx.vout.push_back(MakeCC1vout(cp->evalcode,CCchange,mypk));
+            mtx.vout.push_back(MakeCC1vout(cp->evalcode,txfee,batonpk));
+            mtx.vout.push_back(CTxOut(datafee,CScript() << ParseHex(HexStr(mypk)) << OP_CHECKSIG));
+            return(FinalizeCCTx(0,cp,mtx,mypk,txfee,EncodeOraclesData('D',oracletxid,batontxid,mypk,data)));
+        }
+    }
+    return("");
+}
+
+UniValue OracleFormat(uint8_t *data,int32_t datalen,char *format,int32_t formatlen)
+{
+    UniValue obj(UniValue::VARR); uint256 hash; int32_t i,j=0; int64_t val; char str[IGUANA_MAXSCRIPTSIZE*2+1];
+    for (i=0; i<formatlen && j<datalen; i++)
+    {
+        str[0] = 0;
+        j = oracle_format(&hash,&val,str,format[i],data,j,datalen);
+        if ( j < 0 )
+            break;
+        obj.push_back(str);
+        if ( j >= datalen )
+            break;
+    }
+    return(obj);
+}
+
+UniValue OracleDataSamples(uint256 reforacletxid,uint256 batontxid,int32_t num)
+{
+    UniValue result(UniValue::VOBJ),a(UniValue::VARR); CTransaction tx,oracletx; uint256 hashBlock,btxid,oracletxid; CPubKey pk; std::string name,description,format; int32_t numvouts,n=0; std::vector<uint8_t> data; char *formatstr = 0;
+    result.push_back(Pair("result","success"));
+    if ( GetTransaction(reforacletxid,oracletx,hashBlock,false) != 0 && (numvouts=oracletx.vout.size()) > 0 )
+    {
+        if ( DecodeOraclesCreateOpRet(oracletx.vout[numvouts-1].scriptPubKey,name,description,format) == 'C' )
+        {
+            while ( GetTransaction(batontxid,tx,hashBlock,false) != 0 && (numvouts=tx.vout.size()) > 0 )
+            {
+                if ( DecodeOraclesData(tx.vout[numvouts-1].scriptPubKey,oracletxid,btxid,pk,data) == 'D' && reforacletxid == oracletxid )
+                {
+                    if ( (formatstr= (char *)format.c_str()) == 0 )
+                        formatstr = (char *)"";
+                    a.push_back(OracleFormat((uint8_t *)data.data(),(int32_t)data.size(),formatstr,(int32_t)format.size()));
+                    batontxid = btxid;
+                    if ( ++n >= num )
+                        break;
+                } else break;
+            }
+        }
+    }
+    result.push_back(Pair("samples",a));
+    return(result);
+}
+
+UniValue OracleInfo(uint256 origtxid)
+{
+    UniValue result(UniValue::VOBJ),a(UniValue::VARR),obj(UniValue::VOBJ);
+    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
+    CMutableTransaction mtx; CTransaction regtx,tx; std::string name,description,format; uint256 hashBlock,txid,oracletxid,batontxid; CPubKey markerpubkey,pk; struct CCcontract_info *cp,C; uint8_t buf33[33]; int64_t datafee,funding; char str[67],markeraddr[64],numstr[64],batonaddr[64]; std::vector <uint8_t> data;
+    cp = CCinit(&C,EVAL_ORACLES);
+    buf33[0] = 0x02;
+    endiancpy(&buf33[1],(uint8_t *)&origtxid,32);
+    markerpubkey = buf2pk(buf33);
+    Getscriptaddress(markeraddr,CScript() << ParseHex(HexStr(markerpubkey)) << OP_CHECKSIG);
+    if ( GetTransaction(origtxid,tx,hashBlock,false) != 0 )
+    {
+        if ( tx.vout.size() > 0 && DecodeOraclesCreateOpRet(tx.vout[tx.vout.size()-1].scriptPubKey,name,description,format) == 'C' )
+        {
+            result.push_back(Pair("result","success"));
+            result.push_back(Pair("txid",uint256_str(str,origtxid)));
+            result.push_back(Pair("name",name));
+            result.push_back(Pair("description",description));
+            result.push_back(Pair("format",format));
+            result.push_back(Pair("marker",markeraddr));
+            SetCCunspents(unspentOutputs,markeraddr);
+            for (std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> >::const_iterator it=unspentOutputs.begin(); it!=unspentOutputs.end(); it++)
+            {
+                txid = it->first.txhash;
+                if ( GetTransaction(txid,regtx,hashBlock,false) != 0 )
+                {
+                    if ( regtx.vout.size() > 0 && DecodeOraclesOpRet(regtx.vout[regtx.vout.size()-1].scriptPubKey,oracletxid,pk,datafee) == 'R' && oracletxid == origtxid )
+                    {
+                        obj.push_back(Pair("publisher",pubkey33_str(str,(uint8_t *)pk.begin())));
+                        Getscriptaddress(batonaddr,regtx.vout[1].scriptPubKey);
+                        batontxid = OracleBatonUtxo(10000,cp,oracletxid,batonaddr,pk,data);
+                        obj.push_back(Pair("baton",batonaddr));
+                        obj.push_back(Pair("batontxid",uint256_str(str,batontxid)));
+                        funding = LifetimeOraclesFunds(cp,oracletxid,pk);
+                        sprintf(numstr,"%.8f",(double)funding/COIN);
+                        obj.push_back(Pair("lifetime",numstr));
+                        funding = AddOracleInputs(cp,mtx,pk,0,0);
+                        sprintf(numstr,"%.8f",(double)funding/COIN);
+                        obj.push_back(Pair("funds",numstr));
+                        sprintf(numstr,"%.8f",(double)datafee/COIN);
+                        obj.push_back(Pair("datafee",numstr));
+                        a.push_back(obj);
+                    }
+                }
+            }
+            result.push_back(Pair("registered",a));
+        }
+    }
+    return(result);
+}
+
+UniValue OraclesList()
+{
+    UniValue result(UniValue::VARR); std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex; struct CCcontract_info *cp,C; uint256 txid,hashBlock; CTransaction createtx; std::string name,description,format; char str[65];
+    cp = CCinit(&C,EVAL_ORACLES);
+    SetCCtxids(addressIndex,cp->normaladdr);
+    for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=addressIndex.begin(); it!=addressIndex.end(); it++)
+    {
+        txid = it->first.txhash;
+        if ( GetTransaction(txid,createtx,hashBlock,false) != 0 )
+        {
+            if ( createtx.vout.size() > 0 && DecodeOraclesCreateOpRet(createtx.vout[createtx.vout.size()-1].scriptPubKey,name,description,format) == 'C' )
+            {
+                result.push_back(uint256_str(str,txid));
+            }
+        }
+    }
+    return(result);
+}
+
diff --git a/src/cc/payments.cpp b/src/cc/payments.cpp
new file mode 100644
index 000000000..6cd751b8d
--- /dev/null
+++ b/src/cc/payments.cpp
@@ -0,0 +1,213 @@
+/******************************************************************************
+ * Copyright © 2014-2018 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+
+#include "CCPayments.h"
+
+/*
+ Payments CC is a catchall CC, supported invoices, zpayments, automated funds allocation, including token based revshare
+ 
+ 
+*/
+
+// start of consensus code
+
+int64_t IsPaymentsvout(struct CCcontract_info *cp,const CTransaction& tx,int32_t v)
+{
+    char destaddr[64];
+    if ( tx.vout[v].scriptPubKey.IsPayToCryptoCondition() != 0 )
+    {
+        if ( Getscriptaddress(destaddr,tx.vout[v].scriptPubKey) > 0 && strcmp(destaddr,cp->unspendableCCaddr) == 0 )
+            return(tx.vout[v].nValue);
+    }
+    return(0);
+}
+
+bool PaymentsExactAmounts(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx,int32_t minage,uint64_t txfee)
+{
+    static uint256 zerohash;
+    CTransaction vinTx; uint256 hashBlock,activehash; int32_t i,numvins,numvouts; int64_t inputs=0,outputs=0,assetoshis;
+    numvins = tx.vin.size();
+    numvouts = tx.vout.size();
+    for (i=0; i<numvins; i++)
+    {
+        //fprintf(stderr,"vini.%d\n",i);
+        if ( (*cp->ismyvin)(tx.vin[i].scriptSig) != 0 )
+        {
+            //fprintf(stderr,"vini.%d check mempool\n",i);
+            if ( eval->GetTxUnconfirmed(tx.vin[i].prevout.hash,vinTx,hashBlock) == 0 )
+                return eval->Invalid("cant find vinTx");
+            else
+            {
+                //fprintf(stderr,"vini.%d check hash and vout\n",i);
+                if ( hashBlock == zerohash )
+                    return eval->Invalid("cant Payments from mempool");
+                if ( (assetoshis= IsPaymentsvout(cp,vinTx,tx.vin[i].prevout.n)) != 0 )
+                    inputs += assetoshis;
+            }
+        }
+    }
+    for (i=0; i<numvouts; i++)
+    {
+        //fprintf(stderr,"i.%d of numvouts.%d\n",i,numvouts);
+        if ( (assetoshis= IsPaymentsvout(cp,tx,i)) != 0 )
+            outputs += assetoshis;
+    }
+    if ( inputs != outputs+txfee )
+    {
+        fprintf(stderr,"inputs %llu vs outputs %llu\n",(long long)inputs,(long long)outputs);
+        return eval->Invalid("mismatched inputs != outputs + txfee");
+    }
+    else return(true);
+}
+
+bool PaymentsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx)
+{
+    int32_t numvins,numvouts,preventCCvins,preventCCvouts,i,numblocks; bool retval; uint256 txid; uint8_t hash[32]; char str[65],destaddr[64];
+    return(false);
+    std::vector<std::pair<CAddressIndexKey, CAmount> > txids;
+    numvins = tx.vin.size();
+    numvouts = tx.vout.size();
+    preventCCvins = preventCCvouts = -1;
+    if ( numvouts < 1 )
+        return eval->Invalid("no vouts");
+    else
+    {
+        for (i=0; i<numvins; i++)
+        {
+            if ( IsCCInput(tx.vin[0].scriptSig) == 0 )
+            {
+                return eval->Invalid("illegal normal vini");
+            }
+        }
+        //fprintf(stderr,"check amounts\n");
+        if ( PaymentsExactAmounts(cp,eval,tx,1,10000) == false )
+        {
+            fprintf(stderr,"Paymentsget invalid amount\n");
+            return false;
+        }
+        else
+        {
+            txid = tx.GetHash();
+            memcpy(hash,&txid,sizeof(hash));
+            retval = PreventCC(eval,tx,preventCCvins,numvins,preventCCvouts,numvouts);
+            if ( retval != 0 )
+                fprintf(stderr,"Paymentsget validated\n");
+            else fprintf(stderr,"Paymentsget invalid\n");
+            return(retval);
+        }
+    }
+}
+// end of consensus code
+
+// helper functions for rpc calls in rpcwallet.cpp
+
+int64_t AddPaymentsInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPubKey pk,int64_t total,int32_t maxinputs)
+{
+    char coinaddr[64]; int64_t nValue,price,totalinputs = 0; uint256 txid,hashBlock; std::vector<uint8_t> origpubkey; CTransaction vintx; int32_t vout,n = 0;
+    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
+    GetCCaddress(cp,coinaddr,pk);
+    SetCCunspents(unspentOutputs,coinaddr);
+    for (std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> >::const_iterator it=unspentOutputs.begin(); it!=unspentOutputs.end(); it++)
+    {
+        txid = it->first.txhash;
+        vout = (int32_t)it->first.index;
+        // no need to prevent dup
+        if ( GetTransaction(txid,vintx,hashBlock,false) != 0 )
+        {
+            if ( (nValue= IsPaymentsvout(cp,vintx,vout)) > 1000000 && myIsutxo_spentinmempool(txid,vout) == 0 )
+            {
+                if ( total != 0 && maxinputs != 0 )
+                    mtx.vin.push_back(CTxIn(txid,vout,CScript()));
+                nValue = it->second.satoshis;
+                totalinputs += nValue;
+                n++;
+                if ( (total > 0 && totalinputs >= total) || (maxinputs > 0 && n >= maxinputs) )
+                    break;
+            }
+        }
+    }
+    return(totalinputs);
+}
+
+std::string PaymentsGet(uint64_t txfee,int64_t nValue)
+{
+    CMutableTransaction mtx,tmpmtx; CPubKey mypk,Paymentspk; int64_t inputs,CCchange=0; struct CCcontract_info *cp,C; std::string rawhex; uint32_t j; int32_t i,len; uint8_t buf[32768]; bits256 hash;
+    cp = CCinit(&C,EVAL_PAYMENTS);
+    if ( txfee == 0 )
+        txfee = 10000;
+    Paymentspk = GetUnspendable(cp,0);
+    mypk = pubkey2pk(Mypubkey());
+    if ( (inputs= AddPaymentsInputs(cp,mtx,Paymentspk,nValue+txfee,60)) > 0 )
+    {
+        if ( inputs > nValue )
+            CCchange = (inputs - nValue - txfee);
+        if ( CCchange != 0 )
+            mtx.vout.push_back(MakeCC1vout(EVAL_PAYMENTS,CCchange,Paymentspk));
+        mtx.vout.push_back(CTxOut(nValue,CScript() << ParseHex(HexStr(mypk)) << OP_CHECKSIG));
+        fprintf(stderr,"start at %u\n",(uint32_t)time(NULL));
+        j = rand() & 0xfffffff;
+        for (i=0; i<1000000; i++,j++)
+        {
+            tmpmtx = mtx;
+            rawhex = FinalizeCCTx(-1LL,cp,tmpmtx,mypk,txfee,CScript() << OP_RETURN << E_MARSHAL(ss << (uint8_t)EVAL_PAYMENTS << (uint8_t)'G' << j));
+            if ( (len= (int32_t)rawhex.size()) > 0 && len < 65536 )
+            {
+                len >>= 1;
+                decode_hex(buf,len,(char *)rawhex.c_str());
+                hash = bits256_doublesha256(0,buf,len);
+                if ( (hash.bytes[0] & 0xff) == 0 && (hash.bytes[31] & 0xff) == 0 )
+                {
+                    fprintf(stderr,"found valid txid after %d iterations %u\n",i,(uint32_t)time(NULL));
+                    return(rawhex);
+                }
+                //fprintf(stderr,"%02x%02x ",hash.bytes[0],hash.bytes[31]);
+            }
+        }
+        fprintf(stderr,"couldnt generate valid txid %u\n",(uint32_t)time(NULL));
+        return("");
+    } else fprintf(stderr,"cant find Payments inputs\n");
+    return("");
+}
+
+std::string PaymentsFund(uint64_t txfee,int64_t funds)
+{
+    CMutableTransaction mtx; CPubKey mypk,Paymentspk; CScript opret; struct CCcontract_info *cp,C;
+    cp = CCinit(&C,EVAL_PAYMENTS);
+    if ( txfee == 0 )
+        txfee = 10000;
+    mypk = pubkey2pk(Mypubkey());
+    Paymentspk = GetUnspendable(cp,0);
+    if ( AddNormalinputs(mtx,mypk,funds+txfee,64) > 0 )
+    {
+        mtx.vout.push_back(MakeCC1vout(EVAL_PAYMENTS,funds,Paymentspk));
+        return(FinalizeCCTx(0,cp,mtx,mypk,txfee,opret));
+    }
+    return("");
+}
+
+UniValue PaymentsInfo()
+{
+    UniValue result(UniValue::VOBJ); char numstr[64];
+    CMutableTransaction mtx; CPubKey Paymentspk; struct CCcontract_info *cp,C; int64_t funding;
+    result.push_back(Pair("result","success"));
+    result.push_back(Pair("name","Payments"));
+    cp = CCinit(&C,EVAL_PAYMENTS);
+    Paymentspk = GetUnspendable(cp,0);
+    funding = AddPaymentsInputs(cp,mtx,Paymentspk,0,0);
+    sprintf(numstr,"%.8f",(double)funding/COIN);
+    result.push_back(Pair("funding",numstr));
+    return(result);
+}
+
diff --git a/src/cc/pegs.cpp b/src/cc/pegs.cpp
new file mode 100644
index 000000000..d9074bd49
--- /dev/null
+++ b/src/cc/pegs.cpp
@@ -0,0 +1,220 @@
+/******************************************************************************
+ * Copyright © 2014-2018 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+
+#include "CCPegs.h"
+
+/*
+ Pegs CC builds on top of Prices CC and would bind a pricefeed to a token bid/ask automated marketmaking. 
+ 
+ Funds deposited into CC address for a specific peg would then be used to fund the bid/ask as the pricefeed changes the price. Profits/losses would accumulate in the associated address.
+ 
+ In the event funds exceed a specified level, it can be spent into a collection address. The idea is that the collection address can further be used for revshares.
+ 
+ int64_t OraclePrice(int32_t height,uint256 reforacletxid,char *markeraddr,char *format);
+
+ OraclePrice is very useful for pegs. 
+ 
+*/
+
+// start of consensus code
+
+int64_t IsPegsvout(struct CCcontract_info *cp,const CTransaction& tx,int32_t v)
+{
+    char destaddr[64];
+    if ( tx.vout[v].scriptPubKey.IsPayToCryptoCondition() != 0 )
+    {
+        if ( Getscriptaddress(destaddr,tx.vout[v].scriptPubKey) > 0 && strcmp(destaddr,cp->unspendableCCaddr) == 0 )
+            return(tx.vout[v].nValue);
+    }
+    return(0);
+}
+
+bool PegsExactAmounts(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx,int32_t minage,uint64_t txfee)
+{
+    static uint256 zerohash;
+    CTransaction vinTx; uint256 hashBlock,activehash; int32_t i,numvins,numvouts; int64_t inputs=0,outputs=0,assetoshis;
+    numvins = tx.vin.size();
+    numvouts = tx.vout.size();
+    for (i=0; i<numvins; i++)
+    {
+        //fprintf(stderr,"vini.%d\n",i);
+        if ( (*cp->ismyvin)(tx.vin[i].scriptSig) != 0 )
+        {
+            //fprintf(stderr,"vini.%d check mempool\n",i);
+            if ( eval->GetTxUnconfirmed(tx.vin[i].prevout.hash,vinTx,hashBlock) == 0 )
+                return eval->Invalid("cant find vinTx");
+            else
+            {
+                //fprintf(stderr,"vini.%d check hash and vout\n",i);
+                if ( hashBlock == zerohash )
+                    return eval->Invalid("cant Pegs from mempool");
+                if ( (assetoshis= IsPegsvout(cp,vinTx,tx.vin[i].prevout.n)) != 0 )
+                    inputs += assetoshis;
+            }
+        }
+    }
+    for (i=0; i<numvouts; i++)
+    {
+        //fprintf(stderr,"i.%d of numvouts.%d\n",i,numvouts);
+        if ( (assetoshis= IsPegsvout(cp,tx,i)) != 0 )
+            outputs += assetoshis;
+    }
+    if ( inputs != outputs+txfee )
+    {
+        fprintf(stderr,"inputs %llu vs outputs %llu\n",(long long)inputs,(long long)outputs);
+        return eval->Invalid("mismatched inputs != outputs + txfee");
+    }
+    else return(true);
+}
+
+bool PegsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx)
+{
+    int32_t numvins,numvouts,preventCCvins,preventCCvouts,i,numblocks; bool retval; uint256 txid; uint8_t hash[32]; char str[65],destaddr[64];
+    return(false);
+    std::vector<std::pair<CAddressIndexKey, CAmount> > txids;
+    numvins = tx.vin.size();
+    numvouts = tx.vout.size();
+    preventCCvins = preventCCvouts = -1;
+    if ( numvouts < 1 )
+        return eval->Invalid("no vouts");
+    else
+    {
+        for (i=0; i<numvins; i++)
+        {
+            if ( IsCCInput(tx.vin[0].scriptSig) == 0 )
+            {
+                return eval->Invalid("illegal normal vini");
+            }
+        }
+        //fprintf(stderr,"check amounts\n");
+        if ( PegsExactAmounts(cp,eval,tx,1,10000) == false )
+        {
+            fprintf(stderr,"Pegsget invalid amount\n");
+            return false;
+        }
+        else
+        {
+            txid = tx.GetHash();
+            memcpy(hash,&txid,sizeof(hash));
+            retval = PreventCC(eval,tx,preventCCvins,numvins,preventCCvouts,numvouts);
+            if ( retval != 0 )
+                fprintf(stderr,"Pegsget validated\n");
+            else fprintf(stderr,"Pegsget invalid\n");
+            return(retval);
+        }
+    }
+}
+// end of consensus code
+
+// helper functions for rpc calls in rpcwallet.cpp
+
+int64_t AddPegsInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPubKey pk,int64_t total,int32_t maxinputs)
+{
+    char coinaddr[64]; int64_t nValue,price,totalinputs = 0; uint256 txid,hashBlock; std::vector<uint8_t> origpubkey; CTransaction vintx; int32_t vout,n = 0;
+    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
+    GetCCaddress(cp,coinaddr,pk);
+    SetCCunspents(unspentOutputs,coinaddr);
+    for (std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> >::const_iterator it=unspentOutputs.begin(); it!=unspentOutputs.end(); it++)
+    {
+        txid = it->first.txhash;
+        vout = (int32_t)it->first.index;
+        // no need to prevent dup
+        if ( GetTransaction(txid,vintx,hashBlock,false) != 0 )
+        {
+            if ( (nValue= IsPegsvout(cp,vintx,vout)) > 1000000 && myIsutxo_spentinmempool(txid,vout) == 0 )
+            {
+                if ( total != 0 && maxinputs != 0 )
+                    mtx.vin.push_back(CTxIn(txid,vout,CScript()));
+                nValue = it->second.satoshis;
+                totalinputs += nValue;
+                n++;
+                if ( (total > 0 && totalinputs >= total) || (maxinputs > 0 && n >= maxinputs) )
+                    break;
+            }
+        }
+    }
+    return(totalinputs);
+}
+
+std::string PegsGet(uint64_t txfee,int64_t nValue)
+{
+    CMutableTransaction mtx,tmpmtx; CPubKey mypk,Pegspk; int64_t inputs,CCchange=0; struct CCcontract_info *cp,C; std::string rawhex; uint32_t j; int32_t i,len; uint8_t buf[32768]; bits256 hash;
+    cp = CCinit(&C,EVAL_PEGS);
+    if ( txfee == 0 )
+        txfee = 10000;
+    Pegspk = GetUnspendable(cp,0);
+    mypk = pubkey2pk(Mypubkey());
+    if ( (inputs= AddPegsInputs(cp,mtx,Pegspk,nValue+txfee,60)) > 0 )
+    {
+        if ( inputs > nValue )
+            CCchange = (inputs - nValue - txfee);
+        if ( CCchange != 0 )
+            mtx.vout.push_back(MakeCC1vout(EVAL_PEGS,CCchange,Pegspk));
+        mtx.vout.push_back(CTxOut(nValue,CScript() << ParseHex(HexStr(mypk)) << OP_CHECKSIG));
+        fprintf(stderr,"start at %u\n",(uint32_t)time(NULL));
+        j = rand() & 0xfffffff;
+        for (i=0; i<1000000; i++,j++)
+        {
+            tmpmtx = mtx;
+            rawhex = FinalizeCCTx(-1LL,cp,tmpmtx,mypk,txfee,CScript() << OP_RETURN << E_MARSHAL(ss << (uint8_t)EVAL_PEGS << (uint8_t)'G' << j));
+            if ( (len= (int32_t)rawhex.size()) > 0 && len < 65536 )
+            {
+                len >>= 1;
+                decode_hex(buf,len,(char *)rawhex.c_str());
+                hash = bits256_doublesha256(0,buf,len);
+                if ( (hash.bytes[0] & 0xff) == 0 && (hash.bytes[31] & 0xff) == 0 )
+                {
+                    fprintf(stderr,"found valid txid after %d iterations %u\n",i,(uint32_t)time(NULL));
+                    return(rawhex);
+                }
+                //fprintf(stderr,"%02x%02x ",hash.bytes[0],hash.bytes[31]);
+            }
+        }
+        fprintf(stderr,"couldnt generate valid txid %u\n",(uint32_t)time(NULL));
+        return("");
+    } else fprintf(stderr,"cant find Pegs inputs\n");
+    return("");
+}
+
+std::string PegsFund(uint64_t txfee,int64_t funds)
+{
+    CMutableTransaction mtx; CPubKey mypk,Pegspk; CScript opret; struct CCcontract_info *cp,C;
+    cp = CCinit(&C,EVAL_PEGS);
+    if ( txfee == 0 )
+        txfee = 10000;
+    mypk = pubkey2pk(Mypubkey());
+    Pegspk = GetUnspendable(cp,0);
+    if ( AddNormalinputs(mtx,mypk,funds+txfee,64) > 0 )
+    {
+        mtx.vout.push_back(MakeCC1vout(EVAL_PEGS,funds,Pegspk));
+        return(FinalizeCCTx(0,cp,mtx,mypk,txfee,opret));
+    }
+    return("");
+}
+
+UniValue PegsInfo()
+{
+    UniValue result(UniValue::VOBJ); char numstr[64];
+    CMutableTransaction mtx; CPubKey Pegspk; struct CCcontract_info *cp,C; int64_t funding;
+    result.push_back(Pair("result","success"));
+    result.push_back(Pair("name","Pegs"));
+    cp = CCinit(&C,EVAL_PEGS);
+    Pegspk = GetUnspendable(cp,0);
+    funding = AddPegsInputs(cp,mtx,Pegspk,0,0);
+    sprintf(numstr,"%.8f",(double)funding/COIN);
+    result.push_back(Pair("funding",numstr));
+    return(result);
+}
+
diff --git a/src/cc/prices.cpp b/src/cc/prices.cpp
new file mode 100644
index 000000000..72e486114
--- /dev/null
+++ b/src/cc/prices.cpp
@@ -0,0 +1,229 @@
+/******************************************************************************
+ * Copyright © 2014-2018 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+
+#include "CCPrices.h"
+
+/*
+ Prices CC would best build on top of the oracles CC, ie. to combine payments for multiple oracles and to calculate a 51% protected price feed.
+ 
+ We need to assume there is an oracle for a specific price. In the event there are more than one provider, the majority need to be within correlation distance to update a pricepoint.
+
+ int64_t OraclePrice(int32_t height,uint256 reforacletxid,char *markeraddr,char *format);
+
+ Using the above function, a consensus price can be obtained for a datasource.
+ 
+ given an oracletxid, the marketaddr and format can be extracted to be used for future calls to OraclePrice. This allows to set a starting price and that in turn allows cash settled leveraged trading!
+ 
+ Funds work like with dice, ie. there is a Prices plan that traders bet against.
+ 
+ PricesOpen -> oracletxid start with 'L' price, leverage, amount
+ funds are locked into global CC address
+    it can be closed at anytime by the trader for cash settlement
+    the house account can close it if rekt
+ 
+ 
+*/
+
+// start of consensus code
+
+int64_t IsPricesvout(struct CCcontract_info *cp,const CTransaction& tx,int32_t v)
+{
+    char destaddr[64];
+    if ( tx.vout[v].scriptPubKey.IsPayToCryptoCondition() != 0 )
+    {
+        if ( Getscriptaddress(destaddr,tx.vout[v].scriptPubKey) > 0 && strcmp(destaddr,cp->unspendableCCaddr) == 0 )
+            return(tx.vout[v].nValue);
+    }
+    return(0);
+}
+
+bool PricesExactAmounts(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx,int32_t minage,uint64_t txfee)
+{
+    static uint256 zerohash;
+    CTransaction vinTx; uint256 hashBlock,activehash; int32_t i,numvins,numvouts; int64_t inputs=0,outputs=0,assetoshis;
+    numvins = tx.vin.size();
+    numvouts = tx.vout.size();
+    for (i=0; i<numvins; i++)
+    {
+        //fprintf(stderr,"vini.%d\n",i);
+        if ( (*cp->ismyvin)(tx.vin[i].scriptSig) != 0 )
+        {
+            //fprintf(stderr,"vini.%d check mempool\n",i);
+            if ( eval->GetTxUnconfirmed(tx.vin[i].prevout.hash,vinTx,hashBlock) == 0 )
+                return eval->Invalid("cant find vinTx");
+            else
+            {
+                //fprintf(stderr,"vini.%d check hash and vout\n",i);
+                if ( hashBlock == zerohash )
+                    return eval->Invalid("cant Prices from mempool");
+                if ( (assetoshis= IsPricesvout(cp,vinTx,tx.vin[i].prevout.n)) != 0 )
+                    inputs += assetoshis;
+            }
+        }
+    }
+    for (i=0; i<numvouts; i++)
+    {
+        //fprintf(stderr,"i.%d of numvouts.%d\n",i,numvouts);
+        if ( (assetoshis= IsPricesvout(cp,tx,i)) != 0 )
+            outputs += assetoshis;
+    }
+    if ( inputs != outputs+txfee )
+    {
+        fprintf(stderr,"inputs %llu vs outputs %llu\n",(long long)inputs,(long long)outputs);
+        return eval->Invalid("mismatched inputs != outputs + txfee");
+    }
+    else return(true);
+}
+
+bool PricesValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx)
+{
+    int32_t numvins,numvouts,preventCCvins,preventCCvouts,i,numblocks; bool retval; uint256 txid; uint8_t hash[32]; char str[65],destaddr[64];
+    return(false);
+    std::vector<std::pair<CAddressIndexKey, CAmount> > txids;
+    numvins = tx.vin.size();
+    numvouts = tx.vout.size();
+    preventCCvins = preventCCvouts = -1;
+    if ( numvouts < 1 )
+        return eval->Invalid("no vouts");
+    else
+    {
+        for (i=0; i<numvins; i++)
+        {
+            if ( IsCCInput(tx.vin[0].scriptSig) == 0 )
+            {
+                return eval->Invalid("illegal normal vini");
+            }
+        }
+        //fprintf(stderr,"check amounts\n");
+        if ( PricesExactAmounts(cp,eval,tx,1,10000) == false )
+        {
+            fprintf(stderr,"Pricesget invalid amount\n");
+            return false;
+        }
+        else
+        {
+            txid = tx.GetHash();
+            memcpy(hash,&txid,sizeof(hash));
+            retval = PreventCC(eval,tx,preventCCvins,numvins,preventCCvouts,numvouts);
+            if ( retval != 0 )
+                fprintf(stderr,"Pricesget validated\n");
+            else fprintf(stderr,"Pricesget invalid\n");
+            return(retval);
+        }
+    }
+}
+// end of consensus code
+
+// helper functions for rpc calls in rpcwallet.cpp
+
+int64_t AddPricesInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPubKey pk,int64_t total,int32_t maxinputs)
+{
+    char coinaddr[64]; int64_t nValue,price,totalinputs = 0; uint256 txid,hashBlock; std::vector<uint8_t> origpubkey; CTransaction vintx; int32_t vout,n = 0;
+    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
+    GetCCaddress(cp,coinaddr,pk);
+    SetCCunspents(unspentOutputs,coinaddr);
+    for (std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> >::const_iterator it=unspentOutputs.begin(); it!=unspentOutputs.end(); it++)
+    {
+        txid = it->first.txhash;
+        vout = (int32_t)it->first.index;
+        // no need to prevent dup
+        if ( GetTransaction(txid,vintx,hashBlock,false) != 0 )
+        {
+            if ( (nValue= IsPricesvout(cp,vintx,vout)) > 1000000 && myIsutxo_spentinmempool(txid,vout) == 0 )
+            {
+                if ( total != 0 && maxinputs != 0 )
+                    mtx.vin.push_back(CTxIn(txid,vout,CScript()));
+                nValue = it->second.satoshis;
+                totalinputs += nValue;
+                n++;
+                if ( (total > 0 && totalinputs >= total) || (maxinputs > 0 && n >= maxinputs) )
+                    break;
+            }
+        }
+    }
+    return(totalinputs);
+}
+
+/*
+ UniValue PriceInfo(uint256 origtxid)
+{
+    UniValue result(UniValue::VOBJ),a(UniValue::VARR),obj(UniValue::VOBJ);
+    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
+    CTransaction regtx,tx; std::string name,description,format; uint256 hashBlock,txid,oracletxid,batontxid; CPubKey markerpubkey,pk; struct CCcontract_info *cp,C; uint8_t buf33[33]; int64_t datafee,funding; char str[67],markeraddr[64],numstr[64],batonaddr[64]; std::vector <uint8_t> data;
+    cp = CCinit(&C,EVAL_ORACLES);
+    buf33[0] = 0x02;
+    endiancpy(&buf33[1],(uint8_t *)&origtxid,32);
+    markerpubkey = buf2pk(buf33);
+    Getscriptaddress(markeraddr,CScript() << ParseHex(HexStr(markerpubkey)) << OP_CHECKSIG);
+    if ( GetTransaction(origtxid,tx,hashBlock,false) != 0 )
+    {
+        if ( tx.vout.size() > 0 && DecodeOraclesCreateOpRet(tx.vout[tx.vout.size()-1].scriptPubKey,name,description,format) == 'C' )
+        {
+            result.push_back(Pair("result","success"));
+            result.push_back(Pair("txid",uint256_str(str,origtxid)));
+            result.push_back(Pair("name",name));
+            result.push_back(Pair("description",description));
+            result.push_back(Pair("format",format));
+            result.push_back(Pair("marker",markeraddr));
+            SetCCunspents(unspentOutputs,markeraddr);
+            for (std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> >::const_iterator it=unspentOutputs.begin(); it!=unspentOutputs.end(); it++)
+            {
+                txid = it->first.txhash;
+                if ( GetTransaction(txid,regtx,hashBlock,false) != 0 )
+                {
+                    if ( regtx.vout.size() > 0 && DecodeOraclesOpRet(regtx.vout[regtx.vout.size()-1].scriptPubKey,oracletxid,pk,datafee) == 'R' && oracletxid == origtxid )
+                    {
+                        obj.push_back(Pair("provider",pubkey33_str(str,(uint8_t *)pk.begin())));
+                        Getscriptaddress(batonaddr,regtx.vout[1].scriptPubKey);
+                        batontxid = OracleBatonUtxo(10000,cp,oracletxid,batonaddr,pk,data);
+                        obj.push_back(Pair("baton",batonaddr));
+                        obj.push_back(Pair("batontxid",uint256_str(str,batontxid)));
+                        funding = LifetimeOraclesFunds(cp,oracletxid,pk);
+                        sprintf(numstr,"%.8f",(double)funding/COIN);
+                        obj.push_back(Pair("lifetime",numstr));
+                        funding = AddOracleInputs(cp,mtx,pk,0,0);
+                        sprintf(numstr,"%.8f",(double)funding/COIN);
+                        obj.push_back(Pair("funds",numstr));
+                        sprintf(numstr,"%.8f",(double)datafee/COIN);
+                        obj.push_back(Pair("datafee",numstr));
+                        a.push_back(obj);
+                    }
+                }
+            }
+            result.push_back(Pair("registered",a));
+        }
+    }
+    return(result);
+}
+
+UniValue PricesList()
+{
+    UniValue result(UniValue::VARR); std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex; struct CCcontract_info *cp,C; uint256 txid,hashBlock; CTransaction createtx; std::string name,description,format; char str[65];
+    cp = CCinit(&C,EVAL_ORACLES);
+    SetCCtxids(addressIndex,cp->normaladdr);
+    for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=addressIndex.begin(); it!=addressIndex.end(); it++)
+    {
+        txid = it->first.txhash;
+        if ( GetTransaction(txid,createtx,hashBlock,false) != 0 )
+        {
+            if ( createtx.vout.size() > 0 && DecodeOraclesCreateOpRet(createtx.vout[createtx.vout.size()-1].scriptPubKey,name,description,format) == 'C' )
+            {
+                result.push_back(uint256_str(str,txid));
+            }
+        }
+    }
+    return(result);
+}
+*/
diff --git a/src/cc/rewards.cpp b/src/cc/rewards.cpp
index 8d9a9fa78..61f10418c 100644
--- a/src/cc/rewards.cpp
+++ b/src/cc/rewards.cpp
@@ -66,8 +66,6 @@
  
  */
 
-extern std::string CCerror;
-
 int64_t RewardsCalc(int64_t amount,uint256 txid,uint64_t APR,uint64_t minseconds,uint64_t maxseconds,uint64_t mindeposit)
 {
     int32_t numblocks; uint64_t duration,reward = 0;
@@ -244,8 +242,6 @@ bool RewardsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &t
                     //vout.0: funding CC change or recover normal payout
                     //vout.1: normal output to unlock address
                     //vout.n-1: opreturn 'U' sbits fundingtxid
-                    //char str[65],str2[65];
-                    //fprintf(stderr,"funding.%s vs %s\n",uint256_str(str,fundingtxid),uint256_str(str2,tx.vin[0].prevout.hash));
                     if ( fundingtxid == tx.vin[0].prevout.hash )
                         return eval->Invalid("cant unlock fundingtxid");
                     else if ( eval->GetTxUnconfirmed(tx.vin[0].prevout.hash,vinTx,hashBlock) == 0 )
diff --git a/src/cc/triggers.cpp b/src/cc/triggers.cpp
new file mode 100644
index 000000000..93107f4a9
--- /dev/null
+++ b/src/cc/triggers.cpp
@@ -0,0 +1,212 @@
+/******************************************************************************
+ * Copyright © 2014-2018 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+
+#include "CCTriggers.h"
+
+/*
+ Triggers CC is a building block CC that allows creation of event -> action processing, where events are defined during trigger creation and actions to be mostly done via payments, but by making payments to other CC contracts, it can be used to invoke other CC contracts
+ 
+*/
+
+// start of consensus code
+
+int64_t IsTriggersvout(struct CCcontract_info *cp,const CTransaction& tx,int32_t v)
+{
+    char destaddr[64];
+    if ( tx.vout[v].scriptPubKey.IsPayToCryptoCondition() != 0 )
+    {
+        if ( Getscriptaddress(destaddr,tx.vout[v].scriptPubKey) > 0 && strcmp(destaddr,cp->unspendableCCaddr) == 0 )
+            return(tx.vout[v].nValue);
+    }
+    return(0);
+}
+
+bool TriggersExactAmounts(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx,int32_t minage,uint64_t txfee)
+{
+    static uint256 zerohash;
+    CTransaction vinTx; uint256 hashBlock,activehash; int32_t i,numvins,numvouts; int64_t inputs=0,outputs=0,assetoshis;
+    numvins = tx.vin.size();
+    numvouts = tx.vout.size();
+    for (i=0; i<numvins; i++)
+    {
+        //fprintf(stderr,"vini.%d\n",i);
+        if ( (*cp->ismyvin)(tx.vin[i].scriptSig) != 0 )
+        {
+            //fprintf(stderr,"vini.%d check mempool\n",i);
+            if ( eval->GetTxUnconfirmed(tx.vin[i].prevout.hash,vinTx,hashBlock) == 0 )
+                return eval->Invalid("cant find vinTx");
+            else
+            {
+                //fprintf(stderr,"vini.%d check hash and vout\n",i);
+                if ( hashBlock == zerohash )
+                    return eval->Invalid("cant Triggers from mempool");
+                if ( (assetoshis= IsTriggersvout(cp,vinTx,tx.vin[i].prevout.n)) != 0 )
+                    inputs += assetoshis;
+            }
+        }
+    }
+    for (i=0; i<numvouts; i++)
+    {
+        //fprintf(stderr,"i.%d of numvouts.%d\n",i,numvouts);
+        if ( (assetoshis= IsTriggersvout(cp,tx,i)) != 0 )
+            outputs += assetoshis;
+    }
+    if ( inputs != outputs+txfee )
+    {
+        fprintf(stderr,"inputs %llu vs outputs %llu\n",(long long)inputs,(long long)outputs);
+        return eval->Invalid("mismatched inputs != outputs + txfee");
+    }
+    else return(true);
+}
+
+bool TriggersValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx)
+{
+    int32_t numvins,numvouts,preventCCvins,preventCCvouts,i,numblocks; bool retval; uint256 txid; uint8_t hash[32]; char str[65],destaddr[64];
+    return(false);
+    std::vector<std::pair<CAddressIndexKey, CAmount> > txids;
+    numvins = tx.vin.size();
+    numvouts = tx.vout.size();
+    preventCCvins = preventCCvouts = -1;
+    if ( numvouts < 1 )
+        return eval->Invalid("no vouts");
+    else
+    {
+        for (i=0; i<numvins; i++)
+        {
+            if ( IsCCInput(tx.vin[0].scriptSig) == 0 )
+            {
+                return eval->Invalid("illegal normal vini");
+            }
+        }
+        //fprintf(stderr,"check amounts\n");
+        if ( TriggersExactAmounts(cp,eval,tx,1,10000) == false )
+        {
+            fprintf(stderr,"Triggersget invalid amount\n");
+            return false;
+        }
+        else
+        {
+            txid = tx.GetHash();
+            memcpy(hash,&txid,sizeof(hash));
+            retval = PreventCC(eval,tx,preventCCvins,numvins,preventCCvouts,numvouts);
+            if ( retval != 0 )
+                fprintf(stderr,"Triggersget validated\n");
+            else fprintf(stderr,"Triggersget invalid\n");
+            return(retval);
+        }
+    }
+}
+// end of consensus code
+
+// helper functions for rpc calls in rpcwallet.cpp
+
+int64_t AddTriggersInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPubKey pk,int64_t total,int32_t maxinputs)
+{
+    char coinaddr[64]; int64_t nValue,price,totalinputs = 0; uint256 txid,hashBlock; std::vector<uint8_t> origpubkey; CTransaction vintx; int32_t vout,n = 0;
+    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
+    GetCCaddress(cp,coinaddr,pk);
+    SetCCunspents(unspentOutputs,coinaddr);
+    for (std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> >::const_iterator it=unspentOutputs.begin(); it!=unspentOutputs.end(); it++)
+    {
+        txid = it->first.txhash;
+        vout = (int32_t)it->first.index;
+        // no need to prevent dup
+        if ( GetTransaction(txid,vintx,hashBlock,false) != 0 )
+        {
+            if ( (nValue= IsTriggersvout(cp,vintx,vout)) > 1000000 && myIsutxo_spentinmempool(txid,vout) == 0 )
+            {
+                if ( total != 0 && maxinputs != 0 )
+                    mtx.vin.push_back(CTxIn(txid,vout,CScript()));
+                nValue = it->second.satoshis;
+                totalinputs += nValue;
+                n++;
+                if ( (total > 0 && totalinputs >= total) || (maxinputs > 0 && n >= maxinputs) )
+                    break;
+            }
+        }
+    }
+    return(totalinputs);
+}
+
+std::string TriggersGet(uint64_t txfee,int64_t nValue)
+{
+    CMutableTransaction mtx,tmpmtx; CPubKey mypk,Triggerspk; int64_t inputs,CCchange=0; struct CCcontract_info *cp,C; std::string rawhex; uint32_t j; int32_t i,len; uint8_t buf[32768]; bits256 hash;
+    cp = CCinit(&C,EVAL_TRIGGERS);
+    if ( txfee == 0 )
+        txfee = 10000;
+    Triggerspk = GetUnspendable(cp,0);
+    mypk = pubkey2pk(Mypubkey());
+    if ( (inputs= AddTriggersInputs(cp,mtx,Triggerspk,nValue+txfee,60)) > 0 )
+    {
+        if ( inputs > nValue )
+            CCchange = (inputs - nValue - txfee);
+        if ( CCchange != 0 )
+            mtx.vout.push_back(MakeCC1vout(EVAL_TRIGGERS,CCchange,Triggerspk));
+        mtx.vout.push_back(CTxOut(nValue,CScript() << ParseHex(HexStr(mypk)) << OP_CHECKSIG));
+        fprintf(stderr,"start at %u\n",(uint32_t)time(NULL));
+        j = rand() & 0xfffffff;
+        for (i=0; i<1000000; i++,j++)
+        {
+            tmpmtx = mtx;
+            rawhex = FinalizeCCTx(-1LL,cp,tmpmtx,mypk,txfee,CScript() << OP_RETURN << E_MARSHAL(ss << (uint8_t)EVAL_TRIGGERS << (uint8_t)'G' << j));
+            if ( (len= (int32_t)rawhex.size()) > 0 && len < 65536 )
+            {
+                len >>= 1;
+                decode_hex(buf,len,(char *)rawhex.c_str());
+                hash = bits256_doublesha256(0,buf,len);
+                if ( (hash.bytes[0] & 0xff) == 0 && (hash.bytes[31] & 0xff) == 0 )
+                {
+                    fprintf(stderr,"found valid txid after %d iterations %u\n",i,(uint32_t)time(NULL));
+                    return(rawhex);
+                }
+                //fprintf(stderr,"%02x%02x ",hash.bytes[0],hash.bytes[31]);
+            }
+        }
+        fprintf(stderr,"couldnt generate valid txid %u\n",(uint32_t)time(NULL));
+        return("");
+    } else fprintf(stderr,"cant find Triggers inputs\n");
+    return("");
+}
+
+std::string TriggersFund(uint64_t txfee,int64_t funds)
+{
+    CMutableTransaction mtx; CPubKey mypk,Triggerspk; CScript opret; struct CCcontract_info *cp,C;
+    cp = CCinit(&C,EVAL_TRIGGERS);
+    if ( txfee == 0 )
+        txfee = 10000;
+    mypk = pubkey2pk(Mypubkey());
+    Triggerspk = GetUnspendable(cp,0);
+    if ( AddNormalinputs(mtx,mypk,funds+txfee,64) > 0 )
+    {
+        mtx.vout.push_back(MakeCC1vout(EVAL_TRIGGERS,funds,Triggerspk));
+        return(FinalizeCCTx(0,cp,mtx,mypk,txfee,opret));
+    }
+    return("");
+}
+
+UniValue TriggersInfo()
+{
+    UniValue result(UniValue::VOBJ); char numstr[64];
+    CMutableTransaction mtx; CPubKey Triggerspk; struct CCcontract_info *cp,C; int64_t funding;
+    result.push_back(Pair("result","success"));
+    result.push_back(Pair("name","Triggers"));
+    cp = CCinit(&C,EVAL_TRIGGERS);
+    Triggerspk = GetUnspendable(cp,0);
+    funding = AddTriggersInputs(cp,mtx,Triggerspk,0,0);
+    sprintf(numstr,"%.8f",(double)funding/COIN);
+    result.push_back(Pair("funding",numstr));
+    return(result);
+}
+
diff --git a/src/deprecation.cpp b/src/deprecation.cpp
index 73ff8046d..fa8b7c521 100644
--- a/src/deprecation.cpp
+++ b/src/deprecation.cpp
@@ -31,7 +31,7 @@ void EnforceNodeDeprecation(int nHeight, bool forceLogging) {
         if (blocksToDeprecation == 0 || forceLogging) {
             auto msg = strprintf(_("This version has been deprecated as of block height %d."),
                                  DEPRECATION_HEIGHT) + " " +
-                       _("You should upgrade to the latest version of Zcash.");
+                       _("You should upgrade to the latest version of Komodo.");
             if (!disableDeprecation) {
                 msg += " " + strprintf(_("To disable deprecation for this version, set %s%s."),
                                        "-disabledeprecation=", CLIENT_VERSION_STR);
@@ -48,11 +48,11 @@ void EnforceNodeDeprecation(int nHeight, bool forceLogging) {
         if (disableDeprecation) {
             msg = strprintf(_("This version will be deprecated at block height %d."),
                             DEPRECATION_HEIGHT) + " " +
-                  _("You should upgrade to the latest version of Zcash.");
+                  _("You should upgrade to the latest version of Komodo.");
         } else {
             msg = strprintf(_("This version will be deprecated at block height %d, and will automatically shut down."),
                             DEPRECATION_HEIGHT) + " " +
-                  _("You should upgrade to the latest version of Zcash.") + " " +
+                  _("You should upgrade to the latest version of Komodo.") + " " +
                   strprintf(_("To disable deprecation for this version, set %s%s."),
                             "-disabledeprecation=", CLIENT_VERSION_STR);
         }
diff --git a/src/init.cpp b/src/init.cpp
index a9bdc6151..1105cda31 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -1399,6 +1399,28 @@ bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
     LogPrintf("* Using %.1fMiB for chain state database\n", nCoinDBCache * (1.0 / 1024 / 1024));
     LogPrintf("* Using %.1fMiB for in-memory UTXO set\n", nCoinCacheUsage * (1.0 / 1024 / 1024));
 
+    if ( fReindex == 0 )
+    {
+        bool checkval,fAddressIndex,fSpentIndex;
+        pblocktree = new CBlockTreeDB(nBlockTreeDBCache, false, fReindex, dbCompression, dbMaxOpenFiles);
+        fAddressIndex = GetBoolArg("-addressindex", DEFAULT_ADDRESSINDEX);
+        pblocktree->ReadFlag("addressindex", checkval);
+        if ( checkval != fAddressIndex  )
+        {
+            pblocktree->WriteFlag("addressindex", fAddressIndex);
+            fprintf(stderr,"set addressindex, will reindex. sorry will take a while.\n");
+            fReindex = true;
+        }
+        fSpentIndex = GetBoolArg("-spentindex", DEFAULT_SPENTINDEX);
+        pblocktree->ReadFlag("spentindex", checkval);
+        if ( checkval != fSpentIndex )
+        {
+            pblocktree->WriteFlag("spentindex", fSpentIndex);
+            fprintf(stderr,"set spentindex, will reindex. sorry will take a while.\n");
+            fReindex = true;
+        }
+    }
+    
     bool fLoaded = false;
     while (!fLoaded) {
         bool fReset = fReindex;
@@ -1568,7 +1590,7 @@ bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
                 InitWarning(msg);
             }
             else if (nLoadWalletRet == DB_TOO_NEW)
-                strErrors << _("Error loading wallet.dat: Wallet requires newer version of Zcash") << "\n";
+                strErrors << _("Error loading wallet.dat: Wallet requires newer version of Komodo") << "\n";
             else if (nLoadWalletRet == DB_NEED_REWRITE)
             {
                 strErrors << _("Wallet needed to be rewritten: restart Zcash to complete") << "\n";
diff --git a/src/komodo.h b/src/komodo.h
index 4b61cafa0..b233f2ffa 100644
--- a/src/komodo.h
+++ b/src/komodo.h
@@ -158,7 +158,7 @@ int32_t komodo_parsestatefile(struct komodo_state *sp,FILE *fp,char *symbol,char
         }
         else if ( func == 'R' )
         {
-            uint16_t olen,v; uint64_t ovalue; uint256 txid; uint8_t opret[16384];
+            uint16_t olen,v; uint64_t ovalue; uint256 txid; uint8_t opret[16384*4];
             if ( fread(&txid,1,sizeof(txid),fp) != sizeof(txid) )
                 errs++;
             if ( fread(&v,1,sizeof(v),fp) != sizeof(v) )
@@ -298,7 +298,7 @@ int32_t komodo_parsestatefiledata(struct komodo_state *sp,uint8_t *filedata,long
         }
         else if ( func == 'R' )
         {
-            uint16_t olen,v; uint64_t ovalue; uint256 txid; uint8_t opret[16384];
+            uint16_t olen,v; uint64_t ovalue; uint256 txid; uint8_t opret[16384*4];
             if ( memread(&txid,sizeof(txid),filedata,&fpos,datalen) != sizeof(txid) )
                 errs++;
             if ( memread(&v,sizeof(v),filedata,&fpos,datalen) != sizeof(v) )
diff --git a/src/komodo_defs.h b/src/komodo_defs.h
index 1d7351638..7c339856c 100644
--- a/src/komodo_defs.h
+++ b/src/komodo_defs.h
@@ -6,6 +6,7 @@
 #define ROUNDROBIN_DELAY 61
 #define KOMODO_ASSETCHAIN_MAXLEN 65
 #define KOMODO_LIMITED_NETWORKSIZE 4
+#define IGUANA_MAXSCRIPTSIZE 10001
 #define KOMODO_MAXMEMPOOLTIME 3600 // affects consensus
 #define CRYPTO777_PUBSECPSTR "020e46e79a2a8d12b9b5d12c7a91adb4e454edfae43c0a0cb805427d2ac7613fd9"
 
diff --git a/src/komodo_gateway.h b/src/komodo_gateway.h
index 20ece62d2..379224b48 100644
--- a/src/komodo_gateway.h
+++ b/src/komodo_gateway.h
@@ -416,7 +416,7 @@ static int _paxorder(const void *a,const void *b)
 
 int32_t komodo_pending_withdraws(char *opretstr) // todo: enforce deterministic order
 {
-    struct pax_transaction *pax,*pax2,*tmp,*paxes[64]; uint8_t opretbuf[16384]; int32_t i,n,ht,len=0; uint64_t total = 0;
+    struct pax_transaction *pax,*pax2,*tmp,*paxes[64]; uint8_t opretbuf[16384*4]; int32_t i,n,ht,len=0; uint64_t total = 0;
     if ( KOMODO_PAX == 0 || KOMODO_PASSPORT_INITDONE == 0 )
         return(0);
     if ( komodo_isrealtime(&ht) == 0 || ASSETCHAINS_SYMBOL[0] != 0 )
@@ -465,7 +465,7 @@ int32_t komodo_pending_withdraws(char *opretstr) // todo: enforce deterministic
 
 int32_t komodo_gateway_deposits(CMutableTransaction *txNew,char *base,int32_t tokomodo)
 {
-    struct pax_transaction *pax,*tmp; char symbol[KOMODO_ASSETCHAIN_MAXLEN],dest[KOMODO_ASSETCHAIN_MAXLEN]; uint8_t *script,opcode,opret[16384],data[16384]; int32_t i,baseid,ht,len=0,opretlen=0,numvouts=1; struct komodo_state *sp; uint64_t available,deposited,issued,withdrawn,approved,redeemed,mask,sum = 0;
+    struct pax_transaction *pax,*tmp; char symbol[KOMODO_ASSETCHAIN_MAXLEN],dest[KOMODO_ASSETCHAIN_MAXLEN]; uint8_t *script,opcode,opret[16384*4],data[16384*4]; int32_t i,baseid,ht,len=0,opretlen=0,numvouts=1; struct komodo_state *sp; uint64_t available,deposited,issued,withdrawn,approved,redeemed,mask,sum = 0;
     if ( KOMODO_PASSPORT_INITDONE == 0 )//KOMODO_PAX == 0 ||
         return(0);
     struct komodo_state *kmdsp = komodo_stateptrget((char *)"KMD");
@@ -755,6 +755,7 @@ int32_t komodo_check_deposit(int32_t height,const CBlock& block,uint32_t prevtim
             if ( height > 1 && checktoshis == 0 )
             {
                 checktoshis = ((uint64_t)GetBlockSubsidy(height, Params().GetConsensus()) - block.vtx[0].vout[0].nValue);
+                // some pools will need to change their pool fee to be (poolfee % - txfees)
                 //checktoshis += txn_count * 0.001; // rely on higher level validations to prevent emitting more coins than actual txfees
             }
             if ( height >= 2 && (overflow != 0 || total > checktoshis || strangeout != 0) )
diff --git a/src/komodo_globals.h b/src/komodo_globals.h
index 918e7c4f6..cc5104d12 100644
--- a/src/komodo_globals.h
+++ b/src/komodo_globals.h
@@ -33,7 +33,6 @@ int32_t komodo_bannedset(int32_t *indallvoutsp,uint256 *array,int32_t max);
 pthread_mutex_t komodo_mutex;
 
 #define KOMODO_ELECTION_GAP 2000    //((ASSETCHAINS_SYMBOL[0] == 0) ? 2000 : 100)
-#define IGUANA_MAXSCRIPTSIZE 10001
 #define KOMODO_ASSETCHAIN_MAXLEN 65
 
 struct pax_transaction *PAX;
diff --git a/src/komodo_kv.h b/src/komodo_kv.h
index 4cf482116..37e11d06d 100644
--- a/src/komodo_kv.h
+++ b/src/komodo_kv.h
@@ -100,7 +100,7 @@ int32_t komodo_kvsearch(uint256 *pubkeyp,int32_t current_height,uint32_t *flagsp
 void komodo_kvupdate(uint8_t *opretbuf,int32_t opretlen,uint64_t value)
 {
     static uint256 zeroes;
-    uint32_t flags; uint256 pubkey,refpubkey,sig; int32_t i,refvaluesize,hassig,coresize,haspubkey,height,kvheight; uint16_t keylen,valuesize,newflag = 0; uint8_t *key,*valueptr,keyvalue[IGUANA_MAXSCRIPTSIZE]; struct komodo_kv *ptr; char *transferpubstr,*tstr; uint64_t fee;
+    uint32_t flags; uint256 pubkey,refpubkey,sig; int32_t i,refvaluesize,hassig,coresize,haspubkey,height,kvheight; uint16_t keylen,valuesize,newflag = 0; uint8_t *key,*valueptr,keyvalue[IGUANA_MAXSCRIPTSIZE*8]; struct komodo_kv *ptr; char *transferpubstr,*tstr; uint64_t fee;
     if ( ASSETCHAINS_SYMBOL[0] == 0 ) // disable KV for KMD
         return;
     iguana_rwnum(0,&opretbuf[1],sizeof(keylen),&keylen);
diff --git a/src/komodo_utils.h b/src/komodo_utils.h
index 23e6b280e..d98418c82 100644
--- a/src/komodo_utils.h
+++ b/src/komodo_utils.h
@@ -1651,7 +1651,7 @@ void komodo_args(char *argv0)
             //printf("created (%s)\n",fname);
         } else printf("error creating (%s)\n",fname);
 #endif
-        if ( KOMODO_CCACTIVATE != 0 && ASSETCHAINS_CC == 0 )
+        if ( KOMODO_CCACTIVATE != 0 && ASSETCHAINS_CC < 2 )
         {
             ASSETCHAINS_CC = 2;
             fprintf(stderr,"smart utxo CC contracts will activate at height.%d\n",KOMODO_CCACTIVATE);
diff --git a/src/main.cpp b/src/main.cpp
index e25d6419b..093237051 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -598,10 +598,10 @@ UniValue komodo_snapshot(int top)
 	    if ( pblocktree != 0 ) {
 		result = pblocktree->Snapshot(top);
 	    } else {
-		fprintf(stderr,"null pblocktree start with -addressindex=true\n");
+		fprintf(stderr,"null pblocktree start with -addressindex=1\n");
 	    }
     } else {
-	    fprintf(stderr,"getsnapshot requires -addressindex=true\n");
+	    fprintf(stderr,"getsnapshot requires -addressindex=1\n");
     }
     return(result);
 }
@@ -742,6 +742,11 @@ bool IsStandardTx(const CTransaction& tx, string& reason, const int nHeight)
         
         if (whichType == TX_NULL_DATA)
         {
+            if ( txout.scriptPubKey.size() > IGUANA_MAXSCRIPTSIZE )
+            {
+                reason = "opreturn too big";
+                return(false);
+            }
             nDataOut++;
             //fprintf(stderr,"is OP_RETURN\n");
         }
@@ -3422,7 +3427,7 @@ bool static DisconnectTip(CValidationState &state, bool fBare = false) {
     for (int i = 0; i < block.vtx.size(); i++)
     {
         CTransaction &tx = block.vtx[i];
-        if ( (i == (block.vtx.size() - 1)) && komodo_isPoS((CBlock *)&block) != 0 )
+        if ( ASSETCHAINS_STAKED != 0 && (i == (block.vtx.size() - 1)) && komodo_isPoS((CBlock *)&block) != 0 )
         {
             EraseFromWallets(tx.GetHash());
         }
@@ -4176,13 +4181,12 @@ bool CheckBlock(int32_t *futureblockp,int32_t height,CBlockIndex *pindex,const C
             for (i=0; i<block.vtx.size(); i++)
             {
                 CTransaction Tx; const CTransaction &tx = (CTransaction)block.vtx[i];
-                if (tx.IsCoinBase() != 0 )
+                if ( tx.IsCoinBase() != 0 )
                     continue;
                 else if ( ASSETCHAINS_STAKED != 0 && (i == (block.vtx.size() - 1)) && komodo_isPoS((CBlock *)&block) != 0 )
                     continue;
                 Tx = tx;
-                if ( myAddtomempool(Tx) == false ) // can happen with out of order tx in block on resync
-                //if ( AcceptToMemoryPool(mempool, stateDummy, tx, false, NULL) == false )
+                if ( myAddtomempool(Tx) == false ) // happens with out of order tx in block on resync
                     rejects++;
             }
             if ( rejects == 0 || rejects == lastrejects )
@@ -5321,11 +5325,11 @@ bool InitBlockIndex() {
     
     // Initialize global variables that cannot be constructed at startup.
     recentRejects.reset(new CRollingBloomFilter(120000, 0.000001));
-    
     // Check whether we're already initialized
     if (chainActive.Genesis() != NULL)
+    {
         return true;
-    
+    }
     // Use the provided setting for -txindex in the new database
     fTxIndex = GetBoolArg("-txindex", true);
     pblocktree->WriteFlag("txindex", fTxIndex);
@@ -5336,9 +5340,10 @@ bool InitBlockIndex() {
     // Use the provided setting for -timestampindex in the new database
     fTimestampIndex = GetBoolArg("-timestampindex", DEFAULT_TIMESTAMPINDEX);
     pblocktree->WriteFlag("timestampindex", fTimestampIndex);
-
+    
     fSpentIndex = GetBoolArg("-spentindex", DEFAULT_SPENTINDEX);
     pblocktree->WriteFlag("spentindex", fSpentIndex);
+    fprintf(stderr,"fAddressIndex.%d/%d fSpentIndex.%d/%d\n",fAddressIndex,DEFAULT_ADDRESSINDEX,fSpentIndex,DEFAULT_SPENTINDEX);
     LogPrintf("Initializing databases...\n");
     
     // Only add the genesis block if not reindexing (in which case we reuse the one already on disk)
diff --git a/src/rpcblockchain.cpp b/src/rpcblockchain.cpp
index 7f01c862f..aac0c0f21 100644
--- a/src/rpcblockchain.cpp
+++ b/src/rpcblockchain.cpp
@@ -31,6 +31,7 @@ using namespace std;
 
 extern void TxToJSON(const CTransaction& tx, const uint256 hashBlock, UniValue& entry);
 void ScriptPubKeyToJSON(const CScript& scriptPubKey, UniValue& out, bool fIncludeHex);
+int32_t komodo_longestchain();
 
 double GetDifficultyINTERNAL(const CBlockIndex* blockindex, bool networkDifficulty)
 {
@@ -797,7 +798,7 @@ int32_t komodo_kvsearch(uint256 *refpubkeyp,int32_t current_height,uint32_t *fla
 
 UniValue kvsearch(const UniValue& params, bool fHelp)
 {
-    UniValue ret(UniValue::VOBJ); uint32_t flags; uint8_t value[IGUANA_MAXSCRIPTSIZE],key[IGUANA_MAXSCRIPTSIZE]; int32_t duration,j,height,valuesize,keylen; uint256 refpubkey; static uint256 zeroes;
+    UniValue ret(UniValue::VOBJ); uint32_t flags; uint8_t value[IGUANA_MAXSCRIPTSIZE*8],key[IGUANA_MAXSCRIPTSIZE*8]; int32_t duration,j,height,valuesize,keylen; uint256 refpubkey; static uint256 zeroes;
     if (fHelp || params.size() != 1 )
         throw runtime_error(
             "kvsearch key\n"
@@ -1297,14 +1298,20 @@ UniValue getblockchaininfo(const UniValue& params, bool fHelp)
         );
 
     LOCK(cs_main);
-
+    double progress;
+    if ( ASSETCHAINS_SYMBOL[0] == 0 ) {
+        progress = Checkpoints::GuessVerificationProgress(Params().Checkpoints(), chainActive.LastTip());
+    } else {
+	    int32_t longestchain = komodo_longestchain();
+	    progress = (longestchain > 0 ) ? (double) chainActive.Height() / longestchain : 1.0;
+    }
     UniValue obj(UniValue::VOBJ);
     obj.push_back(Pair("chain",                 Params().NetworkIDString()));
     obj.push_back(Pair("blocks",                (int)chainActive.Height()));
     obj.push_back(Pair("headers",               pindexBestHeader ? pindexBestHeader->nHeight : -1));
     obj.push_back(Pair("bestblockhash",         chainActive.LastTip()->GetBlockHash().GetHex()));
     obj.push_back(Pair("difficulty",            (double)GetNetworkDifficulty()));
-    obj.push_back(Pair("verificationprogress",  Checkpoints::GuessVerificationProgress(Params().Checkpoints(), chainActive.LastTip())));
+    obj.push_back(Pair("verificationprogress",  progress));
     obj.push_back(Pair("chainwork",             chainActive.LastTip()->nChainWork.GetHex()));
     obj.push_back(Pair("pruned",                fPruneMode));
 
diff --git a/src/rpcserver.cpp b/src/rpcserver.cpp
index 0cac14c8b..21d24e112 100644
--- a/src/rpcserver.cpp
+++ b/src/rpcserver.cpp
@@ -375,6 +375,43 @@ static const CRPCCommand vRPCCommands[] =
     { "faucet",       "faucetget",       &faucetget,          true },
     { "faucet",       "faucetaddress",   &faucetaddress,      true },
     
+    /* MofN */
+    { "MofN",       "mofnaddress",   &mofnaddress,      true },
+    
+    /* Channels */
+    { "channels",       "channelsaddress",   &channelsaddress,   true },
+    { "channels",       "channelsinfo",      &channelsinfo,      true },
+    { "channels",       "channelsopen",      &channelsopen,      true },
+    { "channels",       "channelspayment",   &channelspayment,   true },
+    { "channels",       "channelscollect",   &channelscollect,   true },
+    { "channels",       "channelsstop",      &channelsstop,      true },
+    { "channels",       "channelsrefund",    &channelsrefund,    true },
+    
+    /* Oracles */
+    { "oracles",       "oraclesaddress",   &oraclesaddress,     true },
+    { "oracles",       "oracleslist",      &oracleslist,        true },
+    { "oracles",       "oraclesinfo",      &oraclesinfo,        true },
+    { "oracles",       "oraclescreate",    &oraclescreate,      true },
+    { "oracles",       "oraclesregister",  &oraclesregister,    true },
+    { "oracles",       "oraclessubscribe", &oraclessubscribe,   true },
+    { "oracles",       "oraclesdata",      &oraclesdata,        true },
+    { "oracles",       "oraclessamples",   &oraclessamples,     true },
+    
+    /* Prices */
+    { "prices",       "pricesaddress",   &pricesaddress,      true },
+    
+    /* Pegs */
+    { "pegs",       "pegsaddress",   &pegsaddress,      true },
+    
+    /* Triggers */
+    { "triggers",       "triggersaddress",   &triggersaddress,      true },
+    
+    /* Payments */
+    { "payments",       "paymentsaddress",   &paymentsaddress,      true },
+    
+    /* Gateways */
+    { "gateways",       "gatewaysaddress",   &gatewaysaddress,      true },
+
     /* dice */
     { "dice",       "dicelist",      &dicelist,         true },
     { "dice",       "diceinfo",      &diceinfo,         true },
diff --git a/src/rpcserver.h b/src/rpcserver.h
index 336595156..1cc68798c 100644
--- a/src/rpcserver.h
+++ b/src/rpcserver.h
@@ -221,6 +221,28 @@ extern UniValue tokenfillbid(const UniValue& params, bool fHelp);
 extern UniValue tokenask(const UniValue& params, bool fHelp);
 extern UniValue tokencancelask(const UniValue& params, bool fHelp);
 extern UniValue tokenfillask(const UniValue& params, bool fHelp);
+extern UniValue mofnaddress(const UniValue& params, bool fHelp);
+extern UniValue channelsaddress(const UniValue& params, bool fHelp);
+extern UniValue oraclesaddress(const UniValue& params, bool fHelp);
+extern UniValue oracleslist(const UniValue& params, bool fHelp);
+extern UniValue oraclesinfo(const UniValue& params, bool fHelp);
+extern UniValue oraclescreate(const UniValue& params, bool fHelp);
+extern UniValue oraclesregister(const UniValue& params, bool fHelp);
+extern UniValue oraclessubscribe(const UniValue& params, bool fHelp);
+extern UniValue oraclesdata(const UniValue& params, bool fHelp);
+extern UniValue oraclessamples(const UniValue& params, bool fHelp);
+extern UniValue pricesaddress(const UniValue& params, bool fHelp);
+extern UniValue pegsaddress(const UniValue& params, bool fHelp);
+extern UniValue triggersaddress(const UniValue& params, bool fHelp);
+extern UniValue paymentsaddress(const UniValue& params, bool fHelp);
+extern UniValue gatewaysaddress(const UniValue& params, bool fHelp);
+extern UniValue channelsinfo(const UniValue& params, bool fHelp);
+extern UniValue channelsopen(const UniValue& params, bool fHelp);
+extern UniValue channelspayment(const UniValue& params, bool fHelp);
+extern UniValue channelscollect(const UniValue& params, bool fHelp);
+extern UniValue channelsstop(const UniValue& params, bool fHelp);
+extern UniValue channelsrefund(const UniValue& params, bool fHelp);
+
 //extern UniValue tokenswapask(const UniValue& params, bool fHelp);
 //extern UniValue tokenfillswap(const UniValue& params, bool fHelp);
 extern UniValue faucetfund(const UniValue& params, bool fHelp);
diff --git a/src/script/standard.cpp b/src/script/standard.cpp
index 58d2bc701..fde836154 100644
--- a/src/script/standard.cpp
+++ b/src/script/standard.cpp
@@ -73,8 +73,10 @@ bool Solver(const CScript& scriptPubKey, txnouttype& typeRet, vector<vector<unsi
 
     if (IsCryptoConditionsEnabled()) {
         // Shortcut for pay-to-crypto-condition
-        if (scriptPubKey.IsPayToCryptoCondition()) {
-            if (scriptPubKey.MayAcceptCryptoCondition()) {
+        if (scriptPubKey.IsPayToCryptoCondition())
+        {
+            if (scriptPubKey.MayAcceptCryptoCondition())
+            {
                 typeRet = TX_CRYPTOCONDITION;
                 vector<unsigned char> hashBytes; uint160 x; int32_t i; uint8_t hash20[20],*ptr;;
                 x = Hash160(scriptPubKey);
diff --git a/src/sendalert.cpp b/src/sendalert.cpp
index 3b7b53734..218465994 100644
--- a/src/sendalert.cpp
+++ b/src/sendalert.cpp
@@ -88,7 +88,7 @@ void ThreadSendAlert()
     //  4000 or higher will put the RPC into safe mode
     alert.nPriority     = 4000;
     alert.strComment    = "";
-    alert.strStatusBar  = "Your client version 1.0.10 has degraded networking behavior. Please update to the most recent version of Zcash (1.0.10-1 or later).";
+    alert.strStatusBar  = "Your client version 1.0.10 has degraded networking behavior. Please update to the most recent version of Komodo (1.0.10-1 or later).";
     alert.strRPCError   = alert.strStatusBar;
 
     // Set specific client version/versions here. If setSubVer is empty, no filtering on subver is done:
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index 467298be1..6f80041fa 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -517,7 +517,7 @@ UniValue kvupdate(const UniValue& params, bool fHelp)
 {
     static uint256 zeroes;
     CWalletTx wtx; UniValue ret(UniValue::VOBJ);
-    uint8_t keyvalue[IGUANA_MAXSCRIPTSIZE],opretbuf[IGUANA_MAXSCRIPTSIZE]; int32_t i,coresize,haveprivkey,duration,opretlen,height; uint16_t keylen=0,valuesize=0,refvaluesize=0; uint8_t *key,*value=0; uint32_t flags,tmpflags,n; struct komodo_kv *ptr; uint64_t fee; uint256 privkey,pubkey,refpubkey,sig;
+    uint8_t keyvalue[IGUANA_MAXSCRIPTSIZE*8],opretbuf[IGUANA_MAXSCRIPTSIZE*8]; int32_t i,coresize,haveprivkey,duration,opretlen,height; uint16_t keylen=0,valuesize=0,refvaluesize=0; uint8_t *key,*value=0; uint32_t flags,tmpflags,n; struct komodo_kv *ptr; uint64_t fee; uint256 privkey,pubkey,refpubkey,sig;
     if (fHelp || params.size() < 3 )
         throw runtime_error(
             "kvupdate key \"value\" days passphrase\n"
@@ -4855,10 +4855,21 @@ int32_t ensure_CCrequirements()
 #include "../cc/CCfsm.h"
 #include "../cc/CCauction.h"
 #include "../cc/CClotto.h"
+#include "../cc/CCchannels.h"
+#include "../cc/CCOracles.h"
 
 UniValue CCaddress(struct CCcontract_info *cp,char *name,std::vector<unsigned char> &pubkey)
 {
-    UniValue result(UniValue::VOBJ); ; char destaddr[64],str[64];
+    UniValue result(UniValue::VOBJ); char destaddr[64],str[64]; CPubKey pk;
+    pk = GetUnspendable(cp,0);
+    GetCCaddress(cp,destaddr,pk);
+    if ( strcmp(destaddr,cp->unspendableCCaddr) != 0 )
+    {
+        uint8_t priv[32];
+        Myprivkey(priv); // it is assumed the CC's normal address'es -pubkey was used
+        fprintf(stderr,"fix mismatched CCaddr %s -> %s\n",cp->unspendableCCaddr,destaddr);
+        strcpy(cp->unspendableCCaddr,destaddr);
+    }
     result.push_back(Pair("result", "success"));
     sprintf(str,"%sCCaddress",name);
     result.push_back(Pair(str,cp->unspendableCCaddr));
@@ -4876,6 +4887,115 @@ UniValue CCaddress(struct CCcontract_info *cp,char *name,std::vector<unsigned ch
     return(result);
 }
 
+UniValue channelsaddress(const UniValue& params, bool fHelp)
+{
+    UniValue result(UniValue::VOBJ);  struct CCcontract_info *cp,C; std::vector<unsigned char> destpubkey; CPubKey pk,pk2; char destaddr[64];
+    cp = CCinit(&C,EVAL_CHANNELS);
+    if ( fHelp || params.size() != 1 )
+        throw runtime_error("channelsaddress destpubkey\n");
+    if ( ensure_CCrequirements() < 0 )
+        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    destpubkey = ParseHex(params[0].get_str().c_str());
+    pk = pubkey2pk(Mypubkey());
+    pk2 = pubkey2pk(destpubkey);
+    result = CCaddress(cp,(char *)"Channels",destpubkey);
+    result.push_back(Pair("otherpubkey", params[0].get_str()));
+    GetCCaddress1of2(cp,destaddr,pk,pk2);
+    result.push_back(Pair("channeladdress",destaddr));
+    return(result);
+}
+
+UniValue oraclesaddress(const UniValue& params, bool fHelp)
+{
+    struct CCcontract_info *cp,C; std::vector<unsigned char> pubkey;
+    cp = CCinit(&C,EVAL_ORACLES);
+    if ( fHelp || params.size() > 1 )
+        throw runtime_error("oraclesaddress [pubkey]\n");
+    if ( ensure_CCrequirements() < 0 )
+        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    if ( params.size() == 1 )
+        pubkey = ParseHex(params[0].get_str().c_str());
+    return(CCaddress(cp,(char *)"Oracles",pubkey));
+}
+
+UniValue pricesaddress(const UniValue& params, bool fHelp)
+{
+    struct CCcontract_info *cp,C; std::vector<unsigned char> pubkey;
+    cp = CCinit(&C,EVAL_PRICES);
+    if ( fHelp || params.size() > 1 )
+        throw runtime_error("pricesaddress [pubkey]\n");
+    if ( ensure_CCrequirements() < 0 )
+        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    if ( params.size() == 1 )
+        pubkey = ParseHex(params[0].get_str().c_str());
+    return(CCaddress(cp,(char *)"Prices",pubkey));
+}
+
+UniValue pegsaddress(const UniValue& params, bool fHelp)
+{
+    struct CCcontract_info *cp,C; std::vector<unsigned char> pubkey;
+    cp = CCinit(&C,EVAL_PEGS);
+    if ( fHelp || params.size() > 1 )
+        throw runtime_error("pegssaddress [pubkey]\n");
+    if ( ensure_CCrequirements() < 0 )
+        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    if ( params.size() == 1 )
+        pubkey = ParseHex(params[0].get_str().c_str());
+    return(CCaddress(cp,(char *)"Pegs",pubkey));
+}
+
+UniValue triggersaddress(const UniValue& params, bool fHelp)
+{
+    struct CCcontract_info *cp,C; std::vector<unsigned char> pubkey;
+    cp = CCinit(&C,EVAL_TRIGGERS);
+    if ( fHelp || params.size() > 1 )
+        throw runtime_error("triggersaddress [pubkey]\n");
+    if ( ensure_CCrequirements() < 0 )
+        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    if ( params.size() == 1 )
+        pubkey = ParseHex(params[0].get_str().c_str());
+    return(CCaddress(cp,(char *)"Triggers",pubkey));
+}
+
+UniValue paymentsaddress(const UniValue& params, bool fHelp)
+{
+    struct CCcontract_info *cp,C; std::vector<unsigned char> pubkey;
+    cp = CCinit(&C,EVAL_PAYMENTS);
+    if ( fHelp || params.size() > 1 )
+        throw runtime_error("paymentsaddress [pubkey]\n");
+    if ( ensure_CCrequirements() < 0 )
+        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    if ( params.size() == 1 )
+        pubkey = ParseHex(params[0].get_str().c_str());
+    return(CCaddress(cp,(char *)"Payments",pubkey));
+}
+
+UniValue gatewaysaddress(const UniValue& params, bool fHelp)
+{
+    struct CCcontract_info *cp,C; std::vector<unsigned char> pubkey;
+    cp = CCinit(&C,EVAL_GATEWAYS);
+    if ( fHelp || params.size() > 1 )
+        throw runtime_error("gatewaysaddress [pubkey]\n");
+    if ( ensure_CCrequirements() < 0 )
+        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    if ( params.size() == 1 )
+        pubkey = ParseHex(params[0].get_str().c_str());
+    return(CCaddress(cp,(char *)"Gateways",pubkey));
+}
+
+UniValue mofnaddress(const UniValue& params, bool fHelp)
+{
+    struct CCcontract_info *cp,C; std::vector<unsigned char> pubkey;
+    cp = CCinit(&C,EVAL_MOFN);
+    if ( fHelp || params.size() > 1 )
+        throw runtime_error("mofnaddress [pubkey]\n");
+    if ( ensure_CCrequirements() < 0 )
+        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    if ( params.size() == 1 )
+        pubkey = ParseHex(params[0].get_str().c_str());
+    return(CCaddress(cp,(char *)"MofN",pubkey));
+}
+
 UniValue lottoaddress(const UniValue& params, bool fHelp)
 {
     struct CCcontract_info *cp,C; std::vector<unsigned char> pubkey;
@@ -4969,6 +5089,120 @@ UniValue tokenaddress(const UniValue& params, bool fHelp)
     return(CCaddress(cp,(char *)"Assets",pubkey));
 }
 
+UniValue channelsinfo(const UniValue& params, bool fHelp)
+{
+    if ( fHelp || params.size() != 0 )
+        throw runtime_error("channelsinfo\n");
+    if ( ensure_CCrequirements() < 0 )
+        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    return(ChannelsInfo());
+}
+
+UniValue channelsopen(const UniValue& params, bool fHelp)
+{
+    UniValue result(UniValue::VOBJ); int32_t numpayments; int64_t payment; std::vector<unsigned char> destpub; struct CCcontract_info *cp,C; std::string hex;
+    cp = CCinit(&C,EVAL_CHANNELS);
+    if ( fHelp || params.size() != 3 )
+        throw runtime_error("channelsopen destpubkey numpayments payment\n");
+    if ( ensure_CCrequirements() < 0 )
+        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    LOCK(cs_main);
+    destpub = ParseHex(params[0].get_str().c_str());
+    numpayments = atoi(params[1].get_str().c_str());
+    payment = atol(params[2].get_str().c_str());
+    hex = ChannelOpen(0,pubkey2pk(destpub),numpayments,payment);
+    if ( hex.size() > 0 )
+    {
+        result.push_back(Pair("result", "success"));
+        result.push_back(Pair("hex", hex));
+    } else ERR_RESULT("couldnt create channelsopen transaction");
+    return(result);
+}
+
+UniValue channelsstop(const UniValue& params, bool fHelp)
+{
+    UniValue result(UniValue::VOBJ); std::vector<unsigned char> destpub; struct CCcontract_info *cp,C; std::string hex; uint256 origtxid;
+    cp = CCinit(&C,EVAL_CHANNELS);
+    if ( fHelp || params.size() != 2 )
+        throw runtime_error("channelsstop destpubkey origtxid\n");
+    if ( ensure_CCrequirements() < 0 )
+        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    LOCK(cs_main);
+    destpub = ParseHex(params[0].get_str().c_str());
+    origtxid = Parseuint256((char *)params[1].get_str().c_str());
+    hex = ChannelStop(0,pubkey2pk(destpub),origtxid);
+    if ( hex.size() > 0 )
+    {
+        result.push_back(Pair("result", "success"));
+        result.push_back(Pair("hex", hex));
+    } else ERR_RESULT("couldnt create channelsstop transaction");
+    return(result);
+}
+
+UniValue channelspayment(const UniValue& params, bool fHelp)
+{
+    UniValue result(UniValue::VOBJ); struct CCcontract_info *cp,C; std::string hex; uint256 origtxid,prevtxid; int32_t n; int64_t amount;
+    cp = CCinit(&C,EVAL_CHANNELS);
+    if ( fHelp || params.size() != 4 )
+        throw runtime_error("channelspayment prevtxid origtxid n amount\n");
+    if ( ensure_CCrequirements() < 0 )
+        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    LOCK(cs_main);
+    prevtxid = Parseuint256((char *)params[0].get_str().c_str());
+    origtxid = Parseuint256((char *)params[1].get_str().c_str());
+    n = atoi((char *)params[2].get_str().c_str());
+    amount = atoi((char *)params[3].get_str().c_str());
+    hex = ChannelPayment(0,prevtxid,origtxid,n,amount);
+    if ( hex.size() > 0 )
+    {
+        result.push_back(Pair("result", "success"));
+        result.push_back(Pair("hex", hex));
+    } else ERR_RESULT("couldnt create channelspayment transaction");
+    return(result);
+}
+
+UniValue channelscollect(const UniValue& params, bool fHelp)
+{
+    UniValue result(UniValue::VOBJ); struct CCcontract_info *cp,C; std::string hex; uint256 origtxid,paytxid; int32_t n; int64_t amount;
+    cp = CCinit(&C,EVAL_CHANNELS);
+    if ( fHelp || params.size() != 4 )
+        throw runtime_error("channelscollect paytxid origtxid n amount\n");
+    if ( ensure_CCrequirements() < 0 )
+        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    LOCK(cs_main);
+    paytxid = Parseuint256((char *)params[0].get_str().c_str());
+    origtxid = Parseuint256((char *)params[1].get_str().c_str());
+    n = atoi((char *)params[2].get_str().c_str());
+    amount = atoi((char *)params[3].get_str().c_str());
+    hex = ChannelCollect(0,paytxid,origtxid,n,amount);
+    if ( hex.size() > 0 )
+    {
+        result.push_back(Pair("result", "success"));
+        result.push_back(Pair("hex", hex));
+    } else ERR_RESULT("couldnt create channelscollect transaction");
+    return(result);
+}
+
+UniValue channelsrefund(const UniValue& params, bool fHelp)
+{
+    UniValue result(UniValue::VOBJ); struct CCcontract_info *cp,C; std::string hex; uint256 origtxid,stoptxid;
+    cp = CCinit(&C,EVAL_CHANNELS);
+    if ( fHelp || params.size() != 2 )
+        throw runtime_error("channelsrefund stoptxid origtxid\n");
+    if ( ensure_CCrequirements() < 0 )
+        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    LOCK(cs_main);
+    stoptxid = Parseuint256((char *)params[0].get_str().c_str());
+    origtxid = Parseuint256((char *)params[1].get_str().c_str());
+    hex = ChannelRefund(0,stoptxid,origtxid);
+    if ( hex.size() > 0 )
+    {
+        result.push_back(Pair("result", "success"));
+        result.push_back(Pair("hex", hex));
+    } else ERR_RESULT("couldnt create channelsrefund transaction");
+    return(result);
+}
+
 UniValue rewardscreatefunding(const UniValue& params, bool fHelp)
 {
     UniValue result(UniValue::VOBJ); char *name; int64_t funds,APR,minseconds,maxseconds,mindeposit; std::string hex;
@@ -4985,6 +5219,11 @@ UniValue rewardscreatefunding(const UniValue& params, bool fHelp)
     name = (char *)params[0].get_str().c_str();
     funds = atof(params[1].get_str().c_str()) * COIN;
 
+    if (!VALID_PLAN_NAME(name)) {
+        ERR_RESULT(strprintf("Plan name can be at most %d ASCII characters",PLAN_NAME_MAX));
+        return(result);
+    }
+
     if ( funds <= 0 ) {
         ERR_RESULT("funds must be positive");
         return result;
@@ -5046,6 +5285,11 @@ UniValue rewardslock(const UniValue& params, bool fHelp)
     fundingtxid = Parseuint256((char *)params[1].get_str().c_str());
     amount = atof(params[2].get_str().c_str()) * COIN;
     hex = RewardsLock(0,name,fundingtxid,amount);
+
+    if (!VALID_PLAN_NAME(name)) {
+            ERR_RESULT(strprintf("Plan name can be at most %d ASCII characters",PLAN_NAME_MAX));
+            return(result);
+    }
     if ( CCerror != "" ){
         ERR_RESULT(CCerror);
     } else if ( amount > 0 ) {
@@ -5071,6 +5315,11 @@ UniValue rewardsaddfunding(const UniValue& params, bool fHelp)
     fundingtxid = Parseuint256((char *)params[1].get_str().c_str());
     amount = atof(params[2].get_str().c_str()) * COIN;
     hex = RewardsAddfunding(0,name,fundingtxid,amount);
+
+    if (!VALID_PLAN_NAME(name)) {
+            ERR_RESULT(strprintf("Plan name can be at most %d ASCII characters",PLAN_NAME_MAX));
+            return(result);
+    }
     if (CCerror != "") {
         ERR_RESULT(CCerror);
     } else if (amount > 0) {
@@ -5099,6 +5348,11 @@ UniValue rewardsunlock(const UniValue& params, bool fHelp)
     LOCK2(cs_main, pwalletMain->cs_wallet);
     name = (char *)params[0].get_str().c_str();
     fundingtxid = Parseuint256((char *)params[1].get_str().c_str());
+
+    if (!VALID_PLAN_NAME(name)) {
+            ERR_RESULT(strprintf("Plan name can be at most %d ASCII characters",PLAN_NAME_MAX));
+            return(result);
+    }
     if ( params.size() > 2 )
         txid = Parseuint256((char *)params[2].get_str().c_str());
     else memset(&txid,0,sizeof(txid));
@@ -5114,7 +5368,6 @@ UniValue rewardsunlock(const UniValue& params, bool fHelp)
 
 UniValue rewardslist(const UniValue& params, bool fHelp)
 {
-    uint256 tokenid;
     if ( fHelp || params.size() > 0 )
         throw runtime_error("rewardslist\n");
     if ( ensure_CCrequirements() < 0 )
@@ -5133,6 +5386,130 @@ UniValue rewardsinfo(const UniValue& params, bool fHelp)
     return(RewardsInfo(fundingtxid));
 }
 
+UniValue oracleslist(const UniValue& params, bool fHelp)
+{
+    if ( fHelp || params.size() > 0 )
+        throw runtime_error("oracleslist\n");
+    if ( ensure_CCrequirements() < 0 )
+        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    return(OraclesList());
+}
+
+UniValue oraclesinfo(const UniValue& params, bool fHelp)
+{
+    uint256 txid;
+    if ( fHelp || params.size() != 1 )
+        throw runtime_error("oraclesinfo oracletxid\n");
+    if ( ensure_CCrequirements() < 0 )
+        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    txid = Parseuint256((char *)params[0].get_str().c_str());
+    return(OracleInfo(txid));
+}
+
+UniValue oraclesregister(const UniValue& params, bool fHelp)
+{
+    UniValue result(UniValue::VOBJ); uint256 txid; int64_t datafee; std::string hex;
+    if ( fHelp || params.size() != 2 )
+        throw runtime_error("oraclesregister oracletxid datafee\n");
+    if ( ensure_CCrequirements() < 0 )
+        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    txid = Parseuint256((char *)params[0].get_str().c_str());
+    datafee = atol((char *)params[1].get_str().c_str());
+    hex = OracleRegister(0,txid,datafee);
+    if ( hex.size() > 0 )
+    {
+        result.push_back(Pair("result", "success"));
+        result.push_back(Pair("hex", hex));
+    } else ERR_RESULT("couldnt register with oracle txid");
+    return(result);
+}
+
+UniValue oraclessubscribe(const UniValue& params, bool fHelp)
+{
+    UniValue result(UniValue::VOBJ); uint256 txid; int64_t amount; std::string hex; std::vector<unsigned char> pubkey;
+    if ( fHelp || params.size() != 3 )
+        throw runtime_error("oraclessubscribe oracletxid publisher amount\n");
+    if ( ensure_CCrequirements() < 0 )
+        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    txid = Parseuint256((char *)params[0].get_str().c_str());
+    pubkey = ParseHex(params[1].get_str().c_str());
+    amount = atof((char *)params[2].get_str().c_str()) * COIN;
+    hex = OracleSubscribe(0,txid,pubkey2pk(pubkey),amount);
+    if ( hex.size() > 0 )
+    {
+        result.push_back(Pair("result", "success"));
+        result.push_back(Pair("hex", hex));
+    } else ERR_RESULT("couldnt subscribe with oracle txid");
+    return(result);
+}
+
+UniValue oraclessamples(const UniValue& params, bool fHelp)
+{
+    UniValue result(UniValue::VOBJ); uint256 txid,batontxid; int32_t num; 
+    if ( fHelp || params.size() != 3 )
+        throw runtime_error("oraclessamples oracletxid batonutxo num\n");
+    if ( ensure_CCrequirements() < 0 )
+        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    txid = Parseuint256((char *)params[0].get_str().c_str());
+    batontxid = Parseuint256((char *)params[1].get_str().c_str());
+    num = atoi((char *)params[2].get_str().c_str());
+    return(OracleDataSamples(txid,batontxid,num));
+}
+
+UniValue oraclesdata(const UniValue& params, bool fHelp)
+{
+    UniValue result(UniValue::VOBJ); uint256 txid; std::vector<unsigned char> data; std::string hex;
+    if ( fHelp || params.size() != 2 )
+        throw runtime_error("oraclesdata oracletxid hexstr\n");
+    if ( ensure_CCrequirements() < 0 )
+        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    txid = Parseuint256((char *)params[0].get_str().c_str());
+    data = ParseHex(params[1].get_str().c_str());
+    hex = OracleData(0,txid,data);
+    if ( hex.size() > 0 )
+    {
+        result.push_back(Pair("result", "success"));
+        result.push_back(Pair("hex", hex));
+    } else ERR_RESULT("couldnt publish data with oracle txid");
+    return(result);
+}
+
+UniValue oraclescreate(const UniValue& params, bool fHelp)
+{
+    UniValue result(UniValue::VOBJ); std::string name,description,format,hex;
+    if ( fHelp || params.size() != 3 )
+        throw runtime_error("oraclescreate name description format\n");
+    if ( ensure_CCrequirements() < 0 )
+        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    const CKeyStore& keystore = *pwalletMain;
+    LOCK2(cs_main, pwalletMain->cs_wallet);
+    name = params[0].get_str();
+    if ( name.size() == 0 || name.size() > 32)
+    {
+        ERR_RESULT("oracles name must not be empty and up to 32 characters");
+        return(result);
+    }
+    description = params[1].get_str();
+    if ( description.size() > 4096 )
+    {
+        ERR_RESULT("oracles description must be <= 4096 characters");
+        return(result);
+    }
+    format = params[2].get_str();
+    if ( format.size() > 4096 )
+    {
+        ERR_RESULT("oracles format must be <= 4096 characters");
+        return(result);
+    }
+    hex = OracleCreate(0,name,description,format);
+    if ( hex.size() > 0 )
+    {
+        result.push_back(Pair("result", "success"));
+        result.push_back(Pair("hex", hex));
+    } else ERR_RESULT("couldnt create oracle");
+    return(result);
+}
+
 UniValue FSMcreate(const UniValue& params, bool fHelp)
 {
     UniValue result(UniValue::VOBJ); std::string name,states,hex;