Merge pull request #2 from jl777/FSM

Fsm
2019-06-10 12:36:37 +02:00
parent 5c77b99a66 94c7bec747
commit cd189ae070
50 changed files with 2353 additions and 839 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -132,6 +132,7 @@ src/cc/rogue/rogue
 src/cc/rogue/rogue.so

 src/cc/rogue/test.zip
+src/cc/dapps/a.out
 src/checkfile

 src/foo.zip
@@ -145,8 +146,6 @@ src/rogue.530623577502174316.pack
 src/rogue.530623577502174316.player


-src/cc/rogue/config.h
-
 src/cc/rogue/config.h

 src/ROGUE.conf
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -0,0 +1,62 @@
+
+# Komodo Core (komodod) Software Contribution Guidelines
+
+Thank you for reaching out and trying to make Komodo an even better software application and blockchain platform. These contribution guidelines shall help you figuring out where you can be helpful and how to easily get started.
+
+## Table of Contents
+
+0. [Types of contributions we're looking for](#types-of-contributions-were-looking-for)
+0. [Ground rules & expectations](#ground-rules--expectations)
+0. [How to contribute](#how-to-contribute)
+0. [Style guide](#style-guide)
+0. [Setting up your environment](#setting-up-your-environment)
+0. [Contribution review process](#contribution-review-process)
+0. [Community](#community)
+
+## Types of contributions we're looking for
+There are many ways you can directly contribute to Komodo:
+
+* Debug and test the Komodo Core code
+* Find and fix bugs
+* Improve suboptimal code
+* Extend our software
+* Perform a secure code review of Komodo Core and other Komodo-related software
+
+Interested in making a contribution? Read on!
+
+## Ground rules & expectations
+
+Before we get started, here are a few things we expect from you (and that you should expect from others):
+
+* Be kind and thoughtful in your conversations around this project. We all come from different backgrounds and projects, which means we likely have different perspectives on "how open source is done." Try to listen to others rather than convince them that your way is correct.
+* Open Source Guides are released with a [Contributor Code of Conduct](./code_of_conduct.md). By participating in this project, you agree to abide by its terms.
+* If you open a pull request, please ensure that your contribution passes all tests. If there are test failures, you will need to address them before we can merge your contribution.
+* When adding content, please consider if it is widely valuable. Please don't add references or links to things you or your employer have created as others will do so if they appreciate it.
+
+## How to contribute
+
+If you'd like to contribute, start by searching through the [issues](https://github.com/komodoplatform/komodo/issues) and [pull requests](https://github.com/komodoplatform/komodo/pulls) to see whether someone else has raised a similar idea or question.
+
+If you don't see your idea listed, and you think it can contribute to Komodo, do one of the following:
+* **If your contribution is minor,** such as a fixing a typo, open a pull request.
+* **If your contribution is major,** such as a new feature or bugfix, start by opening an issue first. That way, other contributors can weigh in on the discussion before you do any work.
+
+## Style guide
+Write clear, clean and consistent code. Follow well-known and established style guidelines like [Google's C++ Style Guide](https://google.github.io/styleguide/cppguide.html) or [Bjarne Stroustrup's C++ Style FAQ](http://www.stroustrup.com/bs_faq2.html).
+
+## Setting up your environment
+
+The Komodo Core (komodod) is mainly written in C++ with specific modules written in C. Follow the [Getting Started](https://github.com/komodoplatform/komodo#getting-started) instructions to build komodod from sources. For more informations about the Komodo Platform and a full API documentation please visit the official [Komodo developer documentation](https://docs.komodoplatform.com/). 
+
+## Contribution review process
+
+Our team and community will review your contribution and start a transparent testing and quality assurance process. As soon as your contribution has undergone sucessful review and QA signoff it gets merged into the Komodo sourcecode. 
+
+## Community
+
+Discussions about Komodo's development take place on our [discord server](https://discord.gg/yhfzqsg). Anybody is welcome to join these conversations. There is also a [newsletter](http://komodoplatform.com) with regular updates.
+
+Wherever possible, do not take these conversations to private channels, including contacting the maintainers directly. Keeping communication public means everybody can benefit and learn from the conversation.
+
+
+This contribution guideline is adapted from the Open Source Guides.
--- a/README.md
+++ b/README.md
@@ -38,7 +38,7 @@ This is the official Komodo sourcecode repository based on https://github.com/jl

 ## Tech Specification
 - Max Supply: 200 million KMD
- Block Time: 1m 2s
+- Block Time: 60 seconds
 - Block Reward: 3 KMD
 - Mining Algorithm: Equihash

@@ -84,7 +84,7 @@ brew update
 brew upgrade
 brew tap discoteq/discoteq; brew install flock
 brew install autoconf autogen automake
-brew install gcc@6
+brew update && brew install gcc@8
 brew install binutils
 brew install protobuf
 brew install coreutils
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -0,0 +1,30 @@
+## Reporting a Vulnerability
+
+Please use the below [contact data](https://komodoplatform.com/.well-known/security.txt.asc) to report vulnerabilities. We kindly ask you to not publish or exploit any found vulnerabilities. 
+
+```
+-----BEGIN PGP SIGNED MESSAGE-----
+Hash: SHA256
+
+Contact: security@komodoplatform.com
+Contact: ca333@komodoplatform.com
+Contact: noashh@komodoplatform.com
+Encryption: http://pgp.key-server.io:11371/0x379287998EE6CF47
+-----BEGIN PGP SIGNATURE-----
+
+iQJNBAEBCAA3FiEEVez5U2AlPa805zvqN5KHmY7mz0cFAlz6EuMZHGNhMzMzQGtv
+bW9kb3BsYXRmb3JtLmNvbQAKCRA3koeZjubPR8cIEACP+JjyXDIzjgIewMMi/02b
+tsYswPyQ+9bAoEJnis3r94d1FP1rqXmt4oNz6VwFTqQLEa5opW+gvvaxBTFJSPb0
+UzbS+1PjfAOox5cnT3Dnv9kcy4ECslnW/G+mH+85BUgz1HuqYc8A3kNQJL7KqLoi
+YeD0Hd09KtlG+B4PWdnqLw/uvfbavSKdMn6WSIU6adNZWX0ewSubWPXvrWea5cI2
+yKDdMcDqB8Sc9J4JR2L9zW8NqPQuaxfLQbkCt2tg9QjlClrAqQgb8OZQJgY9f1T/
+kBlVXoA4ZUZeifvjSKxQ/3TdRFP+jbV9xsb6sr14zTx+Wcoqtgsh3l9F4+T3V2m8
+/c/iS4mFlK31pJtwYyrJAq9hpggqymdCVi0Pa3yLZsEj3orBPaPWbmq2v7xeF3J8
+y8vqAkt3M3T6251aZAKEcaN5RXYJW70CTseadwp0tmrAL2nIVmziNCMOF+Bufyxi
+HddkasTcNX8VYfPCLWqBwrocx8d3n3E7dBGeS2x2iwuRVQ85pH5d+imxaMftcbqm
+YrNuiqcI/0XDGk9pS6f1gpu5Eh5Q2QXGmOoRlfosfkAEfgFxfaMvmcu5Ay1s0gSR
+MsTn0PrQyMYC3t3KpyP47C8ui9x7FtJFltR/QT4yzBF1QyDmINnK86ldQqSui402
+2+gQFt7YFvLIBUiy1fh1Jw==
+=UITq
+-----END PGP SIGNATURE-----
+```
--- a/depends/builders/darwin.mk
+++ b/depends/builders/darwin.mk
@@ -1,5 +1,5 @@
-build_darwin_CC = gcc-6
-build_darwin_CXX = g++-6
+build_darwin_CC = gcc-8
+build_darwin_CXX = g++-8
 build_darwin_AR: = $(shell xcrun -f ar)
 build_darwin_RANLIB: = $(shell xcrun -f ranlib)
 build_darwin_STRIP: = $(shell xcrun -f strip)
@@ -10,8 +10,8 @@ build_darwin_SHA256SUM = shasum -a 256
 build_darwin_DOWNLOAD = curl --connect-timeout $(DOWNLOAD_CONNECT_TIMEOUT) --retry $(DOWNLOAD_RETRIES) -L -f -o

 #darwin host on darwin builder. overrides darwin host preferences.
-darwin_CC= gcc-6
-darwin_CXX= g++-6
+darwin_CC= gcc-8
+darwin_CXX= g++-8
 darwin_AR:=$(shell xcrun -f ar)
 darwin_RANLIB:=$(shell xcrun -f ranlib)
 darwin_STRIP:=$(shell xcrun -f strip)
--- a/depends/hosts/darwin.mk
+++ b/depends/hosts/darwin.mk
@@ -1,9 +1,9 @@
-OSX_MIN_VERSION=10.8
-OSX_SDK_VERSION=10.11
+OSX_MIN_VERSION=10.12
+OSX_SDK_VERSION=10.12
 OSX_SDK=$(SDK_PATH)/MacOSX$(OSX_SDK_VERSION).sdk
 LD64_VERSION=253.9
-darwin_CC=gcc-6 -target $(host) -mmacosx-version-min=$(OSX_MIN_VERSION) --sysroot $(OSX_SDK) -mlinker-version=$(LD64_VERSION)
-darwin_CXX=g++-6 -target $(host) -mmacosx-version-min=$(OSX_MIN_VERSION) --sysroot $(OSX_SDK) -mlinker-version=$(LD64_VERSION)
+darwin_CC=gcc-8 -target $(host) -mmacosx-version-min=$(OSX_MIN_VERSION) --sysroot $(OSX_SDK) -mlinker-version=$(LD64_VERSION)
+darwin_CXX=g++-8 -target $(host) -mmacosx-version-min=$(OSX_MIN_VERSION) --sysroot $(OSX_SDK) -mlinker-version=$(LD64_VERSION)

 darwin_CFLAGS=-pipe
 darwin_CXXFLAGS=$(darwin_CFLAGS)
--- a/qa/rpc-tests/cryptoconditions_oracles.py
+++ b/qa/rpc-tests/cryptoconditions_oracles.py
@@ -3,7 +3,6 @@
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.

-
 from test_framework.test_framework import CryptoconditionsTestFramework
 from test_framework.authproxy import JSONRPCException
 from test_framework.util import assert_equal, assert_greater_than, \
@@ -11,13 +10,11 @@ from test_framework.util import assert_equal, assert_greater_than, \
    stop_nodes, sync_blocks, sync_mempools, wait_bitcoinds, rpc_port, assert_raises
 from cryptoconditions import assert_success, assert_error, generate_random_string

-
 class CryptoconditionsOraclesTest(CryptoconditionsTestFramework):

    def run_oracles_tests(self):
        rpc = self.nodes[0]
        rpc1 = self.nodes[1]
-
        result = rpc1.oraclesaddress()

        result = rpc.oraclesaddress()
@@ -54,159 +51,197 @@ class CryptoconditionsOraclesTest(CryptoconditionsTestFramework):
        too_long_description = generate_random_string(4100)
        result = rpc.oraclescreate("Test", too_long_description, "s")
        assert_error(result)
+
+        # need uxtos to create oracle? Crashes if without generate
+        rpc.generate(2)
+
        # valid creating oracles of different types
        # using such naming to re-use it for data publishing / reading (e.g. oracle_s for s type)
+
        valid_formats = ["s", "S", "d", "D", "c", "C", "t", "T", "i", "I", "l", "L", "h", "Ihh"]
        for f in valid_formats:
-            result = rpc.oraclescreate("Test", "Test", f)
+            result = rpc.oraclescreate("Test_"+f, "Test_"+f, f)
            assert_success(result)
            globals()["oracle_{}".format(f)] = self.send_and_mine(result['hex'], rpc)

        # trying to register with negative datafee
-        for f in valid_formats:
            result = rpc.oraclesregister(globals()["oracle_{}".format(f)], "-100")
            assert_error(result)

        # trying to register with zero datafee
-        for f in valid_formats:
            result = rpc.oraclesregister(globals()["oracle_{}".format(f)], "0")
            assert_error(result)

        # trying to register with datafee less than txfee
-        for f in valid_formats:
            result = rpc.oraclesregister(globals()["oracle_{}".format(f)], "500")
            assert_error(result)

-        # trying to register valid
-        for f in valid_formats:
+        # trying to register valid (unfunded)
            result = rpc.oraclesregister(globals()["oracle_{}".format(f)], "10000")
+            assert_error(result)
+
+        # Fund the oracles
+            result = rpc.oraclesfund(globals()["oracle_{}".format(f)])
+            assert_success(result)
+            fund_txid = self.send_and_mine(result["hex"], rpc)
+            assert fund_txid, "got txid"
+
+        # trying to register valid (funded)
+            result = rpc.oraclesregister(globals()["oracle_{}".format(f)], "10000")
+            print(f)
            assert_success(result)
            register_txid = self.send_and_mine(result["hex"], rpc)
            assert register_txid, "got txid"

        # TODO: for most of the non valid oraclesregister and oraclessubscribe transactions generating and broadcasting now
        # so trying only valid oraclessubscribe atm
-        for f in valid_formats:
            result = rpc.oraclessubscribe(globals()["oracle_{}".format(f)], self.pubkey, "1")
            assert_success(result)
            subscribe_txid = self.send_and_mine(result["hex"], rpc)
            assert register_txid, "got txid"

+            rpc.generate(1)
+
        # now lets publish and read valid data for each oracle type

        # s type
        result = rpc.oraclesdata(globals()["oracle_{}".format("s")], "05416e746f6e")
        assert_success(result)
-        # baton
-        oraclesdata_s = self.send_and_mine(result["hex"], rpc)
-        result = rpc.oraclessamples(globals()["oracle_{}".format("s")], oraclesdata_s, "1")
-        assert_equal("[u'Anton']", str(result["samples"][0]), "Data match")
+        oraclesdata_s = self.send_and_mine(result["hex"], rpc)        
+        info = rpc.oraclesinfo(globals()["oracle_{}".format("s")])
+        batonaddr = info['registered'][0]['baton']
+        result = rpc.oraclessamples(globals()["oracle_{}".format("s")], batonaddr, "1")
+        assert_equal("[u'Anton']", str(result["samples"][0]['data']), "Data match")

        # S type
        result = rpc.oraclesdata(globals()["oracle_{}".format("S")], "000161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161")
        assert_success(result)
-        # baton
        oraclesdata_S = self.send_and_mine(result["hex"], rpc)
-        result = rpc.oraclessamples(globals()["oracle_{}".format("S")], oraclesdata_S, "1")
-        assert_equal("[u'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa']", str(result["samples"][0]), "Data match")
+        info = rpc.oraclesinfo(globals()["oracle_{}".format("S")])
+        batonaddr = info['registered'][0]['baton']
+        result = rpc.oraclessamples(globals()["oracle_{}".format("S")], batonaddr, "1")
+        assert_equal("[u'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa']", str(result["samples"][0]['data']), "Data match")

        # d type
        result = rpc.oraclesdata(globals()["oracle_{}".format("d")], "0101")
        assert_success(result)
        # baton
        oraclesdata_d = self.send_and_mine(result["hex"], rpc)
-        result = rpc.oraclessamples(globals()["oracle_{}".format("d")], oraclesdata_d, "1")
-        assert_equal("[u'01']", str(result["samples"][0]), "Data match")
+        info = rpc.oraclesinfo(globals()["oracle_{}".format("d")])
+        batonaddr = info['registered'][0]['baton']
+        result = rpc.oraclessamples(globals()["oracle_{}".format("d")], batonaddr, "1")
+        assert_equal("[u'01']", str(result["samples"][0]['data']), "Data match")

        # D type
        result = rpc.oraclesdata(globals()["oracle_{}".format("D")], "010001")
        assert_success(result)
        # baton
        oraclesdata_D = self.send_and_mine(result["hex"], rpc)
-        result = rpc.oraclessamples(globals()["oracle_{}".format("D")], oraclesdata_D, "1")
-        assert_equal("[u'01']", str(result["samples"][0]), "Data match")
+        info = rpc.oraclesinfo(globals()["oracle_{}".format("D")])
+        batonaddr = info['registered'][0]['baton']
+        result = rpc.oraclessamples(globals()["oracle_{}".format("D")], batonaddr, "1")
+        assert_equal("[u'01']", str(result["samples"][0]['data']), "Data match")

        # c type
        result = rpc.oraclesdata(globals()["oracle_{}".format("c")], "ff")
        assert_success(result)
        # baton
        oraclesdata_c = self.send_and_mine(result["hex"], rpc)
-        result = rpc.oraclessamples(globals()["oracle_{}".format("c")], oraclesdata_c, "1")
-        assert_equal("[u'-1']", str(result["samples"][0]), "Data match")
+        info = rpc.oraclesinfo(globals()["oracle_{}".format("c")])
+        batonaddr = info['registered'][0]['baton']
+        result = rpc.oraclessamples(globals()["oracle_{}".format("c")], batonaddr, "1")
+        assert_equal("[u'-1']", str(result["samples"][0]['data']), "Data match")

        # C type
        result = rpc.oraclesdata(globals()["oracle_{}".format("C")], "ff")
        assert_success(result)
        # baton
        oraclesdata_C = self.send_and_mine(result["hex"], rpc)
-        result = rpc.oraclessamples(globals()["oracle_{}".format("C")], oraclesdata_C, "1")
-        assert_equal("[u'255']", str(result["samples"][0]), "Data match")
+        info = rpc.oraclesinfo(globals()["oracle_{}".format("C")])
+        batonaddr = info['registered'][0]['baton']
+        result = rpc.oraclessamples(globals()["oracle_{}".format("C")], batonaddr, "1")
+        assert_equal("[u'255']", str(result["samples"][0]['data']), "Data match")

        # t type
        result = rpc.oraclesdata(globals()["oracle_{}".format("t")], "ffff")
        assert_success(result)
        # baton
        oraclesdata_t = self.send_and_mine(result["hex"], rpc)
-        result = rpc.oraclessamples(globals()["oracle_{}".format("t")], oraclesdata_t, "1")
-        assert_equal("[u'-1']", str(result["samples"][0]), "Data match")
+        info = rpc.oraclesinfo(globals()["oracle_{}".format("t")])
+        batonaddr = info['registered'][0]['baton']
+        result = rpc.oraclessamples(globals()["oracle_{}".format("t")], batonaddr, "1")
+        assert_equal("[u'-1']", str(result["samples"][0]['data']), "Data match")

        # T type
        result = rpc.oraclesdata(globals()["oracle_{}".format("T")], "ffff")
        assert_success(result)
        # baton
        oraclesdata_T = self.send_and_mine(result["hex"], rpc)
-        result = rpc.oraclessamples(globals()["oracle_{}".format("T")], oraclesdata_T, "1")
-        assert_equal("[u'65535']", str(result["samples"][0]), "Data match")
+        info = rpc.oraclesinfo(globals()["oracle_{}".format("T")])
+        batonaddr = info['registered'][0]['baton']
+        result = rpc.oraclessamples(globals()["oracle_{}".format("T")], batonaddr, "1")
+        assert_equal("[u'65535']", str(result["samples"][0]['data']), "Data match")

        # i type
        result = rpc.oraclesdata(globals()["oracle_{}".format("i")], "ffffffff")
        assert_success(result)
        # baton
        oraclesdata_i = self.send_and_mine(result["hex"], rpc)
-        result = rpc.oraclessamples(globals()["oracle_{}".format("i")], oraclesdata_i, "1")
-        assert_equal("[u'-1']", str(result["samples"][0]), "Data match")
+        info = rpc.oraclesinfo(globals()["oracle_{}".format("i")])
+        batonaddr = info['registered'][0]['baton']
+        result = rpc.oraclessamples(globals()["oracle_{}".format("i")], batonaddr, "1")
+        assert_equal("[u'-1']", str(result["samples"][0]['data']), "Data match")

        # I type
        result = rpc.oraclesdata(globals()["oracle_{}".format("I")], "ffffffff")
        assert_success(result)
        # baton
        oraclesdata_I = self.send_and_mine(result["hex"], rpc)
-        result = rpc.oraclessamples(globals()["oracle_{}".format("I")], oraclesdata_I, "1")
-        assert_equal("[u'4294967295']", str(result["samples"][0]), "Data match")
+        info = rpc.oraclesinfo(globals()["oracle_{}".format("I")])
+        batonaddr = info['registered'][0]['baton']
+        result = rpc.oraclessamples(globals()["oracle_{}".format("I")], batonaddr, "1")
+        assert_equal("[u'4294967295']", str(result["samples"][0]['data']), "Data match")

        # l type
        result = rpc.oraclesdata(globals()["oracle_{}".format("l")], "00000000ffffffff")
        assert_success(result)
        # baton
        oraclesdata_l = self.send_and_mine(result["hex"], rpc)
-        result = rpc.oraclessamples(globals()["oracle_{}".format("l")], oraclesdata_l, "1")
-        # TODO: working not correct now!
-        #assert_equal("[u'-4294967296']", str(result["samples"][0]), "Data match")
+        info = rpc.oraclesinfo(globals()["oracle_{}".format("l")])
+        batonaddr = info['registered'][0]['baton']
+        result = rpc.oraclessamples(globals()["oracle_{}".format("l")], batonaddr, "1")
+        assert_equal("[u'-4294967296']", str(result["samples"][0]['data']), "Data match")

        # L type
        result = rpc.oraclesdata(globals()["oracle_{}".format("L")], "00000000ffffffff")
        assert_success(result)
        # baton
        oraclesdata_L = self.send_and_mine(result["hex"], rpc)
-        result = rpc.oraclessamples(globals()["oracle_{}".format("L")], oraclesdata_L, "1")
-        assert_equal("[u'18446744069414584320']", str(result["samples"][0]), "Data match")
+        info = rpc.oraclesinfo(globals()["oracle_{}".format("L")])
+        batonaddr = info['registered'][0]['baton']
+        result = rpc.oraclessamples(globals()["oracle_{}".format("L")], batonaddr, "1")
+        assert_equal("[u'18446744069414584320']", str(result["samples"][0]['data']), "Data match")

        # h type
        result = rpc.oraclesdata(globals()["oracle_{}".format("h")], "00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff")
        assert_success(result)
        # baton
        oraclesdata_h = self.send_and_mine(result["hex"], rpc)
-        result = rpc.oraclessamples(globals()["oracle_{}".format("h")], oraclesdata_h, "1")
-        assert_equal("[u'ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000']", str(result["samples"][0]), "Data match")
+        info = rpc.oraclesinfo(globals()["oracle_{}".format("h")])
+        batonaddr = info['registered'][0]['baton']
+        result = rpc.oraclessamples(globals()["oracle_{}".format("h")], batonaddr, "1")
+        assert_equal("[u'ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000']", str(result["samples"][0]['data']), "Data match")

        # Ihh type
        result = rpc.oraclesdata(globals()["oracle_{}".format("Ihh")], "ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff")
        assert_success(result)
        # baton
        oraclesdata_Ihh = self.send_and_mine(result["hex"], rpc)
-        result = rpc.oraclessamples(globals()["oracle_{}".format("Ihh")], oraclesdata_Ihh, "1")
-        assert_equal("[u'4294967295', u'ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000', u'ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000']", str(result["samples"][0]), "Data match")
-
+        info = rpc.oraclesinfo(globals()["oracle_{}".format("Ihh")])
+        batonaddr = info['registered'][0]['baton']
+        result = rpc.oraclessamples(globals()["oracle_{}".format("Ihh")], batonaddr, "1")
+        print(result)
+        assert_equal("[u'4294967295', u'ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000', u'ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000']", str(result["samples"][0]['data']), "Data match")

    def run_test(self):
        print("Mining blocks...")
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -599,11 +599,19 @@ if ENABLE_PROTON
 komodod_LDADD += $(LIBBITCOIN_PROTON) $(PROTON_LIBS)
 endif

+# [+] Decker: use static linking for libstdc++.6.dylib, libgomp.1.dylib, libgcc_s.1.dylib
+if TARGET_DARWIN
+komodod_LDFLAGS += -static-libgcc
+endif
+
 # bitcoin-cli binary #
 komodo_cli_SOURCES = bitcoin-cli.cpp
 komodo_cli_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) $(EVENT_CFLAGS)
 komodo_cli_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
 komodo_cli_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
+if TARGET_DARWIN
+komodo_cli_LDFLAGS += -static-libgcc
+endif

 # wallet-utility binary #
 if ENABLE_WALLET
--- a/src/ac/k64
+++ b/src/ac/k64
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=K64 $1 $2 $3 $4 $5 $6
--- a/src/ac/zex
+++ b/src/ac/zex
@@ -1,2 +0,0 @@
-#!/bin/bash
-./komodo-cli -ac_name=ZEX $1 $2 $3 $4 $5 $6
--- a/src/ac/zexo
+++ b/src/ac/zexo
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=ZEXO $1 $2 $3 $4 $5 $6
--- a/src/assetchains.json
+++ b/src/assetchains.json
@@ -159,18 +159,6 @@
      "136.243.102.225"
    ]
  },
-  {
-    "ac_name": "MGNX",
-    "ac_supply": "12465003",
-    "ac_staked": "90",
-    "ac_reward": "2000000000",
-    "ac_halving": "525960",
-    "ac_cc": "2",
-    "ac_end": "2629800",
-    "addnode": [
-      "142.93.27.180"
-    ]
-  },
  {
    "ac_name": "PGT",
    "ac_supply": "10000000",
@@ -202,17 +190,6 @@
       "144.76.217.232"
     ]
   },
-   {
-    "ac_name": "ZEX",
-    "ac_founders": "1",
-    "ac_reward": "13000000000",
-    "ac_halving": "525600",
-    "ac_cc": "2",
-    "ac_pubkey": "039d4a50cc70d1184e462a22edb3b66385da97cc8059196f8305c184a3e21440af",
-    "addnode": [
-      "5.9.102.210"
-    ]
-  },
  {
   "ac_name": "KSB",
   "ac_supply": "1000000000",
@@ -268,5 +245,28 @@
   "ac_name": "KOIN",
   "ac_supply": "125000000",
   "addnode": ["3.0.32.10"]
+ },
+ {
+   "ac_name": "ZEXO",
+   "ac_reward": "1478310502",
+   "ac_halving": "525600",
+   "ac_cc": "42",
+   "ac_ccenable": "236",
+   "ac_supply": "100000000",
+   "ac_perc": "77700",
+   "ac_staked": "93",
+   "ac_pubkey": "02713bd85e054db923694b6b7a85306264edf4d6bd6d331814f2b40af444b3ebbc",
+   "ac_public": "1",
+   "addnode": [
+     "195.201.20.230",
+     "80.240.17.222"
+    ]
+ },
+ {
+   "ac_name": "K64",
+   "ac_reward": "0",
+   "ac_supply": "64000777",
+   "ac_staked": "10",
+   "addnode": ["18.197.20.21"]
 }
 ]
--- a/src/assetchains.old
+++ b/src/assetchains.old
@@ -39,11 +39,10 @@ echo $pubkey
 ./komodod -pubkey=$pubkey -ac_name=SEC -ac_cc=333 -ac_supply=1000000000 -addnode=185.148.145.43 &
 ./komodod -pubkey=$pubkey -ac_name=CCL -ac_supply=200000000 -ac_end=1 -ac_cc=2 -addressindex=1 -spentindex=1 -addnode=142.93.136.89 -addnode=195.201.22.89 &
 ./komodod -pubkey=$pubkey -ac_name=PIRATE -ac_supply=0 -ac_reward=25600000000 -ac_halving=77777 -ac_private=1 -addnode=178.63.77.56 &
-./komodod -pubkey=$pubkey -ac_name=MGNX -ac_supply=12465003 -ac_staked=90 -ac_reward=2000000000 -ac_halving=525960 -ac_cc=2 -ac_end=2629800 -addnode=142.93.27.180 &
+#./komodod -pubkey=$pubkey -ac_name=MGNX -ac_supply=12465003 -ac_staked=90 -ac_reward=2000000000 -ac_halving=525960 -ac_cc=2 -ac_end=2629800 -addnode=142.93.27.180 &
 ./komodod -pubkey=$pubkey -ac_name=PGT -ac_supply=10000000 -ac_end=1 -addnode=190.114.254.104 &
 ./komodod -pubkey=$pubkey -ac_name=KMDICE -ac_supply=10500000 -ac_reward=2500000000 -ac_halving=210000 -ac_cc=2 -addressindex=1 -spentindex=1 -addnode=144.76.217.232 &
 ./komodod -pubkey=$pubkey -ac_name=DION -ac_supply=3900000000 -ac_reward=22260000000 -ac_staked=100 -ac_cc=1 -ac_end=4300000000 -addnode=51.75.124.34 &
-./komodod -pubkey=$pubkey -ac_name=ZEX -ac_cc=2 -ac_founders=1 -ac_halving=525600 -ac_reward=13000000000 -ac_pubkey=039d4a50cc70d1184e462a22edb3b66385da97cc8059196f8305c184a3e21440af -addnode=5.9.102.210 &
 ./komodod -pubkey=$pubkey -ac_name=KSB -ac_supply=1000000000 -ac_end=1 -ac_public=1 -addnode=37.187.225.231 &
 ./komodod -pubkey=$pubkey -ac_name=OUR -ac_reward=1478310502 -ac_halving=525600 -ac_cc=42 -ac_supply=100000000 -ac_perc=77700 -ac_staked=93 -ac_pubkey=02652a3f3e00b3a1875a918314f0bac838d6dd189a346fa623f5efe9541ac0b98c -ac_public=1 -addnode=51.255.195.65 -addnode=217.182.129.38 -addnode=37.187.225.231 &
 ./komodod -pubkey=$pubkey -ac_name=ILN -ac_supply=10000000000 -ac_cc=2 -addressindex=1 -spentindex=1 -addnode=51.75.122.83 &
@@ -51,4 +50,5 @@ echo $pubkey
 ./komodod -pubkey=$pubkey -ac_name=MORTY -ac_supply=90000000000 -ac_reward=100000000 -ac_cc=3 -addnode=138.201.136.145 &
 ./komodod -pubkey=$pubkey -ac_name=VOTE2019 -ac_supply=123651638 -ac_public=1 -addnode=95.213.238.98 &
 ./komodod -pubkey=$pubkey -ac_name=KOIN -ac_supply=125000000 -addnode=3.0.32.10 &
-~/hush3/src/komodod -pubkey=$pubkey -ac_name=HUSH3 -ac_sapling=1 -ac_reward=0,1125000000,562500000 -ac_halving=129,340000,840000 -ac_end=128,340000,5422111 -ac_eras=3 -ac_blocktime=150 -ac_cc=2 -ac_ccenable=228,234,235,236,241 -ac_founders=1 -ac_supply=6178674 -ac_perc=11111111 -clientname=GoldenSandtrout -addnode=188.165.212.101 -ac_cclib=hush3 -ac_script=76a9145eb10cf64f2bab1b457f1f25e658526155928fac88ac &
+./komodod -pubkey=$pubkey -ac_name=ZEXO -ac_supply=100000000 -ac_reward=1478310502 -ac_halving=525600 -ac_cc=42 -ac_ccenable=236 -ac_perc=77700 -ac_staked=93 -ac_pubkey=02713bd85e054db923694b6b7a85306264edf4d6bd6d331814f2b40af444b3ebbc -ac_public=1 -addnode=80.240.17.222 &
+./komodod -pubkey=$pubkey -ac_name=K64 -ac_supply=64000777 -ac_reward=0 -ac_staked=10 -addnode=18.197.20.211 &
--- a/src/cc/CCOracles.h
+++ b/src/cc/CCOracles.h
@@ -21,12 +21,12 @@

 bool OraclesValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx, uint32_t nIn);
 std::string OracleCreate(int64_t txfee,std::string name,std::string description,std::string format);
+std::string OracleFund(int64_t txfee,uint256 oracletxid);
 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 OracleDataSamples(uint256 reforacletxid,char* batonaddr,int32_t num);
 UniValue OracleInfo(uint256 origtxid);
 UniValue OraclesList();

--- a/src/cc/CCPrices.h
+++ b/src/cc/CCPrices.h
@@ -38,8 +38,12 @@ extern CScript KOMODO_EARLYTXID_SCRIPTPUB;
 #define PRICES_MMM (KOMODO_MAXPRICES * 7)               //          0011 1000 0000 0000
 #define PRICES_DDD (KOMODO_MAXPRICES * 8)               //          0100 0000 0000 0000

-#define PRICES_NORMFACTOR   (int64_t)(SATOSHIDEN)
-#define PRICES_POINTFACTOR   (int64_t)10000
+//#define PRICES_NORMFACTOR   (int64_t)(SATOSHIDEN)
+//#define PRICES_POINTFACTOR   (int64_t)10000
+
+#define PRICES_REVSHAREDUST 10000
+#define PRICES_SUBREVSHAREFEE(amount) ((amount) * 199 / 200)    // revshare fee percentage == 0.005
+#define PRICES_MINAVAILFUNDFRACTION  0.1                             // leveraged bet limit < fund fraction

 bool PricesValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx, uint32_t nIn);

@@ -52,6 +56,7 @@ UniValue PricesCashout(int64_t txfee,uint256 bettxid);
 UniValue PricesInfo(uint256 bettxid,int32_t refheight);
 UniValue PricesList(uint32_t filter, CPubKey mypk);
 UniValue PricesGetOrderbook();
+UniValue PricesRefillFund(int64_t amount);


 #endif
--- a/src/cc/Makefile_rogue
+++ b/src/cc/Makefile_rogue
@@ -1,6 +1,6 @@
 SHELL		= /bin/sh
 CC		= gcc
-CC_DARWIN	= g++-6
+CC_DARWIN	= g++-8
 CC_WIN		= x86_64-w64-mingw32-gcc-posix
 CFLAGS_DARWIN	= -DBUILD_ROGUE -std=c++11 -arch x86_64 -I../../depends/$(shell echo `../..//depends/config.guess`/include) -I../univalue/include -I../cryptoconditions/include -I../cryptoconditions/src -I../cryptoconditions/src/asn -I.. -I. -fPIC -Wl,-undefined -Wl,dynamic_lookup -Wno-write-strings -shared -dynamiclib
 CFLAGS		= -Wno-write-strings -DBUILD_ROGUE -std=c++11 -I../../depends/$(shell echo `../..//depends/config.guess`/include) -I../univalue/include -I../cryptoconditions/include -I../cryptoconditions/src -I../cryptoconditions/src/asn -I.. -I. -fPIC -shared
@@ -14,7 +14,7 @@ TARGET  = librogue.so
 TARGET_DARWIN = librogue.dylib
 TARGET_WIN = librogue.dll
 SOURCES = cclib.cpp
-#HEADERS = $(shell echo ../cryptoconditions/include/*.h) -I/usr/local/Cellar/gcc\@6/6.4.0_2/include/c++/6.4.0/
+#HEADERS = $(shell echo ../cryptoconditions/include/*.h) -I/usr/local/Cellar/gcc\@8/8.3.0/include/c++/8.3.0/

 all: $(TARGET)

--- a/src/cc/crypto777/OS_portable.h
+++ b/src/cc/crypto777/OS_portable.h
@@ -309,8 +309,8 @@ 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);
+void sort64s(uint64_t *buf,uint32_t num,int32_t size);
+void 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();
--- a/src/cc/dapps/zmigrate.c
+++ b/src/cc/dapps/zmigrate.c
@@ -938,7 +938,498 @@ int32_t have_pending_opid(char *coinstr,int32_t clearresults)
    return(pending);
 }

+int64_t utxo_value(char *refcoin,char *srcaddr,bits256 txid,int32_t v)
+{
+    cJSON *txjson,*vouts,*vout,*sobj,*array; int32_t numvouts,numaddrs; int64_t val,value = 0; char *addr,str[65];
+    srcaddr[0] = 0;
+    if ( (txjson= get_rawtransaction(refcoin,"",txid)) != 0 )
+    {
+        if ( (vouts= jarray(&numvouts,txjson,"vout")) != 0 && v < numvouts )
+        {
+            vout = jitem(vouts,v);
+            if ( (val= jdouble(vout,"value")*SATOSHIDEN) != 0 && (sobj= jobj(vout,"scriptPubKey")) != 0 )
+            {
+                if ( (array= jarray(&numaddrs,sobj,"addresses")) != 0 && numaddrs == 1 && (addr= jstri(array,0)) != 0 && strlen(addr) < 64 )
+                {
+                    strcpy(srcaddr,addr);
+                    value = val;
+                } else printf("couldnt get unique address for %s/%d\n",bits256_str(str,txid),v);
+            } else printf("error getting value for %s/v%d\n",bits256_str(str,txid),v);
+        }
+    }
+    return(value);
+}
+
+int32_t verify_vin(char *refcoin,bits256 txid,int32_t v,char *cmpaddr)
+{
+    cJSON *txjson,*vins,*vin; int32_t numvins; char vinaddr[64],str[65];
+    vinaddr[0] = 0;
+    if ( (txjson= get_rawtransaction(refcoin,"",txid)) != 0 )
+    {
+        if ( (vins= jarray(&numvins,txjson,"vin")) != 0 && v < numvins )
+        {
+            vin = jitem(vins,v);
+            if ( utxo_value(refcoin,vinaddr,jbits256(vin,"txid"),jint(vin,"vout")) > 0 && strcmp(vinaddr,cmpaddr) == 0 )
+                return(0);
+            printf("mismatched vinaddr.(%s) vs %s\n",vinaddr,cmpaddr);
+        }
+    }
+    return(-1);
+}
+
+int32_t txid_in_vins(char *refcoin,bits256 txid,bits256 cmptxid)
+{
+    cJSON *txjson,*vins,*vin; int32_t numvins,v,vinvout; bits256 vintxid; char str[65];
+    if ( (txjson= get_rawtransaction(refcoin,"",txid)) != 0 )
+    {
+        if ( (vins= jarray(&numvins,txjson,"vin")) != 0 )
+        {
+            for (v=0; v<numvins; v++)
+            {
+                vin = jitem(vins,v);
+                vintxid = jbits256(vin,"txid");
+                vinvout = jint(vin,"vout");
+                if ( memcmp(&vintxid,&cmptxid,sizeof(vintxid)) == 0 && vinvout == 0 )
+                {
+                    return(0);
+                }
+            }
+        }
+    }
+    return(-1);
+}
+
+void genpayout(char *coinstr,char *destaddr,int32_t amount)
+{
+    char cmd[1024];
+    sprintf(cmd,"curl -s --url \"http://127.0.0.1:7783\" --data \"{\\\"userpass\\\":\\\"$userpass\\\",\\\"method\\\":\\\"withdraw\\\",\\\"coin\\\":\\\"%s\\\",\\\"outputs\\\":[{\\\"%s\\\":%.8f},{\\\"RWXL82m4xnBTg1kk6PuS2xekonu7oEeiJG\\\":0.0002}],\\\"broadcast\\\":1}\"\nsleep 3\n",coinstr,destaddr,dstr(amount+20000));
+    printf("%s",cmd);
+}
+
+bits256 SECONDVIN; int32_t SECONDVOUT;
+
+void genrefund(char *cmd,char *coinstr,bits256 vintxid,char *destaddr,int64_t amount)
+{
+    char str[65],str2[65];
+    sprintf(cmd,"curl -s --url \"http://127.0.0.1:7783\" --data \"{\\\"userpass\\\":\\\"$userpass\\\",\\\"method\\\":\\\"withdraw\\\",\\\"coin\\\":\\\"%s\\\",\\\"onevin\\\":2,\\\"utxotxid\\\":\\\"%s\\\",\\\"utxovout\\\":1,\\\"utxotxid2\\\":\\\"%s\\\",\\\"utxovout2\\\":%d,\\\"outputs\\\":[{\\\"%s\\\":%.8f}],\\\"broadcast\\\":1}\"\nsleep 3\n",coinstr,bits256_str(str,vintxid),bits256_str(str2,SECONDVIN),SECONDVOUT,destaddr,dstr(amount));
+    system(cmd);
+}
+
+struct addritem
+{
+    int64_t total,numutxos;
+    char addr[64];
+    
+} ADDRESSES[1200];
+
+struct claimitem
+{
+    bits256 txid;
+    int64_t total,refundvalue;
+    int32_t numutxos,disputed,approved;
+    char oldaddr[64],destaddr[64],username[64];
+    
+} CLAIMS[10000];
+
+int32_t NUM_ADDRESSES,NUM_CLAIMS;
+
+int32_t itemvalid(char *refcoin,int64_t *refundedp,int64_t *waitingp,struct claimitem *item)
+{
+    cJSON *curljson,*txids; int32_t i,numtxids; char str[65],str2[65],url[1000],*retstr; bits256 txid;
+    *refundedp = *waitingp = 0;
+    if ( item->refundvalue < 0 )
+        return(-1);
+    sprintf(url,"https://kmd.explorer.dexstats.info/insight-api-komodo/addr/%s",item->destaddr);
+    if ( (retstr= send_curl(url,"/tmp/itemvalid")) != 0 )
+    {
+        if ( (curljson= cJSON_Parse(retstr)) != 0 )
+        {
+            if ( (txids= jarray(&numtxids,curljson,"transactions")) != 0 )
+            {
+                for (i=0; i<numtxids; i++)
+                {
+                    txid = jbits256i(txids,i);
+                    if ( txid_in_vins(refcoin,txid,item->txid) == 0 )
+                    {
+                        printf("found item->txid %s inside %s\n",bits256_str(str,item->txid),bits256_str(str2,txid));
+                        item->approved = 1;
+                        break;
+                    }
+                }
+            }
+            free_json(curljson);
+        }
+        //printf("%s\n",retstr);
+        free(retstr);
+    }
+    if ( item->approved != 0 )
+        return(1);
+    *waitingp = item->refundvalue;
+    return(-1);
+}
+
+void scan_claims(int32_t issueflag,char *refcoin,int32_t batchid)
+{
+    char str[65]; int32_t i,num,numstolen=0,numcandidates=0,numinvalids=0,numrefunded=0,numwaiting=0; struct claimitem *item; int64_t batchmin,batchmax,waiting,refunded,possiblerefund=0,possiblestolen = 0,invalidsum=0,totalrefunded=0,waitingsum=0;
+    if ( batchid == 0 )
+    {
+        batchmin = 0;
+        batchmax = 7 * SATOSHIDEN;
+    }
+    else if ( batchid == 1 )
+    {
+        batchmin = 7 * SATOSHIDEN;
+        batchmax = 777 * SATOSHIDEN;
+    }
+    else if ( batchid == 2 )
+    {
+        batchmin = 1;//777 * SATOSHIDEN;
+        batchmax = 17777 * SATOSHIDEN;
+    }
+    else if ( batchid == 3 )
+    {
+        batchmin = 17777 * SATOSHIDEN;
+        batchmax = 1000000 * SATOSHIDEN;
+    }
+    for (i=0; i<NUM_CLAIMS; i++)
+    {
+        item = &CLAIMS[i];
+        if ( item->refundvalue < batchmin || item->refundvalue >= batchmax )
+            continue;
+        if ( itemvalid(refcoin,&refunded,&waiting,item) < 0 )
+        {
+            if ( refunded != 0 )
+            {
+                numrefunded++;
+                totalrefunded += refunded;
+            }
+            else if ( waiting != 0 )
+            {
+                numwaiting++;
+                waitingsum += waiting;
+            }
+            else
+            {
+                invalidsum += item->refundvalue;
+                numinvalids++;
+            }
+            continue;
+        }
+        if ( item->total > item->refundvalue*1.05 + 10*SATOSHIDEN )
+        {
+            //if ( (item->total-item->refundvalue) > 777*SATOSHIDEN )
+            printf("possible.%d stolen %s %.8f vs refund %.8f -> %.8f\n",batchid,item->oldaddr,dstr(item->total),dstr(item->refundvalue),dstr(item->total)-dstr(item->refundvalue));
+            numstolen++;
+            possiblestolen += (item->total - item->refundvalue);
+            item->approved = 0;
+        }
+        else
+        {
+            printf("candidate.%d %s %.8f vs refund %.8f -> %s\n",batchid,item->oldaddr,dstr(item->total),dstr(item->refundvalue),item->destaddr);
+            numcandidates++;
+            possiblerefund += item->refundvalue;
+        }
+    }
+    printf("batchid.%d TOTAL exposure %d %.8f, possible refund %d %.8f, invalids %d %.8f, numrefunded %d %.8f, waiting %d %.8f\n",batchid,numstolen,dstr(possiblestolen),numcandidates,dstr(possiblerefund),numinvalids,dstr(invalidsum),numrefunded,dstr(totalrefunded),numwaiting,dstr(waitingsum));
+    for (i=num=0; i<NUM_CLAIMS; i++)
+    {
+        item = &CLAIMS[i];
+        if ( item->approved != 0 )
+        {
+            printf("%d.%d: approved.%d %s %.8f vs refund %.8f -> %s\n",i,num,batchid,item->oldaddr,dstr(item->total),dstr(item->refundvalue),item->destaddr);
+            num++;
+            if ( issueflag != 0 )
+            {
+                static FILE *fp; char cmd[1024];
+                if ( fp == 0 )
+                    fp = fopen("refund.log","wb");
+                genrefund(cmd,refcoin,item->txid,item->destaddr,item->refundvalue);
+                if ( fp != 0 )
+                {
+                    fprintf(fp,"%s,%s,%s,%s,%s,%.8f,%s\n",item->username,refcoin,bits256_str(str,item->txid),item->oldaddr,item->destaddr,dstr(item->refundvalue),cmd);
+                    fflush(fp);
+                }
+                memset(&SECONDVIN,0,sizeof(SECONDVIN));
+                SECONDVOUT = 1;
+//printf(">>>>>>>>>>>>>>>>>> getchar after (%s)\n",cmd);
+//getchar();
+            }
+        }
+    }
+}
+
+int32_t update_claimvalue(int32_t *disputedp,char *addr,int64_t amount,bits256 txid)
+{
+    int32_t i; struct claimitem *item;
+    *disputedp = 0;
+    for (i=0; i<NUM_CLAIMS; i++)
+    {
+        if ( strcmp(addr,CLAIMS[i].oldaddr) == 0 )
+        {
+            item = &CLAIMS[i];
+            item->refundvalue = amount;
+            if ( bits256_nonz(item->txid) != 0 )
+                printf("disputed.%d %s claimed %.8f vs %.8f\n",item->disputed,addr,dstr(item->total),dstr(amount));
+            item->txid = txid;
+            if ( item->disputed != 0 )
+                *disputedp = 1;
+            return(i);
+        }
+    }
+    return(-1);
+}
+
+int64_t update_claimstats(char *username,char *oldaddr,char *destaddr,int64_t amount)
+{
+    int32_t i; struct claimitem *item;
+    for (i=0; i<NUM_CLAIMS; i++)
+    {
+        if ( strcmp(oldaddr,CLAIMS[i].oldaddr) == 0 )
+        {
+            item = &CLAIMS[i];
+            if ( strcmp(destaddr,item->destaddr) != 0 )//|| strcmp(username,item->username) != 0 )
+            {
+                item->disputed++;
+                printf("disputed.%d claim.%-4d: (%36s -> %36s %s) vs. (%36s -> %36s %s) \n",item->disputed,i,oldaddr,destaddr,username,item->oldaddr,item->destaddr,item->username);
+            }
+            item->numutxos++;
+            item->total += amount;
+            return(amount);
+        }
+    }
+    item = &CLAIMS[NUM_CLAIMS++];
+    item->total = amount;
+    item->numutxos = 1;
+    strncpy(item->oldaddr,oldaddr,sizeof(item->oldaddr));
+    strncpy(item->destaddr,destaddr,sizeof(item->destaddr));
+    strncpy(item->username,username,sizeof(item->username));
+    printf("new claim.%-4d: %36s %16.8f -> %36s %s\n",NUM_CLAIMS,oldaddr,dstr(amount),destaddr,username);
+    return(amount);
+}
+
+int32_t update_addrstats(char *srcaddr,int64_t amount)
+{
+    int32_t i; struct addritem *item;
+    for (i=0; i<NUM_ADDRESSES; i++)
+    {
+        if ( strcmp(srcaddr,ADDRESSES[i].addr) == 0 )
+        {
+            ADDRESSES[i].numutxos++;
+            ADDRESSES[i].total += amount;
+            return(i);
+        }
+    }
+    item = &ADDRESSES[NUM_ADDRESSES++];
+    item->total = amount;
+    item->numutxos = 1;
+    strcpy(item->addr,srcaddr);
+    printf("%d new address %s\n",NUM_ADDRESSES,srcaddr);
+    return(-1);
+}
+
+int64_t sum_of_vins(char *refcoin,int32_t *totalvinsp,int32_t *uniqaddrsp,bits256 txid)
+{
+    cJSON *txjson,*vins,*vin; char str[65],srcaddr[64]; int32_t i,numarray; int64_t amount,total = 0;
+    if ( (txjson= get_rawtransaction(refcoin,"",txid)) != 0 )
+    {
+        if ( (vins= jarray(&numarray,txjson,"vin")) != 0)
+        {
+            for (i=0; i<numarray; i++)
+            {
+                if ( (vin= jitem(vins,i)) != 0 )
+                {
+                    if ( (amount= utxo_value(refcoin,srcaddr,jbits256(vin,"txid"),jint(vin,"vout"))) == 0 )
+                        printf("error getting value from %s/v%d\n",bits256_str(str,jbits256(vin,"txid")),jint(vin,"vout"));
+                    else
+                    {
+                        if ( update_addrstats(srcaddr,amount) < 0 )
+                            (*uniqaddrsp)++;
+                        //printf("add %s <- %.8f\n",srcaddr,dstr(amount));
+                        total += amount;
+                        (*totalvinsp)++;
+                    }
+                }
+            }
+        }
+    }
+    if ( total == 0 )
+        printf("sum_of_vins error %s\n",bits256_str(str,txid));
+    return(total);
+}
+
+void reconcile_claims(char *fname)
+{
+    FILE *fp; double amount; int32_t i,n,numlines = 0; char buf[1024],fields[16][256],*str; int64_t total = 0;
+    if ( (fp= fopen(fname,"rb")) != 0 )
+    {
+        while ( fgets(buf,sizeof(buf),fp) > 0 )
+        {
+            //printf("%d.(%s)\n",numlines,buf);
+            str = buf;
+            n = i = 0;
+            memset(fields,0,sizeof(fields));
+            while ( *str != 0 )
+            {
+                if ( *str == ',' || *str == '\n' || *str == '\r' )
+                {
+                    fields[n][i] = 0;
+                    i = 0;
+                    if ( n > 1 )
+                    {
+                        //printf("(%16s) ",fields[n]);
+                    }
+                    n++;
+                    if ( *str == '\n' || *str == '\r' )
+                        break;
+                }
+                if ( *str == ',' || *str == ' ' )
+                    str++;
+                else fields[n][i++] = *str++;
+            }
+            //printf("%s\n",fields[0]);
+            total += update_claimstats(fields[0],fields[2],fields[4],atof(fields[3])*SATOSHIDEN + 0.0000000049);
+            numlines++;
+        }
+        fclose(fp);
+    }
+    printf("total claims %.8f\n",dstr(total));
+}
+
 int32_t main(int32_t argc,char **argv)
+{
+    char *coinstr,*addr,buf[64],srcaddr[64],str[65]; cJSON *retjson,*item; int32_t i,n,disputed,numdisputed,numsmall=0,numpayouts=0,numclaims=0,num=0,totalvins=0,uniqaddrs=0; int64_t amount,total = 0,total2 = 0,payout,maxpayout,smallpayout=0,totalpayout = 0,totaldisputed = 0,totaldisputed2 = 0,fundingamount = 0;
+    if ( argc != 2 )
+    {
+        printf("argc needs to be 2: <prog> coin\n");
+        return(-1);
+    }
+    if ( strcmp(argv[1],"KMD") == 0 )
+    {
+        REFCOIN_CLI = "./komodo-cli";
+        coinstr = clonestr("KMD");
+    }
+    else
+    {
+        sprintf(buf,"./komodo-cli -ac_name=%s",argv[1]);
+        REFCOIN_CLI = clonestr(buf);
+        coinstr = clonestr(argv[1]);
+    }
+    if ( 1 )
+    {
+        sprintf(buf,"%s-Claims.csv",coinstr);
+        reconcile_claims(buf);
+        for (i=0; i<NUM_CLAIMS; i++)
+        {
+            if ( CLAIMS[i].disputed != 0 )
+            {
+                totaldisputed += CLAIMS[i].total;
+                printf("disputed %s %.8f\n",CLAIMS[i].oldaddr,dstr(CLAIMS[i].total));
+            }
+        }
+        printf("total disputed %.8f\n",dstr(totaldisputed));
+        totaldisputed2 = 0;
+        if ( (retjson=  get_listunspent(coinstr,"")) != 0 )
+        {
+            if ( (n= cJSON_GetArraySize(retjson)) > 0 )
+            {
+                for (i=0; i<n; i++)
+                {
+                    item = jitem(retjson,i);
+                    amount = jdouble(item,"amount")*SATOSHIDEN;
+                    if ( (addr= jstr(item,"address")) != 0 && strcmp(addr,"RWXL82m4xnBTg1kk6PuS2xekonu7oEeiJG") == 0 )
+                    {
+                        if ( amount != 20000 )
+                        {
+                            if ( amount > fundingamount )
+                            {
+                                fundingamount = amount;
+                                SECONDVIN = jbits256(item,"txid");
+                                SECONDVOUT = jint(item,"vout");
+                                printf("set SECONDVIN to %s/v%d %.8f\n",bits256_str(str,SECONDVIN),SECONDVOUT,dstr(amount));
+                            }
+                            continue;
+                        }
+                        if ( strcmp(coinstr,"KMD") == 0 && verify_vin(coinstr,jbits256(item,"txid"),0,"R9JCEd6xnCxNUSpLrHEWvzPSh7CNXm7z75") < 0 )
+                        {
+                            printf("WARNING: imposter dust detected! %s\n",bits256_str(str,jbits256(item,"txid")));
+                            continue;
+                        }
+                        else if ( strcmp(coinstr,"KMD") != 0 && verify_vin(coinstr,jbits256(item,"txid"),0,"R9MUnxXijovvSeT9sFuUX23TiFtVvZEGjT") < 0 )
+                        {
+                            printf("WARNING: imposter dust detected! %s\n",bits256_str(str,jbits256(item,"txid")));
+                            continue;
+                        }
+                        amount = (utxo_value(coinstr,srcaddr,jbits256(item,"txid"),0) - 20000) * SATOSHIDEN;
+                        //printf("%d: %s claimvalue %.8f\n",num,srcaddr,dstr(amount));
+                        num++;
+                        total2 += amount;
+                        if ( update_claimvalue(&disputed,srcaddr,amount,jbits256(item,"txid")) >= 0 )
+                        {
+                            if ( disputed != 0 )
+                            {
+                                totaldisputed2 += amount;
+                                numdisputed++;
+                            }
+                            else
+                            {
+                                numclaims++;
+                                total += amount;
+                            }
+                        }
+                    }
+                }
+            }
+            free_json(retjson);
+            printf("remaining refunds.%d %.8f, numclaims.%d %.8f, numdisputed.%d %.8f\n",num,dstr(total2),numclaims,dstr(total),numdisputed,dstr(totaldisputed2));
+        }
+        //scan_claims(0,coinstr,0);
+        //scan_claims(0,coinstr,1);
+        scan_claims(0,coinstr,2);
+        //scan_claims(0,coinstr,3);
+    }
+    else if ( (retjson=  get_listunspent(coinstr,"")) != 0 )
+    {
+        if ( (n= cJSON_GetArraySize(retjson)) > 0 )
+        {
+            for (i=0; i<n; i++)
+            {
+                item = jitem(retjson,i);
+                if ( (addr= jstr(item,"address")) != 0 && strcmp(addr,"RSgD2cmm3niFRu2kwwtrEHoHMywJdkbkeF") == 0 )
+                {
+                    if ( (amount= jdouble(item,"amount")*SATOSHIDEN) != 0 )
+                    {
+                        num++;
+                        total += amount;
+                        total2 += sum_of_vins(coinstr,&totalvins,&uniqaddrs,jbits256(item,"txid"));
+                    }
+                }
+            }
+        }
+        free_json(retjson);
+        maxpayout = 0;
+        for (i=0; i<NUM_ADDRESSES; i++)
+        {
+            if ( ADDRESSES[i].total >= SATOSHIDEN )
+            {
+                payout = ADDRESSES[i].total / SATOSHIDEN;
+                if ( payout > maxpayout )
+                    maxpayout = payout;
+                totalpayout += payout;
+                numpayouts++;
+                if ( payout >= 7 )
+                {
+                    numsmall++;
+                    smallpayout += payout;
+                    genpayout(coinstr,ADDRESSES[i].addr,payout);
+                }
+                //printf("%-4d: %-64s numutxos.%-4lld %llu\n",i,ADDRESSES[i].addr,ADDRESSES[i].numutxos,(long long)payout);
+            }
+        }
+        printf("num.%d total %.8f vs vintotal %.8f, totalvins.%d uniqaddrs.%d:%d totalpayout %llu maxpayout %llu numpayouts.%d numsmall.%d %llu\n",num,dstr(total),dstr(total2),totalvins,uniqaddrs,NUM_ADDRESSES,(long long)totalpayout,(long long)maxpayout,numpayouts,numsmall,(long long)smallpayout);
+    }
+}
+    
+int32_t zmigratemain(int32_t argc,char **argv)
 {
    char buf[1024],*zsaddr,*coinstr;
    if ( argc != 3 )
--- a/src/cc/oracles.cpp
+++ b/src/cc/oracles.cpp
@@ -92,10 +92,11 @@
 vout.n-1: opreturn with oracletxid, prevbatontxid and data in proper format

 */
+extern int32_t komodo_currentheight();
+#define PUBKEY_SPOOFING_FIX_ACTIVATION 1563148800
+#define CC_MARKER_VALUE 10000

 // 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;
@@ -124,6 +125,7 @@ uint8_t DecodeOraclesCreateOpRet(const CScript &scriptPubKey,std::string &name,s
 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);
 }
@@ -131,11 +133,12 @@ CScript EncodeOraclesOpRet(uint8_t funcid,uint256 oracletxid,CPubKey pk,int64_t
 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() > 2 && script[0] == EVAL_ORACLES )
    {
-        if (script[0] == EVAL_ORACLES && (script[1]== 'R' || script[1] == 'S') && E_UNMARSHAL(vopret,ss >> e; ss >> f; ss >> oracletxid; ss >> pk; ss >> num)!=0)
+        if (script[0] == EVAL_ORACLES && (script[1]== 'R' || script[1] == 'S' || script[1] == 'F') && E_UNMARSHAL(vopret,ss >> e; ss >> f; ss >> oracletxid; ss >> pk; ss >> num)!=0)
            return(f);
        else return(script[1]);
    }
@@ -633,9 +636,25 @@ bool OraclesDataValidate(struct CCcontract_info *cp,Eval* eval,const CTransactio
    else return(true);
 }

+int32_t GetLatestTimestamp(int32_t height)
+{
+    uint256 blockHash; CBlock block; CBlockIndex* pindex;
+
+    blockHash = chainActive[height]->GetBlockHash();
+    pindex = mapBlockIndex[blockHash];
+    if ( komodo_blockload(block,pindex) == 0 )
+    {
+        return(block.nTime);
+    }
+    return(0);
+}
+
 bool OraclesValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx, uint32_t nIn)
 {
-    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;
+    uint256 oracletxid,batontxid; uint64_t txfee=10000; int32_t numvins,numvouts,preventCCvins,preventCCvouts; int64_t amount; uint256 hashblock;
+    uint8_t *script; std::vector<uint8_t> vopret,data; CPubKey publisher,tmppk,oraclespk; char tmpaddress[64],vinaddress[64],oraclesaddr[64];
+    CTransaction tmptx; std::string name,desc,format;
+
    numvins = tx.vin.size();
    numvouts = tx.vout.size();
    preventCCvins = preventCCvouts = -1;
@@ -643,10 +662,11 @@ bool OraclesValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &t
        return eval->Invalid("no vouts");
    else
    {
-        txid = tx.GetHash();
        GetOpReturnData(tx.vout[numvouts-1].scriptPubKey,vopret);
        if ( vopret.size() > 2 )
-        {
+        {   
+            oraclespk=GetUnspendable(cp,0);
+            Getscriptaddress(oraclesaddr,CScript() << ParseHex(HexStr(oraclespk)) << OP_CHECKSIG);
            script = (uint8_t *)vopret.data();
            switch ( script[1] )
            {
@@ -657,13 +677,45 @@ bool OraclesValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &t
                    // vout.n-1: opreturn with name and description and format for data
                    return eval->Invalid("unexpected OraclesValidate for create");
                    break;
-                case 'R': // register
+                case 'F': // fund (activation on Jul 15th 2019 00:00)
                    // vins.*: normal inputs
+                    // vout.0: txfee to oracle CC address of users pubkey
+                    // vout.1: change, if any
+                    // vout.n-1: opreturn with createtxid, pubkey and amount
+                    return eval->Invalid("unexpected OraclesValidate for create");
+                    break;
+                case 'R': // register
+                    // vin.0: normal inputs
+                    // vin.n-1: CC input from pubkeys oracle CC addres - to prove that register came from pubkey that is registred (activation on Jul 15th 2019 00:00)
                    // vout.0: txfee tag to normal marker address
                    // vout.1: baton CC utxo
-                    // vout.2: change, if any
+                    // vout.2: marker from oraclesfund tx to normal pubkey address (activation on Jul 15th 2019 00:00)
+                    // vout.n-2: change, if any
                    // vout.n-1: opreturn with createtxid, pubkey and price per data point
-                    return eval->Invalid("unexpected OraclesValidate for register");
+                    if (GetLatestTimestamp(eval->GetCurrentHeight())>PUBKEY_SPOOFING_FIX_ACTIVATION)
+                    {
+                        if ((numvouts=tx.vout.size()) < 1 || DecodeOraclesOpRet(tx.vout[numvouts-1].scriptPubKey,oracletxid,tmppk,amount)!='R')
+                            return eval->Invalid("invalid oraclesregister OP_RETURN data!"); 
+                        else if (myGetTransaction(oracletxid,tmptx,hashblock) == 0)
+                            return eval->Invalid("invalid oraclescreate txid!");
+                        else if ((numvouts=tmptx.vout.size()) < 1 || DecodeOraclesCreateOpRet(tmptx.vout[numvouts-1].scriptPubKey,name,desc,format)!='C')
+                            return eval->Invalid("invalid oraclescreate OP_RETURN data!"); 
+                        else if ( IsCCInput(tmptx.vin[0].scriptSig) != 0 )
+                            return eval->Invalid("vin.0 is normal for oraclescreate!");
+                        else if (ConstrainVout(tmptx.vout[0],0,oraclesaddr,txfee)==0)
+                            return eval->Invalid("invalid marker for oraclescreate!");
+                        else if ( IsCCInput(tx.vin[0].scriptSig) != 0 )
+                            return eval->Invalid("vin.0 is normal for oraclesregister!");
+                        else if ((*cp->ismyvin)(tx.vin[tx.vin.size()-1].scriptSig) == 0 || myGetTransaction(tx.vin[tx.vin.size()-1].prevout.hash,tmptx,hashblock)==0
+                                || tmptx.vout[tx.vin[tx.vin.size()-1].prevout.n].nValue!=CC_MARKER_VALUE || !Getscriptaddress(vinaddress,tmptx.vout[tx.vin[tx.vin.size()-1].prevout.n].scriptPubKey)
+                                || !GetCCaddress(cp,tmpaddress,tmppk) || strcmp(tmpaddress,vinaddress)!=0)
+                            return eval->Invalid("vin."+std::to_string(tx.vin.size()-1)+" is CC for oraclesregister or pubkey not same as vin pubkey, register must be done from owner of pubkey that registers to oracle!!");
+                        else if (CCtxidaddr(tmpaddress,oracletxid).IsValid() && ConstrainVout(tx.vout[0],0,tmpaddress,txfee)==0)
+                            return eval->Invalid("invalid marker for oraclesregister!");
+                        else if (!Getscriptaddress(tmpaddress,CScript() << ParseHex(HexStr(tmppk)) << OP_CHECKSIG) || ConstrainVout(tx.vout[2],0,tmpaddress,CC_MARKER_VALUE)==0)
+                            return eval->Invalid("pubkey in OP_RETURN and in vout.2 not matching, register must be done from owner of pubkey that registers to oracle!");
+                    }
+                    else return eval->Invalid("unexpected OraclesValidate for register");
                    break;
                case 'S': // subscribe
                    // vins.*: normal inputs
@@ -762,6 +814,45 @@ int64_t LifetimeOraclesFunds(struct CCcontract_info *cp,uint256 oracletxid,CPubK
    return(total);
 }

+int64_t AddMyOraclesFunds(struct CCcontract_info *cp,CMutableTransaction &mtx,CPubKey pk,uint256 oracletxid)
+{
+    char coinaddr[64],funcid; int64_t nValue,tmpamount; uint256 tmporacletxid,txid,hashBlock,ignoretxid; int32_t numvouts,vout,ignorevin;
+    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs; CTransaction vintx; CPubKey tmppk;
+
+    GetCCaddress(cp,coinaddr,pk);
+    SetCCunspents(unspentOutputs,coinaddr,true);
+    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;
+        nValue = it->second.satoshis;
+        if ( GetTransaction(txid,vintx,hashBlock,false) != 0 && (numvouts=vintx.vout.size())>0)
+        {
+            if ((funcid=DecodeOraclesOpRet(vintx.vout[numvouts-1].scriptPubKey,tmporacletxid,tmppk,tmpamount))!=0 && funcid=='F' && tmppk==pk 
+            && tmporacletxid==oracletxid && tmpamount==nValue && myIsutxo_spentinmempool(ignoretxid,ignorevin,txid,vout)==0)
+            {
+                mtx.vin.push_back(CTxIn(txid,vout,CScript()));
+                return (nValue);
+            }
+        } else fprintf(stderr,"couldnt find transaction\n");
+    }
+
+    BOOST_FOREACH(const CTxMemPoolEntry &e, mempool.mapTx)
+    {
+        const CTransaction &txmempool = e.GetTx();
+        const uint256 &hash = txmempool.GetHash();
+        nValue=txmempool.vout[0].nValue;
+
+        if ((funcid=DecodeOraclesOpRet(txmempool.vout[txmempool.vout.size()-1].scriptPubKey,tmporacletxid,tmppk,tmpamount))!=0 && funcid=='F' 
+        && tmppk==pk && tmporacletxid==oracletxid && tmpamount==nValue && myIsutxo_spentinmempool(ignoretxid,ignorevin,hash,0)==0)
+        {
+            mtx.vin.push_back(CTxIn(hash,0,CScript()));
+            return (nValue);
+        }
+    }
+    return (0);
+}
+
 std::string OracleCreate(int64_t txfee,std::string name,std::string description,std::string format)
 {
    CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
@@ -802,10 +893,36 @@ std::string OracleCreate(int64_t txfee,std::string name,std::string description,
    return("");
 }

+std::string OracleFund(int64_t txfee,uint256 oracletxid)
+{
+    CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
+    CPubKey mypk,oraclespk; struct CCcontract_info *cp,C;
+
+    if (GetLatestTimestamp(komodo_currentheight())<PUBKEY_SPOOFING_FIX_ACTIVATION)
+    {
+        CCerror = strprintf("oraclesfund not active yet, activation scheduled for July 15th");
+        fprintf(stderr,"%s\n", CCerror.c_str() );
+        return("");
+    }
+    cp = CCinit(&C,EVAL_ORACLES);
+    if ( txfee == 0 )
+        txfee = 10000;
+    mypk = pubkey2pk(Mypubkey());
+    if (AddNormalinputs(mtx,mypk,txfee+CC_MARKER_VALUE,2))    
+    {
+        mtx.vout.push_back(MakeCC1vout(cp->evalcode,CC_MARKER_VALUE,mypk));
+        return(FinalizeCCTx(0,cp,mtx,mypk,txfee,EncodeOraclesOpRet('F',oracletxid,mypk,CC_MARKER_VALUE)));
+    }
+    CCerror = strprintf("error adding normal inputs");
+    fprintf(stderr,"%s\n", CCerror.c_str() );
+    return("");
+}
+
 std::string OracleRegister(int64_t txfee,uint256 oracletxid,int64_t datafee)
 {
    CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
-    CPubKey mypk,markerpubkey,batonpk; struct CCcontract_info *cp,C; char markeraddr[64],batonaddr[64];
+    CPubKey mypk,markerpubkey,batonpk,oraclespk; struct CCcontract_info *cp,C; char markeraddr[64],batonaddr[64];
+
    cp = CCinit(&C,EVAL_ORACLES);
    if ( txfee == 0 )
        txfee = 10000;
@@ -816,12 +933,20 @@ std::string OracleRegister(int64_t txfee,uint256 oracletxid,int64_t datafee)
        return("");
    }
    mypk = pubkey2pk(Mypubkey());
+    oraclespk = GetUnspendable(cp,0);
    batonpk = OracleBatonPk(batonaddr,cp);
    markerpubkey = CCtxidaddr(markeraddr,oracletxid);
-    if ( AddNormalinputs(mtx,mypk,3*txfee,4) > 0 )
+    if (AddNormalinputs(mtx,mypk,3*txfee,4))
    {
+        if (GetLatestTimestamp(komodo_currentheight())>PUBKEY_SPOOFING_FIX_ACTIVATION && AddMyOraclesFunds(cp,mtx,mypk,oracletxid)!=CC_MARKER_VALUE)
+        {
+            CCerror = strprintf("error adding inputs from your Oracles CC address, please fund it first with oraclesfund rpc!");
+            fprintf(stderr,"%s\n", CCerror.c_str() );
+            return("");
+        }            
        mtx.vout.push_back(CTxOut(txfee,CScript() << ParseHex(HexStr(markerpubkey)) << OP_CHECKSIG));
        mtx.vout.push_back(MakeCC1vout(cp->evalcode,txfee,batonpk));
+        if (GetLatestTimestamp(komodo_currentheight())>PUBKEY_SPOOFING_FIX_ACTIVATION) mtx.vout.push_back(CTxOut(txfee,CScript() << ParseHex(HexStr(mypk)) << OP_CHECKSIG));
        return(FinalizeCCTx(0,cp,mtx,mypk,txfee,EncodeOraclesOpRet('R',oracletxid,mypk,datafee)));
    }
    CCerror = strprintf("error adding normal inputs");
@@ -924,43 +1049,70 @@ std::string OracleData(int64_t txfee,uint256 oracletxid,std::vector <uint8_t> da

 UniValue OracleFormat(uint8_t *data,int32_t datalen,char *format,int32_t formatlen)
 {
-    uint256 hash; int32_t i,j=0; int64_t val; char str[IGUANA_MAXSCRIPTSIZE*2+1];
+    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);
+        obj.push_back(str);
        if ( j < 0 )
            break;
        if ( j >= datalen )
            break;
    }
-    return(str);
+    return(obj);
 }

-UniValue OracleDataSamples(uint256 reforacletxid,uint256 batontxid,int32_t num)
+UniValue OracleDataSamples(uint256 reforacletxid,char* batonaddr,int32_t num)
 {
-    UniValue result(UniValue::VOBJ),b(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 str[67], *formatstr = 0;
+    UniValue result(UniValue::VOBJ),b(UniValue::VARR); CTransaction tx,oracletx; uint256 txid,hashBlock,btxid,oracletxid; 
+    CPubKey pk; std::string name,description,format; int32_t numvouts,n=0,vout; std::vector<uint8_t> data; char *formatstr = 0;
+    std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex; int64_t nValue;
    
    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 )
+            BOOST_FOREACH(const CTxMemPoolEntry &e, mempool.mapTx)
            {
-                if ( DecodeOraclesData(tx.vout[numvouts-1].scriptPubKey,oracletxid,btxid,pk,data) == 'D' && reforacletxid == oracletxid )
+                const CTransaction &txmempool = e.GetTx();
+                const uint256 &hash = txmempool.GetHash();
+                if ((numvouts=txmempool.vout.size())>0 && DecodeOraclesData(txmempool.vout[numvouts-1].scriptPubKey,oracletxid,btxid,pk,data) == 'D' && reforacletxid == oracletxid )
                {
                    if ( (formatstr= (char *)format.c_str()) == 0 )
                        formatstr = (char *)"";
                    UniValue a(UniValue::VOBJ);
-                    a.push_back(Pair("data",OracleFormat((uint8_t *)data.data(),(int32_t)data.size(),formatstr,(int32_t)format.size())));
-                    a.push_back(Pair("txid",uint256_str(str,batontxid)));
+                    a.push_back(Pair("txid",hash.GetHex()));
+                    a.push_back(Pair("data",OracleFormat((uint8_t *)data.data(),(int32_t)data.size(),formatstr,(int32_t)format.size())));            
                    b.push_back(a);
-                    batontxid = btxid;
                    if ( ++n >= num && num != 0)
                        break;
-                } else break;
+                }
+            }
+            SetCCtxids(addressIndex,batonaddr,true);
+            if (addressIndex.size()>0)
+            {
+                for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=addressIndex.end()-1; it!=addressIndex.begin(); it--)
+                {
+                    txid=it->first.txhash;
+                    vout = (int32_t)it->first.index;
+                    nValue = (int64_t)it->second;
+                    if (vout==1 && nValue==10000 && GetTransaction(txid,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 *)"";
+                            UniValue a(UniValue::VOBJ);
+                            a.push_back(Pair("txid",txid.GetHex()));
+                            a.push_back(Pair("data",OracleFormat((uint8_t *)data.data(),(int32_t)data.size(),formatstr,(int32_t)format.size())));                            
+                            b.push_back(a);
+                            if ( ++n >= num && num != 0)
+                                break;
+                        }
+                    }
+                }
            }
        }
    }
@@ -971,10 +1123,12 @@ UniValue OracleDataSamples(uint256 reforacletxid,uint256 batontxid,int32_t num)
 UniValue OracleInfo(uint256 origtxid)
 {
    UniValue result(UniValue::VOBJ),a(UniValue::VARR);
-    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
+    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs; int32_t height;
    CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
-    CTransaction regtx,tx; std::string name,description,format; uint256 hashBlock,txid,oracletxid,batontxid; CPubKey pk;
+    CTransaction tx; std::string name,description,format; uint256 hashBlock,txid,oracletxid,batontxid; CPubKey pk;
    struct CCcontract_info *cp,C; int64_t datafee,funding; char str[67],markeraddr[64],numstr[64],batonaddr[64]; std::vector <uint8_t> data;
+    std::map<CPubKey,std::pair<uint256,int32_t>> publishers;
+
    cp = CCinit(&C,EVAL_ORACLES);
    CCtxidaddr(markeraddr,origtxid);
    if ( GetTransaction(origtxid,tx,hashBlock,false) == 0 )
@@ -998,28 +1152,38 @@ UniValue OracleInfo(uint256 origtxid)
            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 )
+                height = (int32_t)it->second.blockHeight;
+                if ( GetTransaction(txid,tx,hashBlock,false) != 0 && tx.vout.size() > 0 &&
+                    DecodeOraclesOpRet(tx.vout[tx.vout.size()-1].scriptPubKey,oracletxid,pk,datafee) == 'R' && oracletxid == origtxid )
                {
-                    if ( regtx.vout.size() > 0 && DecodeOraclesOpRet(regtx.vout[regtx.vout.size()-1].scriptPubKey,oracletxid,pk,datafee) == 'R' && oracletxid == origtxid )
+                    if (publishers.find(pk)==publishers.end() || height>publishers[pk].second)
                    {
-                        UniValue obj(UniValue::VOBJ);
-                        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,oracletxid,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);
+                        publishers[pk].first=txid;
+                        publishers[pk].second=height;
                    }
                }
            }
+            for (std::map<CPubKey,std::pair<uint256,int32_t>>::iterator it = publishers.begin(); it != publishers.end(); ++it)
+            {
+                if ( GetTransaction(it->second.first,tx,hashBlock,false) != 0 && DecodeOraclesOpRet(tx.vout[tx.vout.size()-1].scriptPubKey,oracletxid,pk,datafee) == 'R')
+                {
+                    UniValue obj(UniValue::VOBJ);
+                    obj.push_back(Pair("publisher",pubkey33_str(str,(uint8_t *)pk.begin())));
+                    Getscriptaddress(batonaddr,tx.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,oracletxid,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));
        }
    }
--- a/src/cc/payments.cpp
+++ b/src/cc/payments.cpp
@@ -406,6 +406,7 @@ bool PaymentsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &
                    {
                        // token snapshot
                        // payments_gettokenallocations(top, bottom, excludeScriptPubKeys, tokenid, mpzTotalAllocations, scriptPubKeys, allocations);
+                        return(eval->Invalid("tokens not yet implemented"));
                    }
                }
                // sanity check to make sure we got all the required info, skip for merge type tx
@@ -519,8 +520,8 @@ bool PaymentsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &
                else if ( i == dust+1 )
                    return(eval->Invalid("cannot merge only dust"));
            }
-        } else return(eval->Invalid("create transaction cannot decode"));
-    } else return(eval->Invalid("Could not get contract transaction"));
+        } else return(eval->Invalid("cannot decode create transaction"));
+    } else return(eval->Invalid("could not get contract transaction"));
    return(true);
 }
 // end of consensus code
@@ -1067,15 +1068,27 @@ UniValue PaymentsMerge(struct CCcontract_info *cp,char *jsonstr)
 UniValue PaymentsTxidopret(struct CCcontract_info *cp,char *jsonstr)
 {
    CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight()); UniValue result(UniValue::VOBJ); CPubKey mypk; std::string rawtx;
-    std::vector<uint8_t> scriptPubKey,opret; int32_t n,retval0,retval1=0; int64_t allocation;
+    std::vector<uint8_t> scriptPubKey,opret; int32_t n,retval0,retval1=0; int64_t allocation; CScript test; txnouttype whichType;
    cJSON *params = payments_reparse(&n,jsonstr);
    mypk = pubkey2pk(Mypubkey());
    if ( params != 0 && n > 1 && n <= 3 )
    {
        allocation = (int64_t)jint(jitem(params,0),0);
-        retval0 = payments_parsehexdata(scriptPubKey,jitem(params,1),0);
-        CScript test = CScript(scriptPubKey.begin(),scriptPubKey.end());
-        txnouttype whichType;
+        std::string address; 
+        address.append(jstri(params,1));
+        CTxDestination destination = DecodeDestination(address);
+        if ( IsValidDestination(destination) )
+        {
+            // its an address 
+            test = GetScriptForDestination(destination);
+            scriptPubKey = std::vector<uint8_t> (test.begin(),test.end());
+        }
+        else 
+        {
+            // its a scriptpubkey
+            retval0 = payments_parsehexdata(scriptPubKey,jitem(params,1),0);
+            test = CScript(scriptPubKey.begin(),scriptPubKey.end());
+        }
        if (!::IsStandard(test, whichType))
        {
            result.push_back(Pair("result","error"));
@@ -1279,7 +1292,8 @@ UniValue PaymentsAirdropTokens(struct CCcontract_info *cp,char *jsonstr)
    uint256 hashBlock, tokenid = zeroid; CTransaction tx; CPubKey Paymentspk,mypk; char markeraddr[64]; std::string rawtx; 
    int32_t lockedblocks,minrelease,top,bottom,n,i,minimum=10000; std::vector<std::vector<uint8_t>> excludeScriptPubKeys; int8_t fixedAmount;
    cJSON *params = payments_reparse(&n,jsonstr);
-    if ( params != 0 && n >= 6 )
+    // disable for now. Need token snapshot function. 
+    if ( 0 ) //params != 0 && n >= 6 )
    {
        tokenid = payments_juint256(jitem(params,0));
        lockedblocks = juint(jitem(params,1),0);
@@ -1346,7 +1360,8 @@ UniValue PaymentsAirdropTokens(struct CCcontract_info *cp,char *jsonstr)
    else
    {
        result.push_back(Pair("result","error"));
-        result.push_back(Pair("error","parameters error"));
+        //result.push_back(Pair("error","parameters error"));
+        result.push_back(Pair("error","tokens airdrop not yet impmlemented"));
    }
    if ( params != 0 )
        free_json(params);
--- a/src/cc/prices.cpp
+++ b/src/cc/prices.cpp
--- a/src/crypto/verus_hash.h
+++ b/src/crypto/verus_hash.h
@@ -1,134 +1,134 @@
-// (C) 2018 Michael Toutonghi
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-/*
-This provides the PoW hash function for Verus, enabling CPU mining.
-*/
-#ifndef VERUS_HASH_H_
-#define VERUS_HASH_H_
-
-#include <cstring>
-#include <vector>
-
-#include <cpuid.h>
-
-extern "C" 
-{
-#include "crypto/haraka.h"
-#include "crypto/haraka_portable.h"
-}
-
-class CVerusHash
-{
-    public:
-        static void Hash(void *result, const void *data, size_t len);
-        static void (*haraka512Function)(unsigned char *out, const unsigned char *in);
-
-        static void init();
-
-        CVerusHash() { }
-
-        CVerusHash &Write(const unsigned char *data, size_t len);
-
-        CVerusHash &Reset()
-        {
-            curBuf = buf1;
-            result = buf2;
-            curPos = 0;
-            std::fill(buf1, buf1 + sizeof(buf1), 0);
-            return *this;
-        }
-
-        int64_t *ExtraI64Ptr() { return (int64_t *)(curBuf + 32); }
-        void ClearExtra()
-        {
-            if (curPos)
-            {
-                std::fill(curBuf + 32 + curPos, curBuf + 64, 0);
-            }
-        }
-        void ExtraHash(unsigned char hash[32]) { (*haraka512Function)(hash, curBuf); }
-
-        void Finalize(unsigned char hash[32])
-        {
-            if (curPos)
-            {
-                std::fill(curBuf + 32 + curPos, curBuf + 64, 0);
-                (*haraka512Function)(hash, curBuf);
-            }
-            else
-                std::memcpy(hash, curBuf, 32);
-        }
-
-    private:
-        // only buf1, the first source, needs to be zero initialized
-        unsigned char buf1[64] = {0}, buf2[64];
-        unsigned char *curBuf = buf1, *result = buf2;
-        size_t curPos = 0;
-};
-
-class CVerusHashV2
-{
-    public:
-        static void Hash(void *result, const void *data, size_t len);
-        static void (*haraka512Function)(unsigned char *out, const unsigned char *in);
-
-        static void init();
-
-        CVerusHashV2() {}
-
-        CVerusHashV2 &Write(const unsigned char *data, size_t len);
-
-        CVerusHashV2 &Reset()
-        {
-            curBuf = buf1;
-            result = buf2;
-            curPos = 0;
-            std::fill(buf1, buf1 + sizeof(buf1), 0);
-            return *this; 
-        }
-
-        int64_t *ExtraI64Ptr() { return (int64_t *)(curBuf + 32); }
-        void ClearExtra()
-        {
-            if (curPos)
-            {
-                std::fill(curBuf + 32 + curPos, curBuf + 64, 0);
-            }
-        }
-        void ExtraHash(unsigned char hash[32]) { (*haraka512Function)(hash, curBuf); }
-
-        void Finalize(unsigned char hash[32])
-        {
-            if (curPos)
-            {
-                std::fill(curBuf + 32 + curPos, curBuf + 64, 0);
-                (*haraka512Function)(hash, curBuf);
-            }
-            else
-                std::memcpy(hash, curBuf, 32);
-        }
-
-    private:
-        // only buf1, the first source, needs to be zero initialized
-        unsigned char buf1[64] = {0}, buf2[64];
-        unsigned char *curBuf = buf1, *result = buf2;
-        size_t curPos = 0;
-};
-
-extern void verus_hash(void *result, const void *data, size_t len);
-extern void verus_hash_v2(void *result, const void *data, size_t len);
-
-inline bool IsCPUVerusOptimized()
-{
-    unsigned int eax,ebx,ecx,edx;
-
-    if (!__get_cpuid(1,&eax,&ebx,&ecx,&edx))
-    {
-        return false;
-    }
-    return ((ecx & (bit_AVX | bit_AES)) == (bit_AVX | bit_AES));
-};
-
-#endif
+// (C) 2018 Michael Toutonghi
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+/*
+This provides the PoW hash function for Verus, enabling CPU mining.
+*/
+#ifndef VERUS_HASH_H_
+#define VERUS_HASH_H_
+
+#include <cstring>
+#include <vector>
+
+#include <cpuid.h>
+
+extern "C" 
+{
+#include "crypto/haraka.h"
+#include "crypto/haraka_portable.h"
+}
+
+class CVerusHash
+{
+    public:
+        static void Hash(void *result, const void *data, size_t len);
+        static void (*haraka512Function)(unsigned char *out, const unsigned char *in);
+
+        static void init();
+
+        CVerusHash() { }
+
+        CVerusHash &Write(const unsigned char *data, size_t len);
+
+        CVerusHash &Reset()
+        {
+            curBuf = buf1;
+            result = buf2;
+            curPos = 0;
+            std::fill(buf1, buf1 + sizeof(buf1), 0);
+            return *this;
+        }
+
+        int64_t *ExtraI64Ptr() { return (int64_t *)(curBuf + 32); }
+        void ClearExtra()
+        {
+            if (curPos)
+            {
+                std::fill(curBuf + 32 + curPos, curBuf + 64, 0);
+            }
+        }
+        void ExtraHash(unsigned char hash[32]) { (*haraka512Function)(hash, curBuf); }
+
+        void Finalize(unsigned char hash[32])
+        {
+            if (curPos)
+            {
+                std::fill(curBuf + 32 + curPos, curBuf + 64, 0);
+                (*haraka512Function)(hash, curBuf);
+            }
+            else
+                std::memcpy(hash, curBuf, 32);
+        }
+
+    private:
+        // only buf1, the first source, needs to be zero initialized
+        unsigned char buf1[64] = {0}, buf2[64];
+        unsigned char *curBuf = buf1, *result = buf2;
+        size_t curPos = 0;
+};
+
+class CVerusHashV2
+{
+    public:
+        static void Hash(void *result, const void *data, size_t len);
+        static void (*haraka512Function)(unsigned char *out, const unsigned char *in);
+
+        static void init();
+
+        CVerusHashV2() {}
+
+        CVerusHashV2 &Write(const unsigned char *data, size_t len);
+
+        CVerusHashV2 &Reset()
+        {
+            curBuf = buf1;
+            result = buf2;
+            curPos = 0;
+            std::fill(buf1, buf1 + sizeof(buf1), 0);
+            return *this;
+        }
+
+        int64_t *ExtraI64Ptr() { return (int64_t *)(curBuf + 32); }
+        void ClearExtra()
+        {
+            if (curPos)
+            {
+                std::fill(curBuf + 32 + curPos, curBuf + 64, 0);
+            }
+        }
+        void ExtraHash(unsigned char hash[32]) { (*haraka512Function)(hash, curBuf); }
+
+        void Finalize(unsigned char hash[32])
+        {
+            if (curPos)
+            {
+                std::fill(curBuf + 32 + curPos, curBuf + 64, 0);
+                (*haraka512Function)(hash, curBuf);
+            }
+            else
+                std::memcpy(hash, curBuf, 32);
+        }
+
+    private:
+        // only buf1, the first source, needs to be zero initialized
+        unsigned char buf1[64] = {0}, buf2[64];
+        unsigned char *curBuf = buf1, *result = buf2;
+        size_t curPos = 0;
+};
+
+extern void verus_hash(void *result, const void *data, size_t len);
+extern void verus_hash_v2(void *result, const void *data, size_t len);
+
+inline bool IsCPUVerusOptimized()
+{
+    unsigned int eax,ebx,ecx,edx;
+
+    if (!__get_cpuid(1,&eax,&ebx,&ecx,&edx))
+    {
+        return false;
+    }
+    return ((ecx & (bit_AVX | bit_AES)) == (bit_AVX | bit_AES));
+};
+
+#endif
--- a/src/fiat/k64
+++ b/src/fiat/k64
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=K64 $1 $2 $3 $4 $5 $6
--- a/src/fiat/zex
+++ b/src/fiat/zex
@@ -1,2 +0,0 @@
-#!/bin/bash
-./komodo-cli -ac_name=ZEX $1 $2 $3 $4 $5 $6
--- a/src/fiat/zexo
+++ b/src/fiat/zexo
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=ZEXO $1 $2 $3 $4 $5 $6
--- a/src/komodo.h
+++ b/src/komodo.h
@@ -713,9 +713,9 @@ int32_t komodo_voutupdate(bool fJustCheck,int32_t *isratificationp,int32_t notar
                        sp->MoMdepth = MoMdepth;
                    }
                    komodo_stateupdate(height,0,0,0,zero,0,0,0,0,0,0,0,0,0,0,sp->MoM,sp->MoMdepth);
-                    if ( ASSETCHAINS_SYMBOL[0] != 0 )
+                    //if ( ASSETCHAINS_SYMBOL[0] != 0 )
                        printf("[%s] ht.%d NOTARIZED.%d %s.%s %sTXID.%s lens.(%d %d) MoM.%s %d\n",ASSETCHAINS_SYMBOL,height,sp->NOTARIZED_HEIGHT,ASSETCHAINS_SYMBOL[0]==0?"KMD":ASSETCHAINS_SYMBOL,srchash.ToString().c_str(),ASSETCHAINS_SYMBOL[0]==0?"BTC":"KMD",desttxid.ToString().c_str(),opretlen,len,sp->MoM.ToString().c_str(),sp->MoMdepth);
-                                        
+                    
                    if ( ASSETCHAINS_SYMBOL[0] == 0 )
                    {
                        if ( signedfp == 0 )
@@ -803,7 +803,10 @@ int32_t komodo_notarycmp(uint8_t *scriptPubKey,int32_t scriptlen,uint8_t pubkeys
    return(-1);
 }

-// int32_t ! 
+// int32_t (!!!)
+/*
+    read blackjok3rtt comments in main.cpp 
+*/
 int32_t komodo_connectblock(bool fJustCheck, CBlockIndex *pindex,CBlock& block)
 {
    static int32_t hwmheight;
@@ -897,8 +900,8 @@ int32_t komodo_connectblock(bool fJustCheck, CBlockIndex *pindex,CBlock& block)
            }
            numvalid = bitweight(signedmask);
            if ( ((height < 90000 || (signedmask & 1) != 0) && numvalid >= KOMODO_MINRATIFY) ||
-                  (numvalid >= KOMODO_MINRATIFY && ASSETCHAINS_SYMBOL[0] != 0) ||
-                  numvalid > (numnotaries/5) )
+                (numvalid >= KOMODO_MINRATIFY && ASSETCHAINS_SYMBOL[0] != 0) ||
+                numvalid > (numnotaries/5) )
            {
                if ( !fJustCheck && ASSETCHAINS_SYMBOL[0] != 0)
                {
@@ -918,7 +921,7 @@ int32_t komodo_connectblock(bool fJustCheck, CBlockIndex *pindex,CBlock& block)
                        fflush(signedfp);
                    }
                    transaction = i;
-                     printf("[%s] ht.%d txi.%d signedmask.%llx numvins.%d numvouts.%d <<<<<<<<<<<  notarized\n",ASSETCHAINS_SYMBOL,height,i,(long long)signedmask,numvins,numvouts);
+                    printf("[%s] ht.%d txi.%d signedmask.%llx numvins.%d numvouts.%d <<<<<<<<<<<  notarized\n",ASSETCHAINS_SYMBOL,height,i,(long long)signedmask,numvins,numvouts);
                }
                notarized = 1;
            }
@@ -1014,7 +1017,9 @@ int32_t komodo_connectblock(bool fJustCheck, CBlockIndex *pindex,CBlock& block)
            printf("%s ht.%d\n",ASSETCHAINS_SYMBOL[0] == 0 ? "KMD" : ASSETCHAINS_SYMBOL,height);
        if ( !fJustCheck && pindex->GetHeight() == hwmheight )
            komodo_stateupdate(height,0,0,0,zero,0,0,0,0,height,(uint32_t)pindex->nTime,0,0,0,0,zero,0);
-    } else fprintf(stderr,"komodo_connectblock: unexpected null pindex\n");
+    } 
+    else 
+        { fprintf(stderr,"komodo_connectblock: unexpected null pindex\n"); return(0); }
    //KOMODO_INITDONE = (uint32_t)time(NULL);
    //fprintf(stderr,"%s end connect.%d\n",ASSETCHAINS_SYMBOL,pindex->GetHeight());
    if (fJustCheck)
@@ -1025,6 +1030,12 @@ int32_t komodo_connectblock(bool fJustCheck, CBlockIndex *pindex,CBlock& block)
            return(1);
        if ( notarisations.size() > 1 || (notarisations.size() == 1 && notarisations[0] != 1) )
            return(-1);
+        
+        fprintf(stderr,"komodo_connectblock: unxexpected behaviour when fJustCheck == true, report blackjok3rtt plz ! \n");
+        /* this needed by gcc-8, it counts here that control reaches end of non-void function without this.
+           by default, we count that if control reached here -> the valid notarization isnt in position 1 or there are too many notarizations in this block.
+        */
+        return(-1); 
    }
    else return(0);
 }
--- a/src/komodo_bitcoind.h
+++ b/src/komodo_bitcoind.h
@@ -682,11 +682,32 @@ int32_t komodo_WhoStaked(CBlock *pblock, CTxDestination &addressout)

 bool MarmaraPoScheck(char *destaddr,CScript opret,CTransaction staketx);

-int32_t komodo_isPoS(CBlock *pblock,int32_t height)
+int32_t komodo_isPoS2(CBlock *pblock)
 {
-    int32_t n,vout,numvouts; uint32_t txtime; uint64_t value; char voutaddr[64],destaddr[64]; CTxDestination voutaddress; uint256 txid; CScript opret;
+    CBlockIndex *pindex = komodo_blockindex(pblock->GetHash());
+    if ( pindex != 0 && pindex->segid >= -1 )
+    {
+        //fprintf(stderr,"isPoSblock segid.%d\n",pindex->segid);
+        if ( pindex->segid == -1 )
+            return(0);
+        else return(1);
+    }
+    return (-1);
+}
+
+int32_t komodo_isPoS(CBlock *pblock,int32_t height,bool fJustCheck)
+{
+    int32_t n,vout,numvouts,ret; uint32_t txtime; uint64_t value; char voutaddr[64],destaddr[64]; CTxDestination voutaddress; uint256 txid; CScript opret;
    if ( ASSETCHAINS_STAKED != 0 )
    {
+        if ( fJustCheck )
+        {
+            // check pindex first, if that does not work, continue with slow check.
+            if ( (ret= komodo_isPoS2(pblock)) == 1 )
+                return (1);
+            else if ( ret == 0 )
+                return (0);
+        }
        n = pblock->vtx.size();
        //fprintf(stderr,"ht.%d check for PoS numtx.%d numvins.%d numvouts.%d\n",height,n,(int32_t)pblock->vtx[n-1].vin.size(),(int32_t)pblock->vtx[n-1].vout.size());
        if ( n > 1 && pblock->vtx[n-1].vin.size() == 1 && pblock->vtx[n-1].vout.size() == 1+(ASSETCHAINS_MARMARA!=0) )
@@ -1401,10 +1422,6 @@ arith_uint256 komodo_PoWtarget(int32_t *percPoSp,arith_uint256 target,int32_t he
        if ( ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASH || ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASHV1_1 )
            percPoS = (percPoS*100) / (m+n); 
        else
-            // This seems to be inverse. The actual PoS % is backwards in the first 100 blocks. 
-            // I dont't understand the math here, or why its backwards, so I am just disabling it for VerusHash.
-            // No doubt this is probably wrong for equihash aswell, we may need to test an equihash chain with the rule above.
-            // Need to ask james what the deal is here! Seems to be causeing ALL the problems.
            percPoS = ((percPoS * n) + (goalperc * (100-n))) / 100;            
    } 
    if ( dispflag != 0 && ASSETCHAINS_STAKED < 100 )
@@ -1585,7 +1602,7 @@ uint32_t komodo_stake(int32_t validateflag,arith_uint256 bnTarget,int32_t nHeigh

 int32_t komodo_is_PoSblock(int32_t slowflag,int32_t height,CBlock *pblock,arith_uint256 bnTarget,arith_uint256 bhash)
 {
-    CBlockIndex *previndex,*pindex; char voutaddr[64],destaddr[64]; uint256 txid; uint32_t txtime,prevtime=0; int32_t vout,PoSperc,txn_count,eligible=0,isPoS = 0,segid; uint64_t value; CTxDestination voutaddress; arith_uint256 POWTarget;
+    CBlockIndex *previndex,*pindex; char voutaddr[64],destaddr[64]; uint256 txid; uint32_t txtime,prevtime=0; int32_t ret,vout,PoSperc,txn_count,eligible=0,isPoS = 0,segid; uint64_t value; CTxDestination voutaddress; arith_uint256 POWTarget;
    if ( ASSETCHAINS_STAKED == 100 && height <= 10 )
        return(1);
    BlockMap::const_iterator it = mapBlockIndex.find(pblock->GetHash());
@@ -1612,7 +1629,7 @@ int32_t komodo_is_PoSblock(int32_t slowflag,int32_t height,CBlock *pblock,arith_
        vout = pblock->vtx[txn_count-1].vin[0].prevout.n;
        if ( slowflag != 0 && prevtime != 0 )
        {
-            if ( komodo_isPoS(pblock,height) != 0 )
+            if ( komodo_isPoS(pblock,height,false) != 0 )
            {
                eligible = komodo_stake(1,bnTarget,height,txid,vout,pblock->nTime,prevtime+27,(char *)"",PoSperc);
            }
@@ -1644,7 +1661,7 @@ int32_t komodo_is_PoSblock(int32_t slowflag,int32_t height,CBlock *pblock,arith_
        } 
        else if ( slowflag == 0 ) // previous blocks are not seen yet, do the best approx
        {
-            if ( komodo_isPoS(pblock,height) != 0 )
+            if ( komodo_isPoS(pblock,height,false) != 0 )
                isPoS = 1;
        }
        if ( slowflag != 0 && isPoS != 0 )
@@ -2503,7 +2520,6 @@ int32_t komodo_staked(CMutableTransaction &txNew,uint32_t nBits,uint32_t *blockt
    komodo_segids(hashbuf,nHeight-101,100);
    if ( *blocktimep < tipindex->nTime+60)
        *blocktimep = tipindex->nTime+60;
-//fprintf(stderr,"Start scan of utxo for staking %u ht.%d\n",(uint32_t)time(NULL),nHeight);

    bool resetstaker = false;
    if ( array != 0 )
@@ -2588,9 +2604,8 @@ int32_t komodo_staked(CMutableTransaction &txNew,uint32_t nBits,uint32_t *blockt
            }
        }
        lasttime = (uint32_t)time(NULL);
-//fprintf(stderr,"finished kp data of utxo for staking %u ht.%d numkp.%d maxkp.%d\n",(uint32_t)time(NULL),nHeight,numkp,maxkp);
+        //fprintf(stderr,"finished kp data of utxo for staking %u ht.%d numkp.%d maxkp.%d\n",(uint32_t)time(NULL),nHeight,numkp,maxkp);
    }
-//fprintf(stderr,"numkp.%d blocktime.%u\n",numkp,*blocktimep);
    block_from_future_rejecttime = (uint32_t)GetAdjustedTime() + 57;    
    for (i=winners=0; i<numkp; i++)
    {
@@ -2603,44 +2618,28 @@ int32_t komodo_staked(CMutableTransaction &txNew,uint32_t nBits,uint32_t *blockt
        }
        kp = &array[i];
        eligible = komodo_stake(0,bnTarget,nHeight,kp->txid,kp->vout,0,(uint32_t)tipindex->nTime+27,kp->address,PoSperc);
-        //fprintf(stderr,"i.%d %u vs %u\n",i,eligible2,eligible);
        if ( eligible > 0 )
        {
-            besttime = m = 0;
+            besttime = 0;
            if ( eligible == komodo_stake(1,bnTarget,nHeight,kp->txid,kp->vout,eligible,(uint32_t)tipindex->nTime+27,kp->address,PoSperc) )
            {
-                while ( eligible == komodo_stake(1,bnTarget,nHeight,kp->txid,kp->vout,eligible,(uint32_t)tipindex->nTime+27,kp->address,PoSperc) )
+                // have elegible utxo to stake with. 
+                if ( earliest == 0 || eligible < earliest || (eligible == earliest && (*utxovaluep == 0 || kp->nValue < *utxovaluep)) )
                {
-                    besttime = eligible;
-                    eligible--;
-                    if ( eligible < block_from_future_rejecttime ) // nothing gained by going earlier
-                        break;
-                    m++;
-//fprintf(stderr,"m.%d ht.%d validated winning blocktime %u -> %.8f eligible.%u test prior\n",m,nHeight,*blocktimep,(double)kp->nValue/COIN,eligible);
+                    // is better than the previous best, so use it instead.
+                    earliest = eligible;
+                    best_scriptPubKey = kp->scriptPubKey;
+                    *utxovaluep = (uint64_t)kp->nValue;
+                    decode_hex((uint8_t *)utxotxidp,32,(char *)kp->txid.GetHex().c_str());
+                    *utxovoutp = kp->vout;
+                    *txtimep = kp->txtime;
                }
-            }
-            else
-            {
-                //fprintf(stderr,"ht.%d error validating winning blocktime %u -> %.8f eligible.%u test prior\n",nHeight,*blocktimep,(double)kp->nValue/COIN,eligible);
-                continue;
-            }
-            eligible = besttime;
-            winners++;
-//fprintf(stderr,"ht.%d validated winning [%d] -> %.8f eligible.%u test prior\n",nHeight,(int32_t)(eligible - tipindex->nTime),(double)kp->nValue/COIN,eligible);
-            if ( earliest == 0 || eligible < earliest || (eligible == earliest && (*utxovaluep == 0 || kp->nValue < *utxovaluep)) )
-            {
-                earliest = eligible;
-                best_scriptPubKey = kp->scriptPubKey; //out.tx->vout[out.i].scriptPubKey;
-                *utxovaluep = (uint64_t)kp->nValue;
-                //decode_hex((uint8_t *)utxotxidp,32,(char *)out.tx->GetHash().GetHex().c_str());
-                decode_hex((uint8_t *)utxotxidp,32,(char *)kp->txid.GetHex().c_str());
-                *utxovoutp = kp->vout;
-                *txtimep = kp->txtime;//(uint32_t)out.tx->nLockTime;
-                //fprintf(stderr,"ht.%d earliest.%u [%d].%d (%s) nValue %.8f locktime.%u counter.%d winners.%d\n",nHeight,earliest,(int32_t)(earliest - tipindex->nTime),m,kp->address,(double)kp->nValue/COIN,*txtimep,counter,winners);
-            }
-        } //else fprintf(stderr,"utxo not eligible\n");
+                if ( eligible < block_from_future_rejecttime ) // nothing gained by going earlier
+                    break;
+            } else continue;
+        }
    }
-    if ( numkp < 1000 && array != 0 )
+    if ( numkp < 500 && array != 0 )
    {
        free(array);
        array = 0;
@@ -2659,7 +2658,7 @@ int32_t komodo_staked(CMutableTransaction &txNew,uint32_t nBits,uint32_t *blockt
            ((uint8_t *)&revtxid)[i] = ((uint8_t *)utxotxidp)[31 - i];
        txNew.vin[0].prevout.hash = revtxid;
        txNew.vin[0].prevout.n = *utxovoutp;
-        txNew.vout[0].scriptPubKey = best_scriptPubKey;// CScript() << ParseHex(NOTARY_PUBKEY) << OP_CHECKSIG;
+        txNew.vout[0].scriptPubKey = best_scriptPubKey;
        txNew.vout[0].nValue = *utxovaluep - txfee;
        txNew.nLockTime = earliest;
        CTransaction txNewConst(txNew);
@@ -2670,7 +2669,7 @@ int32_t komodo_staked(CMutableTransaction &txNew,uint32_t nBits,uint32_t *blockt
            ptr = (uint8_t *)&sigdata.scriptSig[0];
            siglen = sigdata.scriptSig.size();
            for (i=0; i<siglen; i++)
-                utxosig[i] = ptr[i];//, fprintf(stderr,"%02x",ptr[i]);
+                utxosig[i] = ptr[i];
        }
        else
        {
@@ -2682,12 +2681,7 @@ int32_t komodo_staked(CMutableTransaction &txNew,uint32_t nBits,uint32_t *blockt
        if (!signSuccess)
            fprintf(stderr,"failed to create signature\n");
        else
-        {
-            //fprintf(stderr," siglen.%d\n",siglen);
-//fprintf(stderr,"best %u from %u, gap %d lag.%d\n",earliest,*blocktimep,(int32_t)(earliest - *blocktimep),(int32_t)(time(NULL) - *blocktimep));
            *blocktimep = earliest;
-        }
-    } //else fprintf(stderr,"no earliest utxo for staking\n");
-    //fprintf(stderr,"end scan of utxo for staking t.%u counter.%d numkp.%d winners.%d\n",(uint32_t)time(NULL),counter,numkp,winners);
+    }
    return(siglen);
 }
--- a/src/komodo_defs.h
+++ b/src/komodo_defs.h
@@ -31,6 +31,221 @@
 #define KOMODO_SAPLING_DEADLINE 1550188800 // Feb 15th, 2019
 #define _COINBASE_MATURITY 100

+// KMD Notary Seasons 
+// 1: May 1st 2018 1530921600
+// 2: July 15th 2019 1563148800 -> estimated height 1444000
+// 3: 3rd season ending isnt known, so use very far times in future.
+    // 1751328000 = dummy timestamp, 1 July 2025!
+    // 7113400 = 5x current KMD blockheight. 
+// to add 4th season, change NUM_KMD_SEASONS to 4, and add timestamp and height of activation to these arrays. 
+#define NUM_KMD_SEASONS 3
+#define NUM_KMD_NOTARIES 64
+static const uint32_t KMD_SEASON_TIMESTAMPS[NUM_KMD_SEASONS] = {1525132800, 1563148800, 1751328000};
+static const int32_t KMD_SEASON_HEIGHTS[NUM_KMD_SEASONS] = {814000, 1444000, 7113400};
+
+// Era array of pubkeys. Add extra seasons to bottom as requried, after adding appropriate info above. 
+static const char *notaries_elected[NUM_KMD_SEASONS][NUM_KMD_NOTARIES][2] =
+{
+    {
+        { "0_jl777_testA", "03b7621b44118017a16043f19b30cc8a4cfe068ac4e42417bae16ba460c80f3828" },
+        { "0_jl777_testB", "02ebfc784a4ba768aad88d44d1045d240d47b26e248cafaf1c5169a42d7a61d344" },
+        { "0_kolo_testA", "0287aa4b73988ba26cf6565d815786caf0d2c4af704d7883d163ee89cd9977edec" },
+        { "artik_AR", "029acf1dcd9f5ff9c455f8bb717d4ae0c703e089d16cf8424619c491dff5994c90" },
+        { "artik_EU", "03f54b2c24f82632e3cdebe4568ba0acf487a80f8a89779173cdb78f74514847ce" },
+        { "artik_NA", "0224e31f93eff0cc30eaf0b2389fbc591085c0e122c4d11862c1729d090106c842" },
+        { "artik_SH", "02bdd8840a34486f38305f311c0e2ae73e84046f6e9c3dd3571e32e58339d20937" },
+        { "badass_EU", "0209d48554768dd8dada988b98aca23405057ac4b5b46838a9378b95c3e79b9b9e" },
+        { "badass_NA", "02afa1a9f948e1634a29dc718d218e9d150c531cfa852843a1643a02184a63c1a7" },
+        { "badass_SH", "026b49dd3923b78a592c1b475f208e23698d3f085c4c3b4906a59faf659fd9530b" },
+        { "crackers_EU", "03bc819982d3c6feb801ec3b720425b017d9b6ee9a40746b84422cbbf929dc73c3" }, // 10
+        { "crackers_NA", "03205049103113d48c7c7af811b4c8f194dafc43a50d5313e61a22900fc1805b45" },
+        { "crackers_SH", "02be28310e6312d1dd44651fd96f6a44ccc269a321f907502aae81d246fabdb03e" },
+        { "durerus_EU", "02bcbd287670bdca2c31e5d50130adb5dea1b53198f18abeec7211825f47485d57" },
+        { "etszombi_AR", "031c79168d15edabf17d9ec99531ea9baa20039d0cdc14d9525863b83341b210e9" },
+        { "etszombi_EU", "0281b1ad28d238a2b217e0af123ce020b79e91b9b10ad65a7917216eda6fe64bf7" }, // 15
+        { "etszombi_SH", "025d7a193c0757f7437fad3431f027e7b5ed6c925b77daba52a8755d24bf682dde" },
+        { "farl4web_EU", "0300ecf9121cccf14cf9423e2adb5d98ce0c4e251721fa345dec2e03abeffbab3f" },
+        { "farl4web_SH", "0396bb5ed3c57aa1221d7775ae0ff751e4c7dc9be220d0917fa8bbdf670586c030" },
+        { "fullmoon_AR", "0254b1d64840ce9ff6bec9dd10e33beb92af5f7cee628f999cb6bc0fea833347cc" },
+        { "fullmoon_NA", "031fb362323b06e165231c887836a8faadb96eda88a79ca434e28b3520b47d235b" }, // 20
+        { "fullmoon_SH", "030e12b42ec33a80e12e570b6c8274ce664565b5c3da106859e96a7208b93afd0d" },
+        { "grewal_NA", "03adc0834c203d172bce814df7c7a5e13dc603105e6b0adabc942d0421aefd2132" },
+        { "grewal_SH", "03212a73f5d38a675ee3cdc6e82542a96c38c3d1c79d25a1ed2e42fcf6a8be4e68" },
+        { "indenodes_AR", "02ec0fa5a40f47fd4a38ea5c89e375ad0b6ddf4807c99733c9c3dc15fb978ee147" },
+        { "indenodes_EU", "0221387ff95c44cb52b86552e3ec118a3c311ca65b75bf807c6c07eaeb1be8303c" },
+        { "indenodes_NA", "02698c6f1c9e43b66e82dbb163e8df0e5a2f62f3a7a882ca387d82f86e0b3fa988" },
+        { "indenodes_SH", "0334e6e1ec8285c4b85bd6dae67e17d67d1f20e7328efad17ce6fd24ae97cdd65e" },
+        { "jeezy_EU", "023cb3e593fb85c5659688528e9a4f1c4c7f19206edc7e517d20f794ba686fd6d6" },
+        { "jsgalt_NA", "027b3fb6fede798cd17c30dbfb7baf9332b3f8b1c7c513f443070874c410232446" },
+        { "karasugoi_NA", "02a348b03b9c1a8eac1b56f85c402b041c9bce918833f2ea16d13452309052a982" }, // 30
+        { "kashifali_EU", "033777c52a0190f261c6f66bd0e2bb299d30f012dcb8bfff384103211edb8bb207" },
+        { "kolo_AR", "03016d19344c45341e023b72f9fb6e6152fdcfe105f3b4f50b82a4790ff54e9dc6" },
+        { "kolo_SH", "02aa24064500756d9b0959b44d5325f2391d8e95c6127e109184937152c384e185" },
+        { "metaphilibert_AR", "02adad675fae12b25fdd0f57250b0caf7f795c43f346153a31fe3e72e7db1d6ac6" },
+        { "movecrypto_AR", "022783d94518e4dc77cbdf1a97915b29f427d7bc15ea867900a76665d3112be6f3" },
+        { "movecrypto_EU", "021ab53bc6cf2c46b8a5456759f9d608966eff87384c2b52c0ac4cc8dd51e9cc42" },
+        { "movecrypto_NA", "02efb12f4d78f44b0542d1c60146738e4d5506d27ec98a469142c5c84b29de0a80" },
+        { "movecrypto_SH", "031f9739a3ebd6037a967ce1582cde66e79ea9a0551c54731c59c6b80f635bc859" },
+        { "muros_AR", "022d77402fd7179335da39479c829be73428b0ef33fb360a4de6890f37c2aa005e" },
+        { "noashh_AR", "029d93ef78197dc93892d2a30e5a54865f41e0ca3ab7eb8e3dcbc59c8756b6e355" }, // 40
+        { "noashh_EU", "02061c6278b91fd4ac5cab4401100ffa3b2d5a277e8f71db23401cc071b3665546" },
+        { "noashh_NA", "033c073366152b6b01535e15dd966a3a8039169584d06e27d92a69889b720d44e1" },
+        { "nxtswe_EU", "032fb104e5eaa704a38a52c126af8f67e870d70f82977e5b2f093d5c1c21ae5899" },
+        { "polycryptoblog_NA", "02708dcda7c45fb54b78469673c2587bfdd126e381654819c4c23df0e00b679622" },
+        { "pondsea_AR", "032e1c213787312099158f2d74a89e8240a991d162d4ce8017d8504d1d7004f735" },
+        { "pondsea_EU", "0225aa6f6f19e543180b31153d9e6d55d41bc7ec2ba191fd29f19a2f973544e29d" },
+        { "pondsea_NA", "031bcfdbb62268e2ff8dfffeb9ddff7fe95fca46778c77eebff9c3829dfa1bb411" },
+        { "pondsea_SH", "02209073bc0943451498de57f802650311b1f12aa6deffcd893da198a544c04f36" },
+        { "popcornbag_AR", "02761f106fb34fbfc5ddcc0c0aa831ed98e462a908550b280a1f7bd32c060c6fa3" },
+        { "popcornbag_NA", "03c6085c7fdfff70988fda9b197371f1caf8397f1729a844790e421ee07b3a93e8" }, // 50
+        { "ptytrader_NA", "0328c61467148b207400b23875234f8a825cce65b9c4c9b664f47410b8b8e3c222" },
+        { "ptytrader_SH", "0250c93c492d8d5a6b565b90c22bee07c2d8701d6118c6267e99a4efd3c7748fa4" },
+        { "rnr_AR", "029bdb08f931c0e98c2c4ba4ef45c8e33a34168cb2e6bf953cef335c359d77bfcd" },
+        { "rnr_EU", "03f5c08dadffa0ffcafb8dd7ffc38c22887bd02702a6c9ac3440deddcf2837692b" },
+        { "rnr_NA", "02e17c5f8c3c80f584ed343b8dcfa6d710dfef0889ec1e7728ce45ce559347c58c" },
+        { "rnr_SH", "037536fb9bdfed10251f71543fb42679e7c52308bcd12146b2568b9a818d8b8377" },
+        { "titomane_AR", "03cda6ca5c2d02db201488a54a548dbfc10533bdc275d5ea11928e8d6ab33c2185" },
+        { "titomane_EU", "02e41feded94f0cc59f55f82f3c2c005d41da024e9a805b41105207ef89aa4bfbd" },
+        { "titomane_SH", "035f49d7a308dd9a209e894321f010d21b7793461b0c89d6d9231a3fe5f68d9960" },
+        { "vanbreuk_EU", "024f3cad7601d2399c131fd070e797d9cd8533868685ddbe515daa53c2e26004c3" }, // 60
+        { "xrobesx_NA", "03f0cc6d142d14a40937f12dbd99dbd9021328f45759e26f1877f2a838876709e1" },
+        { "xxspot1_XX", "02ef445a392fcaf3ad4176a5da7f43580e8056594e003eba6559a713711a27f955" },
+        { "xxspot2_XX", "03d85b221ea72ebcd25373e7961f4983d12add66a92f899deaf07bab1d8b6f5573" }
+    },
+    {
+        {"0dev1_jl777", "03b7621b44118017a16043f19b30cc8a4cfe068ac4e42417bae16ba460c80f3828" },
+        {"0dev2_kolo", "030f34af4b908fb8eb2099accb56b8d157d49f6cfb691baa80fdd34f385efed961" },
+        {"0dev3_kolo", "025af9d2b2a05338478159e9ac84543968fd18c45fd9307866b56f33898653b014" },
+        {"0dev4_decker", "028eea44a09674dda00d88ffd199a09c9b75ba9782382cc8f1e97c0fd565fe5707" },
+        {"a-team_SH", "03b59ad322b17cb94080dc8e6dc10a0a865de6d47c16fb5b1a0b5f77f9507f3cce" },
+        {"artik_AR", "029acf1dcd9f5ff9c455f8bb717d4ae0c703e089d16cf8424619c491dff5994c90" },
+        {"artik_EU", "03f54b2c24f82632e3cdebe4568ba0acf487a80f8a89779173cdb78f74514847ce" },
+        {"artik_NA", "0224e31f93eff0cc30eaf0b2389fbc591085c0e122c4d11862c1729d090106c842" },
+        {"artik_SH", "02bdd8840a34486f38305f311c0e2ae73e84046f6e9c3dd3571e32e58339d20937" },
+        {"badass_EU", "0209d48554768dd8dada988b98aca23405057ac4b5b46838a9378b95c3e79b9b9e" },
+        {"badass_NA", "02afa1a9f948e1634a29dc718d218e9d150c531cfa852843a1643a02184a63c1a7" }, // 10
+        {"batman_AR", "033ecb640ec5852f42be24c3bf33ca123fb32ced134bed6aa2ba249cf31b0f2563" },
+        {"batman_SH", "02ca5898931181d0b8aafc75ef56fce9c43656c0b6c9f64306e7c8542f6207018c" },
+        {"ca333_EU", "03fc87b8c804f12a6bd18efd43b0ba2828e4e38834f6b44c0bfee19f966a12ba99" },
+        {"chainmakers_EU", "02f3b08938a7f8d2609d567aebc4989eeded6e2e880c058fdf092c5da82c3bc5ee" },
+        {"chainmakers_NA", "0276c6d1c65abc64c8559710b8aff4b9e33787072d3dda4ec9a47b30da0725f57a" },
+        {"chainstrike_SH", "0370bcf10575d8fb0291afad7bf3a76929734f888228bc49e35c5c49b336002153" },
+        {"cipi_AR", "02c4f89a5b382750836cb787880d30e23502265054e1c327a5bfce67116d757ce8" },
+        {"cipi_NA", "02858904a2a1a0b44df4c937b65ee1f5b66186ab87a751858cf270dee1d5031f18" },
+        {"crackers_EU", "03bc819982d3c6feb801ec3b720425b017d9b6ee9a40746b84422cbbf929dc73c3" },
+        {"crackers_NA", "03205049103113d48c7c7af811b4c8f194dafc43a50d5313e61a22900fc1805b45" }, // 20
+        {"dwy_EU", "0259c646288580221fdf0e92dbeecaee214504fdc8bbdf4a3019d6ec18b7540424" },
+        {"emmanux_SH", "033f316114d950497fc1d9348f03770cd420f14f662ab2db6172df44c389a2667a" },
+        {"etszombi_EU", "0281b1ad28d238a2b217e0af123ce020b79e91b9b10ad65a7917216eda6fe64bf7" },
+        {"fullmoon_AR", "03380314c4f42fa854df8c471618751879f9e8f0ff5dbabda2bd77d0f96cb35676" },
+        {"fullmoon_NA", "030216211d8e2a48bae9e5d7eb3a42ca2b7aae8770979a791f883869aea2fa6eef" },
+        {"fullmoon_SH", "03f34282fa57ecc7aba8afaf66c30099b5601e98dcbfd0d8a58c86c20d8b692c64" },
+        {"goldenman_EU", "02d6f13a8f745921cdb811e32237bb98950af1a5952be7b3d429abd9152f8e388d" },
+        {"indenodes_AR", "02ec0fa5a40f47fd4a38ea5c89e375ad0b6ddf4807c99733c9c3dc15fb978ee147" },
+        {"indenodes_EU", "0221387ff95c44cb52b86552e3ec118a3c311ca65b75bf807c6c07eaeb1be8303c" },
+        {"indenodes_NA", "02698c6f1c9e43b66e82dbb163e8df0e5a2f62f3a7a882ca387d82f86e0b3fa988" }, // 30
+        {"indenodes_SH", "0334e6e1ec8285c4b85bd6dae67e17d67d1f20e7328efad17ce6fd24ae97cdd65e" },
+        {"jackson_AR", "038ff7cfe34cb13b524e0941d5cf710beca2ffb7e05ddf15ced7d4f14fbb0a6f69" },
+        {"jeezy_EU", "023cb3e593fb85c5659688528e9a4f1c4c7f19206edc7e517d20f794ba686fd6d6" },
+        {"karasugoi_NA", "02a348b03b9c1a8eac1b56f85c402b041c9bce918833f2ea16d13452309052a982" },
+        {"komodoninja_EU", "038e567b99806b200b267b27bbca2abf6a3e8576406df5f872e3b38d30843cd5ba" },
+        {"komodoninja_SH", "033178586896915e8456ebf407b1915351a617f46984001790f0cce3d6f3ada5c2" },
+        {"komodopioneers_SH", "033ace50aedf8df70035b962a805431363a61cc4e69d99d90726a2d48fb195f68c" },
+        {"libscott_SH", "03301a8248d41bc5dc926088a8cf31b65e2daf49eed7eb26af4fb03aae19682b95" },
+        {"lukechilds_AR", "031aa66313ee024bbee8c17915cf7d105656d0ace5b4a43a3ab5eae1e14ec02696" },
+        {"madmax_AR", "03891555b4a4393d655bf76f0ad0fb74e5159a615b6925907678edc2aac5e06a75" }, // 40
+        {"meshbits_AR", "02957fd48ae6cb361b8a28cdb1b8ccf5067ff68eb1f90cba7df5f7934ed8eb4b2c" },
+        {"meshbits_SH", "025c6e94877515dfd7b05682b9cc2fe4a49e076efe291e54fcec3add78183c1edb" },
+        {"metaphilibert_AR", "02adad675fae12b25fdd0f57250b0caf7f795c43f346153a31fe3e72e7db1d6ac6" },
+        {"metaphilibert_SH", "0284af1a5ef01503e6316a2ca4abf8423a794e9fc17ac6846f042b6f4adedc3309" },
+        {"patchkez_SH", "0296270f394140640f8fa15684fc11255371abb6b9f253416ea2734e34607799c4" },
+        {"pbca26_NA", "0276aca53a058556c485bbb60bdc54b600efe402a8b97f0341a7c04803ce204cb5" },
+        {"peer2cloud_AR", "034e5563cb885999ae1530bd66fab728e580016629e8377579493b386bf6cebb15" },
+        {"peer2cloud_SH", "03396ac453b3f23e20f30d4793c5b8ab6ded6993242df4f09fd91eb9a4f8aede84" },
+        {"polycryptoblog_NA", "02708dcda7c45fb54b78469673c2587bfdd126e381654819c4c23df0e00b679622" },
+        {"hyper_AR", "020f2f984d522051bd5247b61b080b4374a7ab389d959408313e8062acad3266b4" }, // 50
+        {"hyper_EU", "03d00cf9ceace209c59fb013e112a786ad583d7de5ca45b1e0df3b4023bb14bf51" },
+        {"hyper_SH", "0383d0b37f59f4ee5e3e98a47e461c861d49d0d90c80e9e16f7e63686a2dc071f3" },
+        {"hyper_NA", "03d91c43230336c0d4b769c9c940145a8c53168bf62e34d1bccd7f6cfc7e5592de" },
+        {"popcornbag_AR", "02761f106fb34fbfc5ddcc0c0aa831ed98e462a908550b280a1f7bd32c060c6fa3" },
+        {"popcornbag_NA", "03c6085c7fdfff70988fda9b197371f1caf8397f1729a844790e421ee07b3a93e8" },
+        {"alien_AR", "0348d9b1fc6acf81290405580f525ee49b4749ed4637b51a28b18caa26543b20f0" },
+        {"alien_EU", "020aab8308d4df375a846a9e3b1c7e99597b90497efa021d50bcf1bbba23246527" },
+        {"thegaltmines_NA", "031bea28bec98b6380958a493a703ddc3353d7b05eb452109a773eefd15a32e421" },
+        {"titomane_AR", "029d19215440d8cb9cc6c6b7a4744ae7fb9fb18d986e371b06aeb34b64845f9325" },
+        {"titomane_EU", "0360b4805d885ff596f94312eed3e4e17cb56aa8077c6dd78d905f8de89da9499f" }, // 60
+        {"titomane_SH", "03573713c5b20c1e682a2e8c0f8437625b3530f278e705af9b6614de29277a435b" },
+        {"webworker01_NA", "03bb7d005e052779b1586f071834c5facbb83470094cff5112f0072b64989f97d7" },
+        {"xrobesx_NA", "03f0cc6d142d14a40937f12dbd99dbd9021328f45759e26f1877f2a838876709e1" },
+    },
+    {
+        {"madmax_NA", "0237e0d3268cebfa235958808db1efc20cc43b31100813b1f3e15cc5aa647ad2c3" }, // 0
+        {"alright_AR", "020566fe2fb3874258b2d3cf1809a5d650e0edc7ba746fa5eec72750c5188c9cc9" },
+        {"strob_NA", "0206f7a2e972d9dfef1c424c731503a0a27de1ba7a15a91a362dc7ec0d0fb47685" },
+        {"dwy_EU", "021c7cf1f10c4dc39d13451123707ab780a741feedab6ac449766affe37515a29e" },
+        {"phm87_SH", "021773a38db1bc3ede7f28142f901a161c7b7737875edbb40082a201c55dcf0add" },
+        {"chainmakers_NA", "02285d813c30c0bf7eefdab1ff0a8ad08a07a0d26d8b95b3943ce814ac8e24d885" },
+        {"indenodes_EU", "0221387ff95c44cb52b86552e3ec118a3c311ca65b75bf807c6c07eaeb1be8303c" },
+        {"blackjok3r_SH", "0226293d7644e1380555ecc2d385ba038a66f4202b24b643ab31bcad0dc1474de2" },
+        {"chainmakers_EU", "03fdf5a3fce8db7dee89724e706059c32e5aa3f233a6b6cc256fea337f05e3dbf7" },
+        {"titomane_AR", "023e3aa9834c46971ff3e7cb86a200ec9c8074a9566a3ea85d400d5739662ee989" },
+        {"fullmoon_SH", "023b7252968ea8a955cd63b9e57dee45a74f2d7ba23b4e0595572138ad1fb42d21" }, // 10
+        {"indenodes_NA", "02698c6f1c9e43b66e82dbb163e8df0e5a2f62f3a7a882ca387d82f86e0b3fa988" },
+        {"chmex_EU", "0281304ebbcc39e4f09fda85f4232dd8dacd668e20e5fc11fba6b985186c90086e" },
+        {"metaphilibert_SH", "0284af1a5ef01503e6316a2ca4abf8423a794e9fc17ac6846f042b6f4adedc3309" },
+        {"ca333_DEV", "02856843af2d9457b5b1c907068bef6077ea0904cc8bd4df1ced013f64bf267958" },
+        {"cipi_NA", "02858904a2a1a0b44df4c937b65ee1f5b66186ab87a751858cf270dee1d5031f18" },
+        {"pungocloud_SH", "02863628f842a8aa424daf745cf43a1717cfcd571338ba87bfcec4d340703d01d6" },
+        {"voskcoin_EU", "0221365d89a6f6373b15daa4a50d56d34ad1b4b8a48a7fd090163b6b5a5ecd7a0a" },
+        {"decker_DEV", "028eea44a09674dda00d88ffd199a09c9b75ba9782382cc8f1e97c0fd565fe5707" },
+        {"cryptoeconomy_EU", "0290ab4937e85246e048552df3e9a66cba2c1602db76e03763e16c671e750145d1" },
+        {"etszombi_EU", "0293ea48d8841af7a419a24d9da11c34b39127ef041f847651bae6ab14dcd1f6b4" },  // 20
+        {"karasugoi_NA", "02a348b03b9c1a8eac1b56f85c402b041c9bce918833f2ea16d13452309052a982" },
+        {"pirate_AR", "02a5e865af771eee0c6bd3bd238f01f5eb589907ba52efa9f37e5102375c8eb7a0" },
+        {"metaphilibert_AR", "02adad675fae12b25fdd0f57250b0caf7f795c43f346153a31fe3e72e7db1d6ac6" },
+        {"zatjum_SH", "02d6b0c89cacd58a0af038139a9a90c9e02cd1e33803a1f15fceabea1f7e9c263a" },
+        {"madmax_AR", "03c5941fe49d673c094bc8e9bb1a95766b4670c88be76d576e915daf2c30a454d3" },
+        {"lukechilds_NA", "03f1051e62c2d280212481c62fe52aab0a5b23c95de5b8e9ad5f80d8af4277a64b" },
+        {"cipi_AR", "02c4f89a5b382750836cb787880d30e23502265054e1c327a5bfce67116d757ce8" },
+        {"tonyl_AR", "02cc8bc862f2b65ad4f99d5f68d3011c138bf517acdc8d4261166b0be8f64189e1" },
+        {"infotech_DEV", "02d7d63ac441dbcd5535bcad741701519c190e89e17e4180aa0f61fdda0b6195ea" },
+        {"fullmoon_NA", "032c716701fe3a6a3f90a97b9d874a9d6eedb066419209eed7060b0cc6b710c60b" },  // 30
+        {"etszombi_AR", "02e55e104aa94f70cde68165d7df3e162d4410c76afd4643b161dea044aa6d06ce" },
+        {"node-9_EU", "02e90f0528f8fd7d2b7f28d53ed7368cc4b1dfc5814c70c486c533862ee05e37dc" },
+        {"phba2061_EU", "03f6bd15dba7e986f0c976ea19d8a9093cb7c989d499f1708a0386c5c5659e6c4e" },
+        {"indenodes_AR", "02ec0fa5a40f47fd4a38ea5c89e375ad0b6ddf4807c99733c9c3dc15fb978ee147" },
+        {"and1-89_EU", "02f2af778c62888cfb106c0ef5c89cefe012ef3e6abed3ef28425092637d7ae3cc" },
+        {"komodopioneers_SH", "032a238a5747777da7e819cfa3c859f3677a2daf14e4dce50916fc65d00ad9c52a" },
+        {"komodopioneers_EU", "036d02425916444fff8cc7203fcbfc155c956dda5ceb647505836bef59885b6866" },
+        {"d0ct0r_NA", "0303725d8525b6f969122faf04152653eb4bf34e10de92182263321769c334bf58" },
+        {"kolo_DEV", "02849e12199dcc27ba09c3902686d2ad0adcbfcee9d67520e9abbdda045ba83227" },
+        {"peer2cloud_AR", "030fe3c77db0f91d79c26f951b674bba557b899f16570cd75332829a07031b0097" }, // 40
+        {"webworker01_SH", "031e50ba6de3c16f99d414bb89866e578d963a54bde7916c810608966fb5700776" },
+        {"webworker01_NA", "032735e9cad1bb00eaababfa6d27864fa4c1db0300c85e01e52176be2ca6a243ce" },
+        {"pbca26_NA", "03a97606153d52338bcffd1bf19bb69ef8ce5a7cbdc2dbc3ff4f89d91ea6bbb4dc" },
+        {"indenodes_SH", "0334e6e1ec8285c4b85bd6dae67e17d67d1f20e7328efad17ce6fd24ae97cdd65e" },
+        {"pirate_NA", "033c8cef71f704f357c9ac1aeaafde3acd7bbfd0a09494e5e129ee0999fb2bc368" },
+        {"lukechilds_AR", "025c6a73ff6d750b9ddf6755b390948cffdd00f344a639472d398dd5c6b4735d23" },
+        {"dragonhound_NA", "0224a9d951d3a06d8e941cc7362b788bb1237bb0d56cc313e797eb027f37c2d375" },
+        {"fullmoon_AR", "03da64dd7cd0db4c123c2f79d548a96095a5a103e5b9d956e9832865818ffa7872" },
+        {"chainzilla_SH", "0360804b8817fd25ded6e9c0b50e3b0782ac666545b5416644198e18bc3903d9f9" },
+        {"titomane_EU", "03772ac0aad6b0e9feec5e591bff5de6775d6132e888633e73d3ba896bdd8e0afb" }, // 50
+        {"jeezy_EU", "037f182facbad35684a6e960699f5da4ba89e99f0d0d62a87e8400dd086c8e5dd7" },
+        {"titomane_SH", "03850fdddf2413b51790daf51dd30823addb37313c8854b508ea6228205047ef9b" },
+        {"alien_AR", "03911a60395801082194b6834244fa78a3c30ff3e888667498e157b4aa80b0a65f" },
+        {"pirate_EU", "03986339bebe3891e369a528356a220bc17a5bef3d337edfcf0114e66e6b1c120f" },
+        {"thegaltmines_NA", "02db1a16c7043f45d6033ccfbd0a51c2d789b32db428902f98b9e155cf0d7910ed" },
+        {"computergenie_NA", "03a78ae070a5e9e935112cf7ea8293f18950f1011694ea0260799e8762c8a6f0a4" },
+        {"nutellalicka_SH", "02f7d90d0510c598ce45915e6372a9cd0ba72664cb65ce231f25d526fc3c5479fc" },
+        {"chainstrike_SH", "03b806be3bf7a1f2f6290ec5c1ea7d3ea57774dcfcf2129a82b2569e585100e1cb" },
+        {"dwy_SH", "036536d2d52d85f630b68b050f29ea1d7f90f3b42c10f8c5cdf3dbe1359af80aff" },
+        {"alien_EU", "03bb749e337b9074465fa28e757b5aa92cb1f0fea1a39589bca91a602834d443cd" }, // 60
+        {"gt_AR", "0348430538a4944d3162bb4749d8c5ed51299c2434f3ee69c11a1f7815b3f46135" },
+        {"patchkez_SH", "03f45e9beb5c4cd46525db8195eb05c1db84ae7ef3603566b3d775770eba3b96ee" },
+        {"decker_AR", "03ffdf1a116300a78729608d9930742cd349f11a9d64fcc336b8f18592dd9c91bc" }, // 63
+    }
+};
+
 #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)))
@@ -82,12 +297,14 @@ extern int32_t VERUS_MIN_STAKEAGE;
 extern std::string DONATION_PUBKEY;
 extern uint8_t ASSETCHAINS_PRIVATE;
 extern int32_t USE_EXTERNAL_PUBKEY;
-extern char NOTARYADDRS[64][64];
+extern char NOTARYADDRS[64][64]; // should be depreciated later. Only affects labs.
+extern char NOTARY_ADDRESSES[NUM_KMD_SEASONS][64][64];
 extern int32_t KOMODO_TESTNODE, KOMODO_SNAPSHOT_INTERVAL;
 extern int32_t ASSETCHAINS_EARLYTXIDCONTRACT;
 int tx_height( const uint256 &hash );
 extern std::vector<std::string> vWhiteListAddress;
 void komodo_netevent(std::vector<uint8_t> payload);
+int32_t getacseason(uint32_t timestamp);

 #define IGUANA_MAXSCRIPTSIZE 10001
 #define KOMODO_KVDURATION 1440
--- a/src/komodo_gateway.h
+++ b/src/komodo_gateway.h
@@ -627,7 +627,7 @@ int32_t komodo_gateway_deposits(CMutableTransaction *txNew,char *base,int32_t to

 const char *banned_txids[] =
 {
-    "78cb4e21245c26b015b888b14c4f5096e18137d2741a6de9734d62b07014dfca", //233559
+    "78cb4e21245c26b015b888b14c4f5096e18137d2741a6de9734d62b07014dfca", // vout1 only 233559
    "00697be658e05561febdee1aafe368b821ca33fbb89b7027365e3d77b5dfede5", //234172
    "e909465788b32047c472d73e882d79a92b0d550f90be008f76e1edaee6d742ea", //234187
    "f56c6873748a327d0b92b8108f8ec8505a2843a541b1926022883678fb24f9dc", //234188
@@ -645,8 +645,24 @@ const char *banned_txids[] =
    // all vouts banned
    "c4ea1462c207547cd6fb6a4155ca6d042b22170d29801a465db5c09fec55b19d", //246748
    "305dc96d8bc23a69d3db955e03a6a87c1832673470c32fe25473a46cc473c7d1", //247204
+    "43416a0c4da6b1a5c1d375bdbe8f7dc8d44d8f60df593d3376aa8221ec66357e", // vout0 only
+    "1eb295ed54c47f35cbccd7e7e40d03041f1853581da6d41102a9d8813782b6cb",
+    "db121e4012222adfc841824984a2a90b7e5b018dd71307822537d58160195e43",
+    "28f95b8148ac4ae6e09c7380e34422fab41d568a411e53dc94823e36a3d6f386",
+    "01d8c839463bda2f2f6400ede4611357913684927a767422a8560ead1b22557c",
+    "6e4980a9e1bd669f4df04732dc6f11b7773b6de88d1abcf89a6b9007d72ef9ac",
+    "6cc1d0495170bc0e11fd3925297623562e529ea1336b66ea61f8a1159041aed2",
 };

+int32_t komodo_checkvout(int32_t vout,int32_t k,int32_t indallvouts)
+{
+    if ( k < indallvouts )
+        return(vout == 1);
+    else if ( k == indallvouts || k == indallvouts+1 )
+        return(1);
+    else return(vout == 0);
+}
+
 int32_t komodo_bannedset(int32_t *indallvoutsp,uint256 *array,int32_t max)
 {
    int32_t i;
@@ -657,7 +673,7 @@ int32_t komodo_bannedset(int32_t *indallvoutsp,uint256 *array,int32_t max)
    }
    for (i=0; i<sizeof(banned_txids)/sizeof(*banned_txids); i++)
        array[i] = uint256S(banned_txids[i]);
-    *indallvoutsp = i-2;
+    *indallvoutsp = i-6;
    return(i);
 }

@@ -691,7 +707,7 @@ int32_t komodo_check_deposit(int32_t height,const CBlock& block,uint32_t prevtim
            {
                for (k=0; k<numbanned; k++)
                {
-                    if ( block.vtx[i].vin[j].prevout.hash == array[k] && (block.vtx[i].vin[j].prevout.n == 1 || k >= indallvouts)  )
+                    if ( block.vtx[i].vin[j].prevout.hash == array[k] && komodo_checkvout(block.vtx[i].vin[j].prevout.n,k,indallvouts) != 0 ) //(block.vtx[i].vin[j].prevout.n == 1 || k >= indallvouts)  )
                    {
                        printf("banned tx.%d being used at ht.%d txi.%d vini.%d\n",k,height,i,j);
                        return(-1);
@@ -2597,7 +2613,7 @@ static int cmp_llu(const void *a, const void*b)
    else return(1);
 }

-static int64_t sort64(int64_t *l, int32_t llen)
+static void sort64(int64_t *l, int32_t llen)
 {
    qsort(l,llen,sizeof(uint64_t),cmp_llu);
 }
@@ -2611,7 +2627,7 @@ static int revcmp_llu(const void *a, const void*b)
    else return(1);
 }

-static int64_t revsort64(int64_t *l, int32_t llen)
+static void revsort64(int64_t *l, int32_t llen)
 {
    qsort(l,llen,sizeof(uint64_t),revcmp_llu);
 }
--- a/src/komodo_globals.h
+++ b/src/komodo_globals.h
@@ -29,6 +29,7 @@ uint64_t komodo_paxtotal();
 int32_t komodo_longestchain();
 uint64_t komodo_maxallowed(int32_t baseid);
 int32_t komodo_bannedset(int32_t *indallvoutsp,uint256 *array,int32_t max);
+int32_t komodo_checkvout(int32_t vout,int32_t k,int32_t indallvouts);

 pthread_mutex_t komodo_mutex,staked_mutex;

@@ -53,6 +54,7 @@ bool VERUS_MINTBLOCKS;
 std::vector<uint8_t> Mineropret;
 std::vector<std::string> vWhiteListAddress;
 char NOTARYADDRS[64][64];
+char NOTARY_ADDRESSES[NUM_KMD_SEASONS][64][64];

 char ASSETCHAINS_SYMBOL[KOMODO_ASSETCHAIN_MAXLEN],ASSETCHAINS_USERPASS[4096];
 uint16_t ASSETCHAINS_P2PPORT,ASSETCHAINS_RPCPORT,ASSETCHAINS_BEAMPORT,ASSETCHAINS_CODAPORT;
--- a/src/komodo_notary.h
+++ b/src/komodo_notary.h
@@ -20,6 +20,7 @@
 #include "notaries_staked.h"

 #define KOMODO_MAINNET_START 178999
+#define KOMODO_NOTARIES_HEIGHT1 814000

 const char *Notaries_genesis[][2] =
 {
@@ -60,194 +61,78 @@ const char *Notaries_genesis[][2] =
    { "titomane_SH", "035f49d7a308dd9a209e894321f010d21b7793461b0c89d6d9231a3fe5f68d9960" },
 };

-const char *Notaries_elected0[][2] =
-{
-    { "0_jl777_testA", "03b7621b44118017a16043f19b30cc8a4cfe068ac4e42417bae16ba460c80f3828" },
-    { "0_jl777_testB", "02ebfc784a4ba768aad88d44d1045d240d47b26e248cafaf1c5169a42d7a61d344" },
-    { "0_kolo_testA", "0287aa4b73988ba26cf6565d815786caf0d2c4af704d7883d163ee89cd9977edec" },
-    { "artik_AR", "029acf1dcd9f5ff9c455f8bb717d4ae0c703e089d16cf8424619c491dff5994c90" },
-    { "artik_EU", "03f54b2c24f82632e3cdebe4568ba0acf487a80f8a89779173cdb78f74514847ce" },
-    { "artik_NA", "0224e31f93eff0cc30eaf0b2389fbc591085c0e122c4d11862c1729d090106c842" },
-    { "artik_SH", "02bdd8840a34486f38305f311c0e2ae73e84046f6e9c3dd3571e32e58339d20937" },
-    { "badass_EU", "0209d48554768dd8dada988b98aca23405057ac4b5b46838a9378b95c3e79b9b9e" },
-    { "badass_NA", "02afa1a9f948e1634a29dc718d218e9d150c531cfa852843a1643a02184a63c1a7" },
-    { "badass_SH", "026b49dd3923b78a592c1b475f208e23698d3f085c4c3b4906a59faf659fd9530b" },
-    { "crackers_EU", "03bc819982d3c6feb801ec3b720425b017d9b6ee9a40746b84422cbbf929dc73c3" }, // 10
-    { "crackers_NA", "03205049103113d48c7c7af811b4c8f194dafc43a50d5313e61a22900fc1805b45" },
-    { "crackers_SH", "02be28310e6312d1dd44651fd96f6a44ccc269a321f907502aae81d246fabdb03e" },
-    { "durerus_EU", "02bcbd287670bdca2c31e5d50130adb5dea1b53198f18abeec7211825f47485d57" },
-    { "etszombi_AR", "031c79168d15edabf17d9ec99531ea9baa20039d0cdc14d9525863b83341b210e9" },
-    { "etszombi_EU", "0281b1ad28d238a2b217e0af123ce020b79e91b9b10ad65a7917216eda6fe64bf7" }, // 15
-    { "etszombi_SH", "025d7a193c0757f7437fad3431f027e7b5ed6c925b77daba52a8755d24bf682dde" },
-    { "farl4web_EU", "0300ecf9121cccf14cf9423e2adb5d98ce0c4e251721fa345dec2e03abeffbab3f" },
-    { "farl4web_SH", "0396bb5ed3c57aa1221d7775ae0ff751e4c7dc9be220d0917fa8bbdf670586c030" },
-    { "fullmoon_AR", "0254b1d64840ce9ff6bec9dd10e33beb92af5f7cee628f999cb6bc0fea833347cc" },
-    { "fullmoon_NA", "031fb362323b06e165231c887836a8faadb96eda88a79ca434e28b3520b47d235b" }, // 20
-    { "fullmoon_SH", "030e12b42ec33a80e12e570b6c8274ce664565b5c3da106859e96a7208b93afd0d" },
-    { "grewal_NA", "03adc0834c203d172bce814df7c7a5e13dc603105e6b0adabc942d0421aefd2132" },
-    { "grewal_SH", "03212a73f5d38a675ee3cdc6e82542a96c38c3d1c79d25a1ed2e42fcf6a8be4e68" },
-    { "indenodes_AR", "02ec0fa5a40f47fd4a38ea5c89e375ad0b6ddf4807c99733c9c3dc15fb978ee147" },
-    { "indenodes_EU", "0221387ff95c44cb52b86552e3ec118a3c311ca65b75bf807c6c07eaeb1be8303c" },
-    { "indenodes_NA", "02698c6f1c9e43b66e82dbb163e8df0e5a2f62f3a7a882ca387d82f86e0b3fa988" },
-    { "indenodes_SH", "0334e6e1ec8285c4b85bd6dae67e17d67d1f20e7328efad17ce6fd24ae97cdd65e" },
-    { "jeezy_EU", "023cb3e593fb85c5659688528e9a4f1c4c7f19206edc7e517d20f794ba686fd6d6" },
-    { "jsgalt_NA", "027b3fb6fede798cd17c30dbfb7baf9332b3f8b1c7c513f443070874c410232446" },
-    { "karasugoi_NA", "02a348b03b9c1a8eac1b56f85c402b041c9bce918833f2ea16d13452309052a982" }, // 30
-    { "kashifali_EU", "033777c52a0190f261c6f66bd0e2bb299d30f012dcb8bfff384103211edb8bb207" },
-    { "kolo_AR", "03016d19344c45341e023b72f9fb6e6152fdcfe105f3b4f50b82a4790ff54e9dc6" },
-    { "kolo_SH", "02aa24064500756d9b0959b44d5325f2391d8e95c6127e109184937152c384e185" },
-    { "metaphilibert_AR", "02adad675fae12b25fdd0f57250b0caf7f795c43f346153a31fe3e72e7db1d6ac6" },
-    { "movecrypto_AR", "022783d94518e4dc77cbdf1a97915b29f427d7bc15ea867900a76665d3112be6f3" },
-    { "movecrypto_EU", "021ab53bc6cf2c46b8a5456759f9d608966eff87384c2b52c0ac4cc8dd51e9cc42" },
-    { "movecrypto_NA", "02efb12f4d78f44b0542d1c60146738e4d5506d27ec98a469142c5c84b29de0a80" },
-    { "movecrypto_SH", "031f9739a3ebd6037a967ce1582cde66e79ea9a0551c54731c59c6b80f635bc859" },
-    { "muros_AR", "022d77402fd7179335da39479c829be73428b0ef33fb360a4de6890f37c2aa005e" },
-    { "noashh_AR", "029d93ef78197dc93892d2a30e5a54865f41e0ca3ab7eb8e3dcbc59c8756b6e355" }, // 40
-    { "noashh_EU", "02061c6278b91fd4ac5cab4401100ffa3b2d5a277e8f71db23401cc071b3665546" },
-    { "noashh_NA", "033c073366152b6b01535e15dd966a3a8039169584d06e27d92a69889b720d44e1" },
-    { "nxtswe_EU", "032fb104e5eaa704a38a52c126af8f67e870d70f82977e5b2f093d5c1c21ae5899" },
-    { "polycryptoblog_NA", "02708dcda7c45fb54b78469673c2587bfdd126e381654819c4c23df0e00b679622" },
-    { "pondsea_AR", "032e1c213787312099158f2d74a89e8240a991d162d4ce8017d8504d1d7004f735" },
-    { "pondsea_EU", "0225aa6f6f19e543180b31153d9e6d55d41bc7ec2ba191fd29f19a2f973544e29d" },
-    { "pondsea_NA", "031bcfdbb62268e2ff8dfffeb9ddff7fe95fca46778c77eebff9c3829dfa1bb411" },
-    { "pondsea_SH", "02209073bc0943451498de57f802650311b1f12aa6deffcd893da198a544c04f36" },
-    { "popcornbag_AR", "02761f106fb34fbfc5ddcc0c0aa831ed98e462a908550b280a1f7bd32c060c6fa3" },
-    { "popcornbag_NA", "03c6085c7fdfff70988fda9b197371f1caf8397f1729a844790e421ee07b3a93e8" }, // 50
-    { "ptytrader_NA", "0328c61467148b207400b23875234f8a825cce65b9c4c9b664f47410b8b8e3c222" },
-    { "ptytrader_SH", "0250c93c492d8d5a6b565b90c22bee07c2d8701d6118c6267e99a4efd3c7748fa4" },
-    { "rnr_AR", "029bdb08f931c0e98c2c4ba4ef45c8e33a34168cb2e6bf953cef335c359d77bfcd" },
-    { "rnr_EU", "03f5c08dadffa0ffcafb8dd7ffc38c22887bd02702a6c9ac3440deddcf2837692b" },
-    { "rnr_NA", "02e17c5f8c3c80f584ed343b8dcfa6d710dfef0889ec1e7728ce45ce559347c58c" },
-    { "rnr_SH", "037536fb9bdfed10251f71543fb42679e7c52308bcd12146b2568b9a818d8b8377" },
-    { "titomane_AR", "03cda6ca5c2d02db201488a54a548dbfc10533bdc275d5ea11928e8d6ab33c2185" },
-    { "titomane_EU", "02e41feded94f0cc59f55f82f3c2c005d41da024e9a805b41105207ef89aa4bfbd" },
-    { "titomane_SH", "035f49d7a308dd9a209e894321f010d21b7793461b0c89d6d9231a3fe5f68d9960" },
-    { "vanbreuk_EU", "024f3cad7601d2399c131fd070e797d9cd8533868685ddbe515daa53c2e26004c3" }, // 60
-    { "xrobesx_NA", "03f0cc6d142d14a40937f12dbd99dbd9021328f45759e26f1877f2a838876709e1" },
-    { "xxspot1_XX", "02ef445a392fcaf3ad4176a5da7f43580e8056594e003eba6559a713711a27f955" },
-    { "xxspot2_XX", "03d85b221ea72ebcd25373e7961f4983d12add66a92f899deaf07bab1d8b6f5573" }
-};
-
-#define KOMODO_NOTARIES_TIMESTAMP1 1525132800 // May 1st 2018 1530921600 // 7/7/2017
-#define KOMODO_NOTARIES_HEIGHT1 ((814000 / KOMODO_ELECTION_GAP) * KOMODO_ELECTION_GAP)
-
-const char *Notaries_elected1[][2] =
-{
-    {"0dev1_jl777", "03b7621b44118017a16043f19b30cc8a4cfe068ac4e42417bae16ba460c80f3828" },
-    {"0dev2_kolo", "030f34af4b908fb8eb2099accb56b8d157d49f6cfb691baa80fdd34f385efed961" },
-    {"0dev3_kolo", "025af9d2b2a05338478159e9ac84543968fd18c45fd9307866b56f33898653b014" },
-    {"0dev4_decker", "028eea44a09674dda00d88ffd199a09c9b75ba9782382cc8f1e97c0fd565fe5707" },
-    {"a-team_SH", "03b59ad322b17cb94080dc8e6dc10a0a865de6d47c16fb5b1a0b5f77f9507f3cce" },
-    {"artik_AR", "029acf1dcd9f5ff9c455f8bb717d4ae0c703e089d16cf8424619c491dff5994c90" },
-    {"artik_EU", "03f54b2c24f82632e3cdebe4568ba0acf487a80f8a89779173cdb78f74514847ce" },
-    {"artik_NA", "0224e31f93eff0cc30eaf0b2389fbc591085c0e122c4d11862c1729d090106c842" },
-    {"artik_SH", "02bdd8840a34486f38305f311c0e2ae73e84046f6e9c3dd3571e32e58339d20937" },
-    {"badass_EU", "0209d48554768dd8dada988b98aca23405057ac4b5b46838a9378b95c3e79b9b9e" },
-    {"badass_NA", "02afa1a9f948e1634a29dc718d218e9d150c531cfa852843a1643a02184a63c1a7" }, // 10
-    {"batman_AR", "033ecb640ec5852f42be24c3bf33ca123fb32ced134bed6aa2ba249cf31b0f2563" },
-    {"batman_SH", "02ca5898931181d0b8aafc75ef56fce9c43656c0b6c9f64306e7c8542f6207018c" },
-    {"ca333_EU", "03fc87b8c804f12a6bd18efd43b0ba2828e4e38834f6b44c0bfee19f966a12ba99" },
-    {"chainmakers_EU", "02f3b08938a7f8d2609d567aebc4989eeded6e2e880c058fdf092c5da82c3bc5ee" },
-    {"chainmakers_NA", "0276c6d1c65abc64c8559710b8aff4b9e33787072d3dda4ec9a47b30da0725f57a" },
-    {"chainstrike_SH", "0370bcf10575d8fb0291afad7bf3a76929734f888228bc49e35c5c49b336002153" },
-    {"cipi_AR", "02c4f89a5b382750836cb787880d30e23502265054e1c327a5bfce67116d757ce8" },
-    {"cipi_NA", "02858904a2a1a0b44df4c937b65ee1f5b66186ab87a751858cf270dee1d5031f18" },
-    {"crackers_EU", "03bc819982d3c6feb801ec3b720425b017d9b6ee9a40746b84422cbbf929dc73c3" },
-    {"crackers_NA", "03205049103113d48c7c7af811b4c8f194dafc43a50d5313e61a22900fc1805b45" }, // 20
-    {"dwy_EU", "0259c646288580221fdf0e92dbeecaee214504fdc8bbdf4a3019d6ec18b7540424" },
-    {"emmanux_SH", "033f316114d950497fc1d9348f03770cd420f14f662ab2db6172df44c389a2667a" },
-    {"etszombi_EU", "0281b1ad28d238a2b217e0af123ce020b79e91b9b10ad65a7917216eda6fe64bf7" },
-    {"fullmoon_AR", "03380314c4f42fa854df8c471618751879f9e8f0ff5dbabda2bd77d0f96cb35676" },
-    {"fullmoon_NA", "030216211d8e2a48bae9e5d7eb3a42ca2b7aae8770979a791f883869aea2fa6eef" },
-    {"fullmoon_SH", "03f34282fa57ecc7aba8afaf66c30099b5601e98dcbfd0d8a58c86c20d8b692c64" },
-    {"goldenman_EU", "02d6f13a8f745921cdb811e32237bb98950af1a5952be7b3d429abd9152f8e388d" },
-    {"indenodes_AR", "02ec0fa5a40f47fd4a38ea5c89e375ad0b6ddf4807c99733c9c3dc15fb978ee147" },
-    {"indenodes_EU", "0221387ff95c44cb52b86552e3ec118a3c311ca65b75bf807c6c07eaeb1be8303c" },
-    {"indenodes_NA", "02698c6f1c9e43b66e82dbb163e8df0e5a2f62f3a7a882ca387d82f86e0b3fa988" }, // 30
-    {"indenodes_SH", "0334e6e1ec8285c4b85bd6dae67e17d67d1f20e7328efad17ce6fd24ae97cdd65e" },
-    {"jackson_AR", "038ff7cfe34cb13b524e0941d5cf710beca2ffb7e05ddf15ced7d4f14fbb0a6f69" },
-    {"jeezy_EU", "023cb3e593fb85c5659688528e9a4f1c4c7f19206edc7e517d20f794ba686fd6d6" },
-    {"karasugoi_NA", "02a348b03b9c1a8eac1b56f85c402b041c9bce918833f2ea16d13452309052a982" },
-    {"komodoninja_EU", "038e567b99806b200b267b27bbca2abf6a3e8576406df5f872e3b38d30843cd5ba" },
-    {"komodoninja_SH", "033178586896915e8456ebf407b1915351a617f46984001790f0cce3d6f3ada5c2" },
-    {"komodopioneers_SH", "033ace50aedf8df70035b962a805431363a61cc4e69d99d90726a2d48fb195f68c" },
-    {"libscott_SH", "03301a8248d41bc5dc926088a8cf31b65e2daf49eed7eb26af4fb03aae19682b95" },
-    {"lukechilds_AR", "031aa66313ee024bbee8c17915cf7d105656d0ace5b4a43a3ab5eae1e14ec02696" },
-    {"madmax_AR", "03891555b4a4393d655bf76f0ad0fb74e5159a615b6925907678edc2aac5e06a75" }, // 40
-    {"meshbits_AR", "02957fd48ae6cb361b8a28cdb1b8ccf5067ff68eb1f90cba7df5f7934ed8eb4b2c" },
-    {"meshbits_SH", "025c6e94877515dfd7b05682b9cc2fe4a49e076efe291e54fcec3add78183c1edb" },
-    {"metaphilibert_AR", "02adad675fae12b25fdd0f57250b0caf7f795c43f346153a31fe3e72e7db1d6ac6" },
-    {"metaphilibert_SH", "0284af1a5ef01503e6316a2ca4abf8423a794e9fc17ac6846f042b6f4adedc3309" },
-    {"patchkez_SH", "0296270f394140640f8fa15684fc11255371abb6b9f253416ea2734e34607799c4" },
-    {"pbca26_NA", "0276aca53a058556c485bbb60bdc54b600efe402a8b97f0341a7c04803ce204cb5" },
-    {"peer2cloud_AR", "034e5563cb885999ae1530bd66fab728e580016629e8377579493b386bf6cebb15" },
-    {"peer2cloud_SH", "03396ac453b3f23e20f30d4793c5b8ab6ded6993242df4f09fd91eb9a4f8aede84" },
-    {"polycryptoblog_NA", "02708dcda7c45fb54b78469673c2587bfdd126e381654819c4c23df0e00b679622" },
-    {"hyper_AR", "020f2f984d522051bd5247b61b080b4374a7ab389d959408313e8062acad3266b4" }, // 50
-    {"hyper_EU", "03d00cf9ceace209c59fb013e112a786ad583d7de5ca45b1e0df3b4023bb14bf51" },
-    {"hyper_SH", "0383d0b37f59f4ee5e3e98a47e461c861d49d0d90c80e9e16f7e63686a2dc071f3" },
-    {"hyper_NA", "03d91c43230336c0d4b769c9c940145a8c53168bf62e34d1bccd7f6cfc7e5592de" },
-    {"popcornbag_AR", "02761f106fb34fbfc5ddcc0c0aa831ed98e462a908550b280a1f7bd32c060c6fa3" },
-    {"popcornbag_NA", "03c6085c7fdfff70988fda9b197371f1caf8397f1729a844790e421ee07b3a93e8" },
-    {"alien_AR", "0348d9b1fc6acf81290405580f525ee49b4749ed4637b51a28b18caa26543b20f0" },
-    {"alien_EU", "020aab8308d4df375a846a9e3b1c7e99597b90497efa021d50bcf1bbba23246527" },
-    {"thegaltmines_NA", "031bea28bec98b6380958a493a703ddc3353d7b05eb452109a773eefd15a32e421" },
-    {"titomane_AR", "029d19215440d8cb9cc6c6b7a4744ae7fb9fb18d986e371b06aeb34b64845f9325" },
-    {"titomane_EU", "0360b4805d885ff596f94312eed3e4e17cb56aa8077c6dd78d905f8de89da9499f" }, // 60
-    {"titomane_SH", "03573713c5b20c1e682a2e8c0f8437625b3530f278e705af9b6614de29277a435b" },
-    {"webworker01_NA", "03bb7d005e052779b1586f071834c5facbb83470094cff5112f0072b64989f97d7" },
-    {"xrobesx_NA", "03f0cc6d142d14a40937f12dbd99dbd9021328f45759e26f1877f2a838876709e1" },
-};
 #define CRYPTO777_PUBSECPSTR "020e46e79a2a8d12b9b5d12c7a91adb4e454edfae43c0a0cb805427d2ac7613fd9"

+int32_t getkmdseason(int32_t height)
+{
+    if ( height <= KMD_SEASON_HEIGHTS[0] )
+        return(1);
+    for (int32_t i = 1; i < NUM_KMD_SEASONS; i++)
+    {
+        if ( height <= KMD_SEASON_HEIGHTS[i] && height >= KMD_SEASON_HEIGHTS[i-1] )
+            return(i+1);
+    }
+    return(0);
+};
+
+int32_t getacseason(uint32_t timestamp)
+{
+    if ( timestamp <= KMD_SEASON_TIMESTAMPS[0] )
+        return(1);
+    for (int32_t i = 1; i < NUM_KMD_SEASONS; i++)
+    {
+        if ( timestamp <= KMD_SEASON_TIMESTAMPS[i] && timestamp >= KMD_SEASON_TIMESTAMPS[i-1] )
+            return(i+1);
+    }
+    return(0);
+};
+
 int32_t komodo_notaries(uint8_t pubkeys[64][33],int32_t height,uint32_t timestamp)
 {
-    static uint8_t elected_pubkeys0[64][33],elected_pubkeys1[64][33],did0,did1; static int32_t n0,n1;
    int32_t i,htind,n; uint64_t mask = 0; struct knotary_entry *kp,*tmp;
-
+    static uint8_t kmd_pubkeys[NUM_KMD_SEASONS][64][33],didinit[NUM_KMD_SEASONS];
+    
    if ( timestamp == 0 && ASSETCHAINS_SYMBOL[0] != 0 )
        timestamp = komodo_heightstamp(height);
    else if ( ASSETCHAINS_SYMBOL[0] == 0 )
        timestamp = 0;

    // If this chain is not a staked chain, use the normal Komodo logic to determine notaries. This allows KMD to still sync and use its proper pubkeys for dPoW.
-    if (is_STAKED(ASSETCHAINS_SYMBOL) == 0)
+    if ( is_STAKED(ASSETCHAINS_SYMBOL) == 0 )
    {
-        if ( height >= KOMODO_NOTARIES_HARDCODED || ASSETCHAINS_SYMBOL[0] != 0 )
-            timestamp = 0;
-        if ( (timestamp != 0 && timestamp <= KOMODO_NOTARIES_TIMESTAMP1) || (ASSETCHAINS_SYMBOL[0] == 0 && height <= KOMODO_NOTARIES_HEIGHT1) )
+        int32_t kmd_season = 0;
+        if ( ASSETCHAINS_SYMBOL[0] == 0 )
        {
-            if ( did0 == 0 )
-            {
-                n0 = (int32_t)(sizeof(Notaries_elected0)/sizeof(*Notaries_elected0));
-                for (i=0; i<n0; i++) {
-                    decode_hex(elected_pubkeys0[i],33,(char *)Notaries_elected0[i][1]);
-                }
-                did0 = 1;
-            }
-            memcpy(pubkeys,elected_pubkeys0,n0 * 33);
-            //if ( ASSETCHAINS_SYMBOL[0] != 0 )
-            //fprintf(stderr,"%s height.%d t.%u elected.%d notaries\n",ASSETCHAINS_SYMBOL,height,timestamp,n0);
-            return(n0);
+            // This is KMD, use block heights to determine the KMD notary season.. 
+            if ( height >= KOMODO_NOTARIES_HARDCODED )
+                kmd_season = getkmdseason(height);
        }
-        else //if ( (timestamp != 0 && timestamp <= KOMODO_NOTARIES_TIMESTAMP2) || height <= KOMODO_NOTARIES_HEIGHT2 )
+        else 
        {
-          if ( did1 == 0 )
+            // This is a non LABS assetchain, use timestamp to detemine notary pubkeys. 
+            kmd_season = getacseason(timestamp);
+        }
+        if ( kmd_season != 0 )
+        {
+            if ( didinit[kmd_season-1] == 0 )
            {
-    	          n1 = (int32_t)(sizeof(Notaries_elected1)/sizeof(*Notaries_elected1));
-                for (i=0; i<n1; i++) {
-                  decode_hex(elected_pubkeys1[i],33,(char *)Notaries_elected1[i][1]);
+                for (i=0; i<NUM_KMD_NOTARIES; i++) 
+                    decode_hex(kmd_pubkeys[kmd_season-1][i],33,(char *)notaries_elected[kmd_season-1][i][1]);
+                if ( ASSETCHAINS_PRIVATE != 0 )
+                {
+                    // this is PIRATE, we need to populate the address array for the notary exemptions. 
+                    for (i = 0; i<NUM_KMD_NOTARIES; i++)
+                        pubkey2addr((char *)NOTARY_ADDRESSES[kmd_season-1][i],(uint8_t *)kmd_pubkeys[kmd_season-1][i]);
                }
-                if ( 0 && ASSETCHAINS_SYMBOL[0] != 0 )
-                    fprintf(stderr,"%s height.%d t.%u elected.%d notaries2\n",ASSETCHAINS_SYMBOL,height,timestamp,n1);
-                did1 = 1;
+                didinit[kmd_season-1] = 1;
            }
-            memcpy(pubkeys,elected_pubkeys1,n1 * 33);
-            return(n1);
+            memcpy(pubkeys,kmd_pubkeys[kmd_season-1],NUM_KMD_NOTARIES * 33);
+            return(NUM_KMD_NOTARIES);
        }
    }
-    else if (timestamp != 0)
-    { // here we can activate our pubkeys for STAKED chains everythig is in notaries_staked.cpp
+    else if ( timestamp != 0 )
+    { 
+        // here we can activate our pubkeys for LABS chains everythig is in notaries_staked.cpp
        int32_t staked_era; int8_t numSN;
        uint8_t staked_pubkeys[64][33];
        staked_era = STAKED_era(timestamp);
--- a/src/komodo_utils.h
+++ b/src/komodo_utils.h
@@ -1425,7 +1425,7 @@ void komodo_configfile(char *symbol,uint16_t rpcport)
 #ifndef FROM_CLI
            if ( (fp= fopen(fname,"wb")) != 0 )
            {
-                fprintf(fp,"rpcuser=user%u\nrpcpassword=pass%s\nrpcport=%u\nserver=1\ntxindex=1\nrpcworkqueue=256\nrpcallowip=127.0.0.1\n",crc,password,rpcport);
+                fprintf(fp,"rpcuser=user%u\nrpcpassword=pass%s\nrpcport=%u\nserver=1\ntxindex=1\nrpcworkqueue=256\nrpcallowip=127.0.0.1\nrpcbind=127.0.0.1\n",crc,password,rpcport);
                fclose(fp);
                printf("Created (%s)\n",fname);
            } else printf("Couldnt create (%s)\n",fname);
@@ -1691,14 +1691,9 @@ int8_t equihash_params_possible(uint64_t n, uint64_t k)

 void komodo_args(char *argv0)
 {
-    extern const char *Notaries_elected1[][2];
    std::string name,addn,hexstr,symbol; char *dirname,fname[512],arg0str[64],magicstr[9]; uint8_t magic[4],extrabuf[32756],disablebits[32],*extraptr=0; FILE *fp; uint64_t val; uint16_t port; int32_t i,nonz=0,baseid,len,n,extralen = 0; uint64_t ccenables[256];
    IS_KOMODO_NOTARY = GetBoolArg("-notary", false);
    IS_STAKED_NOTARY = GetArg("-stakednotary", -1);
-    if ( IS_STAKED_NOTARY != -1 && IS_KOMODO_NOTARY == true ) {
-        fprintf(stderr, "Cannot be STAKED and KMD notary at the same time!\n");
-        StartShutdown();
-    }
    memset(ccenables,0,sizeof(ccenables));
    memset(disablebits,0,sizeof(disablebits));
    if ( GetBoolArg("-gen", false) != 0 )
@@ -1717,17 +1712,24 @@ void komodo_args(char *argv0)
        USE_EXTERNAL_PUBKEY = 1;
        if ( IS_KOMODO_NOTARY == 0 )
        {
+            // We dont have any chain data yet, so use system clock to guess. 
+            // I think on season change should reccomend notaries to use -notary to avoid needing this. 
+            int32_t kmd_season = getacseason(time(NULL));
            for (i=0; i<64; i++)
-                if ( strcmp(NOTARY_PUBKEY.c_str(),Notaries_elected1[i][1]) == 0 )
+                if ( strcmp(NOTARY_PUBKEY.c_str(),notaries_elected[kmd_season][NUM_KMD_NOTARIES][1]) == 0 )
                {
                    IS_KOMODO_NOTARY = 1;
                    KOMODO_MININGTHREADS = 1;
                    mapArgs ["-genproclimit"] = itostr(KOMODO_MININGTHREADS);
                    IS_STAKED_NOTARY = -1;
-                    fprintf(stderr,"running as notary.%d %s\n",i,Notaries_elected1[i][0]);
+                    fprintf(stderr,"running as notary.%d %s\n",i,notaries_elected[kmd_season][NUM_KMD_NOTARIES][0]);
                    break;
                }
        }
+    }
+    if ( IS_STAKED_NOTARY != -1 && IS_KOMODO_NOTARY == true ) {
+        fprintf(stderr, "Cannot be STAKED and KMD notary at the same time!\n");
+        StartShutdown();
    }
 	name = GetArg("-ac_name","");
    if ( argv0 != 0 )
@@ -1760,7 +1762,6 @@ void komodo_args(char *argv0)
    }
    KOMODO_EARLYTXID = Parseuint256(GetArg("-earlytxid","0").c_str());
    ASSETCHAINS_EARLYTXIDCONTRACT = GetArg("-ac_earlytxidcontract",0);
-    fprintf(stderr, "ASSETCHAINS_EARLYTXIDCONTRACT.%i\n", ASSETCHAINS_EARLYTXIDCONTRACT);
    if ( name.c_str()[0] != 0 )
    {
        std::string selectedAlgo = GetArg("-ac_algo", std::string(ASSETCHAINS_ALGORITHMS[0]));
@@ -2295,6 +2296,60 @@ void komodo_args(char *argv0)
            fprintf(stderr,"-ac_private for a non-PIRATE chain is not supported. The only reason to have an -ac_private chain is for total privacy and that is best achieved with the largest anon set. PIRATE has that and it is recommended to just use PIRATE\n");
            StartShutdown();
        }
+        // Set cc enables for all existing ac_cc chains here. 
+        if ( strcmp("AXO",ASSETCHAINS_SYMBOL) == 0 )
+        {
+            // No CCs used on this chain yet please ask AXO777 what he needs. 
+            memset(ASSETCHAINS_CCDISABLES,1,sizeof(ASSETCHAINS_CCDISABLES));
+        }
+        if ( strcmp("CCL",ASSETCHAINS_SYMBOL) == 0 )
+        {
+            // No CCs used on this chain yet. 
+            memset(ASSETCHAINS_CCDISABLES,1,sizeof(ASSETCHAINS_CCDISABLES));
+        }
+        if ( strcmp("COQUI",ASSETCHAINS_SYMBOL) == 0 )
+        {
+            memset(ASSETCHAINS_CCDISABLES,1,sizeof(ASSETCHAINS_CCDISABLES));
+            ASSETCHAINS_CCDISABLES[230] = 0; // DICE
+            ASSETCHAINS_CCDISABLES[235] = 0; // CHANNELS 
+            ASSETCHAINS_CCDISABLES[236] = 0; // ORACLES
+        }
+        if ( strcmp("DION",ASSETCHAINS_SYMBOL) == 0 )
+        {
+            // No CCs used on this chain yet. 
+            memset(ASSETCHAINS_CCDISABLES,1,sizeof(ASSETCHAINS_CCDISABLES));
+        }
+        if ( strcmp("EQL",ASSETCHAINS_SYMBOL) == 0 )
+        {
+            // No CCs used on this chain yet. 
+            memset(ASSETCHAINS_CCDISABLES,1,sizeof(ASSETCHAINS_CCDISABLES));
+        }
+        if ( strcmp("ILN",ASSETCHAINS_SYMBOL) == 0 )
+        {
+            // No CCs used on this chain yet. 
+            memset(ASSETCHAINS_CCDISABLES,1,sizeof(ASSETCHAINS_CCDISABLES));
+        }
+        if ( strcmp("MORTY",ASSETCHAINS_SYMBOL) == 0 )
+        {
+            memset(ASSETCHAINS_CCDISABLES,1,sizeof(ASSETCHAINS_CCDISABLES));
+            ASSETCHAINS_CCDISABLES[228] = 0; // FAUCET
+        }
+        if ( strcmp("RICK",ASSETCHAINS_SYMBOL) == 0 )
+        {
+            memset(ASSETCHAINS_CCDISABLES,1,sizeof(ASSETCHAINS_CCDISABLES));
+            ASSETCHAINS_CCDISABLES[228] = 1; // FAUCET
+        }
+        if ( strcmp("SEC",ASSETCHAINS_SYMBOL) == 0 )
+        {
+            memset(ASSETCHAINS_CCDISABLES,1,sizeof(ASSETCHAINS_CCDISABLES));
+            ASSETCHAINS_CCDISABLES[227] = 0; // ASSETS
+            ASSETCHAINS_CCDISABLES[242] = 0; // TOKENS
+        }
+        if ( strcmp("KMDICE",ASSETCHAINS_SYMBOL) == 0 )
+        {
+            memset(ASSETCHAINS_CCDISABLES,1,sizeof(ASSETCHAINS_CCDISABLES));
+            ASSETCHAINS_CCDISABLES[230] = 0; // DICE
+        }
    } else BITCOIND_RPCPORT = GetArg("-rpcport", BaseParams().RPCPort());
    KOMODO_DPOWCONFS = GetArg("-dpowconfs",dpowconfs);
    if ( ASSETCHAINS_SYMBOL[0] == 0 || strcmp(ASSETCHAINS_SYMBOL,"SUPERNET") == 0 || strcmp(ASSETCHAINS_SYMBOL,"DEX") == 0 || strcmp(ASSETCHAINS_SYMBOL,"COQUI") == 0 || strcmp(ASSETCHAINS_SYMBOL,"PIRATE") == 0 || strcmp(ASSETCHAINS_SYMBOL,"KMDICE") == 0 )
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1341,16 +1341,19 @@ bool CheckTransaction(uint32_t tiptime,const CTransaction& tx, CValidationState
    if ( *(int32_t *)&array[0] == 0 )
        numbanned = komodo_bannedset(&indallvouts,array,(int32_t)(sizeof(array)/sizeof(*array)));
    n = tx.vin.size();
-    for (j=0; j<n; j++)
+    if ( ASSETCHAINS_SYMBOL[0] == 0 )
    {
-        for (k=0; k<numbanned; k++)
+        for (j=0; j<n; j++)
        {
-            if ( tx.vin[j].prevout.hash == array[k] && (tx.vin[j].prevout.n == 1 || k >= indallvouts) )
+            for (k=0; k<numbanned; k++)
            {
-                static uint32_t counter;
-                if ( counter++ < 100 )
-                    printf("MEMPOOL: banned tx.%d being used at ht.%d vout.%d\n",k,(int32_t)chainActive.Tip()->GetHeight(),j);
-                return(false);
+                if ( tx.vin[j].prevout.hash == array[k] && komodo_checkvout(tx.vin[j].prevout.n,k,indallvouts) != 0 ) //(tx.vin[j].prevout.n == 1 || k >= indallvouts) )
+                {
+                    static uint32_t counter;
+                    if ( counter++ < 100 )
+                        printf("MEMPOOL: banned tx.%d being used at ht.%d vout.%d\n",k,(int32_t)chainActive.Tip()->GetHeight(),j);
+                    return(false);
+                }
            }
        }
    }
@@ -1375,24 +1378,22 @@ bool CheckTransaction(uint32_t tiptime,const CTransaction& tx, CValidationState

 int32_t komodo_isnotaryvout(char *coinaddr,uint32_t tiptime) // from ac_private chains only
 {
-    static int32_t didinit; static char notaryaddrs[sizeof(Notaries_elected1)/sizeof(*Notaries_elected1) + 1][64];
-    //use normal notary functions
-    int32_t i;
-    if ( didinit == 0 )
+    int32_t season = getacseason(tiptime);
+    if ( NOTARY_ADDRESSES[season-1][0][0] == 0 )
    {
-        uint8_t pubkey33[33];
-        for (i=0; i<=sizeof(Notaries_elected1)/sizeof(*Notaries_elected1); i++)
-        {
-            if ( i < sizeof(Notaries_elected1)/sizeof(*Notaries_elected1) )
-                decode_hex(pubkey33,33,(char *)Notaries_elected1[i][1]);
-            else decode_hex(pubkey33,33,(char *)CRYPTO777_PUBSECPSTR);
-            pubkey2addr((char *)notaryaddrs[i],(uint8_t *)pubkey33);
-        }
-        didinit = 1;
+        uint8_t pubkeys[64][33];
+        komodo_notaries(pubkeys,0,tiptime);
    }
-    for (i=0; i<=sizeof(Notaries_elected1)/sizeof(*Notaries_elected1); i++)
-    if ( strcmp(coinaddr,notaryaddrs[i]) == 0 )
+    if ( strcmp(coinaddr,CRYPTO777_KMDADDR) == 0 )
        return(1);
+    for (int32_t i = 0; i < NUM_KMD_NOTARIES; i++) 
+    {
+        if ( strcmp(coinaddr,NOTARY_ADDRESSES[season-1][i]) == 0 )
+        {
+            //fprintf(stderr, "coinaddr.%s notaryaddress[%i].%s\n",coinaddr,i,NOTARY_ADDRESSES[season-1][i]);
+            return(1);
+        }
+    }
    return(0);
 }

@@ -3104,7 +3105,7 @@ bool DisconnectBlock(CBlock& block, CValidationState& state, CBlockIndex* pindex
        *pfClean = false;

    bool fClean = true;
-    komodo_disconnect(pindex,block);
+    //komodo_disconnect(pindex,block); does nothing?
    CBlockUndo blockUndo;
    CDiskBlockPos pos = pindex->GetUndoPos();
    if (pos.IsNull())
@@ -3392,7 +3393,7 @@ bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pin
    {
        // do a full block scan to get notarisation position and to enforce a valid notarization is in position 1.
        // if notarisation in the block, must be position 1 and the coinbase must pay notaries.
-        int notarisationTx = komodo_connectblock(true,pindex,*(CBlock *)&block);  
+        int32_t notarisationTx = komodo_connectblock(true,pindex,*(CBlock *)&block);  
        // -1 means that the valid notarization isnt in position 1 or there are too many notarizations in this block.
        if ( notarisationTx == -1 )
            return state.DoS(100, error("ConnectBlock(): Notarization is not in TX position 1 or block contains more than 1 notarization! Invalid Block!"),
@@ -4050,7 +4051,7 @@ bool static DisconnectTip(CValidationState &state, bool fBare = false) {
            CValidationState stateDummy;

            // don't keep staking or invalid transactions
-            if (tx.IsCoinBase() || ((i == (block.vtx.size() - 1)) && (ASSETCHAINS_STAKED && komodo_isPoS((CBlock *)&block,pindexDelete->GetHeight()) != 0)) || !AcceptToMemoryPool(mempool, stateDummy, tx, false, NULL))
+            if (tx.IsCoinBase() || ((i == (block.vtx.size() - 1)) && (ASSETCHAINS_STAKED && komodo_isPoS((CBlock *)&block,pindexDelete->GetHeight(),true) != 0)) || !AcceptToMemoryPool(mempool, stateDummy, tx, false, NULL))
            {
                mempool.remove(tx, removed, true);
            }
@@ -4082,11 +4083,11 @@ bool static DisconnectTip(CValidationState &state, bool fBare = false) {
    {
        CTransaction &tx = block.vtx[i];
        //if ((i == (block.vtx.size() - 1)) && ((ASSETCHAINS_LWMAPOS && block.IsVerusPOSBlock()) || (ASSETCHAINS_STAKED != 0 && (komodo_isPoS((CBlock *)&block) != 0))))
-        if ((i == (block.vtx.size() - 1)) && (ASSETCHAINS_STAKED != 0 && (komodo_isPoS((CBlock *)&block,pindexDelete->GetHeight()) != 0)))
+        if ((i == (block.vtx.size() - 1)) && (ASSETCHAINS_STAKED != 0 && (komodo_isPoS((CBlock *)&block,pindexDelete->GetHeight(),true) != 0)))
        {
 #ifdef ENABLE_WALLET
-            LOCK2(cs_main, pwalletMain->cs_wallet);
-            pwalletMain->EraseFromWallet(tx.GetHash());
+            if ( !GetBoolArg("-disablewallet", false) )
+                pwalletMain->EraseFromWallet(tx.GetHash());
 #endif
        }
        else
@@ -4267,7 +4268,10 @@ bool static ConnectTip(CValidationState &state, CBlockIndex *pindexNew, CBlock *
    {
        uint64_t start = time(NULL);
        if ( !komodo_dailysnapshot(pindexNew->GetHeight()) )
-            fprintf(stderr, "daily snapshot failed, please reindex your chain\n"); // maybe force shutdown here?
+        {
+            fprintf(stderr, "daily snapshot failed, please reindex your chain\n");
+            StartShutdown();
+        }
        fprintf(stderr, "snapshot completed in: %lu seconds\n", time(NULL)-start);
    }
    return true;
@@ -5094,7 +5098,7 @@ bool CheckBlock(int32_t *futureblockp,int32_t height,CBlockIndex *pindex,const C
                CValidationState state;
                CTransaction Tx;
                const CTransaction &tx = (CTransaction)block.vtx[i];
-                if (tx.IsCoinBase() || !tx.vjoinsplit.empty() || !tx.vShieldedSpend.empty() || ((i == (block.vtx.size() - 1)) && (ASSETCHAINS_STAKED && komodo_isPoS((CBlock *)&block,height) != 0)))
+                if (tx.IsCoinBase() || !tx.vjoinsplit.empty() || !tx.vShieldedSpend.empty() || ((i == (block.vtx.size() - 1)) && (ASSETCHAINS_STAKED && komodo_isPoS((CBlock *)&block,height,true) != 0)))
                    continue;
                Tx = tx;
                if ( myAddtomempool(Tx, &state, true) == false ) // happens with out of order tx in block on resync
@@ -6501,15 +6505,15 @@ bool LoadExternalBlockFile(FILE* fileIn, CDiskBlockPos *dbp)
            }
            try {
                // read block
+                CBlock block;
                uint64_t nBlockPos = blkdat.GetPos();
                if (dbp)
                    dbp->nPos = nBlockPos;
                blkdat.SetLimit(nBlockPos + nSize);
                blkdat.SetPos(nBlockPos);
-                CBlock block;
                blkdat >> block;
-                nRewind = blkdat.GetPos(); 
-
+                
+                nRewind = blkdat.GetPos();
                // detect out of order blocks, and store them for later
                uint256 hash = block.GetHash();
                if (hash != chainparams.GetConsensus().hashGenesisBlock && mapBlockIndex.find(block.hashPrevBlock) == mapBlockIndex.end()) {
@@ -6540,6 +6544,7 @@ bool LoadExternalBlockFile(FILE* fileIn, CDiskBlockPos *dbp)
                    std::pair<std::multimap<uint256, CDiskBlockPos>::iterator, std::multimap<uint256, CDiskBlockPos>::iterator> range = mapBlocksUnknownParent.equal_range(head);
                    while (range.first != range.second) {
                        std::multimap<uint256, CDiskBlockPos>::iterator it = range.first;
+                        
                        if (ReadBlockFromDisk(mapBlockIndex.count(hash)!=0?mapBlockIndex[hash]->GetHeight():0,block, it->second,1))
                        {
                            LogPrintf("%s: Processing out of order child %s of %s\n", __func__, block.GetHash().ToString(),
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -810,12 +810,17 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
            //fprintf(stderr,"check validity\n");
            if ( !TestBlockValidity(state, *pblock, pindexPrev, false, false)) // invokes CC checks
            {
+                if ( ASSETCHAINS_SYMBOL[0] == 0 || (ASSETCHAINS_SYMBOL[0] != 0 && !isStake) )
+                {
+                    LEAVE_CRITICAL_SECTION(cs_main);
+                    LEAVE_CRITICAL_SECTION(mempool.cs);
+                }
                throw std::runtime_error("CreateNewBlock(): TestBlockValidity failed");
            }
            //fprintf(stderr,"valid\n");
        }
    }
-    if ( ASSETCHAINS_SYMBOL[0] == 0 ||  (ASSETCHAINS_SYMBOL[0] != 0 && !isStake) )
+    if ( ASSETCHAINS_SYMBOL[0] == 0 || (ASSETCHAINS_SYMBOL[0] != 0 && !isStake) )
    {
        LEAVE_CRITICAL_SECTION(cs_main);
        LEAVE_CRITICAL_SECTION(mempool.cs);
@@ -1051,7 +1056,7 @@ int32_t roundrobin_delay;
 arith_uint256 HASHTarget,HASHTarget_POW;

 // wait for peers to connect
-int32_t waitForPeers(const CChainParams &chainparams)
+void waitForPeers(const CChainParams &chainparams)
 {
    if (chainparams.MiningRequiresPeers())
    {
--- a/src/notaries_staked.cpp
+++ b/src/notaries_staked.cpp
@@ -18,7 +18,7 @@ int8_t is_STAKED(const char *chain_name)
    if (doneinit == 1 && ASSETCHAINS_SYMBOL[0] != 0)
        return(STAKED);
    else STAKED = 0;
-    if ( (strcmp(chain_name, "LABS") == 0) || (strcmp(chain_name, "LABSRCTEST") == 0) ) 
+    if ( (strcmp(chain_name, "LABS") == 0) ) 
        STAKED = 1; // These chains are allowed coin emissions.
    else if ( (strncmp(chain_name, "LABS", 4) == 0) ) 
        STAKED = 2; // These chains have no coin emission, block subsidy is always 0, and comission is 0. Notary pay is allowed.
@@ -113,7 +113,14 @@ void UpdateNotaryAddrs(uint8_t pubkeys[64][33],int8_t numNotaries) {
        // staked era is set.
        pthread_mutex_lock(&staked_mutex);
        for (int i = 0; i<numNotaries; i++)
+        {
            pubkey2addr((char *)NOTARYADDRS[i],(uint8_t *)pubkeys[i]);
+            if ( memcmp(NOTARY_PUBKEY33,pubkeys[i],33) == 0 )
+            {
+                NOTARY_ADDRESS.assign(NOTARYADDRS[i]);
+                IS_STAKED_NOTARY = i;
+            }
+        }
        pthread_mutex_unlock(&staked_mutex);
    }
 }
--- a/src/notaries_staked.h
+++ b/src/notaries_staked.h
@@ -5,118 +5,62 @@
 #include "crosschain.h"
 #include "cc/CCinclude.h"

-static const int32_t iguanaPort = 9997;
+static const int32_t iguanaPort = 9333;
 static const int8_t BTCminsigs = 13;
-static const int8_t overrideMinSigs = 6;
+static const int8_t overrideMinSigs = 7;
 static const char *iguanaSeeds[8][1] =
 {
-  {"80.240.17.222"},
+  {"94.23.1.95"},
  {"103.6.12.112"},
  {"18.224.176.46"},
  {"45.76.120.247"},
  {"185.62.57.32"},
-  {"103.6.12.112"},
-  {"103.6.12.112"},
-  {"103.6.12.112"},
+  {"149.28.253.160"},
+  {"68.183.226.124"},
+  {"149.28.246.230"},
 };

 static const int STAKED_ERA_GAP = 777;

 static const int NUM_STAKED_ERAS = 4;
 static const int STAKED_NOTARIES_TIMESTAMP[NUM_STAKED_ERAS] = {1604244444, 1604244444, 1604244444, 1604244444};
-static const int32_t num_notaries_STAKED[NUM_STAKED_ERAS] = { 20, 25, 19, 17 };
+static const int32_t num_notaries_STAKED[NUM_STAKED_ERAS] = { 22, 1, 1, 1 };

 // Era array of pubkeys.
 static const char *notaries_STAKED[NUM_STAKED_ERAS][64][2] =
 {
    {
-        {"blackjok3r", "021914947402d936a89fbdd1b12be49eb894a1568e5e17bb18c8a6cffbd3dc106e" }, // RTVti13NP4eeeZaCCmQxc2bnPdHxCJFP9x
-        {"alright", "0285657c689b903218c97f5f10fe1d10ace2ed6595112d9017f54fb42ea1c1dda8" }, //RXmXeQ8LfJK6Y1aTM97cRz9Gu5f6fmR3sg
-        {"webworker01", "031d1fb39ae4dca28965c3abdbd21faa0f685f6d7b87a60561afa7c448343fef6d" }, //RGsQiArk5sTmjXZV9UzGMW5njyvtSnsTN8
-        {"CrisF", "024d19acf0d5de212cdd50326cd143292545d366a71b2b9c6df9f2110de2dfa1f2" }, // RKtAD2kyRRMx4EiG1eeTNprF5h2nmGbzzu
-        {"smk762", "029f6c1f38c4d6825acb3b4b5147f7992e943b617cdaa0f4f5f36187e239d52d5a" }, // RPy6Xj2LWrxNoEW9YyREDgBZDZZ5qURXBU
-        {"jorian", "0288e682c1ac449f1b85c4acb2d0bcd216d5df34c15fd18b8a8dd5fa64b8ece8ef" }, // RR1yT5aB19VwFoUCGTW4q4pk4qmhHEEE4t
+        {"blackjok3r", "035fc678bf796ad52f69e1f5759be54ec671c559a22adf27eed067e0ddf1531574" }, // RTcYRJ6WopYkUqcmksyjxoV1CueYyqxFuk    right
+        {"Alright", "02b718c60a035f77b7103a507d36aed942b4f655b8d13bce6f28b8eac523944278" }, //RG77F4mQpP1K1q2CDSc2vZSJvKUZgF8R26
+        {"webworker01", "031d1fb39ae4dca28965c3abdbd21faa0f685f6d7b87a60561afa7c448343fef6d" }, //RGsQiArk5sTmjXZV9UzGMW5njyvtSnsTN8    right
+        {"CrisF", "03745656c8991c4597828aad2820760c43c00ff2e3b381fef3b5c040f32a7b3a34" }, // RNhYJAaPHJCVXGWNVEJeP3TfepEPdhjrRr         right
+        {"smk762", "02381616fbc02d3f0398c912fe7b7daf2f3f29e55dc35287f686b15686d8135a9f" }, // RSchwBApVquaG6mXH31bQ6P83kMN4Hound        right
+        {"jorian", "0343eec31037d7b909efd968a5b5e7af60321bf7e464da28f815f0fb23ee7aadd7" }, // RJorianBXNwfNDYPxtNYJJ6vX7Z3VdTR25        right
        {"TonyL", "021a559101e355c907d9c553671044d619769a6e71d624f68bfec7d0afa6bd6a96" }, // RHq3JsvLxU45Z8ufYS6RsDpSG4wi6ucDev
-        {"CHMEX", "03ed125d1beb118d12ff0a052bdb0cee32591386d718309b2924f2c36b4e7388e6" }, // RF4HiVeuYpaznRPs7fkRAKKYqT5tuxQQTL
-        {"metaphilibert", "0344182c376f054e3755d712361672138660bda8005abb64067eb5aa98bdb40d10" }, // RG28QSnYFADBg1dAVkH1uPGYS6F8ioEUM2
-        {"greentea", "02054c14ae81838a063d22a75eaa3c961415f6825a57c8b8e4148d19dad64f128e" }, // REF7R76WpL1v7nSXjjiNHtRa2xYtq5qk1p
-        {"CMaurice", "025830ce81bd1301fb67d5872344efa7a9ff99ae85fe1234f18c085db9072b740f" }, // RX7pXUaV24xFn6DVKV8t3PrRF3gKw6TBjf
+        {"CHMEX", "03ed125d1beb118d12ff0a052bdb0cee32591386d718309b2924f2c36b4e7388e6" }, // RF4HiVeuYpaznRPs7fkRAKKYqT5tuxQQTL         right 
+        {"metaphilibert", "0344182c376f054e3755d712361672138660bda8005abb64067eb5aa98bdb40d10" }, // RG28QSnYFADBg1dAVkH1uPGYS6F8ioEUM2 right
+        {"gt", "02312dcecb6e4a32927a075972d3c009f3c68635d8100562cc1813ea66751b9fde" }, // RCg4tzKWQ7i3wrZEU8bvCbCQ4xRJnHnyoo            right
+        {"CMaurice", "026c6d094523e810641b89f2d7f0ddd8f0b59d97c32e1fa97f0e3e0ac119c26ae4" }, // RSjayeSuYUE1E22rBjnqoexobaRjbAZ2Yb      right
        {"Bar_F1sh_Rel", "0395f2d9dd9ccb78caf74bff49b6d959afb95af746462e1b35f4a167d8e82b3666" }, // RBbLxJagCA9QHDazQvfnDZe874V1K4Gu8t
-        {"zatJUM", "030fff499b6dc0215344b28a0b6b4becdfb00cd34cd1b36b983ec14f47965fd4bc" }, // RSoEDLBasth7anxS8gbkg6KgeGiz8rhqv1
+        {"zatJUM", "030fff499b6dc0215344b28a0b6b4becdfb00cd34cd1b36b983ec14f47965fd4bc" }, // RSoEDLBasth7anxS8gbkg6KgeGiz8rhqv1        right
        {"dwy", "03669457b2934d98b5761121dd01b243aed336479625b293be9f8c43a6ae7aaeff" }, // RKhZMqRF361FSGFAzstP5AhozekPjoVh5q
-        {"gcharang", "03336ca9db27cb6e882830e20dc525884e27dc94d557a5e68b972a5cbf9e8c62a8" }, // RJYiWn3FRCSSLf9Pe5RJcbrKQYosaMburP
-        {"computergenie", "027313dabde94fb72f823231d0a1c59fc7baa2e5b3bb2af97ca7d70aae116026b9" }, // RLabsCGxTRqJcJvz6foKuXAB61puJ2x8yt
+        {"gcharang", "021569dd350d99e685a739c5b36bd01f217efb4f448a6f9a56da80c5edf6ce20ee" }, // RE8SsNwhYoygXJSvw9DuQbJicDc28dwR78      right
+        {"computergenie", "027313dabde94fb72f823231d0a1c59fc7baa2e5b3bb2af97ca7d70aae116026b9" }, // RLabsCGxTRqJcJvz6foKuXAB61puJ2x8yt right
        {"daemonfox", "0383484bdc745b2b953c85b5a0c496a1f27bc42ae971f15779ed1532421b3dd943" }, //
        {"SHossain", "02791f5c215b8a19c143a98e3371ff03b5613df9ac430c4a331ca55fed5761c800" }, // RKdLoHkyeorXmMtj91B1AAnAGiwsdt9MdF
        {"Nabob", "03ee91c20b6d26e3604022f42df6bb8de6f669da4591f93b568778cba13d9e9ddf" }, // RRwCLPZDzpHEFJnLev4phy51e2stHRUAaU
        {"mylo", "03f6b7fcaf0b8b8ec432d0de839a76598b78418dadd50c8e5594c0e557d914ec09" }, // RXN4hoZkhUkkrnef9nTUDw3E3vVALAD8Kx
+        {"PHBA2061", "039fc98c764bc85aed97d690d7942a4fd1190b2fa4f5f4c5c8e0957fac5c6ede00" }, // RPHba2o61hcpX4ds91oj3sKJ8aDXv6QdQf      right
+        {"Exile13", "0247b2120a39faf83678b5de6883e039180ff42925bcb298d32f3792cd59001aae" }, // RTDJ3CDZ6ANbeDKab8nqTVrGw7ViAKLeDV       right
    },
    {
        {"blackjok3r", "021914947402d936a89fbdd1b12be49eb894a1568e5e17bb18c8a6cffbd3dc106e" }, // RTVti13NP4eeeZaCCmQxc2bnPdHxCJFP9x
-        {"alright", "0285657c689b903218c97f5f10fe1d10ace2ed6595112d9017f54fb42ea1c1dda8" }, //RXmXeQ8LfJK6Y1aTM97cRz9Gu5f6fmR3sg
-        {"webworker01", "031d1fb39ae4dca28965c3abdbd21faa0f685f6d7b87a60561afa7c448343fef6d" }, //RGsQiArk5sTmjXZV9UzGMW5njyvtSnsTN8
-        {"CrisF", "024d19acf0d5de212cdd50326cd143292545d366a71b2b9c6df9f2110de2dfa1f2" }, // RKtAD2kyRRMx4EiG1eeTNprF5h2nmGbzzu
-        {"smk762", "029f6c1f38c4d6825acb3b4b5147f7992e943b617cdaa0f4f5f36187e239d52d5a" }, // RPy6Xj2LWrxNoEW9YyREDgBZDZZ5qURXBU
-        {"jorian", "0288e682c1ac449f1b85c4acb2d0bcd216d5df34c15fd18b8a8dd5fa64b8ece8ef" }, // RR1yT5aB19VwFoUCGTW4q4pk4qmhHEEE4t
-        {"TonyL", "021a559101e355c907d9c553671044d619769a6e71d624f68bfec7d0afa6bd6a96" }, // RHq3JsvLxU45Z8ufYS6RsDpSG4wi6ucDev
-        {"Emman", "038f642dcdacbdf510b7869d74544dbc6792548d9d1f8d73a999dd9f45f513c935" }, //RN2KsQGW36Ah4NorJDxLJp2xiYJJEzk9Y6
-        {"CHMEX", "03ed125d1beb118d12ff0a052bdb0cee32591386d718309b2924f2c36b4e7388e6" }, // RF4HiVeuYpaznRPs7fkRAKKYqT5tuxQQTL
-        {"metaphilibert", "0344182c376f054e3755d712361672138660bda8005abb64067eb5aa98bdb40d10" }, // RG28QSnYFADBg1dAVkH1uPGYS6F8ioEUM2
-        {"jusoaresf", "02dfb7ed72a23f6d07f0ea2f28192ee174733cc8412ec0f97b073007b78fab6346" }, // RBQGfE5Hxsjm1BPraTxbneRuNasPDuoLnu
-        {"mylo", "03f6b7fcaf0b8b8ec432d0de839a76598b78418dadd50c8e5594c0e557d914ec09" }, // RXN4hoZkhUkkrnef9nTUDw3E3vVALAD8Kx
-        {"greentea", "02054c14ae81838a063d22a75eaa3c961415f6825a57c8b8e4148d19dad64f128e" }, // REF7R76WpL1v7nSXjjiNHtRa2xYtq5qk1p
-        {"CMaurice", "025830ce81bd1301fb67d5872344efa7a9ff99ae85fe1234f18c085db9072b740f" }, // RX7pXUaV24xFn6DVKV8t3PrRF3gKw6TBjf
-        {"kmdkrazy", "02da444a2627d420f1f622fcdfb9bddb67d6d4241ad6b4d5054716ddbde8a25dfb" }, // RJPJBbHcm5mkAxhkkERHRfEE9Cvkr4Euoi
-        {"Bar_F1sh_Rel", "0395f2d9dd9ccb78caf74bff49b6d959afb95af746462e1b35f4a167d8e82b3666" }, // RBbLxJagCA9QHDazQvfnDZe874V1K4Gu8t
-        {"zatJUM", "030fff499b6dc0215344b28a0b6b4becdfb00cd34cd1b36b983ec14f47965fd4bc" }, // RSoEDLBasth7anxS8gbkg6KgeGiz8rhqv1
-        {"dwy", "03669457b2934d98b5761121dd01b243aed336479625b293be9f8c43a6ae7aaeff" }, // RKhZMqRF361FSGFAzstP5AhozekPjoVh5q
-        {"dukeleto", "03e4322510ee46d417b8382fe124f5a381a3cef6aef08f8a4e90c66a42a04b4015" }, // RB8vS1fkGuttoNYkA2B1ivNn8vhqbCEqbe
-        {"gcharang", "03336ca9db27cb6e882830e20dc525884e27dc94d557a5e68b972a5cbf9e8c62a8" }, // RJYiWn3FRCSSLf9Pe5RJcbrKQYosaMburP
-        {"ca333", "03a18a33313ccdbf3c9778776e33c423e073ff5833fa1de092ce9e921de52f22f6" }, // RX333A56jWdeW15MwZsaW3mHxGaDu2Yutp
-        {"computergenie", "03448ce28fb21748e8b05bbe32d6b1e758b589ac1eb359e5d552f8868f2b75dc92" }, // RGeniexxkjnR34hg7ZnCf36kmfuJusf6rE
-        {"daemonfox", "0383484bdc745b2b953c85b5a0c496a1f27bc42ae971f15779ed1532421b3dd943" }, //
-        {"SHossain", "02791f5c215b8a19c143a98e3371ff03b5613df9ac430c4a331ca55fed5761c800" }, // RKdLoHkyeorXmMtj91B1AAnAGiwsdt9MdF
-        {"Nabob", "03ee91c20b6d26e3604022f42df6bb8de6f669da4591f93b568778cba13d9e9ddf" }, // RRwCLPZDzpHEFJnLev4phy51e2stHRUAaU
    },
    {
        {"blackjok3r", "021914947402d936a89fbdd1b12be49eb894a1568e5e17bb18c8a6cffbd3dc106e" }, // RTVti13NP4eeeZaCCmQxc2bnPdHxCJFP9x
-        {"alright", "0285657c689b903218c97f5f10fe1d10ace2ed6595112d9017f54fb42ea1c1dda8" }, //RXmXeQ8LfJK6Y1aTM97cRz9Gu5f6fmR3sg
-        {"webworker01", "031d1fb39ae4dca28965c3abdbd21faa0f685f6d7b87a60561afa7c448343fef6d" }, //RGsQiArk5sTmjXZV9UzGMW5njyvtSnsTN8
-        {"CrisF", "024d19acf0d5de212cdd50326cd143292545d366a71b2b9c6df9f2110de2dfa1f2" }, // RKtAD2kyRRMx4EiG1eeTNprF5h2nmGbzzu
-        {"smk762", "029f6c1f38c4d6825acb3b4b5147f7992e943b617cdaa0f4f5f36187e239d52d5a" }, // RPy6Xj2LWrxNoEW9YyREDgBZDZZ5qURXBU
-        {"jorian", "0288e682c1ac449f1b85c4acb2d0bcd216d5df34c15fd18b8a8dd5fa64b8ece8ef" }, // RR1yT5aB19VwFoUCGTW4q4pk4qmhHEEE4t
-        {"TonyL", "021a559101e355c907d9c553671044d619769a6e71d624f68bfec7d0afa6bd6a96" }, // RHq3JsvLxU45Z8ufYS6RsDpSG4wi6ucDev
-        {"CHMEX", "03ed125d1beb118d12ff0a052bdb0cee32591386d718309b2924f2c36b4e7388e6" }, // RF4HiVeuYpaznRPs7fkRAKKYqT5tuxQQTL
-        {"metaphilibert", "0344182c376f054e3755d712361672138660bda8005abb64067eb5aa98bdb40d10" }, // RG28QSnYFADBg1dAVkH1uPGYS6F8ioEUM2
-        {"greentea", "02054c14ae81838a063d22a75eaa3c961415f6825a57c8b8e4148d19dad64f128e" }, // REF7R76WpL1v7nSXjjiNHtRa2xYtq5qk1p
-        {"CMaurice", "025830ce81bd1301fb67d5872344efa7a9ff99ae85fe1234f18c085db9072b740f" }, // RX7pXUaV24xFn6DVKV8t3PrRF3gKw6TBjf
-        {"Bar_F1sh_Rel", "0395f2d9dd9ccb78caf74bff49b6d959afb95af746462e1b35f4a167d8e82b3666" }, // RBbLxJagCA9QHDazQvfnDZe874V1K4Gu8t
-        {"zatJUM", "030fff499b6dc0215344b28a0b6b4becdfb00cd34cd1b36b983ec14f47965fd4bc" }, // RSoEDLBasth7anxS8gbkg6KgeGiz8rhqv1
-        {"dwy", "03669457b2934d98b5761121dd01b243aed336479625b293be9f8c43a6ae7aaeff" }, // RKhZMqRF361FSGFAzstP5AhozekPjoVh5q
-        {"gcharang", "03336ca9db27cb6e882830e20dc525884e27dc94d557a5e68b972a5cbf9e8c62a8" }, // RJYiWn3FRCSSLf9Pe5RJcbrKQYosaMburP
-        {"computergenie", "03448ce28fb21748e8b05bbe32d6b1e758b589ac1eb359e5d552f8868f2b75dc92" }, // RGeniexxkjnR34hg7ZnCf36kmfuJusf6rE
-        {"daemonfox", "0383484bdc745b2b953c85b5a0c496a1f27bc42ae971f15779ed1532421b3dd943" }, //
-        {"SHossain", "02791f5c215b8a19c143a98e3371ff03b5613df9ac430c4a331ca55fed5761c800" }, // RKdLoHkyeorXmMtj91B1AAnAGiwsdt9MdF
-        {"Nabob", "03ee91c20b6d26e3604022f42df6bb8de6f669da4591f93b568778cba13d9e9ddf" }, // RRwCLPZDzpHEFJnLev4phy51e2stHRUAaU
    },
    {
        {"blackjok3r", "021914947402d936a89fbdd1b12be49eb894a1568e5e17bb18c8a6cffbd3dc106e" }, // RTVti13NP4eeeZaCCmQxc2bnPdHxCJFP9x
-        {"alright", "0285657c689b903218c97f5f10fe1d10ace2ed6595112d9017f54fb42ea1c1dda8" }, //RXmXeQ8LfJK6Y1aTM97cRz9Gu5f6fmR3sg
-        {"webworker01", "031d1fb39ae4dca28965c3abdbd21faa0f685f6d7b87a60561afa7c448343fef6d" }, //RGsQiArk5sTmjXZV9UzGMW5njyvtSnsTN8
-        {"CrisF", "03f87f1bccb744d90fdbf7fad1515a98e9fc7feb1800e460d2e7565b88c3971bf3" }, //RMwEpnaVe3cesWbMqqKYPPkaLcDkooTDgZ
-        {"smk762", "02eacef682d2f86e0103c18f4da46116e17196f3fb8f73ed931acb78e81d8e1aa5" }, // RQVvzJ8gepCDVjhqCAc5Tia1kTmt8KDPL9
-        {"jorian", "02150c410a606b898bcab4f083e48e0f98a510e0d48d4db367d37f318d26ae72e3" }, // RFgzxZe2P4RWKx6E9QGPK3rx3TXeWxSqa8
-        {"TonyL", "021a559101e355c907d9c553671044d619769a6e71d624f68bfec7d0afa6bd6a96" }, // RHq3JsvLxU45Z8ufYS6RsDpSG4wi6ucDev
-        {"Emman", "038f642dcdacbdf510b7869d74544dbc6792548d9d1f8d73a999dd9f45f513c935" }, //RN2KsQGW36Ah4NorJDxLJp2xiYJJEzk9Y6
-        {"CHMEX", "03ed125d1beb118d12ff0a052bdb0cee32591386d718309b2924f2c36b4e7388e6" }, // RF4HiVeuYpaznRPs7fkRAKKYqT5tuxQQTL
-        {"metaphilibert", "0344182c376f054e3755d712361672138660bda8005abb64067eb5aa98bdb40d10" }, // RG28QSnYFADBg1dAVkH1uPGYS6F8ioEUM2
-        {"jusoaresf", "02dfb7ed72a23f6d07f0ea2f28192ee174733cc8412ec0f97b073007b78fab6346" }, // RBQGfE5Hxsjm1BPraTxbneRuNasPDuoLnu
-        {"mylo", "03f6b7fcaf0b8b8ec432d0de839a76598b78418dadd50c8e5594c0e557d914ec09" }, // RXN4hoZkhUkkrnef9nTUDw3E3vVALAD8Kx
-        {"blackjok3r2", "02f7597468703c1c5c8465dd6d43acaae697df9df30bed21494d193412a1ea193e" }, // RWHGbrLSP89fTzNVF9U9xiekDYJqcibTca
-        {"blackjok3r3", "03c3e4c0206551dbf3a4b24d18e5d2737080541184211e3bfd2b1092177410b9c2" }, // RMMav2AVse5XHPvDfTzRpMbFhK3GqFmtSN
-        {"kmdkrazy", "02f7597468703c1c5c8465dd6d43acaae697df9df30bed21494d193412a1ea193e" }, // RWHGbrLSP89fTzNVF9U9xiekDYJqcibTca
-        {"alrighttest", "02e9dfe248f453b499315a90375e58a1c9ad79f5f3932ecb2205399a0f262d65fc" }, // RBevSstS8JtDXMEFNcJws4QTYN4PcE2VL5
-        {"alrighttest1", "03527c7ecd6a8c5db6d685a64e6e18c1edb49e2f057a434f56c3f1253a26e9c6a2" }, // RBw2jNU3dnGk86ZLqPMadJwRwg3NU8eC6s
    }
 };

--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -51,6 +51,7 @@ using namespace std;
 extern int32_t KOMODO_INSYNC;
 extern void TxToJSON(const CTransaction& tx, const uint256 hashBlock, UniValue& entry);
 void ScriptPubKeyToJSON(const CScript& scriptPubKey, UniValue& out, bool fIncludeHex);
+int32_t komodo_notarized_height(int32_t *prevMoMheightp,uint256 *hashp,uint256 *txidp);
 #include "komodo_defs.h"
 #include "komodo_structs.h"

@@ -133,6 +134,9 @@ UniValue blockheaderToJSON(const CBlockIndex* blockindex)
        result.push_back(Pair("error", "null blockhash"));
        return(result);
    }
+    uint256 notarized_hash,notarized_desttxid; int32_t prevMoMheight,notarized_height;
+    notarized_height = komodo_notarized_height(&prevMoMheight,&notarized_hash,&notarized_desttxid);
+    result.push_back(Pair("last_notarized_height", notarized_height));
    result.push_back(Pair("hash", blockindex->GetBlockHash().GetHex()));
    int confirmations = -1;
    // Only report confirmations if the block is on the main chain
@@ -284,6 +288,9 @@ UniValue blockToDeltasJSON(const CBlock& block, const CBlockIndex* blockindex)
 UniValue blockToJSON(const CBlock& block, const CBlockIndex* blockindex, bool txDetails = false)
 {
    UniValue result(UniValue::VOBJ);
+    uint256 notarized_hash,notarized_desttxid; int32_t prevMoMheight,notarized_height;
+    notarized_height = komodo_notarized_height(&prevMoMheight,&notarized_hash,&notarized_desttxid);
+    result.push_back(Pair("last_notarized_height", notarized_height));
    result.push_back(Pair("hash", block.GetHash().GetHex()));
    int confirmations = -1;
    // Only report confirmations if the block is on the main chain
@@ -1454,6 +1461,23 @@ UniValue pricesgetorderbook(const UniValue& params, bool fHelp)
    return PricesGetOrderbook();
 }

+// pricesrekt rpc implementation
+UniValue pricesrefillfund(const UniValue& params, bool fHelp)
+{
+    if (fHelp || params.size() != 1)
+        throw runtime_error("pricesrefillfund amount\n");
+    LOCK(cs_main);
+    UniValue ret(UniValue::VOBJ);
+
+    if (ASSETCHAINS_CBOPRET == 0)
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "only -ac_cbopret chains have prices");
+
+    CAmount amount = atof(params[0].get_str().c_str()) * COIN;
+
+    return PricesRefillFund(amount);
+}
+
+
 UniValue gettxout(const UniValue& params, bool fHelp)
 {
    if (fHelp || params.size() < 2 || params.size() > 3)
@@ -1829,7 +1853,6 @@ UniValue getchaintips(const UniValue& params, bool fHelp)

    /* Construct the output array.  */
    UniValue res(UniValue::VARR); const CBlockIndex *forked;
-    BOOST_FOREACH(const CBlockIndex* block, setTips)
    BOOST_FOREACH(const CBlockIndex* block, setTips)
        {
            UniValue obj(UniValue::VOBJ);
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -60,7 +60,8 @@ arith_uint256 komodo_PoWtarget(int32_t *percPoSp,arith_uint256 target,int32_t he
 * or over the difficulty averaging window if 'lookup' is nonpositive.
 * If 'height' is nonnegative, compute the estimate at the time when a given block was found.
 */
-int64_t GetNetworkHashPS(int lookup, int height) {
+int64_t GetNetworkHashPS(int lookup, int height) 
+{
    CBlockIndex *pb = chainActive.LastTip();

    if (height >= 0 && height < chainActive.Height())
@@ -1051,6 +1052,7 @@ UniValue getblocksubsidy(const UniValue& params, bool fHelp)
    return result;
 }

+
 static const CRPCCommand commands[] =
 { //  category              name                      actor (function)         okSafeMode
  //  --------------------- ------------------------  -----------------------  ----------
--- a/src/rpc/net.cpp
+++ b/src/rpc/net.cpp
@@ -219,7 +219,6 @@ int32_t komodo_longestchain()
        depth--;
        if ( num > (n >> 1) )
        {
-            extern char ASSETCHAINS_SYMBOL[];
            if ( 0 && height != KOMODO_LONGESTCHAIN )
                fprintf(stderr,"set %s KOMODO_LONGESTCHAIN <- %d\n",ASSETCHAINS_SYMBOL,height);
            KOMODO_LONGESTCHAIN = height;
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -48,6 +48,8 @@

 #include <univalue.h>

+int32_t komodo_notarized_height(int32_t *prevMoMheightp,uint256 *hashp,uint256 *txidp);
+
 using namespace std;

 extern char ASSETCHAINS_SYMBOL[];
@@ -185,10 +187,13 @@ int32_t myIsutxo_spent(uint256 &spenttxid,uint256 txid,int32_t vout)

 void TxToJSONExpanded(const CTransaction& tx, const uint256 hashBlock, UniValue& entry, int nHeight = 0, int nConfirmations = 0, int nBlockTime = 0)
 {
+    uint256 notarized_hash,notarized_desttxid; int32_t prevMoMheight,notarized_height;
+    notarized_height = komodo_notarized_height(&prevMoMheight,&notarized_hash,&notarized_desttxid);
    uint256 txid = tx.GetHash();
    entry.push_back(Pair("txid", txid.GetHex()));
    entry.push_back(Pair("overwintered", tx.fOverwintered));
    entry.push_back(Pair("version", tx.nVersion));
+    entry.push_back(Pair("last_notarized_height", notarized_height));
    if (tx.fOverwintered) {
        entry.push_back(Pair("versiongroupid", HexInt(tx.nVersionGroupId)));
    }
--- a/src/rpc/server.cpp
+++ b/src/rpc/server.cpp
@@ -1,5 +1,6 @@
 // Copyright (c) 2010 Satoshi Nakamoto
 // Copyright (c) 2009-2014 The Bitcoin Core developers
+// Copyright (c) 2019 The Hush developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.

@@ -45,6 +46,7 @@

 using namespace RPCServer;
 using namespace std;
+extern uint16_t ASSETCHAINS_P2PPORT,ASSETCHAINS_RPCPORT;

 static bool fRPCRunning = false;
 static bool fRPCInWarmup = true;
@@ -454,6 +456,7 @@ static const CRPCCommand vRPCCommands[] =
    { "oracles",       "oracleslist",      &oracleslist,        true },
    { "oracles",       "oraclesinfo",      &oraclesinfo,        true },
    { "oracles",       "oraclescreate",    &oraclescreate,      true },
+    { "oracles",       "oraclesfund",  &oraclesfund,    true },
    { "oracles",       "oraclesregister",  &oraclesregister,    true },
    { "oracles",       "oraclessubscribe", &oraclessubscribe,   true },
    { "oracles",       "oraclesdata",      &oraclesdata,        true },
@@ -471,7 +474,7 @@ static const CRPCCommand vRPCCommands[] =
    { "prices",       "pricesrekt",         &pricesrekt,         true },
    { "prices",       "pricesaddfunding",         &pricesaddfunding,         true },
    { "prices",       "pricesgetorderbook",         &pricesgetorderbook,         true },
-
+    { "prices",       "pricesrefillfund",         &pricesrefillfund,         true },

    // Pegs
    { "pegs",       "pegsaddress",   &pegsaddress,      true },
@@ -853,21 +856,30 @@ UniValue CRPCTable::execute(const std::string &strMethod, const UniValue &params

 std::string HelpExampleCli(const std::string& methodname, const std::string& args)
 {
-    return "> komodo-cli " + methodname + " " + args + "\n";
+    if ( ASSETCHAINS_SYMBOL[0] == 0 ) {
+        return "> komodo-cli " + methodname + " " + args + "\n";
+    } else if ((strncmp(ASSETCHAINS_SYMBOL, "HUSH3", 5) == 0) ) {
+        return "> hush-cli " + methodname + " " + args + "\n";
+    } else {
+        return "> komodo-cli -ac_name=" + strprintf("%s", ASSETCHAINS_SYMBOL) + " " + methodname + " " + args + "\n";
+    }
 }

 std::string HelpExampleRpc(const std::string& methodname, const std::string& args)
 {
-    return "> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\":\"curltest\", "
-        "\"method\": \"" + methodname + "\", \"params\": [" + args + "] }' -H 'content-type: text/plain;' http://127.0.0.1:7771/\n";
+    return  "> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\":\"curltest\", "
+        "\"method\": \"" + methodname + "\", \"params\": [" + args + "] }' -H 'content-type: text/plain;' http://127.0.0.1:" + to_string(ASSETCHAINS_RPCPORT) + "/\n";
 }

 string experimentalDisabledHelpMsg(const string& rpc, const string& enableArg)
 {
+    string daemon = ASSETCHAINS_SYMBOL[0] == 0 ? "komodod" : "hushd";
+    string ticker = ASSETCHAINS_SYMBOL[0] == 0 ? "komodo" : ASSETCHAINS_SYMBOL;
+
    return "\nWARNING: " + rpc + " is disabled.\n"
-        "To enable it, restart zcashd with the -experimentalfeatures and\n"
+        "To enable it, restart " + daemon + " with the -experimentalfeatures and\n"
        "-" + enableArg + " commandline options, or add these two lines\n"
-        "to the zcash.conf file:\n\n"
+        "to the " + ticker + ".conf file:\n\n"
        "experimentalfeatures=1\n"
        + enableArg + "=1\n";
 }
--- a/src/rpc/server.h
+++ b/src/rpc/server.h
@@ -267,6 +267,7 @@ 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 oraclesfund(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);
@@ -510,6 +511,7 @@ extern UniValue pricescashout(const UniValue& params, bool fHelp);
 extern UniValue pricesrekt(const UniValue& params, bool fHelp);
 extern UniValue pricesaddfunding(const UniValue& params, bool fHelp);
 extern UniValue pricesgetorderbook(const UniValue& params, bool fHelp);
+extern UniValue pricesrefillfund(const UniValue& params, bool fHelp);



--- a/src/script/script_ext.cpp
+++ b/src/script/script_ext.cpp
@@ -85,6 +85,7 @@ const CScriptExt &CScriptExt::AddCheckLockTimeVerify(int64_t unlocktime) const
        *((CScript *)this) << OP_DROP;
        return *this;
    }
+    return *this;
 }

 // combined CLTV script and P2PKH
--- a/src/wallet/db.h
+++ b/src/wallet/db.h
@@ -33,9 +33,17 @@

 #include <boost/filesystem/path.hpp>

-// If CCLIB fails to compile with this, use the one below. 
-#include <db_cxx.h>
-//#include "../depends/x86_64-unknown-linux-gnu/include/db_cxx.h"
+#ifdef BUILD_ROGUE
+    #ifdef __APPLE__
+        #include "../depends/x86_64-apple-darwin18.6.0/include/db_cxx.h"
+    #elif defined(_WIN32)
+        #include "../depends/x86_64-w64-mingw32/include/db_cxx.h"
+    #else
+        #include "../depends/x86_64-unknown-linux-gnu/include/db_cxx.h"
+    #endif
+#else
+    #include <db_cxx.h>
+#endif

 extern unsigned int nWalletDBUpdated;

--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -4249,10 +4249,10 @@ UniValue z_sendmany(const UniValue& params, bool fHelp)
            + HelpExampleRpc("z_sendmany", "\"RD6GgnrMpPaTSMn8vai6yiGA7mN4QGPV\", [{\"address\": \"zs14d8tc0hl9q0vg5l28uec5vk6sk34fkj2n8s7jalvw5fxpy6v39yn4s2ga082lymrkjk0x2nqg37\" ,\"amount\": 5.0}]")
        );

-    THROW_IF_SYNCING(KOMODO_INSYNC);
-
    LOCK2(cs_main, pwalletMain->cs_wallet);

+    THROW_IF_SYNCING(KOMODO_INSYNC);
+
    // Check that the from address is valid.
    auto fromaddress = params[0].get_str();
    bool fromTaddr = false;
@@ -4353,8 +4353,9 @@ UniValue z_sendmany(const UniValue& params, bool fHelp)
        //else if ( ASSETCHAINS_PRIVATE != 0 && komodo_isnotaryvout((char *)address.c_str()) == 0 )
        //    throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "cant use transparent addresses in private chain");

-        if (setAddress.count(address))
-            throw JSONRPCError(RPC_INVALID_PARAMETER, string("Invalid parameter, duplicated address: ")+address);
+        // Allowing duplicate receivers helps various HushList protocol operations
+        //if (setAddress.count(address))
+        //    throw JSONRPCError(RPC_INVALID_PARAMETER, string("Invalid parameter, duplicated address: ")+address);
        setAddress.insert(address);

        UniValue memoValue = find_value(o, "memo");
@@ -4560,10 +4561,10 @@ UniValue z_shieldcoinbase(const UniValue& params, bool fHelp)
            + HelpExampleRpc("z_shieldcoinbase", "\"RD6GgnrMpPaTSMn8vai6yiGA7mN4QGPV\", \"zs14d8tc0hl9q0vg5l28uec5vk6sk34fkj2n8s7jalvw5fxpy6v39yn4s2ga082lymrkjk0x2nqg37\"")
        );

-    THROW_IF_SYNCING(KOMODO_INSYNC);
-
    LOCK2(cs_main, pwalletMain->cs_wallet);

+    THROW_IF_SYNCING(KOMODO_INSYNC);
+
    // Validate the from address
    auto fromaddress = params[0].get_str();
    bool isFromWildcard = fromaddress == "*";
@@ -4822,10 +4823,10 @@ UniValue z_mergetoaddress(const UniValue& params, bool fHelp)
        throw JSONRPCError(RPC_WALLET_ERROR, "Error: z_mergetoaddress is disabled.");
    }

-    THROW_IF_SYNCING(KOMODO_INSYNC);
-
    LOCK2(cs_main, pwalletMain->cs_wallet);

+    THROW_IF_SYNCING(KOMODO_INSYNC);
+
    bool useAnyUTXO = false;
    bool useAnySprout = false;
    bool useAnySapling = false;
@@ -6760,6 +6761,26 @@ UniValue oraclesinfo(const UniValue& params, bool fHelp)
    return(OracleInfo(txid));
 }

+UniValue oraclesfund(const UniValue& params, bool fHelp)
+{
+    UniValue result(UniValue::VOBJ); uint256 txid; std::string hex;
+    if ( fHelp || params.size() != 1 )
+        throw runtime_error("oraclesfund oracletxid\n");
+    if ( ensure_CCrequirements(EVAL_ORACLES) < 0 )
+        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    const CKeyStore& keystore = *pwalletMain;
+    LOCK2(cs_main, pwalletMain->cs_wallet);
+    txid = Parseuint256((char *)params[0].get_str().c_str());
+    hex = OracleFund(0,txid);
+    RETURN_IF_ERROR(CCerror);
+    if ( hex.size() > 0 )
+    {
+        result.push_back(Pair("result", "success"));
+        result.push_back(Pair("hex", hex));
+    } else ERR_RESULT("couldnt fund with oracle txid");
+    return(result);
+}
+
 UniValue oraclesregister(const UniValue& params, bool fHelp)
 {
    UniValue result(UniValue::VOBJ); uint256 txid; int64_t datafee; std::string hex;
@@ -6806,17 +6827,17 @@ UniValue oraclessubscribe(const UniValue& params, bool fHelp)

 UniValue oraclessamples(const UniValue& params, bool fHelp)
 {
-    UniValue result(UniValue::VOBJ); uint256 txid,batontxid; int32_t num;
+    UniValue result(UniValue::VOBJ); uint256 txid; int32_t num; char *batonaddr;
    if ( fHelp || params.size() != 3 )
-        throw runtime_error("oraclessamples oracletxid batonutxo num\n");
+        throw runtime_error("oraclessamples oracletxid batonaddress num\n");
    if ( ensure_CCrequirements(EVAL_ORACLES) < 0 )
        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
    const CKeyStore& keystore = *pwalletMain;
    LOCK2(cs_main, pwalletMain->cs_wallet);
    txid = Parseuint256((char *)params[0].get_str().c_str());
-    batontxid = Parseuint256((char *)params[1].get_str().c_str());
+    batonaddr = (char *)params[1].get_str().c_str();
    num = atoi((char *)params[2].get_str().c_str());
-    return(OracleDataSamples(txid,batontxid,num));
+    return(OracleDataSamples(txid,batonaddr,num));
 }

 UniValue oraclesdata(const UniValue& params, bool fHelp)
@@ -8028,9 +8049,9 @@ UniValue opreturn_burn(const UniValue& params, bool fHelp)
    if (fHelp || (params.size() != 2))
 		throw runtime_error("amount to burn, hexstring to send\n");
    struct CCcontract_info *cp, C; UniValue ret(UniValue::VOBJ);
-    if (ensure_CCrequirements(EVAL_PAYMENTS) < 0)
+    if (ensure_CCrequirements(EVAL_ORACLES) < 0)
    	throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
-    cp = CCinit(&C, EVAL_PAYMENTS);
+    cp = CCinit(&C, EVAL_ORACLES);
 	    
 	CAmount nAmount = AmountFromValue(params[0]);
    if (nAmount <= 10000)
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -2874,21 +2874,18 @@ void CWallet::ReacceptWalletTransactions()
            bool invalid = state.IsInvalid(nDoS);

            // log rejection and deletion
-            // printf("ERROR reaccepting wallet transaction %s to mempool, reason: %s, DoS: %d\n", wtx.GetHash().ToString().c_str(), state.GetRejectReason().c_str(), nDoS);
+            //printf("ERROR reaccepting wallet transaction %s to mempool, reason: %s, DoS: %d\n", wtx.GetHash().ToString().c_str(), state.GetRejectReason().c_str(), nDoS);

-            if (!wtx.IsCoinBase() && invalid && nDoS > 0)
+            if (!wtx.IsCoinBase() && invalid && nDoS > 0 && state.GetRejectReason() != "tx-overwinter-expired")
            {
                LogPrintf("erasing transaction %s\n", wtx.GetHash().GetHex().c_str());
                vwtxh.push_back(wtx.GetHash());
            }
        }
    }
-    if ( IsInitialBlockDownload() == 0 )
+    for (auto hash : vwtxh)
    {
-        for (auto hash : vwtxh)
-        {
-            EraseFromWallet(hash);
-        }
+        EraseFromWallet(hash);
    }
 }

@@ -2896,7 +2893,7 @@ bool CWalletTx::RelayWalletTransaction()
 {
    if ( pwallet == 0 )
    {
-        fprintf(stderr,"unexpected null pwallet in RelayWalletTransaction\n");
+        //fprintf(stderr,"unexpected null pwallet in RelayWalletTransaction\n");
        return(false);
    }
    assert(pwallet->GetBroadcastTransactions());
--- a/src/wallet/walletdb.cpp
+++ b/src/wallet/walletdb.cpp
@@ -41,6 +41,7 @@ using namespace std;

 static uint64_t nAccountingEntryNumber = 0;
 static list<uint256> deadTxns; 
+extern CBlockIndex *komodo_blockindex(uint256 hash);

 //
 // CWalletDB
@@ -487,7 +488,8 @@ ReadKeyValue(CWallet* pwallet, CDataStream& ssKey, CDataStream& ssValue,
            auto verifier = libzcash::ProofVerifier::Strict();
            // ac_public chains set at height like KMD and ZEX, will force a rescan if we dont ignore this error: bad-txns-acpublic-chain
            // there cannot be any ztx in the wallet on ac_public chains that started from block 1, so this wont affect those. 
-            if ( !(CheckTransaction(0,wtx, state, verifier) && (wtx.GetHash() == hash) && state.IsValid()) && (state.GetRejectReason() != "bad-txns-acpublic-chain") )
+            // PIRATE fails this check for notary nodes, need exception. Triggers full rescan without it. 
+            if ( !(CheckTransaction(0,wtx, state, verifier) && (wtx.GetHash() == hash) && state.IsValid()) && (state.GetRejectReason() != "bad-txns-acpublic-chain" && state.GetRejectReason() != "bad-txns-acprivacy-chain") )
            {
                //fprintf(stderr, "tx failed: %s rejectreason.%s\n", wtx.GetHash().GetHex().c_str(), state.GetRejectReason().c_str());
                // vin-empty on staking chains is error relating to a failed staking tx, that for some unknown reason did not fully erase. save them here to erase and re-add later on.
@@ -964,21 +966,20 @@ DBErrors CWalletDB::LoadWallet(CWallet* pwallet)
        // staking chains with vin-empty error is a failed staking tx. 
        // we remove then re add the tx here to stop needing a full rescan, which does not actually fix the problem.
        int32_t reAdded = 0;
-        CWalletDB walletdb(pwallet->strWalletFile, "r+", false);
        BOOST_FOREACH (uint256& hash, deadTxns) 
        {
-            fprintf(stderr, "Removing corrupt tx from wallet.%s\n", hash.ToString().c_str());
+            fprintf(stderr, "Removing possible orphaned staking transaction from wallet.%s\n", hash.ToString().c_str());
            if (!EraseTx(hash))
                fprintf(stderr, "could not delete tx.%s\n",hash.ToString().c_str());
-            uint256 blockhash; CTransaction tx;
-            if (GetTransaction(hash,tx,blockhash,true))
+            uint256 blockhash; CTransaction tx; CBlockIndex* pindex;
+            if ( GetTransaction(hash,tx,blockhash,false) && (pindex= komodo_blockindex(blockhash)) != 0 && chainActive.Contains(pindex) )
            {
                CWalletTx wtx(pwallet,tx);
-                pwallet->AddToWallet(wtx, false, &walletdb);
+                pwallet->AddToWallet(wtx, true, NULL);
                reAdded++;
            }
        }
-        fprintf(stderr, "Cleared %li corrupted transactions from wallet. Readded %i known transactions.\n",deadTxns.size(),reAdded);
+        fprintf(stderr, "Cleared %li orphaned staking transactions from wallet. Readded %i real transactions.\n",deadTxns.size(),reAdded);
        fNoncriticalErrors = false;
        deadTxns.clear();
    }
--- a/toolchain-info.sh
+++ b/toolchain-info.sh
@@ -1,6 +1,6 @@
 #!/bin/bash

-tools=("gcc-6" "g++-6" "otool" "nm")
+tools=("gcc-8" "g++-8" "otool" "nm")

 echo "Platform: `uname -a`"
 echo "-------------------------------------"
--- a/zcutil/build-mac.sh
+++ b/zcutil/build-mac.sh
@@ -1,6 +1,6 @@
 #!/bin/bash
-export CC=gcc-6
-export CXX=g++-6
+export CC=gcc-8
+export CXX=g++-8
 export LIBTOOL=libtool
 export AR=ar
 export RANLIB=ranlib
@@ -52,7 +52,7 @@ cd $WD

 ./autogen.sh
 CPPFLAGS="-I$PREFIX/include -arch x86_64" LDFLAGS="-L$PREFIX/lib -arch x86_64 -Wl,-no_pie" \
-CXXFLAGS='-arch x86_64 -I/usr/local/Cellar/gcc\@6/6.4.0_2/include/c++/6.4.0/ -I$PREFIX/include -fwrapv -fno-strict-aliasing -Werror -g -Wl,-undefined -Wl,dynamic_lookup' \
+CXXFLAGS='-arch x86_64 -I/usr/local/Cellar/gcc\@8/8.3.0/include/c++/8.3.0/ -I$PREFIX/include -fwrapv -fno-strict-aliasing -Wno-builtin-declaration-mismatch -Werror -g -Wl,-undefined -Wl,dynamic_lookup' \
 ./configure --prefix="${PREFIX}" --with-gui=no "$HARDENING_ARG" "$LCOV_ARG"

 make "$@" V=1 NO_GTEST=1 STATIC=1
--- a/zcutil/build.sh
+++ b/zcutil/build.sh
@@ -106,7 +106,7 @@ CONFIG_SITE="$PWD/depends/$HOST/share/config.site" ./configure "$HARDENING_ARG"
 WD=$PWD
 cd src/cc
 echo $PWD
-./makecclib
+./makerogue
 cd $WD

 "$MAKE" "$@" V=1