diff --git a/.gitignore b/.gitignore
index b2e5cb99..4ad2d7ba 100644
--- a/.gitignore
+++ b/.gitignore
@@ -43,7 +43,6 @@ share/setup.nsi
 
 cache/
 venv-mnf/
-src/univalue/gen
 
 .deps
 .dirstamp
diff --git a/configure.ac b/configure.ac
index 37d9a221..c011ad4d 100644
--- a/configure.ac
+++ b/configure.ac
@@ -2,8 +2,8 @@ dnl require autoconf 2.60 (AS_ECHO/AS_ECHO_N)
 AC_PREREQ([2.60])
 define(_CLIENT_VERSION_MAJOR, 3)
 define(_CLIENT_VERSION_MINOR, 0)
-define(_CLIENT_VERSION_REVISION, 0)
-define(_CLIENT_VERSION_BUILD, 0)
+define(_CLIENT_VERSION_REVISION, 1)
+define(_CLIENT_VERSION_BUILD, 1)
 define(_ZC_BUILD_VAL, m4_if(m4_eval(_CLIENT_VERSION_BUILD < 25), 1, m4_incr(_CLIENT_VERSION_BUILD), m4_eval(_CLIENT_VERSION_BUILD < 50), 1, m4_eval(_CLIENT_VERSION_BUILD - 24), m4_eval(_CLIENT_VERSION_BUILD == 50), 1, , m4_eval(_CLIENT_VERSION_BUILD - 50)))
 define(_CLIENT_VERSION_SUFFIX, m4_if(m4_eval(_CLIENT_VERSION_BUILD < 25), 1, _CLIENT_VERSION_REVISION-beta$1, m4_eval(_CLIENT_VERSION_BUILD < 50), 1, _CLIENT_VERSION_REVISION-rc$1, m4_eval(_CLIENT_VERSION_BUILD == 50), 1, _CLIENT_VERSION_REVISION, _CLIENT_VERSION_REVISION-$1)))
 define(_CLIENT_VERSION_IS_RELEASE, true)
diff --git a/depends/packages/boost.mk b/depends/packages/boost.mk
index 800c424c..06df125c 100644
--- a/depends/packages/boost.mk
+++ b/depends/packages/boost.mk
@@ -1,8 +1,8 @@
 package=boost
 
-$(package)_version=1_66_0
-$(package)_download_path=https://dl.bintray.com/boostorg/release/1.66.0/source
-$(package)_sha256_hash=5721818253e6a0989583192f96782c4a98eb6204965316df9f5ad75819225ca9
+$(package)_version=1_72_0
+$(package)_download_path=https://dl.bintray.com/boostorg/release/1.72.0/source
+$(package)_sha256_hash=59c9b274bc451cf91a9ba1dd2c7fdcaf5d60b1b3aa83f2c9fa143417cc660722
 $(package)_file_name=$(package)_$($(package)_version).tar.bz2
 
 define $(package)_set_vars
diff --git a/depends/packages/native_ccache.mk b/depends/packages/native_ccache.mk
index b63c18b9..ac2bb9f2 100644
--- a/depends/packages/native_ccache.mk
+++ b/depends/packages/native_ccache.mk
@@ -1,8 +1,8 @@
 package=native_ccache
-$(package)_version=3.3.1
-$(package)_download_path=https://www.samba.org/ftp/ccache
-$(package)_file_name=ccache-$($(package)_version).tar.bz2
-$(package)_sha256_hash=cb6e4bafbb19ba0a2ec43386b123a5f92a20e1e3384c071d5d13e0cb3c84bf73
+$(package)_version=3.7.4
+$(package)_download_path=https://github.com/ccache/ccache/releases/download/v$($(package)_version)
+$(package)_file_name=ccache-$($(package)_version).tar.xz
+$(package)_sha256_hash=04c0af414b8cf89e541daed59735547fbfd323b1aaa983da0216f6b6731e6836
 
 define $(package)_set_vars
 $(package)_config_opts=
diff --git a/src/Makefile.am b/src/Makefile.am
index c0075d82..b7745b11 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -3,6 +3,7 @@ DIST_SUBDIRS = secp256k1 univalue cryptoconditions
 AM_LDFLAGS = $(PTHREAD_CFLAGS) $(LIBTOOL_LDFLAGS) $(SAN_LDFLAGS) $(HARDENED_LDFLAGS)
 AM_CXXFLAGS = $(SAN_CXXFLAGS) $(HARDENED_CXXFLAGS) $(ERROR_CXXFLAGS)
 AM_CPPFLAGS = $(HARDENED_CPPFLAGS)
+EXTRA_LIBRARIES =
 
 if EMBEDDED_LEVELDB
 LEVELDB_CPPFLAGS += -I$(srcdir)/leveldb/include
@@ -20,7 +21,7 @@ $(LIBLEVELDB) $(LIBMEMENV):
 endif
 
 BITCOIN_CONFIG_INCLUDES=-I$(builddir)/config
-BITCOIN_INCLUDES=-I$(builddir) -I$(builddir)/obj $(BOOST_CPPFLAGS) $(LEVELDB_CPPFLAGS) $(CRYPTO_CFLAGS) $(SSL_CFLAGS)
+BITCOIN_INCLUDES=-I$(builddir) -I$(builddir)/obj $(BDB_CPPFLAGS) $(BOOST_CPPFLAGS) $(LEVELDB_CPPFLAGS) $(CRYPTO_CFLAGS) $(SSL_CFLAGS)
 
 BITCOIN_INCLUDES += -I$(srcdir)/secp256k1/include
 BITCOIN_INCLUDES += -I$(srcdir)/cc/includes
diff --git a/src/assetchains b/src/assetchains
old mode 100644
new mode 100755
index ce6c3aac..feecbda3
--- a/src/assetchains
+++ b/src/assetchains
@@ -4,7 +4,8 @@ set -eo pipefail
 # You can now add delay line to pubkey.txt file
 source pubkey.txt
 overide_args="$@"
-seed_ip=`getent hosts zero.kolo.supernet.org | awk '{ print $1 }'`
+seed_ip=`getent hosts zero.komodoseeds.com | awk '{ print $1 }'`
+komodo_binary='./qt/komodo-qt'
 
 if [ -z "$delay" ]; then delay=20; fi
 
@@ -14,6 +15,6 @@ if [ -z "$delay" ]; then delay=20; fi
       gen=" -gen -genproclimit=1"
   fi
 
-  ./komodod $gen $args $overide_args -pubkey=$pubkey -addnode=$seed_ip &
+  $komodo_binary $gen $args $overide_args -pubkey=$pubkey -addnode=$seed_ip &
   sleep $delay
 done
diff --git a/src/assetchains.json b/src/assetchains.json
index 86dc7756..66952c08 100644
--- a/src/assetchains.json
+++ b/src/assetchains.json
@@ -44,9 +44,16 @@
     "ac_supply": "999999"
   },
   {
-    "ac_name": "COQUI",
+    "ac_name": "COQUICASH",
     "ac_supply": "72000000",
-    "ac_ccactivate": "200000"
+    "ac_reward": "7200000000",
+    "ac_staked": "50",
+    "ac_halving": "420000",
+    "ac_cc": "2",
+    "ac_ccenable": "227,235,236,241",
+    "addnode": [
+      "78.47.108.168"
+    ]
   },
   {
     "ac_name": "WLC",
@@ -226,20 +233,22 @@
    "ac_supply": "90000000000",
    "ac_reward": "100000000",
    "ac_cc": "3",
-   "addnode": ["138.201.136.145"]
+   "ac_staked": "10",
+   "addnode": [
+     "138.201.136.145",
+     "95.217.44.58"
+   ]
  },
  {
    "ac_name": "MORTY",
    "ac_supply": "90000000000",
    "ac_reward": "100000000",
    "ac_cc": "3",
-   "addnode": ["138.201.136.145"]
- },
- {
-   "ac_name": "VOTE2019",
-   "ac_supply": "123651638",
-   "ac_public": "1",
-   "addnode": ["95.213.238.98"]
+   "ac_staked": "10",
+   "addnode": [
+     "138.201.136.145",
+     "95.217.44.58"
+   ]
  },
  {
    "ac_name": "KOIN",
@@ -268,5 +277,73 @@
    "ac_supply": "64000777",
    "ac_staked": "10",
    "addnode": ["18.197.20.21"]
- }
+ },
+ {
+   "ac_name": "HUSH3",
+   "ac_sapling": "1",
+   "ac_founders": "1",
+   "ac_reward": "0,1125000000,562500000",
+   "ac_end": "128,340000,5422111",
+   "ac_blocktime": "150",
+   "ac_supply": "6178674",
+   "ac_halving": "129,340000,840000",
+   "ac_cc": "2",
+   "ac_cclib": "hush3",
+   "ac_ccenable": "228,234,235,236,241",
+   "ac_perc": "11111111",
+   "ac_eras": "3",
+   "ac_script": "76a9145eb10cf64f2bab1b457f1f25e658526155928fac88ac",
+   "clientname": "GoldenSandtrout",
+   "addnode": [
+       "188.165.212.101",
+       "136.243.227.142",
+       "5.9.224.250"
+    ]
+ },
+ {
+   "ac_name": "THC",
+   "ac_supply": "251253103",
+   "ac_reward": "360000000,300000000,240000000,180000000,150000000,90000000,0",
+   "ac_staked": "100",
+   "ac_eras": "7",
+   "ac_end": "500001,1000001,1500001,2000001,2500001,4500001,0",
+   "ac_perc": "233333333",
+   "ac_cc": "2",
+   "ac_ccenable": "229,236,240",
+   "ac_script": "2ea22c8020987fad30df055db6fd922c3a57e55d76601229ed3da3b31340112e773df3d0d28103120c008203000401ccb8",
+   "ac_founders": "150",
+   "ac_cbmaturity": "1",
+   "ac_sapling": "1",
+   "earlytxid": "7e4a76259e99c9379551389e9f757fc5f46c33ae922a8644dc2b187af2a6adc1",
+   "addnode": [
+      "157.230.45.184",
+      "165.22.52.123"
+   ]
+ },
+  {
+    "ac_name": "COMMOD",
+    "ac_supply": "0",
+    "ac_reward": "204800000000,100000000",
+    "ac_end": "482130,0",
+    "ac_halving": "43830,525960",
+    "ac_decay": "50000000,10000000",
+    "ac_eras": "2",
+    "ac_cc": "777",
+    "ac_public": "1",
+    "addnode": [
+      "34.246.186.176",
+      "34.251.151.148"
+    ]
+  },
+  {
+    "ac_name": "WLC21",
+    "ac_supply": "21000000",
+    "ac_reward": "190258751",
+    "ac_staked": "90",
+    "ac_public": "1",
+    "addnode": [
+      "37.187.225.231",
+      "51.38.38.134"
+    ]
+  }
 ]
diff --git a/src/assetchains.old b/src/assetchains.old
index 4cf427c4..3e4917ff 100644
--- a/src/assetchains.old
+++ b/src/assetchains.old
@@ -4,38 +4,38 @@ delay=60
 source pubkey.txt
 echo $pubkey
 
-./komodod -pubkey=$pubkey -ac_name=REVS -ac_supply=1300000 -addnode=78.47.196.146 $1 &
-./komodod -pubkey=$pubkey -ac_name=SUPERNET -ac_supply=816061 -addnode=78.47.196.146 $1 &
-./komodod -pubkey=$pubkey -ac_name=DEX -ac_supply=999999 -addnode=78.47.196.146 $1 &
-./komodod -pubkey=$pubkey -ac_name=PANGEA -ac_supply=999999 -addnode=78.47.196.146 $1 &
-./komodod -pubkey=$pubkey -ac_name=JUMBLR -ac_supply=999999 -addnode=78.47.196.146 $1 &
-./komodod -pubkey=$pubkey -ac_name=BET -ac_supply=999999 -addnode=78.47.196.146 $1 &
-./komodod -pubkey=$pubkey -ac_name=CRYPTO -ac_supply=999999 -addnode=78.47.196.146 $1 &
-./komodod -pubkey=$pubkey -ac_name=HODL -ac_supply=9999999 -addnode=78.47.196.146 $1 &
-./komodod -pubkey=$pubkey -ac_name=MSHARK -ac_supply=1400000 -addnode=78.47.196.146 $1 &
-./komodod -pubkey=$pubkey -ac_name=BOTS -ac_supply=999999 -addnode=78.47.196.146 $1 &
-./komodod -pubkey=$pubkey -ac_name=MGW -ac_supply=999999 -addnode=78.47.196.146 $1 &
-./komodod -pubkey=$pubkey -ac_name=COQUI -ac_supply=72000000 -ac_ccactivate=200000 -addnode=78.47.196.146 $1 &
-./komodod -pubkey=$pubkey -ac_name=WLC -ac_supply=210000000 -addnode=148.251.190.89 $1 &
-./komodod -pubkey=$pubkey -ac_name=KV -ac_supply=1000000 -addnode=78.47.196.146 $1 &
-./komodod -pubkey=$pubkey -ac_name=CEAL -ac_supply=366666666 -addnode=78.47.196.146 $1 &
-./komodod -pubkey=$pubkey -ac_name=MESH -ac_supply=1000007 -addnode=78.47.196.146 $1 &
-./komodod -pubkey=$pubkey -ac_name=AXO -ac_supply=200000000 -ac_ccactivate=130000 -addnode=78.47.196.146 &
-./komodod -pubkey=$pubkey -ac_name=ETOMIC -ac_supply=100000000 -addnode=78.47.196.146 &
-./komodod -pubkey=$pubkey -ac_name=BTCH -ac_supply=20998641 -addnode=78.47.196.146 &
-./komodod -pubkey=$pubkey -ac_name=BEER -ac_supply=100000000 -addnode=78.47.196.146 &
-./komodod -pubkey=$pubkey -ac_name=PIZZA -ac_supply=100000000 -addnode=78.47.196.146 &
-./komodod -pubkey=$pubkey -ac_name=NINJA -ac_supply=100000000 -addnode=78.47.196.146 &
-./komodod -pubkey=$pubkey -ac_name=OOT -ac_supply=216000000 -ac_sapling=5000000 -addnode=174.138.107.226 &
-./komodod -pubkey=$pubkey -ac_name=BNTN -ac_supply=500000000 -addnode=94.130.169.205 &
-./komodod -pubkey=$pubkey -ac_name=CHAIN -ac_supply=999999 -addnode=78.47.146.222 &
+./komodod -pubkey=$pubkey -ac_name=REVS -ac_supply=1300000 -addnode=95.213.238.98 $1 &
+./komodod -pubkey=$pubkey -ac_name=SUPERNET -ac_supply=816061 -addnode=95.213.238.98 $1 &
+./komodod -pubkey=$pubkey -ac_name=DEX -ac_supply=999999 -addnode=95.213.238.98 $1 &
+./komodod -pubkey=$pubkey -ac_name=PANGEA -ac_supply=999999 -addnode=95.213.238.98 $1 &
+./komodod -pubkey=$pubkey -ac_name=JUMBLR -ac_supply=999999 -addnode=95.213.238.98 $1 &
+./komodod -pubkey=$pubkey -ac_name=BET -ac_supply=999999 -addnode=95.213.238.98 $1 &
+./komodod -pubkey=$pubkey -ac_name=CRYPTO -ac_supply=999999 -addnode=95.213.238.98 $1 &
+./komodod -pubkey=$pubkey -ac_name=HODL -ac_supply=9999999 -addnode=95.213.238.98 $1 &
+./komodod -pubkey=$pubkey -ac_name=MSHARK -ac_supply=1400000 -addnode=95.213.238.98 $1 &
+./komodod -pubkey=$pubkey -ac_name=BOTS -ac_supply=999999 -addnode=95.213.238.98 $1 &
+./komodod -pubkey=$pubkey -ac_name=MGW -ac_supply=999999 -addnode=95.213.238.98 $1 &
+./komodod -pubkey=$pubkey -ac_name=COQUICASH -ac_supply=72000000 -ac_reward=7200000000 -ac_staked=50 -ac_halving=420000 -ac_cc=2 -ac_ccenable=227,235,236,241 -addnode=78.47.108.168 &
+./komodod -pubkey=$pubkey -ac_name=WLC -ac_supply=210000000 -addnode=95.213.238.98 $1 &
+./komodod -pubkey=$pubkey -ac_name=KV -ac_supply=1000000 -addnode=95.213.238.98 $1 &
+./komodod -pubkey=$pubkey -ac_name=CEAL -ac_supply=366666666 -addnode=95.213.238.98 $1 &
+./komodod -pubkey=$pubkey -ac_name=MESH -ac_supply=1000007 -addnode=95.213.238.98 $1 &
+./komodod -pubkey=$pubkey -ac_name=AXO -ac_supply=200000000 -ac_ccactivate=130000 -addnode=95.213.238.98 &
+./komodod -pubkey=$pubkey -ac_name=ETOMIC -ac_supply=100000000 -addnode=95.213.238.98 &
+./komodod -pubkey=$pubkey -ac_name=BTCH -ac_supply=20998641 -addnode=95.213.238.98 &
+#./komodod -pubkey=$pubkey -ac_name=BEER -ac_supply=100000000 -addnode=95.213.238.98 &
+#./komodod -pubkey=$pubkey -ac_name=PIZZA -ac_supply=100000000 -addnode=95.213.238.98 &
+./komodod -pubkey=$pubkey -ac_name=NINJA -ac_supply=100000000 -addnode=95.213.238.98 &
+./komodod -pubkey=$pubkey -ac_name=OOT -ac_supply=216000000 -ac_sapling=5000000 -addnode=95.213.238.98 &
+./komodod -pubkey=$pubkey -ac_name=BNTN -ac_supply=500000000 -addnode=95.213.238.98 &
+./komodod -pubkey=$pubkey -ac_name=CHAIN -ac_supply=999999 -addnode=95.213.238.98 &
 ./komodod -pubkey=$pubkey -ac_name=PRLPAY -ac_supply=500000000 -addnode=13.250.226.125 &
 ./komodod -pubkey=$pubkey -ac_name=DSEC -ac_supply=7000000 -addnode=185.148.147.30 &
-./komodod -pubkey=$pubkey -ac_name=GLXT -ac_supply=10000000000 -addnode=13.230.224.15 &
+#./komodod -pubkey=$pubkey -ac_name=GLXT -ac_supply=10000000000 -addnode=13.230.224.15 &
 ./komodod -pubkey=$pubkey -ac_name=EQL -ac_supply=500000000 -ac_ccactivate=205000 -addnode=46.101.124.153 &
 ./komodod -pubkey=$pubkey -ac_name=ZILLA -ac_supply=11000000 -ac_sapling=5000000 -addnode=51.68.215.104 &
-./komodod -pubkey=$pubkey -ac_name=RFOX -ac_supply=1000000000 -ac_reward=100000000 -addnode=78.47.196.146 &
-~/VerusCoin/src/komodod -pubkey=$pubkey -ac_name=VRSC -ac_algo=verushash -ac_cc=1 -ac_veruspos=50 -ac_supply=0 -ac_eras=3 -ac_reward=0,38400000000,2400000000 -ac_halving=1,43200,1051920 -ac_decay=100000000,0,0 -ac_end=10080,226080,0 -ac_timelockgte=19200000000 -ac_timeunlockfrom=129600 -ac_timeunlockto=1180800 -addnode=185.25.48.236 -addnode=185.64.105.111 &
+./komodod -pubkey=$pubkey -ac_name=RFOX -ac_supply=1000000000 -ac_reward=100000000 -addnode=95.213.238.98 &
+#~/VerusCoin/src/komodod -pubkey=$pubkey -ac_name=VRSC -ac_algo=verushash -ac_cc=1 -ac_veruspos=50 -ac_supply=0 -ac_eras=3 -ac_reward=0,38400000000,2400000000 -ac_halving=1,43200,1051920 -ac_decay=100000000,0,0 -ac_end=10080,226080,0 -ac_timelockgte=19200000000 -ac_timeunlockfrom=129600 -ac_timeunlockto=1180800 -addnode=185.25.48.236 -addnode=185.64.105.111 &
 ./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 &
@@ -46,9 +46,13 @@ echo $pubkey
 ./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 &
-./komodod -pubkey=$pubkey -ac_name=RICK -ac_supply=90000000000 -ac_reward=100000000 -ac_cc=3 -addnode=138.201.136.145 &
-./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=RICK -ac_supply=90000000000 -ac_reward=100000000 -ac_cc=3 -ac_staked=10 -addnode=95.217.44.58 -addnode=138.201.136.145 &
+./komodod -pubkey=$pubkey -ac_name=MORTY -ac_supply=90000000000 -ac_reward=100000000 -ac_cc=3 -ac_staked=10 -addnode=95.217.44.58 -addnode=138.201.136.145 &
 ./komodod -pubkey=$pubkey -ac_name=KOIN -ac_supply=125000000 -addnode=3.0.32.10 &
 ./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 &
+./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 -addnode=136.243.227.142 -addnode=5.9.224.250 -ac_cclib=hush3 -ac_script=76a9145eb10cf64f2bab1b457f1f25e658526155928fac88ac &
+./komodod -pubkey=$pubkey -ac_name=THC -ac_supply=251253103 -ac_reward=360000000,300000000,240000000,180000000,150000000,90000000,0 -ac_staked=100 -ac_eras=7 -ac_end=500001,1000001,1500001,2000001,2500001,4500001,0 -ac_perc=233333333 -ac_cc=2 -ac_ccenable=229,236,240 -ac_script=2ea22c8020987fad30df055db6fd922c3a57e55d76601229ed3da3b31340112e773df3d0d28103120c008203000401ccb8 -ac_founders=150 -ac_cbmaturity=1 -ac_sapling=1 -addnode=157.230.45.184 -addnode=165.22.52.123 -earlytxid=7e4a76259e99c9379551389e9f757fc5f46c33ae922a8644dc2b187af2a6adc1 &
+./komodod -pubkey=$pubkey -ac_name=COMMOD -ac_supply=0 -ac_reward=204800000000,100000000 -ac_end=482130,0 -ac_halving=43830,525960 -ac_decay=50000000,10000000 -ac_eras=2 -ac_cc=777 -ac_public=1 -addnode=34.246.186.176 -addnode=34.251.151.148 &
+./komodod -pubkey=$pubkey -ac_name=WLC21 -ac_supply=21000000 -ac_reward=190258751 -ac_staked=90 -ac_public=1 -addnode=37.187.225.231 -addnode=51.38.38.134 &
+
diff --git a/src/assetchains_stop b/src/assetchains_stop
index 60549dc2..6fb8f6f7 100644
--- a/src/assetchains_stop
+++ b/src/assetchains_stop
@@ -1,6 +1,7 @@
 #!/bin/bash
 set -eo pipefail
+komodo_cli='./komodo-cli'
 
 ./listassetchains | while read chain; do
-  ./komodo-cli --ac_name=$chain stop
+  $komodo_cli --ac_name=$chain stop
 done
diff --git a/src/bitcoind.cpp b/src/bitcoind.cpp
index 17290376..1a684634 100644
--- a/src/bitcoind.cpp
+++ b/src/bitcoind.cpp
@@ -65,11 +65,25 @@ void komodo_passport_iteration();
 uint64_t komodo_interestsum();
 int32_t komodo_longestchain();
 void komodo_cbopretupdate(int32_t forceflag);
+CBlockIndex *komodo_chainactive(int32_t height);
 
 void WaitForShutdown(boost::thread_group* threadGroup)
 {
-    int32_t i; bool fShutdown = ShutdownRequested();
+    int32_t i,height; CBlockIndex *pindex; bool fShutdown = ShutdownRequested(); const uint256 zeroid;
     // Tell the main threads to shutdown.
+    if (komodo_currentheight()>KOMODO_EARLYTXID_HEIGHT && KOMODO_EARLYTXID!=zeroid && ((height=tx_height(KOMODO_EARLYTXID))==0 || height>KOMODO_EARLYTXID_HEIGHT))
+    {
+        LogPrintf("error: earlytx must be before block height %d or tx does not exist\n",KOMODO_EARLYTXID_HEIGHT);
+        StartShutdown();
+    }
+    /*if ( ASSETCHAINS_STAKED == 0 && ASSETCHAINS_ADAPTIVEPOW == 0 && (pindex= komodo_chainactive(1)) != 0 )
+    {
+        if ( pindex->nTime > ADAPTIVEPOW_CHANGETO_DEFAULTON )
+        {
+            ASSETCHAINS_ADAPTIVEPOW = 1;
+            fprintf(stderr,"default activate adaptivepow\n");
+        } else fprintf(stderr,"height1 time %u vs %u\n",pindex->nTime,ADAPTIVEPOW_CHANGETO_DEFAULTON);
+    } //else fprintf(stderr,"cant find height 1\n");*/
     if ( ASSETCHAINS_CBOPRET != 0 )
         komodo_pricesinit();
     while (!fShutdown)
@@ -77,7 +91,8 @@ void WaitForShutdown(boost::thread_group* threadGroup)
         //LogPrintf("call passport iteration\n");
         if ( ASSETCHAINS_SYMBOL[0] == 0 )
         {
-            komodo_passport_iteration();
+            if ( KOMODO_NSPV_FULLNODE )
+                komodo_passport_iteration();
             for (i=0; i<10; i++)
             {
                 fShutdown = ShutdownRequested();
@@ -155,23 +170,21 @@ bool AppInit(int argc, char* argv[])
 
     try
     {
+        // Check for -testnet or -regtest parameter (Params() calls are only valid after this clause)
+        if (!SelectParamsFromCommandLine()) {
+            LogPrintf("Error: Invalid combination of -regtest and -testnet.\n");
+            return false;
+        }
         void komodo_args(char *argv0);
         komodo_args(argv[0]);
+        void chainparams_commandline();
+        chainparams_commandline();
+
         LogPrintf("call komodo_args.(%s) NOTARY_PUBKEY.(%s)\n",argv[0],NOTARY_PUBKEY.c_str());
-        while ( ASSETCHAIN_INIT == 0 )
-        {
-            //if ( komodo_is_issuer() != 0 )
-            //    komodo_passport_iteration();
-            #ifdef _WIN32
-            boost::this_thread::sleep_for(boost::chrono::seconds(1));
-            #else
-            sleep(1);
-            #endif
-        }
         LogPrintf("initialized %s at %u\n",ASSETCHAINS_SYMBOL,(uint32_t)time(NULL));
         if (!boost::filesystem::is_directory(GetDataDir(false)))
         {
-            LogPrintf( "Error: Specified data directory \"%s\" does not exist.\n", mapArgs["-datadir"].c_str());
+            LogPrintf("Error: Specified data directory \"%s\" does not exist.\n", mapArgs["-datadir"].c_str());
             return false;
         }
         try
@@ -199,11 +212,6 @@ bool AppInit(int argc, char* argv[])
             LogPrintf("Error reading configuration file: %s\n", e.what());
             return false;
         }
-        // Check for -testnet or -regtest parameter (Params() calls are only valid after this clause)
-        if (!SelectParamsFromCommandLine()) {
-            LogPrintf( "Error: Invalid combination of -regtest and -testnet.\n");
-            return false;
-        }
 
         // Command-line RPC
         bool fCommandLine = false;
diff --git a/src/cc/CCGateways.h b/src/cc/CCGateways.h
index 8dfed186..8793c0dc 100644
--- a/src/cc/CCGateways.h
+++ b/src/cc/CCGateways.h
@@ -20,16 +20,16 @@
 #include "CCinclude.h"
 
 bool GatewaysValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx, uint32_t nIn);
-std::string GatewaysBind(uint64_t txfee,std::string coin,uint256 tokenid,int64_t totalsupply,uint256 oracletxid,uint8_t M,uint8_t N,std::vector<CPubKey> pubkeys,uint8_t p1,uint8_t p2,uint8_t p3,uint8_t p4);
-std::string GatewaysDeposit(uint64_t txfee,uint256 bindtxid,int32_t height,std::string refcoin,uint256 cointxid,int32_t claimvout,std::string deposithex,std::vector<uint8_t>proof,CPubKey destpub,int64_t amount);
-std::string GatewaysClaim(uint64_t txfee,uint256 bindtxid,std::string refcoin,uint256 deposittxid,CPubKey destpub,int64_t amount);
-std::string GatewaysWithdraw(uint64_t txfee,uint256 bindtxid,std::string refcoin,CPubKey withdrawpub,int64_t amount);
-std::string GatewaysPartialSign(uint64_t txfee,uint256 txidaddr,std::string refcoin,std::string hex);
-std::string GatewaysCompleteSigning(uint64_t txfee,uint256 txidaddr,std::string refcoin,std::string hex);
-std::string GatewaysMarkDone(uint64_t txfee,uint256 withdrawtxid,std::string refcoin);
-UniValue GatewaysPendingDeposits(uint256 bindtxid,std::string refcoin);
-UniValue GatewaysPendingWithdraws(uint256 bindtxid,std::string refcoin);
-UniValue GatewaysProcessedWithdraws(uint256 bindtxid,std::string refcoin);
+UniValue GatewaysBind(const CPubKey& pk, uint64_t txfee,std::string coin,uint256 tokenid,int64_t totalsupply,uint256 oracletxid,uint8_t M,uint8_t N,std::vector<CPubKey> pubkeys,uint8_t p1,uint8_t p2,uint8_t p3,uint8_t p4);
+UniValue GatewaysDeposit(const CPubKey& pk, uint64_t txfee,uint256 bindtxid,int32_t height,std::string refcoin,uint256 cointxid,int32_t claimvout,std::string deposithex,std::vector<uint8_t>proof,CPubKey destpub,int64_t amount);
+UniValue GatewaysClaim(const CPubKey& pk, uint64_t txfee,uint256 bindtxid,std::string refcoin,uint256 deposittxid,CPubKey destpub,int64_t amount);
+UniValue GatewaysWithdraw(const CPubKey& pk, uint64_t txfee,uint256 bindtxid,std::string refcoin,CPubKey withdrawpub,int64_t amount);
+UniValue GatewaysPartialSign(const CPubKey& pk, uint64_t txfee,uint256 txidaddr,std::string refcoin,std::string hex);
+UniValue GatewaysCompleteSigning(const CPubKey& pk, uint64_t txfee,uint256 txidaddr,std::string refcoin,std::string hex);
+UniValue GatewaysMarkDone(const CPubKey& pk, uint64_t txfee,uint256 withdrawtxid,std::string refcoin);
+UniValue GatewaysPendingDeposits(const CPubKey& pk, uint256 bindtxid,std::string refcoin);
+UniValue GatewaysPendingWithdraws(const CPubKey& pk, uint256 bindtxid,std::string refcoin);
+UniValue GatewaysProcessedWithdraws(const CPubKey& pk, uint256 bindtxid,std::string refcoin);
 
 // CCcustom
 UniValue GatewaysInfo(uint256 bindtxid);
diff --git a/src/cc/CCImportGateway.h b/src/cc/CCImportGateway.h
index 671b431c..9be54f23 100644
--- a/src/cc/CCImportGateway.h
+++ b/src/cc/CCImportGateway.h
@@ -28,7 +28,6 @@ std::string ImportGatewayWithdraw(uint64_t txfee,uint256 bindtxid,std::string re
 std::string ImportGatewayPartialSign(uint64_t txfee,uint256 lasttxid,std::string refcoin, std::string hex);
 std::string ImportGatewayCompleteSigning(uint64_t txfee,uint256 lasttxid,std::string refcoin,std::string hex);
 std::string ImportGatewayMarkDone(uint64_t txfee,uint256 completetxid,std::string refcoin);
-UniValue ImportGatewayPendingDeposits(uint256 bindtxid,std::string refcoin);
 UniValue ImportGatewayPendingWithdraws(uint256 bindtxid,std::string refcoin);
 UniValue ImportGatewayProcessedWithdraws(uint256 bindtxid,std::string refcoin);
 UniValue ImportGatewayExternalAddress(uint256 bindtxid,CPubKey pubkey);
diff --git a/src/cc/CCOracles.h b/src/cc/CCOracles.h
index bb7d4557..10dbfae9 100644
--- a/src/cc/CCOracles.h
+++ b/src/cc/CCOracles.h
@@ -20,13 +20,13 @@
 #include "CCinclude.h"
 
 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);
-
+UniValue OracleCreate(const CPubKey& pk, int64_t txfee,std::string name,std::string description,std::string format);
+UniValue OracleFund(const CPubKey& pk, int64_t txfee,uint256 oracletxid);
+UniValue OracleRegister(const CPubKey& pk, int64_t txfee,uint256 oracletxid,int64_t datafee);
+UniValue OracleSubscribe(const CPubKey& pk, int64_t txfee,uint256 oracletxid,CPubKey publisher,int64_t amount);
+UniValue OracleData(const CPubKey& pk, int64_t txfee,uint256 oracletxid,std::vector <uint8_t> data);
 // CCcustom
+UniValue OracleDataSample(uint256 reforacletxid,uint256 txid);
 UniValue OracleDataSamples(uint256 reforacletxid,char* batonaddr,int32_t num);
 UniValue OracleInfo(uint256 origtxid);
 UniValue OraclesList();
diff --git a/src/cc/CCPegs.h b/src/cc/CCPegs.h
index 8d2a268f..78f1acca 100644
--- a/src/cc/CCPegs.h
+++ b/src/cc/CCPegs.h
@@ -22,6 +22,15 @@
 bool PegsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx, uint32_t nIn);
 
 // CCcustom
-UniValue PegsInfo();
+UniValue PegsCreate(const CPubKey& pk,uint64_t txfee,int64_t amount,std::vector<uint256> bindtxids);
+UniValue PegsFund(const CPubKey& pk,uint64_t txfee,uint256 pegstxid, uint256 tokenid, int64_t amount);
+UniValue PegsGet(const CPubKey& pk,uint64_t txfee,uint256 pegstxid, uint256 tokenid, int64_t amount);
+UniValue PegsRedeem(const CPubKey& pk,uint64_t txfee,uint256 pegstxid, uint256 tokenid);
+UniValue PegsLiquidate(const CPubKey& pk,uint64_t txfee,uint256 pegstxid, uint256 tokenid, uint256 liquidatetxid);
+UniValue PegsExchange(const CPubKey& pk,uint64_t txfee,uint256 pegstxid, uint256 tokenid, int64_t amount);
+UniValue PegsAccountHistory(const CPubKey& pk,uint256 pegstxid);
+UniValue PegsAccountInfo(const CPubKey& pk,uint256 pegstxid);
+UniValue PegsWorstAccounts(uint256 pegstxid);
+UniValue PegsInfo(uint256 pegstxid);
 
 #endif
diff --git a/src/cc/CCassetstx.cpp b/src/cc/CCassetstx.cpp
index 1961e360..c2b0ad93 100644
--- a/src/cc/CCassetstx.cpp
+++ b/src/cc/CCassetstx.cpp
@@ -19,7 +19,6 @@
 
 UniValue AssetOrders(uint256 refassetid, CPubKey pk, uint8_t additionalEvalCode)
 {
-    static uint256 zero;
 	UniValue result(UniValue::VARR);  
 
     struct CCcontract_info *cpAssets, assetsC;
@@ -35,19 +34,19 @@ UniValue AssetOrders(uint256 refassetid, CPubKey pk, uint8_t additionalEvalCode)
 		std::vector<uint8_t> origpubkey;
 		CTransaction ordertx;
 		uint8_t funcid, evalCode;
-		char numstr[32], funcidstr[16], origaddr[64], origtokenaddr[64], assetidstr[65];
+		char numstr[32], funcidstr[16], origaddr[64], origtokenaddr[64];
 
         txid = it->first.txhash;
         LOGSTREAM("ccassets", CCLOG_DEBUG2, stream << "addOrders() checking txid=" << txid.GetHex() << std::endl);
-        if ( GetTransaction(txid, ordertx, hashBlock, false) != 0 ) 
+        if ( myGetTransaction(txid, ordertx, hashBlock) != 0 )
         {
 			// for logging: funcid = DecodeAssetOpRet(vintx.vout[vintx.vout.size() - 1].scriptPubKey, evalCode, assetid, assetid2, price, origpubkey);
             if (ordertx.vout.size() > 0 && (funcid = DecodeAssetTokenOpRet(ordertx.vout[ordertx.vout.size()-1].scriptPubKey, evalCode, assetid, assetid2, price, origpubkey)) != 0)
             {
                 LOGSTREAM("ccassets", CCLOG_DEBUG2, stream << "addOrders() checking ordertx.vout.size()=" << ordertx.vout.size() << " funcid=" << (char)(funcid ? funcid : ' ') << " assetid=" << assetid.GetHex() << std::endl);
 
-                if (refassetid != zero && assetid == refassetid ||
-                    pk != CPubKey() && pk == pubkey2pk(origpubkey) && (funcid == 'S' || funcid == 's'))
+                if (pk == CPubKey() && (refassetid == zeroid || assetid == refassetid)  // tokenorders
+                    || pk != CPubKey() && pk == pubkey2pk(origpubkey) && (funcid == 'S' || funcid == 's'))  // mytokenorders, returns only asks (is this correct?)
                 {
 
                     LOGSTREAM("ccassets", CCLOG_DEBUG2, stream << "addOrders() it->first.index=" << it->first.index << " ordertx.vout[it->first.index].nValue=" << ordertx.vout[it->first.index].nValue << std::endl);
@@ -61,7 +60,7 @@ UniValue AssetOrders(uint256 refassetid, CPubKey pk, uint8_t additionalEvalCode)
                     funcidstr[0] = funcid;
                     funcidstr[1] = 0;
                     item.push_back(Pair("funcid", funcidstr));
-                    item.push_back(Pair("txid", uint256_str(assetidstr, txid)));
+                    item.push_back(Pair("txid", txid.GetHex()));
                     item.push_back(Pair("vout", (int64_t)it->first.index));
                     if (funcid == 'b' || funcid == 'B')
                     {
@@ -77,7 +76,7 @@ UniValue AssetOrders(uint256 refassetid, CPubKey pk, uint8_t additionalEvalCode)
                         sprintf(numstr, "%llu", (long long)ordertx.vout[0].nValue);
                         item.push_back(Pair("askamount", numstr));
                     }
-                    if (origpubkey.size() == 33)
+                    if (origpubkey.size() == CPubKey::COMPRESSED_PUBLIC_KEY_SIZE)
                     {
                         GetCCaddress(cp, origaddr, pubkey2pk(origpubkey));  
                         item.push_back(Pair("origaddress", origaddr));
@@ -86,9 +85,9 @@ UniValue AssetOrders(uint256 refassetid, CPubKey pk, uint8_t additionalEvalCode)
 
                     }
                     if (assetid != zeroid)
-                        item.push_back(Pair("tokenid", uint256_str(assetidstr, assetid)));
+                        item.push_back(Pair("tokenid", assetid.GetHex()));
                     if (assetid2 != zeroid)
-                        item.push_back(Pair("otherid", uint256_str(assetidstr, assetid2)));
+                        item.push_back(Pair("otherid", assetid2.GetHex()));
                     if (price > 0)
                     {
                         if (funcid == 's' || funcid == 'S' || funcid == 'e' || funcid == 'e')
@@ -273,7 +272,7 @@ std::string CreateBuyOffer(int64_t txfee, int64_t bidamount, uint256 assetid, in
         LogPrintf("negative bidamount %lld, pricetotal %lld\n",(long long)bidamount,(long long)pricetotal);
         return("");
     }
-    if (GetTransaction(assetid, vintx, hashBlock, false) == 0)
+    if (myGetTransaction(assetid, vintx, hashBlock) == 0)
     {
         LogPrintf("cant find assetid\n");
         return("");
@@ -467,7 +466,7 @@ std::string CancelBuyOffer(int64_t txfee,uint256 assetid,uint256 bidtxid)
     if (AddNormalinputs(mtx, mypk, txfee, 3) > 0)
     {
         mask = ~((1LL << mtx.vin.size()) - 1);
-        if (GetTransaction(bidtxid, vintx, hashBlock, false) != 0)
+        if (myGetTransaction(bidtxid, vintx, hashBlock) != 0)
         {
             std::vector<uint8_t> vopretNonfungible;
             GetNonfungibleData(assetid, vopretNonfungible);
@@ -516,7 +515,7 @@ std::string CancelSell(int64_t txfee,uint256 assetid,uint256 asktxid)
    if (AddNormalinputs(mtx, mypk, txfee, 3) > 0)
     {
         mask = ~((1LL << mtx.vin.size()) - 1);
-        if (GetTransaction(asktxid, vintx, hashBlock, false) != 0)
+        if (myGetTransaction(asktxid, vintx, hashBlock) != 0)
         {
             std::vector<uint8_t> vopretNonfungible;
             GetNonfungibleData(assetid, vopretNonfungible);
@@ -589,7 +588,7 @@ std::string FillBuyOffer(int64_t txfee,uint256 assetid,uint256 bidtxid,int64_t f
     if (AddNormalinputs(mtx, mypk, 2*txfee, 3) > 0)
     {
         mask = ~((1LL << mtx.vin.size()) - 1);
-        if (GetTransaction(bidtxid, vintx, hashBlock, false) != 0)
+        if (myGetTransaction(bidtxid, vintx, hashBlock) != 0)
         {
             bidamount = vintx.vout[bidvout].nValue;
             SetAssetOrigpubkey(origpubkey, origprice, vintx);
@@ -691,7 +690,7 @@ std::string FillSell(int64_t txfee, uint256 assetid, uint256 assetid2, uint256 a
     //if (AddNormalinputs(mtx, mypk, 2*txfee, 3) > 0)
     //{
         //mask = ~((1LL << mtx.vin.size()) - 1);
-        if (GetTransaction(asktxid, vintx, hashBlock, false) != 0)
+        if (myGetTransaction(asktxid, vintx, hashBlock) != 0)
         {
             orig_assetoshis = vintx.vout[askvout].nValue;
             SetAssetOrigpubkey(origpubkey, total_nValue, vintx);
diff --git a/src/cc/CCchannels.h b/src/cc/CCchannels.h
index 10cb4d22..ecca145d 100644
--- a/src/cc/CCchannels.h
+++ b/src/cc/CCchannels.h
@@ -21,12 +21,12 @@
 #define CHANNELS_MAXPAYMENTS 1000
 
 bool ChannelsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx, uint32_t nIn);
-std::string ChannelOpen(uint64_t txfee,CPubKey destpub,int32_t numpayments,int64_t payment,uint256 tokenid);
-std::string ChannelPayment(uint64_t txfee,uint256 opentxid,int64_t amount, uint256 secret);
-std::string ChannelClose(uint64_t txfee,uint256 opentxid);
-std::string ChannelRefund(uint64_t txfee,uint256 opentxid,uint256 closetxid);
-UniValue ChannelsList();
+UniValue ChannelOpen(const CPubKey& pk,uint64_t txfee,CPubKey destpub,int32_t numpayments,int64_t payment,uint256 tokenid);
+UniValue ChannelPayment(const CPubKey& pk,uint64_t txfee,uint256 opentxid,int64_t amount, uint256 secret);
+UniValue ChannelClose(const CPubKey& pk,uint64_t txfee,uint256 opentxid);
+UniValue ChannelRefund(const CPubKey& pk,uint64_t txfee,uint256 opentxid,uint256 closetxid);
+UniValue ChannelsList(const CPubKey& pk);
 // CCcustom
-UniValue ChannelsInfo(uint256 opentxid);
+UniValue ChannelsInfo(const CPubKey& pk,uint256 opentxid);
 
 #endif
diff --git a/src/cc/CCfaucet.h b/src/cc/CCfaucet.h
index 3cb6c66e..af3237ab 100644
--- a/src/cc/CCfaucet.h
+++ b/src/cc/CCfaucet.h
@@ -25,8 +25,8 @@
 bool FaucetValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx, uint32_t nIn);
 
 // CCcustom
-std::string FaucetFund(uint64_t txfee,int64_t funds);
-std::string FaucetGet(uint64_t txfee);
+UniValue FaucetFund(const CPubKey& mypk,uint64_t txfee,int64_t funds);
+UniValue FaucetGet(const CPubKey& mypk,uint64_t txfee);
 UniValue FaucetInfo();
 
 #endif
diff --git a/src/cc/CCinclude.h b/src/cc/CCinclude.h
index 1d8cf669..1d28e2cc 100644
--- a/src/cc/CCinclude.h
+++ b/src/cc/CCinclude.h
@@ -16,26 +16,43 @@
 #ifndef CC_INCLUDE_H
 #define CC_INCLUDE_H
 
-/*
-there are only a very few types in bitcoin. pay to pubkey, pay to pubkey hash and pay to script hash
-p2pk, p2pkh, p2sh
-there are actually more that are possible, but those three are 99%+ of bitcoin transactions
-so you can pay to a pubkey, or to its hash. or to a script's hash. the last is how most of the more complex scripts are invoked. to spend a p2sh vout, you need to provide the redeemscript, this script's hash is what the p2sh address was.
-all of the above are the standard bitcoin vout types and there should be plenty of materials about it
-Encrypted by a verified device
-what I did with the CC contracts is created a fourth type of vout, the CC vout. this is using the cryptoconditions standard and it is even a different signature mechanism. ed25519 instead of secp256k1. it is basically a big extension to the bitcoin script. There is a special opcode that is added that says it is a CC script.
-
-but it gets more interesting
-each CC script has an evalcode
-this is just an arbitrary number. but what it does is allows to create a self-contained universe of CC utxo that all have the same evalcode and that is how a faucet CC differentiates itself from a dice CC, the eval code is different
-
-one effect from using a different eval code is that even if the rest of the CC script is the same, the bitcoin address that is calculated is different. what this means is that for each pubkey, there is a unique address for each different eval code!
-and this allows efficient segregation of one CC contracts transactions from another
-the final part that will make it all clear how the funds can be locked inside the contract. this is what makes a contract, a contract. I put both the privkey and pubkey for a randomly chosen address and associate it with each CC contract. That means anybody can sign outputs for that privkey. However, it is a CC output, so in addition to the signature, whatever constraints a CC contract implements must also be satistifed. This allows funds to be locked and yet anybody is able to spend it, assuming they satisfy the CC's rules
-
-one other technical note is that komodod has the insight-explorer extensions built in. so it can lookup directly all transactions to any address. this is a key performance boosting thing as if it wasnt there, trying to get all the utxo for an address not in the wallet is quite time consuming
+/*! \file CCinclude.h
+\brief A Documented file.
+
+Details.
 */
 
+/// \mainpage Brief introduction into cryptocondition contracts
+/// There are only a very few types in bitcoin: pay to pubkey, pay to pubkey hash and pay to script hash (p2pk, p2pkh, p2sh).
+/// There are actually more that are possible, but those three are 99%+ of bitcoin transactions.
+/// So you can pay to a pubkey, or to its hash or to a script's hash. The last is how most of the more complex scripts are invoked. To spend a p2sh vout, you need to provide the redeemscript, 
+/// this script's hash is what the p2sh address was.
+/// All of the above are the standard bitcoin vout types and there should be plenty of materials about it.
+///
+/// What I did with the cryptoconditions (CC) contracts (now rebranded as Antara modules) is created a fourth type of vout, the CC vout. This is using the cryptoconditions standard and it is even a different signature mechanism,
+/// ed25519 instead of secp256k1. It is basically a big extension to the bitcoin script. There is a special opcode that is added that says it is a CC script.
+///
+/// But it gets more interesting. Each CC script has an evalcode. 
+/// This is just an arbitrary number but what it does is allows to create a self-contained universe of CC utxo that all have the same evalcode and that is 
+/// how a faucet CC contract differentiates itself from a dice CC contract, the eval code is different.
+///
+/// One effect from using a different eval code is that even if the rest of the CC script is the same, the bitcoin address that is calculated is different. 
+/// What this means is that for each pubkey, there is a unique address for each different eval code!
+/// And this allows efficient segregation of one CC contracts transactions from another.
+/// The final part that will make it all clear how the funds can be locked inside the contract. 
+/// This is what makes a contract, a contract. 
+/// I put both the privkey and pubkey for a randomly chosen address and associate it with each CC contract. 
+/// That means anybody can sign outputs for that privkey. 
+/// However, it is a CC output, so in addition to the signature, whatever constraints a CC contract implements must also be satistifed. 
+/// This allows funds to be locked and yet anybody is able to spend it, assuming they satisfy the CC's rules.
+///
+/// One other technical note is that komodod has the insight-explorer extensions built in 
+/// so it can lookup directly all transactions to any address. 
+/// This is a key performance boosting thing as if it wasnt there, trying to get all the utxo for an address not in the wallet is quite time consuming.
+///
+/// More information about Antara framework:
+/// https://developers.komodoplatform.com/basic-docs/start-here/about-komodo-platform/product-introductions.html#smart-chains-antara
+
 #include <cc/eval.h>
 #include <script/cc.h>
 #include <script/script.h>
@@ -52,9 +69,15 @@ one other technical note is that komodod has the insight-explorer extensions bui
 #include "../utlist.h"
 #include "../uthash.h"
 #include "merkleblock.h"
+#include "../komodo_nSPV_defs.h"
+#include "../komodo_cJSON.h"
+#include "../init.h"
+#include "rpc/server.h"
 
-#define CC_BURNPUBKEY "02deaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddead"
+#define CC_BURNPUBKEY "02deaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddead" //!< 'dead' pubkey in hex for burning tokens (if tokens are sent to it, they become 'burned')
+/// \cond INTERNAL
 #define CC_MAXVINS 1024
+#define CC_REQUIREMENTS_MSG (KOMODO_NSPV_SUPERLITE?"to use CC contracts you need to nspv_login first\n":"to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n")
 
 #define SMALLVAL 0.000000000000001
 #define SATOSHIDEN ((uint64_t)100000000L)
@@ -62,44 +85,58 @@ one other technical note is that komodod has the insight-explorer extensions bui
 #define CCDISABLEALL memset(ASSETCHAINS_CCDISABLES,1,sizeof(ASSETCHAINS_CCDISABLES))
 #define CCENABLE(x) ASSETCHAINS_CCDISABLES[((uint8_t)x)] = 0
 
+/* moved to komodo_cJSON.h
 #ifndef _BITS256
 #define _BITS256
     union _bits256 { uint8_t bytes[32]; uint16_t ushorts[16]; uint32_t uints[8]; uint64_t ulongs[4]; uint64_t txid; };
     typedef union _bits256 bits256;
 #endif
+*/
+/// \endcond
 
-#include "../komodo_cJSON.h"
-
-// token opret additional data block ids:
- enum opretid : uint8_t {
+/// identifiers of additional data blobs in token opreturn script:
+/// @see EncodeTokenCreateOpRet(uint8_t funcid, std::vector<uint8_t> origpubkey, std::string name, std::string description, std::vector<std::pair<uint8_t, vscript_t>> oprets)
+/// @see GetOpretBlob
+enum opretid : uint8_t {
     // cc contracts data:
-    OPRETID_NONFUNGIBLEDATA = 0x11, 
-    OPRETID_ASSETSDATA = 0x12,
-    OPRETID_GATEWAYSDATA = 0x13,
-    OPRETID_CHANNELSDATA = 0x14,
-    OPRETID_HEIRDATA = 0x15,
-    OPRETID_ROGUEGAMEDATA = 0x16,
-
+    OPRETID_NONFUNGIBLEDATA = 0x11, //!< NFT data id
+    OPRETID_ASSETSDATA = 0x12,      //!< assets contract data id
+    OPRETID_GATEWAYSDATA = 0x13,    //!< gateways contract data id
+    OPRETID_CHANNELSDATA = 0x14,    //!< channels contract data id
+    OPRETID_HEIRDATA = 0x15,        //!< heir contract data id
+    OPRETID_ROGUEGAMEDATA = 0x16,   //!< rogue contract data id
+    OPRETID_PEGSDATA = 0x17,        //!< pegs contract data id
+
+    /*! \cond INTERNAL */
     // non cc contract data:
     OPRETID_FIRSTNONCCDATA = 0x80,
-    OPRETID_BURNDATA = 0x80,    
-    OPRETID_IMPORTDATA = 0x81
+    /*! \endcond */
+    OPRETID_BURNDATA = 0x80,        //!< burned token data id
+    OPRETID_IMPORTDATA = 0x81       //!< imported token data id
 };
 
- // find opret blob by opretid
- inline bool GetOpretBlob(const std::vector<std::pair<uint8_t, std::vector<uint8_t>>>  &oprets, uint8_t id, std::vector<uint8_t> &vopret)    {   
-     vopret.clear();
-     for(auto p : oprets)  if (p.first == id) { vopret = p.second; return true; }
-     return false;
- }
+/// finds opret blob data by opretid in the vector of oprets
+/// @param oprets vector of oprets
+/// @param id opret id to search
+/// @param vopret found opret blob as byte array
+/// @returns true if found
+/// @see opretid
+inline bool GetOpretBlob(const std::vector<std::pair<uint8_t, std::vector<uint8_t>>>  &oprets, uint8_t id, std::vector<uint8_t> &vopret)    {   
+    vopret.clear();
+    for(auto p : oprets)  if (p.first == id) { vopret = p.second; return true; }
+    return false;
+}
 
+/// \cond INTERNAL
 struct CC_utxo
 {
     uint256 txid;
     int64_t nValue;
     int32_t vout;
 };
+/// \endcond
 
+/// \cond INTERNAL
 // these are the parameters stored after Verus crypto-condition vouts. new versions may change
 // the format
 struct CC_meta
@@ -110,84 +147,200 @@ struct CC_meta
     uint8_t numDestinations;
     // followed by address destinations
 };
+/// \endcond
 
+/// CC contract (Antara module) info structure that contains data used for signing and validation of cc contract transactions
 struct CCcontract_info
 {
-	// this is for spending from 'unspendable' CC address
-	uint8_t evalcode;
-    uint8_t additionalTokensEvalcode2;  // this is for making three-eval-token vouts (EVAL_TOKENS + evalcode + additionalEvalcode2)
-	char unspendableCCaddr[64], CChexstr[72], normaladdr[64];
-	uint8_t CCpriv[32];
-
-	// this for 1of2 keys coins cryptocondition (for this evalcode)
-	// NOTE: only one evalcode is allowed at this time
-	char coins1of2addr[64];
-    CPubKey coins1of2pk[2]; uint8_t coins1of2priv[32];
-
-	// the same for tokens 1of2 keys cc 
-	char tokens1of2addr[64];
-	CPubKey tokens1of2pk[2];
-
-	// this is for spending from two additional 'unspendable' CC addresses of other eval codes 
-	// (that is, for spending from several cc contract 'unspendable' addresses):
-	uint8_t unspendableEvalcode2, unspendableEvalcode3;  // changed evalcodeN to unspendableEvalcodeN for not mixing up with additionalEvalcodeN
-	char    unspendableaddr2[64], unspendableaddr3[64];
-	uint8_t unspendablepriv2[32], unspendablepriv3[32];
-    CPubKey unspendablepk2,       unspendablepk3;
-
-    bool (*validate)(struct CCcontract_info *cp, Eval* eval, const CTransaction &tx, uint32_t nIn);  // cc contract tx validation callback
-    bool (*ismyvin)(CScript const& scriptSig);	// checks if evalcode is present in the scriptSig param
-
+    uint8_t evalcode;  //!< cc contract eval code, set by CCinit function
+    uint8_t additionalTokensEvalcode2;  //!< additional eval code for spending from three-eval-code vouts with EVAL_TOKENS, evalcode, additionalTokensEvalcode2 
+                                        //!< or vouts with two evalcodes: EVAL_TOKENS, additionalTokensEvalcode2. 
+                                        //!< Set by AddTokenCCInputs function
+
+    char unspendableCCaddr[64]; //!< global contract cryptocondition address, set by CCinit function
+    char CChexstr[72];          //!< global contract pubkey in hex, set by CCinit function
+    char normaladdr[64];        //!< global contract normal address, set by CCinit function
+    uint8_t CCpriv[32];         //!< global contract private key, set by CCinit function
+
+    /// vars for spending from 1of2 cc.
+    /// NOTE: the value of 'evalcode' member variable will be used for constructing 1of2 cryptocondition
+    char coins1of2addr[64];     //!< address of 1of2 cryptocondition, set by CCaddr1of2set function
+    CPubKey coins1of2pk[2];     //!< two pubkeys of 1of2 cryptocondition, set by CCaddr1of2set function
+    uint8_t coins1of2priv[32];  //!< privkey for the one of two pubkeys of 1of2 cryptocondition, set by CCaddr1of2set function
+
+    /// vars for spending from 1of2 token cc.
+    /// NOTE: the value of 'evalcode' member variable will be used for constructing 1of2 token cryptocondition
+    char tokens1of2addr[64];    //!< address of 1of2 token cryptocondition set by CCaddrTokens1of2set function
+    CPubKey tokens1of2pk[2];    //!< two pubkeys of 1of2 token cryptocondition set by CCaddrTokens1of2set function
+    uint8_t tokens1of2priv[32]; //!< privkey for the one of two pubkeys of 1of2 token cryptocondition set by CCaddrTokens1of2set function
+
+    /// vars for spending from two additional global CC addresses of other contracts with their own eval codes
+    uint8_t unspendableEvalcode2;   //!< other contract eval code, set by CCaddr2set function
+    uint8_t unspendableEvalcode3;   //!< yet another other contract eval code, set by CCaddr3set function
+    char    unspendableaddr2[64];   //!< other contract global cc address, set by CCaddr2set function
+    char    unspendableaddr3[64];   //!< yet another contract global cc address, set by CCaddr3set function
+    uint8_t unspendablepriv2[32];   //!< other contract private key for the global cc address, set by CCaddr2set function
+    uint8_t unspendablepriv3[32];   //!< yet another contract private key for the global cc address, set by CCaddr3set function
+    CPubKey unspendablepk2;         //!< other contract global public key, set by CCaddr2set function
+    CPubKey unspendablepk3;         //!< yet another contract global public key, set by CCaddr3set function
+
+    /// cc contract transaction validation callback that enforces the contract consensus rules
+    /// @param cp CCcontract_info structure with initialzed with CCinit
+    /// @param eval object of Eval type, used to report validation error like eval->Invalid("some error");
+    /// @param tx transaction object to validate
+    /// @param nIn not used at this time
+    bool(*validate)(struct CCcontract_info *cp, Eval* eval, const CTransaction &tx, uint32_t nIn);
+
+    /// checks if the value of evalcode in cp object is present in the scriptSig parameter, 
+    /// that is, the vin for this scriptSig will be validated by the cc contract (Antara module) defined by the eval code in this CCcontract_info object
+    /// @param scriptSig scriptSig to check\n
+    /// Example:
+    /// \code
+    /// bool ccFound = false;
+    /// for(int i = 0; i < tx.vin.size(); i ++)
+    ///     if (cp->ismyvin(tx.vin[i].scriptSig)) {
+    ///         ccFound = true;
+    ///         break;
+    ///     }
+    /// \endcode
+    bool (*ismyvin)(CScript const& scriptSig);	
+
+    /// @private
     uint8_t didinit;
 };
+
+/// init CCcontract_info structure with global pubkey, privkey and address for the contract identified by the passed evalcode.\n
+/// Members of the cp object that are filled with this function:\n
+/// cp->unspendableCCaddr\n
+/// cp->normaladdr\n
+/// cp->CChexstr\n
+/// cp->CCpriv\n
+/// cp->validate\n
+/// cp->ismyvin\n
+/// @param cp the address of CCcontract_info structure which will be filled with the global keys and address
+/// @param evalcode eval code for the module
+/// @returns pointer to the passed CCcontract_info structure, it must not be freed
 struct CCcontract_info *CCinit(struct CCcontract_info *cp,uint8_t evalcode);
 
+/// \cond INTERNAL
 struct oracleprice_info
 {
     CPubKey pk;
     std::vector <uint8_t> data;
     int32_t height;
 };
+/// \endcond
+
 
 typedef std::vector<uint8_t> vscript_t;
+extern struct NSPV_CCmtxinfo NSPV_U;  //!< global variable with info about mtx object and used utxo
 
 #ifdef ENABLE_WALLET
-extern CWallet* pwalletMain;
+extern CWallet* pwalletMain;  //!< global wallet object pointer to access wallet functionality
 #endif
 //extern CCoinsViewCache *pcoinsTip;
-bool GetAddressUnspent(uint160 addressHash, int type,std::vector<std::pair<CAddressUnspentKey,CAddressUnspentValue> > &unspentOutputs);
-CBlockIndex *komodo_getblockindex(uint256 hash);
-int32_t komodo_nextheight();
 
+/// @private seems old-style
+bool GetAddressUnspent(uint160 addressHash, int type,std::vector<std::pair<CAddressUnspentKey,CAddressUnspentValue> > &unspentOutputs);
+//CBlockIndex *komodo_getblockindex(uint256 hash);  //moved to komodo_def.h
+//int32_t komodo_nextheight();  //moved to komodo_def.h
+
+/// CCgetspenttxid finds the txid of the transaction which spends a transaction output. The function does this without loading transactions from the chain, by using spent index
+/// @param[out] spenttxid transaction id of the spending transaction
+/// @param[out] vini order number of input of the spending transaction
+/// @param[out] height block height where spending transaction is located
+/// @param txid id of the transaction for which spending tx is searched
+/// @param vout output number of the transaction for which spending transaction is searched
+/// @returns 0 if spending tx is found or -1 if not
 int32_t CCgetspenttxid(uint256 &spenttxid,int32_t &vini,int32_t &height,uint256 txid,int32_t vout);
+
+/// @private
 void CCclearvars(struct CCcontract_info *cp);
 UniValue CClib(struct CCcontract_info *cp,char *method,char *jsonstr);
 UniValue CClib_info(struct CCcontract_info *cp);
-CBlockIndex *komodo_blockindex(uint256 hash);
-CBlockIndex *komodo_chainactive(int32_t height);
-int32_t komodo_blockheight(uint256 hash);
-void StartShutdown();
 
-static const uint256 zeroid;
+//CBlockIndex *komodo_blockindex(uint256 hash); //moved to komodo_def.h
+//CBlockIndex *komodo_chainactive(int32_t height); //moved to komodo_def.h
+//int32_t komodo_blockheight(uint256 hash); //moved to komodo_def.h
+//void StartShutdown();
+
+static const uint256 zeroid;  //!< null uint256 constant
+
+/// \cond INTERNAL
 static uint256 ignoretxid;
 static int32_t ignorevin;
+/// \endcond
+
+/// myGetTransaction is non-locking version of GetTransaction
+/// @param hash hash of transaction to get (txid)
+/// @param[out] txOut returned transaction object
+/// @param[out] hashBlock hash of the block where the tx resides
 bool myGetTransaction(const uint256 &hash, CTransaction &txOut, uint256 &hashBlock);
+
+/// NSPV_myGetTransaction is called in NSPV mode
+/// @param hash hash of transaction to get (txid)
+/// @param[out] txOut returned transaction object
+/// @param[out] hashBlock hash of the block where the tx resides
+/// @param[out] txheight height of the block where the tx resides
+/// @param[out] currentheight current chain height
+bool NSPV_myGetTransaction(const uint256 &hash, CTransaction &txOut, uint256 &hashBlock, int32_t &txheight, int32_t &currentheight);
+
+/// decodes char array in hex encoding to byte array
+int32_t decode_hex(uint8_t *bytes, int32_t n, char *hex);
+
+/// checks if char string has hex symbols
+/// @returns no zero if string has only hex symbols
 int32_t is_hexstr(char *str,int32_t n);
-bool myAddtomempool(CTransaction &tx, CValidationState *pstate = NULL, bool fSkipExpiry = false);
-int32_t CCgettxout(uint256 txid,int32_t vout,int32_t mempoolflag,int32_t lockflag);
+
+/// CCgettxout returns the amount of an utxo. The function does this without loading the utxo transaction from the chain, by using coin cache
+/// @param txid transaction id of the utxo
+/// @param vout utxo transaction vout order number 
+/// @param mempoolflag if true the function checks the mempool to
+/// @param lockflag if true the function locks the mempool while accesses it
+/// @returns utxo value or -1 if utxo not found
+int64_t CCgettxout(uint256 txid,int32_t vout,int32_t mempoolflag,int32_t lockflag);
+
+/// \cond INTERNAL
 bool myIsutxo_spentinmempool(uint256 &spenttxid,int32_t &spentvini,uint256 txid,int32_t vout);
+bool myAddtomempool(CTransaction &tx, CValidationState *pstate = NULL, bool fSkipExpiry = false);
 bool mytxid_inmempool(uint256 txid);
 int32_t myIsutxo_spent(uint256 &spenttxid,uint256 txid,int32_t vout);
-int32_t decode_hex(uint8_t *bytes,int32_t n,char *hex);
+int32_t myGet_mempool_txs(std::vector<CTransaction> &txs,uint8_t evalcode,uint8_t funcid);
+/// \endcond
+
+/// \cond INTERNAL
 int32_t iguana_rwnum(int32_t rwflag,uint8_t *serialized,int32_t len,void *endianedp);
 int32_t iguana_rwbignum(int32_t rwflag,uint8_t *serialized,int32_t len,uint8_t *endianedp);
+/// \endcond
+
 CScript GetScriptForMultisig(int nRequired, const std::vector<CPubKey>& keys);
+
+/// CCaddress_balance returns amount of outputs on an address
+/// @param coinaddr address to search outputs on
+/// @param CCflag if non-zero then address is a cryptocondition address, if false - normal address
 int64_t CCaddress_balance(char *coinaddr,int32_t CCflag);
+
+/// Creates a bitcoin address from a transaction id. This address can never be spent
+/// @param[out] txidaddr returned address created from txid value 
+/// @param txid transaction id
+/// @return the public key for the created address 
 CPubKey CCtxidaddr(char *txidaddr,uint256 txid);
+
+/// Creates a custom bitcoin address from a transaction id. This address can never be spent
+/// @param[out] txidaddr returned address created from txid value 
+/// @param txid transaction id
+/// @param taddr custom address prefix
+/// @param prefix custom pubkey prefix
+/// @param prefix2 custom script prefix
+/// @return public key for the created address 
 CPubKey CCCustomtxidaddr(char *txidaddr,uint256 txid,uint8_t taddr,uint8_t prefix,uint8_t prefix2);
+
+// TODO: description
+/// @private
 bool GetCCParams(Eval* eval, const CTransaction &tx, uint32_t nIn,
                  CTransaction &txOut, std::vector<std::vector<unsigned char>> &preConditions, std::vector<std::vector<unsigned char>> &params);
 
+/// \cond INTERNAL
 int64_t OraclePrice(int32_t height,uint256 reforacletxid,char *markeraddr,char *format);
 uint256 OracleMerkle(int32_t height,uint256 reforacletxid,char *format,std::vector<struct oracle_merklepair>publishers);
 uint256 OraclesBatontxid(uint256 oracletxid,CPubKey pk);
@@ -195,137 +348,661 @@ uint8_t DecodeOraclesCreateOpRet(const CScript &scriptPubKey,std::string &name,s
 uint8_t DecodeOraclesOpRet(const CScript &scriptPubKey,uint256 &oracletxid,CPubKey &pk,int64_t &num);
 uint8_t DecodeOraclesData(const CScript &scriptPubKey,uint256 &oracletxid,uint256 &batontxid,CPubKey &pk,std::vector <uint8_t>&data);
 int32_t oracle_format(uint256 *hashp,int64_t *valp,char *str,uint8_t fmt,uint8_t *data,int32_t offset,int32_t datalen);
-
-//int64_t AddAssetInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPubKey pk,uint256 assetid,int64_t total,int32_t maxinputs);
+/// \endcond
+
+/// Adds token inputs to transaction object. If tokenid is a non-fungible token then the function will set additionalTokensEvalcode2 variable in the cp object to the eval code from NFT data to spend NFT outputs properly
+/// @param cp CCcontract_info structure
+/// @param mtx mutable transaction object
+/// @param pk pubkey for whose token inputs to add
+/// @param tokenid id of token which inputs to add
+/// @param total amount to add (if total==0 no inputs are added and all available amount is returned)
+/// @param maxinputs maximum number of inputs to add. If 0 then CC_MAXVINS define is used
 int64_t AddTokenCCInputs(struct CCcontract_info *cp, CMutableTransaction &mtx, CPubKey pk, uint256 tokenid, int64_t total, int32_t maxinputs);
+
+/// An overload that also returns NFT data in vopretNonfungible parameter
+/// the rest parameters are the same as in the first AddTokenCCInputs overload
+/// @see AddTokenCCInputs
 int64_t AddTokenCCInputs(struct CCcontract_info *cp, CMutableTransaction &mtx, CPubKey pk, uint256 tokenid, int64_t total, int32_t maxinputs, vscript_t &vopretNonfungible);
+
+/// Checks if a transaction vout is true token vout, for this check pubkeys and eval code in token opreturn are used to recreate vout and compare it with the checked vout.
+/// Verifies that the transaction total token inputs value equals to total token outputs (that is, token balance is not changed in this transaction)
+/// @param goDeeper also recursively checks the previous token transactions (or the creation transaction) and ensures token balance is not changed for them too
+/// @param checkPubkeys always true
+/// @param cp CCcontract_info structure initialized for EVAL_TOKENS eval code
+/// @param eval could be NULL, if not NULL then the eval parameter is used to report validation error
+/// @param tx transaction object to check
+/// @param v vout number (starting from 0)
+/// @param reftokenid id of the token. The vout is checked if it has this tokenid
+/// @returns true if vout is true token with the reftokenid id
 int64_t IsTokensvout(bool goDeeper, bool checkPubkeys, struct CCcontract_info *cp, Eval* eval, const CTransaction& tx, int32_t v, uint256 reftokenid);
 
+/// Decodes transaction object into hex encoding
+/// @param tx transaction object
+/// @param[out] strHexTx transaction in hex encoding
+/// returns true if success
 bool DecodeHexTx(CTransaction& tx, const std::string& strHexTx);
-void komodo_sendmessage(int32_t minpeers,int32_t maxpeers,const char *message,std::vector<uint8_t> payload);
-int32_t payments_parsehexdata(std::vector<uint8_t> &hexdata,cJSON *item,int32_t len);
-int32_t komodo_blockload(CBlock& block,CBlockIndex *pindex);
 
+//void komodo_sendmessage(int32_t minpeers,int32_t maxpeers,const char *message,std::vector<uint8_t> payload); // moved to komodo_defs.h
+
+/// @private
+int32_t payments_parsehexdata(std::vector<uint8_t> &hexdata,cJSON *item,int32_t len);
+// int32_t komodo_blockload(CBlock& block,CBlockIndex *pindex); // this def in komodo_defs.h
+
+/// Makes opreturn scriptPubKey for token creation transaction. Normally this function is called internally by the tokencreate rpc. You might need to call this function to create a customized token.
+/// The total opreturn length should not exceed 10001 byte
+/// @param funcid should be set to 'c' character
+/// @param origpubkey token creator pubkey as byte array
+/// @param name token name (no more than 32 char)
+/// @param description token description (no more than 4096 char)
+/// @param vopretNonfungible NFT data, could be empty. If not empty, NFT will be created, the first byte if the NFT data should be set to the eval code of the contract validating this NFT data
+/// @returns scriptPubKey with OP_RETURN script
 CScript EncodeTokenCreateOpRet(uint8_t funcid, std::vector<uint8_t> origpubkey, std::string name, std::string description, vscript_t vopretNonfungible);
+
+/// Makes opreturn scriptPubKey for token creation transaction. Normally this function is called internally by the tokencreate rpc. You might need to call it to create a customized token.
+/// The total opreturn length should not exceed 10001 byte
+/// @param funcid should be set to 'c' character
+/// @param origpubkey token creator pubkey as byte array
+/// @param name token name (no more than 32 char)
+/// @param description token description (no more than 4096 char)
+/// @param oprets vector of pairs of additional data added to the token opret. The first element in the pair is opretid enum, the second is the data as byte array
+/// @returns scriptPubKey with OP_RETURN script
+/// @see opretid
 CScript EncodeTokenCreateOpRet(uint8_t funcid, std::vector<uint8_t> origpubkey, std::string name, std::string description, std::vector<std::pair<uint8_t, vscript_t>> oprets);
 
+/// Makes opreturn scriptPubKey for token transaction. Normally this function is called internally by the token rpcs. You might call this function if your module should create a customized token.
+/// The total opreturn length should not exceed 10001 byte
+/// @param tokenid id of the token
+/// @param voutPubkeys vector of pubkeys used to make the token vout in the same transaction that the created opreturn is for, the pubkeys are used for token vout validation
+/// @param opretWithId a pair of additional opreturn data added to the token opret. Could be empty. The first element in the pair is opretid enum, the second is the data as byte array
+/// @returns scriptPubKey with OP_RETURN script
 CScript EncodeTokenOpRet(uint256 tokenid, std::vector<CPubKey> voutPubkeys, std::pair<uint8_t, vscript_t> opretWithId);
+
+/// An overload to make opreturn scriptPubKey for token transaction. Normally this function is called internally by the token rpcs. You might call this function if your module should create a customized token.
+/// The total opreturn length should not exceed 10001 byte
+/// @param tokenid id of the token
+/// @param voutPubkeys vector of pubkeys used to make the token vout in the same transaction that the created opreturn is for, the pubkeys are used for token vout validation
+/// @param oprets vector of pairs of additional opreturn data added to the token opret. Could be empty. The first element in the pair is opretid enum, the second is the data as byte array
+/// @returns scriptPubKey with OP_RETURN script
 CScript EncodeTokenOpRet(uint256 tokenid, std::vector<CPubKey> voutPubkeys, std::vector<std::pair<uint8_t, vscript_t>> oprets);
-int64_t AddCClibtxfee(struct CCcontract_info *cp,CMutableTransaction &mtx,CPubKey pk);
+
+/// Decodes opreturn scriptPubKey of token creation transaction. Normally this function is called internally by the token rpcs. You might call this function if your module should create a customized token.
+/// @param scriptPubKey OP_RETURN script to decode
+/// @param[out] origpubkey creator public key as a byte array
+/// @param[out] name token name 
+/// @param[out] description token description 
+/// @returns funcid ('c') or NULL if errors
 uint8_t DecodeTokenCreateOpRet(const CScript &scriptPubKey, std::vector<uint8_t> &origpubkey, std::string &name, std::string &description);
+
+/// Overload that decodes opreturn scriptPubKey of token creation transaction and also returns additional data blobs. 
+/// Normally this function is called internally by the token rpcs. You might want to call this function if your module should create a customized token.
+/// @param scriptPubKey OP_RETURN script to decode
+/// @param[out] origpubkey creator public key as a byte array
+/// @param[out] name token name 
+/// @param[out] description token description 
+/// @param[out] oprets vector of pairs of additional opreturn data added to the token opret. Could be empty if not set. The first element in the pair is opretid enum, the second is the data as byte array
+/// @returns funcid ('c') or NULL if errors
 uint8_t DecodeTokenCreateOpRet(const CScript &scriptPubKey, std::vector<uint8_t> &origpubkey, std::string &name, std::string &description, std::vector<std::pair<uint8_t, vscript_t>>  &oprets);
 
+/// Decodes opreturn scriptPubKey of token transaction, also returns additional data blobs. 
+/// Normally this function is called internally by different token rpc. You might want to call if your module created a customized token.
+/// @param scriptPubKey OP_RETURN script to decode
+/// @param[out] evalCodeTokens should be EVAL_TOKENS
+/// @param[out] tokenid id of token 
+/// @param[out] voutPubkeys vector of token output validation pubkeys from the opreturn
+/// @param[out] oprets vector of pairs of additional opreturn data added to the token opret. Could be empty if not set. The first element in the pair is opretid enum, the second is the data as byte array
+/// @returns funcid ('c' if creation tx or 't' if token transfer tx) or NULL if errors
 uint8_t DecodeTokenOpRet(const CScript scriptPubKey, uint8_t &evalCodeTokens, uint256 &tokenid, std::vector<CPubKey> &voutPubkeys, std::vector<std::pair<uint8_t, vscript_t>>  &oprets);
+
+/// @private
+int64_t AddCClibtxfee(struct CCcontract_info *cp, CMutableTransaction &mtx, CPubKey pk);
+
+/// Returns non-fungible data of token if this is a NFT
+/// @param tokenid id of token
+/// @param vopretNonfungible non-fungible token data. The first byte is the evalcode of the contract that validates the NFT-data
 void GetNonfungibleData(uint256 tokenid, vscript_t &vopretNonfungible);
+
+/// @private
 bool ExtractTokensCCVinPubkeys(const CTransaction &tx, std::vector<CPubKey> &vinPubkeys);
 
 // CCcustom
+
+/// Returns global pubkey for the evalcode and sets private key for the global pubkey
+/// @param cp CCcontract_info structure initialized for a evalcode
+/// @param[out] unspendablepriv if not null then in this parameter private key is returned. Must have at least 32 byte size
+/// @returns global contract pubkey.\n
+/// Example: 
+/// \code
+/// struct CCcontract_info *cp, C;
+/// uint8_t ccAssetsPriv[32]
+/// cp = CCinit(&C, EVAL_ASSETS);
+/// CPubKey ccAssetsPk = GetUnspendable(cp, ccAssetsPriv);
+/// \endcode
+/// Now ccAssetsPk has Antara 'Assets' module global pubkey and ccAssetsPriv has its publicly available private key
 CPubKey GetUnspendable(struct CCcontract_info *cp,uint8_t *unspendablepriv);
-//uint8_t DecodeTokenOpRet(const CScript scriptPubKey, uint8_t &evalCodeTokens, uint256 &tokenid, std::vector<CPubKey> &voutPubkeys, std::vector<uint8_t>  &vopret1, std::vector<uint8_t>  &vopret2);
 
 // CCutils
-bool priv2addr(char *coinaddr,uint8_t buf33[33],uint8_t priv32[32]);
+
+/// finds normal address for private key
+/// @param[out] coinaddr returned normal address, must be array of char with length 64
+/// @param[out] buf33 array of length not less than 33 uint8_t, returned public key from private key
+/// @param priv32 private key
+/// @returns true if the address found successfully
+bool priv2addr(char *coinaddr, uint8_t buf33[33], uint8_t priv32[32]);
+
+/// converts public key as array of uint8_t to CPubKey object
+/// @param buf33 public key as array of uint8_t
+/// @returns created CPubKey object
 CPubKey buf2pk(uint8_t *buf33);
+
+/// \cond INTERNAL
 void endiancpy(uint8_t *dest,uint8_t *src,int32_t len);
 uint256 DiceHashEntropy(uint256 &entropy,uint256 _txidpriv,int32_t entropyvout,int32_t usevout);
+/// \endcond
+
+/// MakeCC1vout creates a transaction output with a cryptocondition that allows to spend it by one key. The returned output should be added to a transaction vout array.
+/// @param evalcode cryptocondition eval code (transactions with this eval code in cc inputs will be forwarded to the contract associated with this eval code)
+/// @param nValue value of the output in satoshi
+/// @param pk pubkey to spend the cc
+/// @param vData pointer to vector of vectors of unsigned char data to be added to the created vout for application needs
+/// @returns vout object
 CTxOut MakeCC1vout(uint8_t evalcode,CAmount nValue,CPubKey pk, std::vector<std::vector<unsigned char>>* vData = NULL);
+
+/// MakeCC1of2vout creates creates a transaction output with a 1of2 cryptocondition that allows to spend it by either of two keys. The returned output should be added to a transaction vout array.
+/// @param evalcode cryptocondition eval code (transactions with this eval code in cc inputs will be forwarded to the contract associated with this eval code)
+/// @param nValue value of the output in satoshi
+/// @param pk one of two pubkeys to spend the cc
+/// @param pk2 second of two pubkeys to spend the cc
+/// @param vData pointer to vector of vectors of unsigned char data to be added to the created vout for application needs
+/// @returns vout object
 CTxOut MakeCC1of2vout(uint8_t evalcode,CAmount nValue,CPubKey pk,CPubKey pk2, std::vector<std::vector<unsigned char>>* vData = NULL);
+
+/// @private
 int32_t has_opret(const CTransaction &tx, uint8_t evalcode);
+/// @private
 bool getCCopret(const CScript &scriptPubKey, CScript &opret);
+/// @private
 bool makeCCopret(CScript &opret, std::vector<std::vector<unsigned char>> &vData);
+
+/// MakeCCcond1 creates a cryptocondition that allows to spend it by one key
+/// @param evalcode cryptocondition eval code (transactions with this eval code in cc inputs will be forwarded to the contract associated with this eval code)
+/// @param pk pubkey to spend the cc
+/// @returns cryptocondition object. Must be disposed with cc_free function when not used any more
 CC *MakeCCcond1(uint8_t evalcode,CPubKey pk);
+
+/// MakeCCcond1of2 creates new 1of2 cryptocondition that allows to spend it by either of two keys
+/// @param evalcode cryptocondition eval code (transactions with this eval code in cc inputs will be forwarded to the contract associated with this eval code)
+/// @param pk1 one of two pubkeys to spend the cc
+/// @param pk2 second of two pubkeys to spend the cc
+/// @returns cryptocondition object. Must be disposed with cc_free function when not used any more
 CC *MakeCCcond1of2(uint8_t evalcode,CPubKey pk1,CPubKey pk2);
+
+/// GetCryptoCondition retrieves the cryptocondition from a scriptSig object 
+/// @param scriptSig scriptSig object with a cryptocondition
+/// @returns cc object, must be disposed with cc_free when not used
 CC* GetCryptoCondition(CScript const& scriptSig);
+
+/// CCaddr2set sets private key for additional eval code global address.
+/// This allows to spend from two cc global addresses in one transaction (the first one is set in cp object by @see CCinit function).
+/// @param cp contract info structure (@see CCcontract_info) where the private key is set
+/// @param evalcode eval code of the other contract
+/// @param pk global public key of the other contract
+/// @param priv private key for the global public key of the other contract
+/// @param coinaddr cc address obtained for this global pubkey and eval code with _GetCCaddress
+/// @see CCinit
+/// @see CCcontract_info
+/// @see _GetCCaddress
 void CCaddr2set(struct CCcontract_info *cp,uint8_t evalcode,CPubKey pk,uint8_t *priv,char *coinaddr);
+
+/// CCaddr2set sets private key for yet another eval code global address.
+/// This allows to spend from three cc global addresses in one transaction (the first one is set in cp object by CCinit function, the second is set by CCaddr2set function).
+/// @param cp contract info structure where the private key is set
+/// @param evalcode eval code of the other contract
+/// @param pk global public key of the other contract
+/// @param priv private key for the global public key of the other contract
+/// @param coinaddr the cc address obtained for this global pubkey and eval code with _GetCCaddress
+/// @see CCinit
+/// @see CCcontract_info
+/// @see CCaddr2set
+/// @see _GetCCaddress
 void CCaddr3set(struct CCcontract_info *cp,uint8_t evalcode,CPubKey pk,uint8_t *priv,char *coinaddr);
+
+/// CCaddr1of2set sets pubkeys, private key and cc addr for spending from 1of2 cryptocondition vout
+/// @param cp contract info structure where the private key is set
+/// @param pk1 one of the two public keys of the 1of2 cc
+/// @param pk2 second of the two public keys of the 1of2 cc
+/// @param priv private key for one of the two pubkeys
+/// @param coinaddr the cc address obtained for this 1of2 cc with GetCCaddress1of2
+/// @see CCinit
+/// @see CCcontract_info
+/// @see GetCCaddress1of2
 void CCaddr1of2set(struct CCcontract_info *cp, CPubKey pk1, CPubKey pk2,uint8_t *priv,char *coinaddr);
-CTxOut MakeTokensCC1of2vout(uint8_t evalcode, CAmount nValue, CPubKey pk1, CPubKey pk2);
-CTxOut MakeTokensCC1of2vout(uint8_t evalcode, uint8_t evalcode2, CAmount nValue, CPubKey pk1, CPubKey pk2);
-CTxOut MakeTokensCC1vout(uint8_t evalcode, CAmount nValue, CPubKey pk);
-CTxOut MakeTokensCC1vout(uint8_t evalcode, uint8_t evalcode2, CAmount nValue, CPubKey pk);
-CC *MakeTokensCCcond1of2(uint8_t evalcode, uint8_t evalcode2, CPubKey pk1, CPubKey pk2);
-CC *MakeTokensCCcond1of2(uint8_t evalcode, CPubKey pk1, CPubKey pk2);
+
+/// Creates a token cryptocondition that allows to spend it by one key
+/// The resulting cc will have two eval codes (EVAL_TOKENS and evalcode parameter value).
+/// @param evalcode cryptocondition eval code (transactions with this eval code in cc inputs will be forwarded to the contract associated with this eval code)
+/// @param pk pubkey to spend the cc
+/// @returns cryptocondition object. Must be disposed with cc_free function when not used any more
 CC *MakeTokensCCcond1(uint8_t evalcode, CPubKey pk);
+
+/// Overloaded function that creates a token cryptocondition that allows to spend it by one key
+/// The resulting cc will have two eval codes (EVAL_TOKENS and evalcode parameter value).
+/// @param evalcode cryptocondition eval code (transactions with this eval code in cc inputs will be forwarded to the contract associated with this eval code)
+/// @param evalcode2 yet another cryptocondition eval code (transactions with this eval code in cc inputs will be forwarded to the contract associated with this eval code)
+/// @param pk pubkey to spend the cc
+/// @returns cryptocondition object. Must be disposed with cc_free function when not used any more
 CC *MakeTokensCCcond1(uint8_t evalcode, uint8_t evalcode2, CPubKey pk);
+
+/// Creates new 1of2 token cryptocondition that allows to spend it by either of two keys
+/// Resulting vout will have three eval codes (EVAL_TOKENS, evalcode and evalcode2 parameter values).
+/// @param evalcode cryptocondition eval code (transactions with this eval code in cc inputs will be forwarded to the contract associated with this eval code)
+/// @param pk1 one of two pubkeys to spend the cc
+/// @param pk2 second of two pubkeys to spend the cc
+/// @returns cryptocondition object. Must be disposed with cc_free function when not used any more
+CC *MakeTokensCCcond1of2(uint8_t evalcode, CPubKey pk1, CPubKey pk2);
+
+/// Creates new 1of2 token cryptocondition that allows to spend it by either of two keys
+/// The resulting cc will have two eval codes (EVAL_TOKENS and evalcode parameter value).
+/// @param evalcode cryptocondition eval code (transactions with this eval code in cc inputs will be forwarded to the contract associated with this eval code)
+/// @param evalcode2 yet another cryptocondition eval code (transactions with this eval code in cc inputs will be forwarded to the contract associated with this eval code)
+/// @param pk1 one of two pubkeys to spend the cc
+/// @param pk2 second of two pubkeys to spend the cc
+/// @returns cryptocondition object. Must be disposed with cc_free function when not used any more
+CC *MakeTokensCCcond1of2(uint8_t evalcode, uint8_t evalcode2, CPubKey pk1, CPubKey pk2);
+
+/// Creates a token transaction output with a cryptocondition that allows to spend it by one key. 
+/// The resulting vout will have two eval codes (EVAL_TOKENS and evalcode parameter value).
+/// The returned output should be added to a transaction vout array.
+/// @param evalcode cryptocondition eval code (transactions with this eval code in cc inputs will be forwarded to the contract associated with this eval code)
+/// @param nValue value of the output in satoshi
+/// @param pk pubkey to spend the cc
+/// @returns vout object
+/// @see CCinit
+/// @see CCcontract_info
+CTxOut MakeTokensCC1vout(uint8_t evalcode, CAmount nValue, CPubKey pk);
+
+/// Another MakeTokensCC1vout overloaded function that creates a token transaction output with a cryptocondition with two eval codes that allows to spend it by one key. 
+/// Resulting vout will have three eval codes (EVAL_TOKENS, evalcode and evalcode2 parameter values).
+/// The returned output should be added to a transaction vout array.
+/// @param evalcode cryptocondition eval code (transactions with this eval code in cc inputs will be forwarded to the contract associated with this eval code)
+/// @param evalcode2 yet another cryptocondition eval code (transactions with this eval code in cc inputs will be forwarded to the contract associated with this eval code)
+/// @param nValue value of the output in satoshi
+/// @param pk pubkey to spend the cc
+/// @returns vout object
+/// @see CCinit
+/// @see CCcontract_info
+CTxOut MakeTokensCC1vout(uint8_t evalcode, uint8_t evalcode2, CAmount nValue, CPubKey pk);
+
+/// MakeTokensCC1of2vout creates a token transaction output with a 1of2 cryptocondition that allows to spend it by either of two keys. 
+/// The resulting vout will have two eval codes (EVAL_TOKENS and evalcode parameter value).
+/// The returned output should be added to a transaction vout array.
+/// @param evalcode cryptocondition eval code (transactions with this eval code in cc inputs will be forwarded to the contract associated with this eval code)
+/// @param nValue value of the output in satoshi
+/// @param pk1 one of two pubkeys to spend the cc
+/// @param pk2 second of two pubkeys to spend the cc
+/// @returns vout object
+/// @see CCinit
+/// @see CCcontract_info
+CTxOut MakeTokensCC1of2vout(uint8_t evalcode, CAmount nValue, CPubKey pk1, CPubKey pk2);
+
+/// Another overload of MakeTokensCC1of2vout creates a token transaction output with a 1of2 cryptocondition with two eval codes that allows to spend it by either of two keys. 
+/// The resulting vout will have three eval codes (EVAL_TOKENS, evalcode and evalcode2 parameter values).
+/// The returned output should be added to a transaction vout array.
+/// @param evalcode cryptocondition eval code (transactions with this eval code in cc inputs will be forwarded to the contract associated with this eval code)
+/// @param evalcode2 yet another cryptocondition eval code (transactions with this eval code in cc inputs will be forwarded to the contract associated with this eval code)
+/// @param nValue value of the output in satoshi
+/// @param pk1 one of two pubkeys to spend the cc
+/// @param pk2 second of two pubkeys to spend the cc
+/// @returns vout object
+/// @see CCinit
+/// @see CCcontract_info
+CTxOut MakeTokensCC1of2vout(uint8_t evalcode, uint8_t evalcode2, CAmount nValue, CPubKey pk1, CPubKey pk2);
+
+/// Gets adddress for token cryptocondition vout
+/// @param cp CCcontract_info structure initialized with EVAL_TOKENS eval code
+/// @param[out] destaddr retrieved address
+/// @param pk public key to create the cryptocondition
 bool GetTokensCCaddress(struct CCcontract_info *cp, char *destaddr, CPubKey pk);
+
+/// Gets adddress for token 1of2 cc vout
+/// @param cp CCcontract_info structure initialized with EVAL_TOKENS eval code
+/// @param[out] destaddr retrieved address
+/// @param pk first public key to create the cryptocondition
+/// @param pk2 second public key to create the cryptocondition
 bool GetTokensCCaddress1of2(struct CCcontract_info *cp, char *destaddr, CPubKey pk, CPubKey pk2);
-void CCaddrTokens1of2set(struct CCcontract_info *cp, CPubKey pk1, CPubKey pk2, char *coinaddr);
+
+/// CCaddrTokens1of2set sets pubkeys, private key and cc addr for spending from 1of2 token cryptocondition vout
+/// @param cp contract info structure where the private key is set
+/// @param pk1 one of the two public keys of the 1of2 cc
+/// @param pk2 second of the two public keys of the 1of2 cc
+/// @param priv private key for one of the two pubkeys
+/// @param coinaddr the cc address obtained for this 1of2 token cc with GetTokensCCaddress1of2
+/// @see GetTokensCCaddress
+/// @see CCcontract_info
+void CCaddrTokens1of2set(struct CCcontract_info *cp, CPubKey pk1, CPubKey pk2, uint8_t *priv, char *coinaddr);
+
+/// @private
 int32_t CClib_initcp(struct CCcontract_info *cp,uint8_t evalcode);
 
+/// IsCCInput checks if scriptSig object contains a cryptocondition 
+/// @param scriptSig scriptSig object with a cryptocondition
+/// @returns true if the scriptSig object contains a cryptocondition
 bool IsCCInput(CScript const& scriptSig);
+
+/// CheckTxFee checks if queried transaction fee value is not less than the actual transaction fee of a real transaction
+/// @param tx transaction object which actual txfee to check
+/// @param txfee transaction fee to check
+/// @param height the height of the block where the transaction resides
+/// @param blocktime not used (block time of the block where the transaction resides)
+/// @param[out] actualtxfee the returned actual transaction fee
+/// @returns true if txfee >= actual transaction fee
 bool CheckTxFee(const CTransaction &tx, uint64_t txfee, uint32_t height, uint64_t blocktime,int64_t &actualtxfee);
+
+/// \cond INTERNAL
 int32_t unstringbits(char *buf,uint64_t bits);
 uint64_t stringbits(char *str);
 uint256 revuint256(uint256 txid);
-bool pubkey2addr(char *destaddr,uint8_t *pubkey33);
 char *uint256_str(char *dest,uint256 txid);
 char *pubkey33_str(char *dest,uint8_t *pubkey33);
-uint256 Parseuint256(const char *hexstr);
-CPubKey pubkey2pk(std::vector<uint8_t> pubkey);
+//uint256 Parseuint256(const char *hexstr); // located in komodo_defs
+/// \endcond
+
+/// converts public key as array of uint8_t to normal address
+/// @param[out] destaddr char array with the returned normal address, should have 64 chars 
+/// @param pubkey33 public key as array of uint8_t
+/// @returns true if the normal address is obtained successfully
+bool pubkey2addr(char *destaddr, uint8_t *pubkey33);
+
+/// converts public key as vector of uint8_t to CPubKey object
+/// @param vpubkey public key as vector of uint8_t
+/// @returns created CPubKey object
+CPubKey pubkey2pk(std::vector<uint8_t> vpubkey);
+
+/// CCfullsupply returns token initial supply
+/// @param tokenid id of token (id of token creation tx)
 int64_t CCfullsupply(uint256 tokenid);
+
+/// CCtoken_balance returns token balance for an address
+/// @param destaddr address to search the balance on
+/// @param tokenid id of the token
 int64_t CCtoken_balance(char *destaddr,uint256 tokenid);
+
+/// @private
 int64_t CCtoken_balance2(char *destaddr,uint256 tokenid);
+
+/// _GetCCaddress retrieves the address for the scriptPubKey for the cryptocondition that is made for eval code and public key
+/// @param[out] destaddr the address for the cc scriptPubKey. Should have at least 64 char buffer space
+/// @param evalcode eval code for which cryptocondition will be made
+/// @param pk pubkey for which cryptocondition will be made
 bool _GetCCaddress(char *destaddr,uint8_t evalcode,CPubKey pk);
+
+/// GetCCaddress retrieves the address for the scriptPubKey for the cryptocondition that is made for eval code and public key.
+/// The evalcode is taken from the cp object
+/// @param cp object of CCcontract_info type
+/// @param[out] destaddr the address for the cc scriptPubKey. Should have at least 64 char buffer space
+/// @param pk pubkey for which cryptocondition will be made
+/// @see CCcontract_info
 bool GetCCaddress(struct CCcontract_info *cp,char *destaddr,CPubKey pk);
+
+/// GetCCaddress1of2 retrieves the address for the scriptPubKey for the 1of2 cryptocondition that is made for eval code and two public keys.
+/// The evalcode is taken from the cp object
+/// @param cp object of CCcontract_info type
+/// @param[out] destaddr the address for the cc scriptPubKey. Should have at least 64 char buffer space
+/// @param pk first pubkey 1of2 cryptocondition 
+/// @param pk2 second pubkey of 1of2 cryptocondition 
+/// @see CCcontract_info
 bool GetCCaddress1of2(struct CCcontract_info *cp,char *destaddr,CPubKey pk,CPubKey pk2);
+
+/// @private
 bool ConstrainVout(CTxOut vout,int32_t CCflag,char *cmpaddr,int64_t nValue);
+
+/// @private
 bool PreventCC(Eval* eval,const CTransaction &tx,int32_t preventCCvins,int32_t numvins,int32_t preventCCvouts,int32_t numvouts);
+
+/// Returns bitcoin address for the scriptPubKey parameter
+/// @param[out] destaddr the returned address of the scriptPubKey, the buffer should have size of at least 64 chars
+/// @param scriptPubKey scriptPubKey object
+/// @returns true if success
 bool Getscriptaddress(char *destaddr,const CScript &scriptPubKey);
+
+/// Returns custom bitcoin address for the scriptPubKey parameter
+/// @param[out] destaddr the returned address of the scriptPubKey, the buffer should have size of at least 64 chars
+/// @param scriptPubKey scriptPubKey object
+/// @param taddr custom address prefix
+/// @param prefix custom pubkey prefix
+/// @param prefix2 custom script prefix
+/// @returns true if success
 bool GetCustomscriptaddress(char *destaddr,const CScript &scriptPubKey,uint8_t taddr,uint8_t prefix,uint8_t prefix2);
+
+/// Returns my pubkey, that is set by -pubkey komodod parameter
+/// @returns public key as byte array
 std::vector<uint8_t> Mypubkey();
+
+/// Returns my private key, that is private key for the my pubkey
+/// @returns private key as byte array
+/// @see Mypubkey
 bool Myprivkey(uint8_t myprivkey[]);
+
+/// Returns duration in seconds and number of blocks since the block where a transaction resides till the chain tip
+/// @param[out] numblocks number of blocks from the block where the transaction with txid resides
+/// @param txid id of the transaction that is queried of
+/// @return duration in seconds since the block where the transaction with txid resides
 int64_t CCduration(int32_t &numblocks,uint256 txid);
+
+/// @private
 uint256 CCOraclesReverseScan(char const *logcategory,uint256 &txid,int32_t height,uint256 reforacletxid,uint256 batontxid);
+
+/// @private
 int32_t CCCointxidExists(char const *logcategory,uint256 cointxid);
+
+/// @private
 uint256 BitcoinGetProofMerkleRoot(const std::vector<uint8_t> &proofData, std::vector<uint256> &txids);
-bool komodo_txnotarizedconfirmed(uint256 txid);
+
+// bool komodo_txnotarizedconfirmed(uint256 txid); //moved to komodo_defs.h
+
+/// @private
 CPubKey check_signing_pubkey(CScript scriptSig);
-// CCtx
+
+/// SignTx signs a transaction in normal vin scriptSig
+/// @param mtx transaction object of CMutableTransaction type
+/// @param vini order number of transaction input to sign (starting from 0)
+/// @param utxovalue amount of utxo spent by the input to sign (this amount will be added to the signature hash)
+/// @param scriptPubKey scriptPubKey of the utxo spent by the input to sign
 bool SignTx(CMutableTransaction &mtx,int32_t vini,int64_t utxovalue,const CScript scriptPubKey);
-extern std::vector<CPubKey> NULL_pubkeys;
+
+extern std::vector<CPubKey> NULL_pubkeys; //!< constant value for use in functions where such value might be passed @see FinalizeCCTx
+
+/// overload old-style FinalizeCCTx for compatibility
+/// @param skipmask parameter is not used
+/// @param cp contract info structure with cc eval code, module's global address and privkey. It also could have a vector of probe cryptoconditions created by CCAddVintxCond
+/// @param mtx prepared transaction to sign
+/// @param mypk my pubkey to sign
+/// @param txfee transaction fee
+/// @param opret opreturn vout which function will add if it is not empty 
+/// @param pubkeys array of pubkeys to make multiple probe 1of2 cc's with the call Make1of2cond(cp->evalcode, globalpk, pubkeys[i])
+/// @returns signed transaction in hex encoding
 std::string FinalizeCCTx(uint64_t skipmask,struct CCcontract_info *cp,CMutableTransaction &mtx,CPubKey mypk,uint64_t txfee,CScript opret,std::vector<CPubKey> pubkeys = NULL_pubkeys);
+
+/// FinalizeCCTx is a very useful function that will properly sign both CC and normal inputs, adds normal change and might add an opreturn output.
+/// This allows for Antara module transaction creation rpc functions to create an CMutableTransaction object, add the appropriate vins and vouts to it and use FinalizeCCTx to properly sign the transaction.
+/// By using -addressindex=1 of komodod daemon, it allows tracking of all the CC addresses.
+///
+/// For signing the vins the function builds several default probe scriptPubKeys and checks them against the referred previous transactions (vintx) vouts.
+/// For cryptocondition vins the function creates a basic set of probe cryptconditions with mypk and module global pubkey, both for coins and tokens cases.
+/// For signing 1of2 cryptocondition it is needed to use CCaddr1of2set function to set both pubkeys in cp object before calling FinalizeCCtx.
+/// For a set of 1of2 cc with pairs of module globalpk and some other pk, spending with global pk, pass a vector with pubkeys as 'pubkeys' parameter.
+/// For any other cc case use CCAddVintxCond function to add any possible probe cryptoconditions to the cp opbject.
+/// @param remote true if the caller is in remote nspv mode
+/// @param skipmask parameter is not used
+/// @param cp contract info structure with cc eval code, module's global address and privkey. It also could have a vector of probe cryptoconditions created by CCAddVintxCond
+/// @param mtx prepared transaction to sign
+/// @param mypk my pubkey to sign
+/// @param txfee transaction fee
+/// @param opret opreturn vout which function will add if it is not empty 
+/// @param pubkeys array of pubkeys to make multiple probe 1of2 cc's with the call Make1of2cond(cp->evalcode, globalpk, pubkeys[i])
+/// @returns signed transaction in hex encoding
+UniValue FinalizeCCTxExt(bool remote, uint64_t skipmask, struct CCcontract_info *cp, CMutableTransaction &mtx, CPubKey mypk, uint64_t txfee, CScript opret, std::vector<CPubKey> pubkeys = NULL_pubkeys);
+
+/// SetCCunspents returns a vector of unspent outputs on an address 
+/// @param[out] unspentOutputs vector of pairs of address key and amount
+/// @param coinaddr address where unspent outputs are searched
+/// @param CCflag if true the function searches for cc outputs, otherwise for normal outputs
 void SetCCunspents(std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > &unspentOutputs,char *coinaddr,bool CCflag = true);
+
+/// SetCCtxids returns a vector of all outputs on an address
+/// @param[out] addressIndex vector of pairs of address index key and amount
+/// @param coinaddr address where the unspent outputs are searched
+/// @param CCflag if true the function searches for cc outputs, otherwise for normal outputs
 void SetCCtxids(std::vector<std::pair<CAddressIndexKey, CAmount> > &addressIndex,char *coinaddr,bool CCflag = true);
-int64_t AddNormalinputs(CMutableTransaction &mtx,CPubKey mypk,int64_t total,int32_t maxinputs);
+
+/// overloaded SetCCtxids returns a vector of filtered txids which have outputs on an address
+/// @param[out] txids returned vector of txids
+/// @param coinaddr address where the unspent outputs are searched
+/// @param ccflag if true the function searches for cc outputs, otherwise for normal outputs
+/// @param evalcode evalcode of cc module for which outputs will be filtered
+/// @param filtertxid txid for which outputs will be filtered
+/// @param func funcid for which outputs will be filtered
+void SetCCtxids(std::vector<uint256> &txids,char *coinaddr,bool ccflag, uint8_t evalcode, uint256 filtertxid, uint8_t func);
+
+/// In NSPV mode adds normal (not cc) inputs to the transaction object vin array for the specified total amount using available utxos on mypk's TX_PUBKEY address
+/// @param mtx mutable transaction object
+/// @param mypk pubkey to make TX_PUBKEY address from
+/// @param total amount of inputs to add. If total equals to 0 the function does not add inputs but returns amount of all available normal inputs in the wallet
+/// @param maxinputs maximum number of inputs to add
+/// @param[out] ptr pointer to NSPV_CCmtxinfo structure with the info about the added utxo
+/// @returns amount of added normal inputs or amount of all normal inputs in the wallet
+int64_t NSPV_AddNormalinputs(CMutableTransaction &mtx,CPubKey mypk,int64_t total,int32_t maxinputs,struct NSPV_CCmtxinfo *ptr);
+
+/// AddNormalinputs wrapper for calling either AddNormalinputsLocal or AddNormalinputsRemote 
+/// @param mtx mutable transaction object
+/// @param mypk not used
+/// @param total amount of inputs to add. If total equals to 0 the function does not add inputs but returns amount of all available normal inputs in the wallet
+/// @param maxinputs maximum number of inputs to add
+/// @param remote true if running in remote nspv mode (default false)
+/// @returns amount of added normal inputs or amount of all normal inputs in the wallet
+/// @see AddNormalinputsLocal
+/// @see AddNormalinputsRemote
+int64_t AddNormalinputs(CMutableTransaction &mtx,CPubKey mypk,int64_t total,int32_t maxinputs, bool remote=false);
+
+/// Local version for cc runnnig on the same node, adds normal (not cc) inputs to the transaction object vin array for the specified total amount using available utxos in the wallet, to fund the transaction
+/// @param mtx mutable transaction object
+/// @param mypk not used
+/// @param total amount of inputs to add. If total equals to 0 the function does not add inputs but returns amount of all available normal inputs in the wallet
+/// @param maxinputs maximum number of inputs to add
+/// @returns amount of added normal inputs or amount of all normal inputs in the wallet
+int64_t AddNormalinputsLocal(CMutableTransaction &mtx,CPubKey mypk,int64_t total,int32_t maxinputs);
+
+/// AddNormalinputs2 adds normal (not cc) inputs to the transaction object vin array for the specified total amount using utxos on my pubkey's TX_PUBKEY address (my pubkey is set by -pubkey command line parameter), to fund the transaction.
+/// 'My pubkey' is the -pubkey parameter of komodod.
+/// @param mtx mutable transaction object
+/// @param total amount of inputs to add. If total equals to 0 the function does not add inputs but returns amount of all available normal inputs in the wallet
+/// @param maxinputs maximum number of inputs to add
+/// @returns amount of added normal inputs or amount of all normal inputs on my pubkey's address
 int64_t AddNormalinputs2(CMutableTransaction &mtx,int64_t total,int32_t maxinputs);
+
+/// Remote version, does not use local wallet, adds normal (not cc) inputs to the transaction object vin array for the specified total amount using available utxos on mypk, to fund the transaction
+/// @param mtx mutable transaction object
+/// @param mypk pubkey on which utxo's are searched
+/// @param total amount of inputs to add. If total equals to 0 the function does not add inputs but returns amount of all available normal inputs in the wallet
+/// @param maxinputs maximum number of inputs to add
+/// @returns amount of added normal inputs or amount of all normal inputs in the wallet
+int64_t AddNormalinputsRemote(CMutableTransaction &mtx, CPubKey mypk, int64_t total, int32_t maxinputs);
+
+/// CCutxovalue returns amount of an utxo. The function does this without loading the utxo transaction, by using address index only
+/// @param coinaddr address where the utxo is searched
+/// @param utxotxid transaction id of the utxo
+/// @param utxovout the utxo transaction vout order number (starting form 0)
+/// @param CCflag if true the function searches for cc output, otherwise for normal output
+/// @returns utxo value or 0 if utxo not found
 int64_t CCutxovalue(char *coinaddr,uint256 utxotxid,int32_t utxovout,int32_t CCflag);
 
+/// @private
+int32_t CC_vinselect(int32_t *aboveip, int64_t *abovep, int32_t *belowip, int64_t *belowp, struct CC_utxo utxos[], int32_t numunspents, int64_t value);
+
+/// @private
+bool NSPV_SignTx(CMutableTransaction &mtx,int32_t vini,int64_t utxovalue,const CScript scriptPubKey,uint32_t nTime);
+
+/*! \cond INTERNAL */
 // curve25519 and sha256
 bits256 curve25519_shared(bits256 privkey,bits256 otherpub);
 bits256 curve25519_basepoint9();
 bits256 curve25519(bits256 mysecret,bits256 basepoint);
 void vcalc_sha256(char deprecated[(256 >> 3) * 2 + 1],uint8_t hash[256 >> 3],uint8_t *src,int32_t len);
 bits256 bits256_doublesha256(char *deprecated,uint8_t *data,int32_t datalen);
-UniValue ValueFromAmount(const CAmount& amount);
+// UniValue ValueFromAmount(const CAmount& amount);  // defined in server.h
+/*! \endcond */
 
+/*! \cond INTERNAL */
 int64_t TotalPubkeyNormalInputs(const CTransaction &tx, const CPubKey &pubkey);
 int64_t TotalPubkeyCCInputs(const CTransaction &tx, const CPubKey &pubkey);
 inline std::string STR_TOLOWER(const std::string &str) { std::string out; for (std::string::const_iterator i = str.begin(); i != str.end(); i++) out += std::tolower(*i); return out; }
+/*! \endcond */
+
+#define JSON_HEXTX "hex"
+#define JSON_SIGDATA "SigData"
 
+/// @private add sig data for signing partially signed tx to UniValue object
+void AddSigData2UniValue(UniValue &result, int32_t vini, UniValue& ccjson, std::string sscriptpubkey, int64_t amount);
+
+
+#ifndef LOGSTREAM_DEFINED
+#define LOGSTREAM_DEFINED 
 // bitcoin LogPrintStr with category "-debug" cmdarg support for C++ ostringstream:
-#define CCLOG_INFO   0
-#define CCLOG_DEBUG1 1
-#define CCLOG_DEBUG2 2
-#define CCLOG_DEBUG3 3
-#define CCLOG_MAXLEVEL 3
+
+// log levels:
+#define CCLOG_ERROR  (-1)   //!< error level
+#define CCLOG_INFO   0      //!< info level
+#define CCLOG_DEBUG1 1      //!< debug level 1
+#define CCLOG_DEBUG2 2      //!< debug level 2
+#define CCLOG_DEBUG3 3      //!< debug level 3
+#define CCLOG_MAXLEVEL 3    
+
+/// @private
+extern void CCLogPrintStr(const char *category, int level, const std::string &str);
+
+/// @private
 template <class T>
-void CCLogPrintStream(const char *category, int level, T print_to_stream)
+void CCLogPrintStream(const char *category, int level, const char *functionName, T print_to_stream)
 {
     std::ostringstream stream;
     print_to_stream(stream);
-    if (level < 0)
-        level = 0;
-    if (level > CCLOG_MAXLEVEL)
-        level = CCLOG_MAXLEVEL;
-    for (int i = level; i <= CCLOG_MAXLEVEL; i++)
-        if( LogAcceptCategory((std::string(category) + std::string("-") + std::to_string(i)).c_str())  ||     // '-debug=cctokens-0', '-debug=cctokens-1',...
-            i == 0 && LogAcceptCategory(std::string(category).c_str()) )  {                                  // also supporting '-debug=cctokens' for CCLOG_INFO
-            LogPrintStr(stream.str());
-            break;
-        }
+    if (functionName != NULL)
+        stream << functionName << " ";
+    CCLogPrintStr(category, level, stream.str()); 
 }
-// use: LOGSTREAM("yourcategory", your-debug-level, stream << "some log data" << data2 << data3 << ... << std::endl);
-#define LOGSTREAM(category, level, logoperator) CCLogPrintStream( category, level, [=](std::ostringstream &stream) {logoperator;} )
+/// Macro for logging messages using bitcoin LogAcceptCategory and LogPrintStr functions.
+/// Supports error, info and three levels of debug messages.
+/// Logging category is set by -debug=category komodod param.
+/// To set debug level pass -debug=category-1, -debug=category-2 or -debug=category-3 param. If some level is enabled lower level messages also will be printed.
+/// To print info-level messages pass just -debug=category parameter, with no level.
+/// Error-level messages will always be printed, even if -debug parameter is not set
+/// @param category category of message, for example Antara module name
+/// @param level debug-level, use defines CCLOG_ERROR, CCLOG_INFO, CCLOG_DEBUGN
+/// @param logoperator to form the log message (the 'stream' name is mandatory)
+/// usage: LOGSTREAM("category", debug-level, stream << "some log data" << data2 << data3 << ... << std::endl);
+/// example: LOGSTREAM("heir", CCLOG_INFO, stream << "heir public key is " << HexStr(heirPk) << std::endl);
+#define LOGSTREAM(category, level, logoperator) CCLogPrintStream( category, level, NULL, [=](std::ostringstream &stream) {logoperator;} )
+
+/// LOGSTREAMFN is a version of LOGSTREAM macro which adds calling function name with the standard define \_\_func\_\_ at the beginning of the printed string. 
+/// LOGSTREAMFN parameters are the same as in LOGSTREAM
+/// @see LOGSTREAM
+#define LOGSTREAMFN(category, level, logoperator) CCLogPrintStream( category, level, __func__, [=](std::ostringstream &stream) {logoperator;} )
+
+/// @private
+template <class T>
+UniValue report_ccerror(const char *category, int level, T print_to_stream)
+{
+    UniValue err(UniValue::VOBJ);
+    std::ostringstream stream;
 
+    print_to_stream(stream);
+    err.push_back(Pair("result", "error"));
+    err.push_back(Pair("error", stream.str()));
+    stream << std::endl;
+    CCLogPrintStr(category, level, stream.str());
+    return err;
+}
 
+/// @private
+#define CCERR_RESULT(category,level,logoperator) return report_ccerror(category, level, [=](std::ostringstream &stream) {logoperator;})
+#endif // #ifndef LOGSTREAM_DEFINED
 #endif
diff --git a/src/cc/CCrewards.h b/src/cc/CCrewards.h
index 4d6cc80f..d9f9edf6 100644
--- a/src/cc/CCrewards.h
+++ b/src/cc/CCrewards.h
@@ -18,6 +18,7 @@
 #define CC_REWARDS_H
 
 #include "CCinclude.h"
+#include <gmp.h>
 
 #define EVAL_REWARDS 0xe5
 #define REWARDSCC_MAXAPR (COIN * 25)
diff --git a/src/cc/CCtokens.cpp b/src/cc/CCtokens.cpp
index d6a5038c..19a5f786 100644
--- a/src/cc/CCtokens.cpp
+++ b/src/cc/CCtokens.cpp
@@ -397,6 +397,21 @@ int64_t IsTokensvout(bool goDeeper, bool checkPubkeys /*<--not used, always true
 					}
 				}
 
+                //special check for tx when spending from 1of2 CC address and one of pubkeys is global CC pubkey
+                struct CCcontract_info *cpEvalCode1,CEvalCode1;
+                cpEvalCode1 = CCinit(&CEvalCode1,evalCode1);
+                CPubKey pk=GetUnspendable(cpEvalCode1,0);
+                testVouts.push_back( std::make_pair(MakeTokensCC1of2vout(evalCode1, tx.vout[v].nValue, voutPubkeys[0], pk), std::string("dual-eval1 pegscc cc1of2 pk[0] globalccpk")) ); 
+                if (voutPubkeys.size() == 2) testVouts.push_back( std::make_pair(MakeTokensCC1of2vout(evalCode1, tx.vout[v].nValue, voutPubkeys[1], pk), std::string("dual-eval1 pegscc cc1of2 pk[1] globalccpk")) );
+                if (evalCode2!=0)
+                {
+                    struct CCcontract_info *cpEvalCode2,CEvalCode2;
+                    cpEvalCode2 = CCinit(&CEvalCode2,evalCode2);
+                    CPubKey pk=GetUnspendable(cpEvalCode2,0);
+                    testVouts.push_back( std::make_pair(MakeTokensCC1of2vout(evalCode2, tx.vout[v].nValue, voutPubkeys[0], pk), std::string("dual-eval2 pegscc cc1of2 pk[0] globalccpk")) ); 
+                    if (voutPubkeys.size() == 2) testVouts.push_back( std::make_pair(MakeTokensCC1of2vout(evalCode2, tx.vout[v].nValue, voutPubkeys[1], pk), std::string("dual-eval2 pegscc cc1of2 pk[1] globalccpk")) );
+                }
+
 				// maybe it is single-eval or dual/three-eval token change?
 				std::vector<CPubKey> vinPubkeys, vinPubkeysUnfiltered;
 				ExtractTokensCCVinPubkeys(tx, vinPubkeysUnfiltered);
@@ -639,7 +654,7 @@ int64_t AddTokenCCInputs(struct CCcontract_info *cp, CMutableTransaction &mtx, C
 		if (ivin != mtx.vin.size()) // that is, the tx.vout is already added to mtx.vin (in some previous calls)
 			continue;
 
-		if (GetTransaction(vintxid, vintx, hashBlock, false) != 0)
+		if (myGetTransaction(vintxid, vintx, hashBlock) != 0)
 		{
 			Getscriptaddress(destaddr, vintx.vout[vout].scriptPubKey);
 			if (strcmp(destaddr, tokenaddr) != 0 && 
@@ -809,7 +824,7 @@ std::string CreateToken(int64_t txfee, int64_t tokensupply, std::string name, st
 		txfee = 10000;
 	mypk = pubkey2pk(Mypubkey());
 
-	if (AddNormalinputs(mtx, mypk, tokensupply + 2 * txfee, 64) > 0)
+	if (AddNormalinputs2(mtx, tokensupply + 2 * txfee, 64) > 0)  // add normal inputs only from mypk
 	{
 
         int64_t mypkInputs = TotalPubkeyNormalInputs(mtx, mypk);  
@@ -855,7 +870,12 @@ std::string TokenTransfer(int64_t txfee, uint256 tokenid, vscript_t destpubkey,
 	if (txfee == 0)
 		txfee = 10000;
 	mypk = pubkey2pk(Mypubkey());
-	if (AddNormalinputs(mtx, mypk, txfee, 3) > 0)
+    /*if ( cp->tokens1of2addr[0] == 0 )
+    {
+        GetTokensCCaddress(cp, cp->tokens1of2addr, mypk);
+        fprintf(stderr,"set tokens1of2addr <- %s\n",cp->tokens1of2addr);
+    }*/
+    if (AddNormalinputs(mtx, mypk, txfee, 3) > 0)
 	{
 		mask = ~((1LL << mtx.vin.size()) - 1);  // seems, mask is not used anymore
         
@@ -905,7 +925,7 @@ int64_t GetTokenBalance(CPubKey pk, uint256 tokenid)
 	// CCerror = strprintf("obsolete, cannot return correct value without eval");
 	// return 0;
 
-	if (GetTransaction(tokenid, tokentx, hashBlock, false) == 0)
+	if (myGetTransaction(tokenid, tokentx, hashBlock) == 0)
 	{
         LOGSTREAM((char *)"cctokens", CCLOG_INFO, stream << "cant find tokenid" << std::endl);
 		CCerror = strprintf("cant find tokenid");
@@ -930,14 +950,14 @@ UniValue TokenInfo(uint256 tokenid)
 
     cpTokens = CCinit(&tokensCCinfo, EVAL_TOKENS);
 
-	if( !GetTransaction(tokenid, tokenbaseTx, hashBlock, false) )
+	if( !myGetTransaction(tokenid, tokenbaseTx, hashBlock) )
 	{
 		LogPrintf( "TokenInfo() cant find tokenid\n");
 		result.push_back(Pair("result", "error"));
 		result.push_back(Pair("error", "cant find tokenid"));
 		return(result);
 	}
-    if (hashBlock.IsNull()) {
+    if ( KOMODO_NSPV_FULLNODE && hashBlock.IsNull()) {
         result.push_back(Pair("result", "error"));
         result.push_back(Pair("error", "the transaction is still in mempool"));
         return(result);
@@ -1006,7 +1026,7 @@ UniValue TokenInfo(uint256 tokenid)
 UniValue TokenList()
 {
 	UniValue result(UniValue::VARR);
-	std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex;
+	std::vector<uint256> txids;
     std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > addressIndexCCMarker;
 
 	struct CCcontract_info *cp, C; uint256 txid, hashBlock;
@@ -1016,16 +1036,16 @@ UniValue TokenList()
 	cp = CCinit(&C, EVAL_TOKENS);
 
     auto addTokenId = [&](uint256 txid) {
-        if (GetTransaction(txid, vintx, hashBlock, false) != 0) {
+        if (myGetTransaction(txid, vintx, hashBlock) != 0) {
             if (vintx.vout.size() > 0 && DecodeTokenCreateOpRet(vintx.vout[vintx.vout.size() - 1].scriptPubKey, origpubkey, name, description) != 0) {
                 result.push_back(txid.GetHex());
             }
         }
     };
 
-	SetCCtxids(addressIndex, cp->normaladdr,false);                      // find by old normal addr marker
-   	for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it = addressIndex.begin(); it != addressIndex.end(); it++) 	{
-        addTokenId(it->first.txhash);
+	SetCCtxids(txids, cp->normaladdr,false,cp->evalcode,zeroid,'c');                      // find by old normal addr marker
+   	for (std::vector<uint256>::const_iterator it = txids.begin(); it != txids.end(); it++) 	{
+        addTokenId(*it);
 	}
 
     SetCCunspents(addressIndexCCMarker, cp->unspendableCCaddr,true);    // find by burnable validated cc addr marker
diff --git a/src/cc/CCtx.cpp b/src/cc/CCtx.cpp
index 0255e39f..034c523d 100644
--- a/src/cc/CCtx.cpp
+++ b/src/cc/CCtx.cpp
@@ -17,15 +17,9 @@
 #include "key_io.h"
 
 std::vector<CPubKey> NULL_pubkeys;
+struct NSPV_CCmtxinfo NSPV_U;
 
-/*
- FinalizeCCTx is a very useful function that will properly sign both CC and normal inputs, adds normal change and the opreturn.
-
- This allows the contract transaction functions to create the appropriate vins and vouts and have FinalizeCCTx create a properly signed transaction.
-
- By using -addressindex=1, it allows tracking of all the CC addresses
- */
-
+/* see description to function definition in CCinclude.h */
 bool SignTx(CMutableTransaction &mtx,int32_t vini,int64_t utxovalue,const CScript scriptPubKey)
 {
 #ifdef ENABLE_WALLET
@@ -40,17 +34,35 @@ bool SignTx(CMutableTransaction &mtx,int32_t vini,int64_t utxovalue,const CScrip
     return(false);
 }
 
-std::string FinalizeCCTx(uint64_t CCmask,struct CCcontract_info *cp,CMutableTransaction &mtx,CPubKey mypk,uint64_t txfee,CScript opret,std::vector<CPubKey> pubkeys)
+/*
+FinalizeCCTx is a very useful function that will properly sign both CC and normal inputs, adds normal change and the opreturn.
+
+This allows the contract transaction functions to create the appropriate vins and vouts and have FinalizeCCTx create a properly signed transaction.
+
+By using -addressindex=1, it allows tracking of all the CC addresses
+*/
+std::string FinalizeCCTx(uint64_t CCmask, struct CCcontract_info *cp, CMutableTransaction &mtx, CPubKey mypk, uint64_t txfee, CScript opret, std::vector<CPubKey> pubkeys)
+{
+    UniValue sigData = FinalizeCCTxExt(false, CCmask, cp, mtx, mypk, txfee, opret, pubkeys);
+    return sigData[JSON_HEXTX].getValStr();
+}
+
+
+// extended version that supports signInfo object with conds to vins map for remote cc calls
+UniValue FinalizeCCTxExt(bool remote, uint64_t CCmask, struct CCcontract_info *cp, CMutableTransaction &mtx, CPubKey mypk, uint64_t txfee, CScript opret, std::vector<CPubKey> pubkeys)
 {
     auto consensusBranchId = CurrentEpochBranchId(chainActive.Height() + 1, Params().GetConsensus());
     CTransaction vintx; std::string hex; CPubKey globalpk; uint256 hashBlock; uint64_t mask=0,nmask=0,vinimask=0;
     int64_t utxovalues[CC_MAXVINS],change,normalinputs=0,totaloutputs=0,normaloutputs=0,totalinputs=0,normalvins=0,ccvins=0; 
-    int32_t i,flag,utxovout,n,err = 0;
+    int32_t i,flag,mgret,utxovout,n,err = 0;
 	char myaddr[64], destaddr[64], unspendable[64], mytokensaddr[64], mysingletokensaddr[64], unspendabletokensaddr[64],CC1of2CCaddr[64];
-    uint8_t *privkey, myprivkey[32], unspendablepriv[32], /*tokensunspendablepriv[32],*/ *msg32 = 0;
+    uint8_t *privkey = NULL, myprivkey[32] = { '\0' }, unspendablepriv[32] = { '\0' }, /*tokensunspendablepriv[32],*/ *msg32 = 0;
 	CC *mycond=0, *othercond=0, *othercond2=0,*othercond4=0, *othercond3=0, *othercond1of2=NULL, *othercond1of2tokens = NULL, *cond=0,  *condCC2=0,*mytokenscond = NULL, *mysingletokenscond = NULL, *othertokenscond = NULL;
 	CPubKey unspendablepk /*, tokensunspendablepk*/;
 	struct CCcontract_info *cpTokens, tokensC;
+    UniValue sigData(UniValue::VARR),result(UniValue::VOBJ);
+    const UniValue sigDataNull = NullUniValue;
+
     globalpk = GetUnspendable(cp,0);
     n = mtx.vout.size();
     for (i=0; i<n; i++)
@@ -62,9 +74,18 @@ std::string FinalizeCCTx(uint64_t CCmask,struct CCcontract_info *cp,CMutableTran
     if ( (n= mtx.vin.size()) > CC_MAXVINS )
     {
         LogPrintf("FinalizeCCTx: %d is too many vins\n",n);
-        return("0");
+        result.push_back(Pair(JSON_HEXTX, "0"));
+        return result;
     }
-    Myprivkey(myprivkey);
+
+    //Myprivkey(myprivkey);  // for NSPV mode we need to add myprivkey for the explicitly defined mypk param
+#ifdef ENABLE_WALLET
+    // get privkey for mypk
+    CKeyID keyID = mypk.GetID();
+    CKey vchSecret;
+    if (pwalletMain->GetKey(keyID, vchSecret))
+        memcpy(myprivkey, vchSecret.begin(), sizeof(myprivkey));
+#endif
 
     GetCCaddress(cp,myaddr,mypk);
     mycond = MakeCCcond1(cp->evalcode,mypk);
@@ -96,12 +117,20 @@ std::string FinalizeCCTx(uint64_t CCmask,struct CCcontract_info *cp,CMutableTran
     //This is a must to avoid hardfork change of validation in every CC, because there could be maximum one normal vin at the begining with current validation.
     for (i=0; i<n; i++)
     {
-        if ( GetTransaction(mtx.vin[i].prevout.hash,vintx,hashBlock,false) != 0 )
+        if (i==0 && mtx.vin[i].prevout.n==10e8)
+            continue;
+        if ( myGetTransaction(mtx.vin[i].prevout.hash,vintx,hashBlock) != 0 && mtx.vin[i].prevout.n < vintx.vout.size() )
         {
             if ( vintx.vout[mtx.vin[i].prevout.n].scriptPubKey.IsPayToCryptoCondition() == 0 && ccvins==0)
                 normalvins++;            
             else ccvins++;
-        }            
+        }
+        else
+        {
+            LogPrintf("vin.%d vout.%d is bigger than vintx.%d\n",i,mtx.vin[i].prevout.n,(int32_t)vintx.vout.size());
+            memset(myprivkey,0,32);
+            return UniValue(UniValue::VOBJ);
+        }
     }
     if (normalvins>1 && ccvins)
     {        
@@ -114,7 +143,8 @@ std::string FinalizeCCTx(uint64_t CCmask,struct CCcontract_info *cp,CMutableTran
     memset(utxovalues,0,sizeof(utxovalues));
     for (i=0; i<n; i++)
     {
-        if ( GetTransaction(mtx.vin[i].prevout.hash,vintx,hashBlock,false) != 0 )
+        if (i==0 && mtx.vin[i].prevout.n==10e8) continue;
+        if ( (mgret= myGetTransaction(mtx.vin[i].prevout.hash,vintx,hashBlock)) != 0 )
         {
             utxovout = mtx.vin[i].prevout.n;
             utxovalues[i] = vintx.vout[utxovout].nValue;
@@ -129,7 +159,7 @@ std::string FinalizeCCTx(uint64_t CCmask,struct CCcontract_info *cp,CMutableTran
             {                
                 mask |= (1LL << i);
             }
-        } else LogPrintf("FinalizeCCTx couldnt find %s\n",mtx.vin[i].prevout.hash.ToString().c_str());
+        } else LogPrintf("FinalizeCCTx couldnt find %s mgret.%d\n",mtx.vin[i].prevout.hash.ToString().c_str(),mgret);
     }
     nmask = (1LL << n) - 1;
     if ( 0 && (mask & nmask) != (CCmask & nmask) )
@@ -145,18 +175,43 @@ std::string FinalizeCCTx(uint64_t CCmask,struct CCcontract_info *cp,CMutableTran
     n = mtx.vin.size(); 
     for (i=0; i<n; i++)
     {
-        if ( GetTransaction(mtx.vin[i].prevout.hash,vintx,hashBlock,false) != 0 )
+        if (i==0 && mtx.vin[i].prevout.n==10e8)
+            continue;
+        if ( (mgret= myGetTransaction(mtx.vin[i].prevout.hash,vintx,hashBlock)) != 0 )
         {
             utxovout = mtx.vin[i].prevout.n;
             if ( vintx.vout[utxovout].scriptPubKey.IsPayToCryptoCondition() == 0 )
             {
-                if ( SignTx(mtx,i,vintx.vout[utxovout].nValue,vintx.vout[utxovout].scriptPubKey) == 0 )
-                    LogPrintf("signing error for vini.%d of %llx\n",i,(long long)vinimask);
+                if ( KOMODO_NSPV_FULLNODE )
+                {
+                    if (!remote)
+                    {
+                        if (SignTx(mtx, i, vintx.vout[utxovout].nValue, vintx.vout[utxovout].scriptPubKey) == 0)
+                            LogPrintf("signing error for vini.%d of %llx\n", i, (long long)vinimask);
+                    }
+                    else
+                    {
+                        // if no myprivkey for mypk it means remote call from nspv superlite client
+                        // add sigData for superlite client
+                        UniValue cc(UniValue::VNULL);
+                        AddSigData2UniValue(sigData, i, cc, HexStr(vintx.vout[utxovout].scriptPubKey), vintx.vout[utxovout].nValue );  // store vin i with scriptPubKey
+                    }
+                }
+                else
+                {
+                    {
+                        char addr[64];
+                        Getscriptaddress(addr,vintx.vout[utxovout].scriptPubKey);
+                        LogPrintf("vout[%d] %.8f -> %s\n",utxovout,dstr(vintx.vout[utxovout].nValue),addr);
+                    }
+                    if ( NSPV_SignTx(mtx,i,vintx.vout[utxovout].nValue,vintx.vout[utxovout].scriptPubKey,0) == 0 )
+                        LogPrintf("NSPV signing error for vini.%d of %llx\n",i,(long long)vinimask);
+                }
             }
             else
             {
                 Getscriptaddress(destaddr,vintx.vout[utxovout].scriptPubKey);
-                //LogPrintf("FinalizeCCTx() vin.%d is CC %.8f -> (%s) vs %s\n",i,(double)utxovalues[i]/COIN,destaddr,cp->unspendableaddr2);
+                //fprintf(stderr,"FinalizeCCTx() vin.%d is CC %.8f -> (%s) vs %s\n",i,(double)utxovalues[i]/COIN,destaddr,mysingletokensaddr);
 				//std::cerr << "FinalizeCCtx() searching destaddr=" << destaddr << " for vin[" << i << "] satoshis=" << utxovalues[i] << std::endl;
                 if( strcmp(destaddr, myaddr) == 0 )
                 {
@@ -227,8 +282,8 @@ std::string FinalizeCCTx(uint64_t CCmask,struct CCcontract_info *cp,CMutableTran
 				// check if this is spending from 1of2 cc tokens addr:
 				else if (strcmp(cp->tokens1of2addr, destaddr) == 0)
 				{
-					//LogPrintf("FinalizeCCTx() matched %s cp->tokens1of2addr!\n", cp->tokens1of2addr);
-					privkey = myprivkey;
+//fprintf(stderr,"FinalizeCCTx() matched %s cp->tokens1of2addr!\n", cp->tokens1of2addr);
+					privkey = cp->tokens1of2priv;//myprivkey;
 					if (othercond1of2tokens == 0)
                         // NOTE: if additionalEvalcode2 is not set then it is dual-eval cc else three-eval cc
                         // TODO: verify evalcodes order if additionalEvalcode2 is not 0
@@ -252,32 +307,56 @@ std::string FinalizeCCTx(uint64_t CCmask,struct CCcontract_info *cp,CMutableTran
                             cond = othercond4;
                             flag = 1;
                         }
-                    }
+                    } //else  privkey = myprivkey;
+
                     if ( flag == 0 )
                     {
                         LogPrintf("CC signing error: vini.%d has unknown CC address.(%s)\n",i,destaddr);
-                        return("");
+                        memset(myprivkey,0,32);
+                        return sigDataNull;
                     }
                 }
-                uint256 sighash = SignatureHash(CCPubKey(cond), mtx, i, SIGHASH_ALL, utxovalues[i],consensusBranchId, &txdata);
-                if ( cc_signTreeSecp256k1Msg32(cond,privkey,sighash.begin()) != 0 )
+                uint256 sighash = SignatureHash(CCPubKey(cond), mtx, i, SIGHASH_ALL,utxovalues[i],consensusBranchId, &txdata);
+                if ( 0 )
                 {
-                    //int32_t z;
-                    //for (z=0; z<32; z++)
-                    //    LogPrintf("%02x",((uint8_t *)sighash.begin())[z]);
-                    //LogPrintf(" sighash, ");
-                    //for (z=0; z<32; z++)
-                    //   LogPrintf("%02x",privkey[z]);
-                    //LogPrintf(" signed with privkey\n");
-                    mtx.vin[i].scriptSig = CCSig(cond);
+                    int32_t z;
+                    for (z=0; z<32; z++)
+                        LogPrintf("%02x",privkey[z]);
+                    LogPrintf(" privkey, ");
+                    for (z=0; z<32; z++)
+                        LogPrintf("%02x",((uint8_t *)sighash.begin())[z]);
+                    LogPrintf(" sighash [%d] %.8f %x\n",i,(double)utxovalues[i]/COIN,consensusBranchId);
                 }
-                else
+
+                if (!remote)  // we have privkey in the wallet
                 {
-                    LogPrintf("vini.%d has CC signing error address.(%s)\n",i,destaddr);
-                    return("");
+                    if (cc_signTreeSecp256k1Msg32(cond, privkey, sighash.begin()) != 0)
+                    {
+                        mtx.vin[i].scriptSig = CCSig(cond);
+                    }
+                    else
+                    {
+                        LogPrintf("vini.%d has CC signing error address.(%s) %s\n", i, destaddr, EncodeHexTx(mtx).c_str());
+                        memset(myprivkey, 0, sizeof(myprivkey));
+                        return sigDataNull;
+                    }
+                }
+                else   // no privkey locally - remote call
+                {
+                    // serialize cc:
+                    UniValue ccjson;
+                    ccjson.read(cc_conditionToJSONString(cond));
+                    if (ccjson.empty())
+                    {
+                        LogPrintf("vini.%d can't serialize CC.(%s) %s\n", i, destaddr, EncodeHexTx(mtx).c_str());
+                        memset(myprivkey, 0, sizeof(myprivkey));
+                        return sigDataNull;
+                    }
+
+                    AddSigData2UniValue(sigData, i, ccjson, std::string(), vintx.vout[utxovout].nValue);  // store vin i with scriptPubKey
                 }
             }
-        } else LogPrintf("FinalizeCCTx couldnt find %s\n",mtx.vin[i].prevout.hash.ToString().c_str());
+        } else LogPrintf("FinalizeCCTx2 couldnt find %s mgret.%d\n",mtx.vin[i].prevout.hash.ToString().c_str(),mgret);
     }
     if ( mycond != 0 )
         cc_free(mycond);
@@ -301,15 +380,29 @@ std::string FinalizeCCTx(uint64_t CCmask,struct CCcontract_info *cp,CMutableTran
         cc_free(mysingletokenscond);   
     if ( othertokenscond != 0 )
         cc_free(othertokenscond);   
+    memset(myprivkey,0,sizeof(myprivkey));
     std::string strHex = EncodeHexTx(mtx);
     if ( strHex.size() > 0 )
-        return(strHex);
-    else return("0");
+        result.push_back(Pair(JSON_HEXTX, strHex));
+    else {
+        result.push_back(Pair(JSON_HEXTX, "0"));
+    }
+    if (sigData.size() > 0) result.push_back(Pair(JSON_SIGDATA,sigData));
+    return result;
 }
 
+void NSPV_CCunspents(std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > &unspentOutputs,char *coinaddr,bool ccflag);
+void NSPV_CCtxids(std::vector<std::pair<CAddressIndexKey, CAmount> > &txids,char *coinaddr,bool ccflag);
+void NSPV_CCtxids(std::vector<uint256> &txids,char *coinaddr,bool ccflag, uint8_t evalcode,uint256 filtertxid, uint8_t func);
+
 void SetCCunspents(std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > &unspentOutputs,char *coinaddr,bool ccflag)
 {
     int32_t type=0,i,n; char *ptr; std::string addrstr; uint160 hashBytes; std::vector<std::pair<uint160, int> > addresses;
+    if ( KOMODO_NSPV_SUPERLITE )
+    {
+        NSPV_CCunspents(unspentOutputs,coinaddr,ccflag);
+        return;
+    }
     n = (int32_t)strlen(coinaddr);
     addrstr.resize(n+1);
     ptr = (char *)addrstr.data();
@@ -329,6 +422,11 @@ void SetCCunspents(std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValu
 void SetCCtxids(std::vector<std::pair<CAddressIndexKey, CAmount> > &addressIndex,char *coinaddr,bool ccflag)
 {
     int32_t type=0,i,n; char *ptr; std::string addrstr; uint160 hashBytes; std::vector<std::pair<uint160, int> > addresses;
+    if ( KOMODO_NSPV_SUPERLITE )
+    {
+        NSPV_CCtxids(addressIndex,coinaddr,ccflag);
+        return;
+    }
     n = (int32_t)strlen(coinaddr);
     addrstr.resize(n+1);
     ptr = (char *)addrstr.data();
@@ -345,6 +443,35 @@ void SetCCtxids(std::vector<std::pair<CAddressIndexKey, CAmount> > &addressIndex
     }
 }
 
+void SetCCtxids(std::vector<uint256> &txids,char *coinaddr,bool ccflag, uint8_t evalcode, uint256 filtertxid, uint8_t func)
+{
+    int32_t type=0,i,n; char *ptr; std::string addrstr; uint160 hashBytes; std::vector<std::pair<uint160, int> > addresses;
+    std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex;
+    if ( KOMODO_NSPV_SUPERLITE )
+    {
+        NSPV_CCtxids(txids,coinaddr,ccflag,evalcode,filtertxid,func);
+        return;
+    }
+    n = (int32_t)strlen(coinaddr);
+    addrstr.resize(n+1);
+    ptr = (char *)addrstr.data();
+    for (i=0; i<=n; i++)
+        ptr[i] = coinaddr[i];
+    CBitcoinAddress address(addrstr);
+    if ( address.GetIndexKey(hashBytes, type, ccflag) == 0 )
+        return;
+    addresses.push_back(std::make_pair(hashBytes,type));
+    for (std::vector<std::pair<uint160, int> >::iterator it = addresses.begin(); it != addresses.end(); it++)
+    {
+        if ( GetAddressIndex((*it).first, (*it).second, addressIndex) == 0 )
+            return;
+        for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it1=addressIndex.begin(); it1!=addressIndex.end(); it1++)
+        {
+            if (it1->second>=0) txids.push_back(it1->first.txhash);
+        }
+    } 
+}
+
 int64_t CCutxovalue(char *coinaddr,uint256 utxotxid,int32_t utxovout,int32_t CCflag)
 {
     uint256 txid; std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
@@ -358,7 +485,7 @@ int64_t CCutxovalue(char *coinaddr,uint256 utxotxid,int32_t utxovout,int32_t CCf
     return(0);
 }
 
-int32_t CCgettxout(uint256 txid,int32_t vout,int32_t mempoolflag,int32_t lockflag)
+int64_t CCgettxout(uint256 txid,int32_t vout,int32_t mempoolflag,int32_t lockflag)
 {
     CCoins coins;
     //LogPrintf("CCgettxoud %s/v%d\n",txid.GetHex().c_str(),vout);
@@ -508,9 +635,15 @@ int32_t CC_vinselect(int32_t *aboveip,int64_t *abovep,int32_t *belowip,int64_t *
     else return(belowi);
 }
 
-int64_t AddNormalinputs(CMutableTransaction &mtx,CPubKey mypk,int64_t total,int32_t maxinputs)
+int64_t AddNormalinputsLocal(CMutableTransaction &mtx,CPubKey mypk,int64_t total,int32_t maxinputs)
 {
     int32_t abovei,belowi,ind,vout,i,n = 0; int64_t sum,threshold,above,below; int64_t remains,nValue,totalinputs = 0; uint256 txid,hashBlock; std::vector<COutput> vecOutputs; CTransaction tx; struct CC_utxo *utxos,*up;
+    if ( KOMODO_NSPV_SUPERLITE )
+        return(NSPV_AddNormalinputs(mtx,mypk,total,maxinputs,&NSPV_U));
+
+    // if (mypk != pubkey2pk(Mypubkey()))  //remote superlite mypk, do not use wallet since it is not locked for non-equal pks (see rpcs with nspv support)!
+    //     return(AddNormalinputs3(mtx, mypk, total, maxinputs));
+
 #ifdef ENABLE_WALLET
     assert(pwalletMain != NULL);
     const CKeyStore& keystore = *pwalletMain;
@@ -602,11 +735,20 @@ int64_t AddNormalinputs(CMutableTransaction &mtx,CPubKey mypk,int64_t total,int3
     return(0);
 }
 
+// always uses -pubkey param as mypk
+int64_t AddNormalinputs2(CMutableTransaction &mtx, int64_t total, int32_t maxinputs)
+{
+    CPubKey mypk = pubkey2pk(Mypubkey());
+    return AddNormalinputsRemote(mtx, mypk, total, maxinputs);
+}
 
-int64_t AddNormalinputs2(CMutableTransaction &mtx,int64_t total,int32_t maxinputs)
+// has additional mypk param for nspv calls
+int64_t AddNormalinputsRemote(CMutableTransaction &mtx, CPubKey mypk, int64_t total, int32_t maxinputs)
 {
     int32_t abovei,belowi,ind,vout,i,n = 0; int64_t sum,threshold,above,below; int64_t remains,nValue,totalinputs = 0; char coinaddr[64]; uint256 txid,hashBlock; CTransaction tx; struct CC_utxo *utxos,*up;
     std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
+    if ( KOMODO_NSPV_SUPERLITE )
+        return(NSPV_AddNormalinputs(mtx,mypk,total,maxinputs,&NSPV_U));
     utxos = (struct CC_utxo *)calloc(CC_MAXVINS,sizeof(*utxos));
     if ( maxinputs > CC_MAXVINS )
         maxinputs = CC_MAXVINS;
@@ -614,7 +756,7 @@ int64_t AddNormalinputs2(CMutableTransaction &mtx,int64_t total,int32_t maxinput
         threshold = total/maxinputs;
     else threshold = total;
     sum = 0;
-    Getscriptaddress(coinaddr,CScript() << Mypubkey() << OP_CHECKSIG);
+    Getscriptaddress(coinaddr,CScript() << vscript_t(mypk.begin(), mypk.end()) << OP_CHECKSIG);
     SetCCunspents(unspentOutputs,coinaddr,false);
     for (std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> >::const_iterator it=unspentOutputs.begin(); it!=unspentOutputs.end(); it++)
     {
@@ -692,3 +834,21 @@ int64_t AddNormalinputs2(CMutableTransaction &mtx,int64_t total,int32_t maxinput
     }
     return(0);
 }
+
+int64_t AddNormalinputs(CMutableTransaction &mtx,CPubKey mypk,int64_t total,int32_t maxinputs,bool remote)
+{
+    if (!remote)  return (AddNormalinputsLocal(mtx,mypk,total,maxinputs));
+    else return (AddNormalinputsRemote(mtx,mypk,total,maxinputs));
+}
+
+void AddSigData2UniValue(UniValue &sigdata, int32_t vini, UniValue& ccjson, std::string sscriptpubkey, int64_t amount)
+{
+    UniValue elem(UniValue::VOBJ);
+    elem.push_back(Pair("vin", vini));
+    if (!ccjson.empty())
+        elem.push_back(Pair("cc", ccjson));
+    if (!sscriptpubkey.empty())
+        elem.push_back(Pair("scriptPubKey", sscriptpubkey));
+    elem.push_back(Pair("amount", amount));
+    sigdata.push_back(elem);
+}
\ No newline at end of file
diff --git a/src/cc/CCutilbits.cpp b/src/cc/CCutilbits.cpp
index a936929d..1584d272 100644
--- a/src/cc/CCutilbits.cpp
+++ b/src/cc/CCutilbits.cpp
@@ -1,5 +1,5 @@
 /******************************************************************************
- * Copyright © 2014-2019 The SuperNET Developers.                             *
+ * Copyright ? 2014-2019 The SuperNET Developers.                             *
  *                                                                            *
  * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
  * the top-level directory of this distribution for the individual copyright  *
@@ -93,13 +93,23 @@ CPubKey buf2pk(uint8_t *buf33)
     return(pk);
 }
 
-CPubKey pubkey2pk(std::vector<uint8_t> pubkey)
+CPubKey pubkey2pk(std::vector<uint8_t> vpubkey)
 {
-    CPubKey pk; int32_t i,n; uint8_t *dest,*pubkey33;
-    n = pubkey.size();
-    dest = (uint8_t *)pk.begin();
-    pubkey33 = (uint8_t *)pubkey.data();
-    for (i=0; i<n; i++)
-        dest[i] = pubkey33[i];
+    CPubKey pk; 
+    pk.Set(vpubkey.begin(), vpubkey.end());
     return(pk);
 }
+
+void CCLogPrintStr(const char *category, int level, const std::string &str)
+{
+    if (level < 0)
+        level = 0;
+    if (level > CCLOG_MAXLEVEL)
+        level = CCLOG_MAXLEVEL;
+    for (int i = level; i <= CCLOG_MAXLEVEL; i++)
+        if (LogAcceptCategory((std::string(category) + std::string("-") + std::to_string(i)).c_str()) ||     // '-debug=cctokens-0', '-debug=cctokens-1',...
+            i == 0 && LogAcceptCategory(std::string(category).c_str())) {                                  // also supporting '-debug=cctokens' for CCLOG_INFO
+            LogPrintStr(str);
+            break;
+        }
+}
diff --git a/src/cc/CCutils.cpp b/src/cc/CCutils.cpp
index 13ac2a6a..f842635b 100644
--- a/src/cc/CCutils.cpp
+++ b/src/cc/CCutils.cpp
@@ -18,6 +18,7 @@
  */
 #include "CCinclude.h"
 #include "komodo_structs.h"
+#include "key_io.h"
 
 #ifdef TESTMODE           
     #define MIN_NON_NOTARIZED_CONFIRMS 2
@@ -168,7 +169,12 @@ bool CheckTxFee(const CTransaction &tx, uint64_t txfee, uint32_t height, uint64_
     return true;
 }
 
-// set additional 'unspendable' addr
+uint32_t GetLatestTimestamp(int32_t height)
+{
+    if ( KOMODO_NSPV_SUPERLITE ) return ((uint32_t)NSPV_blocktime(height));
+    return(komodo_heightstamp(height));
+} // :P
+
 void CCaddr2set(struct CCcontract_info *cp,uint8_t evalcode,CPubKey pk,uint8_t *priv,char *coinaddr)
 {
     cp->unspendableEvalcode2 = evalcode;
@@ -177,7 +183,6 @@ void CCaddr2set(struct CCcontract_info *cp,uint8_t evalcode,CPubKey pk,uint8_t *
     strcpy(cp->unspendableaddr2,coinaddr);
 }
 
-// set yet another additional 'unspendable' addr
 void CCaddr3set(struct CCcontract_info *cp,uint8_t evalcode,CPubKey pk,uint8_t *priv,char *coinaddr)
 {
     cp->unspendableEvalcode3 = evalcode;
@@ -186,8 +191,7 @@ void CCaddr3set(struct CCcontract_info *cp,uint8_t evalcode,CPubKey pk,uint8_t *
     strcpy(cp->unspendableaddr3,coinaddr);
 }
 
-// set pubkeys, myprivkey and 1of2 cc addr for spending from 1of2 cryptocondition vout:
-void CCaddr1of2set(struct CCcontract_info *cp, CPubKey pk1, CPubKey pk2,uint8_t *priv,char *coinaddr)
+void CCaddr1of2set(struct CCcontract_info *cp, CPubKey pk1, CPubKey pk2, uint8_t *priv, char *coinaddr)
 {
 	cp->coins1of2pk[0] = pk1;
 	cp->coins1of2pk[1] = pk2;
@@ -195,22 +199,25 @@ void CCaddr1of2set(struct CCcontract_info *cp, CPubKey pk1, CPubKey pk2,uint8_t
     strcpy(cp->coins1of2addr,coinaddr);
 }
 
-// set pubkeys, myprivkey and 1of2 cc addr for spending from 1of2 token cryptocondition vout
-// to get tokenaddr use GetTokensCCaddress()
-void CCaddrTokens1of2set(struct CCcontract_info *cp, CPubKey pk1, CPubKey pk2, char *tokenaddr)
+void CCaddrTokens1of2set(struct CCcontract_info *cp, CPubKey pk1, CPubKey pk2, uint8_t *priv, char *tokenaddr)
 {
 	cp->tokens1of2pk[0] = pk1;
 	cp->tokens1of2pk[1] = pk2;
+    memcpy(cp->tokens1of2priv,priv,32);
 	strcpy(cp->tokens1of2addr, tokenaddr);
 }
 
 bool Getscriptaddress(char *destaddr,const CScript &scriptPubKey)
 {
     CTxDestination address; txnouttype whichType;
-    if ( ExtractDestination(scriptPubKey,address) != 0 )
+    destaddr[0] = 0;
+    if ( scriptPubKey.begin() != 0 )
     {
-        strcpy(destaddr,(char *)CBitcoinAddress(address).ToString().c_str());
-        return(true);
+        if ( ExtractDestination(scriptPubKey,address) != 0 )
+        {
+            strcpy(destaddr,(char *)CBitcoinAddress(address).ToString().c_str());
+            return(true);
+        }
     }
     //LogPrintf("ExtractDestination failed\n");
     return(false);
@@ -352,7 +359,6 @@ bool GetCCaddress1of2(struct CCcontract_info *cp,char *destaddr,CPubKey pk,CPubK
     return(destaddr[0] != 0);
 }
 
-// get scriptPubKey adddress for three/dual eval token 1of2 cc vout
 bool GetTokensCCaddress1of2(struct CCcontract_info *cp, char *destaddr, CPubKey pk, CPubKey pk2)
 {
 	CC *payoutCond;
@@ -437,9 +443,28 @@ std::vector<uint8_t> Mypubkey()
     return(pubkey);
 }
 
+extern char NSPV_wifstr[],NSPV_pubkeystr[];
+extern uint32_t NSPV_logintime;
+#define NSPV_AUTOLOGOUT 777
+
 bool Myprivkey(uint8_t myprivkey[])
 {
     char coinaddr[64],checkaddr[64]; std::string strAddress; char *dest; int32_t i,n; CBitcoinAddress address; CKeyID keyID; CKey vchSecret; uint8_t buf33[33];
+    if ( KOMODO_NSPV_SUPERLITE )
+    {
+        if ( NSPV_logintime == 0 || time(NULL) > NSPV_logintime+NSPV_AUTOLOGOUT )
+        {
+            LogPrintf("need to be logged in to get myprivkey\n");
+            return false;
+        }
+        vchSecret = DecodeSecret(NSPV_wifstr);
+        memcpy(myprivkey,vchSecret.begin(),32);
+        //for (i=0; i<32; i++)
+        //    fprintf(stderr,"%02x",myprivkey[i]);
+        //fprintf(stderr," myprivkey %s\n",NSPV_wifstr);
+        memset((uint8_t *)vchSecret.begin(),0,32);
+        return true;
+    }
     if ( Getscriptaddress(coinaddr,CScript() << Mypubkey() << OP_CHECKSIG) != 0 )
     {
         n = (int32_t)strlen(coinaddr);
@@ -454,6 +479,7 @@ bool Myprivkey(uint8_t myprivkey[])
             if ( pwalletMain->GetKey(keyID,vchSecret) != 0 )
             {
                 memcpy(myprivkey,vchSecret.begin(),32);
+                memset((uint8_t *)vchSecret.begin(),0,32);
                 if ( 0 )
                 {
                     for (i=0; i<32; i++)
@@ -559,9 +585,13 @@ uint256 CCOraclesReverseScan(char const *logcategory,uint256 &txid,int32_t heigh
     return(zeroid);
 }
 
+int32_t NSPV_coinaddr_inmempool(char const *logcategory,char *coinaddr,uint8_t CCflag);
+
 int32_t myIs_coinaddr_inmempoolvout(char const *logcategory,char *coinaddr)
 {
     int32_t i,n; char destaddr[64];
+    if ( KOMODO_NSPV_SUPERLITE )
+        return(NSPV_coinaddr_inmempool(logcategory,coinaddr,1));
     BOOST_FOREACH(const CTxMemPoolEntry &e,mempool.mapTx)
     {
         const CTransaction &tx = e.GetTx();
@@ -582,6 +612,32 @@ int32_t myIs_coinaddr_inmempoolvout(char const *logcategory,char *coinaddr)
     return(0);
 }
 
+extern struct NSPV_mempoolresp NSPV_mempoolresult;
+extern bool NSPV_evalcode_inmempool(uint8_t evalcode,uint8_t funcid);
+
+int32_t myGet_mempool_txs(std::vector<CTransaction> &txs,uint8_t evalcode,uint8_t funcid)
+{
+    int i=0;
+
+    if ( KOMODO_NSPV_SUPERLITE )
+    {
+        CTransaction tx; uint256 hashBlock;
+
+        NSPV_evalcode_inmempool(evalcode,funcid);
+        for (int i=0;i<NSPV_mempoolresult.numtxids;i++)
+        {
+            if (myGetTransaction(NSPV_mempoolresult.txids[i],tx,hashBlock)!=0) txs.push_back(tx);
+        }
+        return (NSPV_mempoolresult.numtxids);
+    }
+    BOOST_FOREACH(const CTxMemPoolEntry &e,mempool.mapTx)
+    {
+        txs.push_back(e.GetTx());
+        i++;
+    }
+    return(i);
+}
+
 int32_t CCCointxidExists(char const *logcategory,uint256 cointxid)
 {
     char txidaddr[64]; std::string coin; int32_t numvouts; uint256 hashBlock;
@@ -608,36 +664,69 @@ uint256 BitcoinGetProofMerkleRoot(const std::vector<uint8_t> &proofData, std::ve
     return merkleBlock.txn.ExtractMatches(txids);
 }
 
+extern struct NSPV_inforesp NSPV_inforesult;
+int32_t komodo_get_current_height()
+{
+    if ( KOMODO_NSPV_SUPERLITE )
+    {
+        return (NSPV_inforesult.height);
+    }
+    else return chainActive.LastTip()->GetHeight();
+}
+
 bool komodo_txnotarizedconfirmed(uint256 txid)
 {
     char str[65];
-    uint32_t confirms,notarized=0,txheight;
+    int32_t confirms,notarized=0,txheight=0,currentheight=0;;
     CTransaction tx;
     uint256 hashBlock;
     CBlockIndex *pindex;    
     char symbol[KOMODO_ASSETCHAIN_MAXLEN],dest[KOMODO_ASSETCHAIN_MAXLEN]; struct komodo_state *sp;
 
-    if ( myGetTransaction(txid,tx,hashBlock) == 0 )
-    {
-        LogPrintf("komodo_txnotarizedconfirmed cant find txid %s\n",txid.ToString().c_str());
-        return(0);
-    }
-    else if ( hashBlock == zeroid )
+    if ( KOMODO_NSPV_SUPERLITE )
     {
-        LogPrintf("komodo_txnotarizedconfirmed no hashBlock for txid %s\n",txid.ToString().c_str());
-        return(0);
+        if ( NSPV_myGetTransaction(txid,tx,hashBlock,txheight,currentheight) == 0 )
+        {
+            LogPrintf("komodo_txnotarizedconfirmed cant find txid %s\n",txid.ToString().c_str());
+            return(0);
+        }
+        else if (txheight<=0)
+        {
+            LogPrintf("komodo_txnotarizedconfirmed no txheight.%d for txid %s\n",txheight,txid.ToString().c_str());
+            return(0);
+        }
+        else if (txheight>currentheight)
+        {
+            LogPrintf("komodo_txnotarizedconfirmed backwards heights for txid %s hts.(%d %d)\n",txid.ToString().c_str(),txheight,currentheight);
+            return(0);
+        }
+        confirms=1 + currentheight - txheight;
     }
-    else if ( (pindex= komodo_blockindex(hashBlock)) == 0 || (txheight= pindex->GetHeight()) <= 0 )
+    else
     {
-        LogPrintf("komodo_txnotarizedconfirmed no txheight.%d %p for txid %s\n",txheight,pindex,txid.ToString().c_str());
-        return(0);
+        if ( myGetTransaction(txid,tx,hashBlock) == 0 )
+        {
+            LogPrintf("komodo_txnotarizedconfirmed cant find txid %s\n",txid.ToString().c_str());
+            return(0);
+        }
+        else if ( hashBlock == zeroid )
+        {
+            LogPrintf("komodo_txnotarizedconfirmed no hashBlock for txid %s\n",txid.ToString().c_str());
+            return(0);
+        }
+        else if ( (pindex= komodo_blockindex(hashBlock)) == 0 || (txheight= pindex->GetHeight()) <= 0 )
+        {
+            LogPrintf("komodo_txnotarizedconfirmed no txheight.%d %p for txid %s\n",txheight,pindex,txid.ToString().c_str());
+            return(0);
+        }
+        else if ( (pindex= chainActive.LastTip()) == 0 || pindex->GetHeight() < txheight )
+        {
+            LogPrintf("komodo_txnotarizedconfirmed backwards heights for txid %s hts.(%d %d)\n",txid.ToString().c_str(),txheight,(int32_t)pindex->GetHeight());
+            return(0);
+        }    
+        confirms=1 + pindex->GetHeight() - txheight;
     }
-    else if ( (pindex= chainActive.LastTip()) == 0 || pindex->GetHeight() < txheight )
-    {
-        LogPrintf("komodo_txnotarizedconfirmed backwards heights for txid %s hts.(%d %d)\n",txid.ToString().c_str(),txheight,(int32_t)pindex->GetHeight());
-        return(0);
-    }    
-    confirms=1 + pindex->GetHeight() - txheight;        
+
     if ((sp= komodo_stateptr(symbol,dest)) != 0 && (notarized=sp->NOTARIZED_HEIGHT) > 0 && txheight > sp->NOTARIZED_HEIGHT)  notarized=0;            
 #ifdef TESTMODE           
     notarized=0;
diff --git a/src/cc/auction.cpp b/src/cc/auction.cpp
index 94910abc..8e9eabbf 100644
--- a/src/cc/auction.cpp
+++ b/src/cc/auction.cpp
@@ -131,7 +131,7 @@ int64_t AddAuctionInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPu
         // prevent dup
         if ( it->second.satoshis < 1000000 )
             continue;
-        if ( GetTransaction(txid,vintx,hashBlock,false) != 0 )
+        if ( myGetTransaction(txid,vintx,hashBlock) != 0 )
         {
             if ( (nValue= IsAuctionvout(cp,vintx,(int32_t)it->first.index)) > 0 )
             {
diff --git a/src/cc/cclib.cpp b/src/cc/cclib.cpp
index 376f6d05..2e55eb19 100644
--- a/src/cc/cclib.cpp
+++ b/src/cc/cclib.cpp
@@ -520,7 +520,7 @@ int64_t AddCClibInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPubK
         if ( it->second.satoshis < threshold || it->second.satoshis == txfee )
             continue;
         // no need to prevent dup
-        if ( GetTransaction(txid,vintx,hashBlock,false) != 0 )
+        if ( myGetTransaction(txid,vintx,hashBlock) != 0 )
         {
             if ( (nValue= IsCClibvout(cp,vintx,vout,cmpaddr)) >= 1000000 && myIsutxo_spentinmempool(ignoretxid,ignorevin,txid,vout) == 0 )
             {
@@ -550,7 +550,7 @@ int64_t AddCClibtxfee(struct CCcontract_info *cp,CMutableTransaction &mtx,CPubKe
         //char str[65]; LogPrintf("%s check %s/v%d %.8f vs %.8f\n",coinaddr,uint256_str(str,txid),vout,(double)it->second.satoshis/COIN,(double)threshold/COIN);
         if ( it->second.satoshis < txfee )
             continue;
-        if ( GetTransaction(txid,vintx,hashBlock,false) != 0 )
+        if ( myGetTransaction(txid,vintx,hashBlock) != 0 )
         {
             if ( (nValue= IsCClibvout(cp,vintx,vout,coinaddr)) != 0 && myIsutxo_spentinmempool(ignoretxid,ignorevin,txid,vout) == 0 )
             {
@@ -570,7 +570,7 @@ std::string Faucet2Fund(struct CCcontract_info *cp,uint64_t txfee,int64_t funds)
         txfee = 10000;
     mypk = pubkey2pk(Mypubkey());
     cclibpk = GetUnspendable(cp,0);
-    if ( AddNormalinputs(mtx,mypk,funds+txfee,64) > 0 )
+    if ( AddNormalinputs2(mtx,funds+txfee,64) > 0 )
     {
         mtx.vout.push_back(MakeCC1vout(cp->evalcode,funds,cclibpk));
         return(FinalizeCCTx(0,cp,mtx,mypk,txfee,opret));
diff --git a/src/cc/channels.cpp b/src/cc/channels.cpp
index 305b8183..256112cd 100644
--- a/src/cc/channels.cpp
+++ b/src/cc/channels.cpp
@@ -416,7 +416,7 @@ int64_t AddChannelsInputs(struct CCcontract_info *cp,CMutableTransaction &mtx, C
     else marker=2;
     for (std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> >::const_iterator it=unspentOutputs.begin(); it!=unspentOutputs.end(); it++)
     {
-        if ( (int32_t)it->first.index==0 && GetTransaction(it->first.txhash,tx,hashBlock,false) != 0 && (numvouts=tx.vout.size()) > 0)
+        if ( (int32_t)it->first.index==0 && myGetTransaction(it->first.txhash,tx,hashBlock) != 0 && (numvouts=tx.vout.size()) > 0)
         {
             if (DecodeChannelsOpRet(tx.vout[numvouts-1].scriptPubKey,tokenid,tmp_txid,srcpub,destpub,param1,param2,param3)!=0 &&
               (tmp_txid==openTx.GetHash() || tx.GetHash()==openTx.GetHash()) && IsChannelsMarkervout(cp,tx,marker==1?srcpub:destpub,marker)>0 &&
@@ -431,12 +431,14 @@ int64_t AddChannelsInputs(struct CCcontract_info *cp,CMutableTransaction &mtx, C
     {
         txid=zeroid;
         int32_t mindepth=CHANNELS_MAXPAYMENTS;
-        BOOST_FOREACH(const CTxMemPoolEntry &e, mempool.mapTx)
+        std::vector<CTransaction> tmp_txs;
+        myGet_mempool_txs(tmp_txs,EVAL_CHANNELS,'P');
+        for (std::vector<CTransaction>::const_iterator it=tmp_txs.begin(); it!=tmp_txs.end(); it++)
         {
-            const CTransaction &txmempool = e.GetTx();
+            const CTransaction &txmempool = *it;
             const uint256 &hash = txmempool.GetHash();
 
-            if ((numvouts=txmempool.vout.size()) > 0 && DecodeChannelsOpRet(txmempool.vout[numvouts-1].scriptPubKey,tokenid,tmp_txid,srcpub,destpub,param1,param2,param3) != 0 &&
+            if ((numvouts=txmempool.vout.size()) > 0 && DecodeChannelsOpRet(txmempool.vout[numvouts-1].scriptPubKey,tokenid,tmp_txid,srcpub,destpub,param1,param2,param3)=='P' &&
               tmp_txid==openTx.GetHash() && param1 < mindepth)
             {
                 txid=hash;
@@ -451,37 +453,40 @@ int64_t AddChannelsInputs(struct CCcontract_info *cp,CMutableTransaction &mtx, C
         mtx.vin.push_back(CTxIn(txid,0,CScript()));
         mtx.vin.push_back(CTxIn(txid,marker,CScript()));
         Myprivkey(myprivkey);        
-        if (tokenid!=zeroid) CCaddrTokens1of2set(cp,srcpub,destpub,coinaddr);
+        if (tokenid!=zeroid) CCaddrTokens1of2set(cp,srcpub,destpub,myprivkey,coinaddr);
         else CCaddr1of2set(cp,srcpub,destpub,myprivkey,coinaddr);
+        memset(myprivkey,0,32);
         return totalinputs;
     }
     else return 0;
 }
 
-std::string ChannelOpen(uint64_t txfee,CPubKey destpub,int32_t numpayments,int64_t payment, uint256 tokenid)
+UniValue ChannelOpen(const CPubKey& pk, uint64_t txfee,CPubKey destpub,int32_t numpayments,int64_t payment, uint256 tokenid)
 {
     CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
     uint8_t hash[32],hashdest[32]; uint64_t amount,tokens=0,funds; int32_t i; uint256 hashchain,entropy,hentropy;
     CPubKey mypk; struct CCcontract_info *cp,*cpTokens,C,CTokens;
     
     if ( numpayments <= 0 || payment <= 0 || numpayments > CHANNELS_MAXPAYMENTS )
-    {
-        CCerror = strprintf("invalid ChannelOpen param numpayments.%d max.%d payment.%lld\n",numpayments,CHANNELS_MAXPAYMENTS,(long long)payment);
-        LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
+        CCERR_RESULT("channelscc",CCLOG_INFO, stream << "invalid ChannelOpen param numpayments." << numpayments << " payment." << payment << " - max_numpayments." << CHANNELS_MAXPAYMENTS);
+    if (!destpub.IsFullyValid())
+        CCERR_RESULT("channelscc",CCLOG_INFO, stream << "invalid destination pubkey");
+    if (numpayments <1)
+        CCERR_RESULT("channelscc",CCLOG_INFO, stream << "invalid number of payments, must be greater than 0");
+    if (payment <1)
+        CCERR_RESULT("channelscc",CCLOG_INFO, stream << "invalid payment amount, must be greater than 0");
     cp = CCinit(&C,EVAL_CHANNELS);
     cpTokens = CCinit(&CTokens,EVAL_TOKENS);
     if ( txfee == 0 )
         txfee = 10000;
-    mypk = pubkey2pk(Mypubkey());
+    mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
     funds = numpayments * payment;
     if (tokenid!=zeroid)
     {
-        amount=AddNormalinputs(mtx,mypk,txfee+2*CC_MARKER_VALUE,5);
+        amount=AddNormalinputs(mtx,mypk,txfee+2*CC_MARKER_VALUE,5,pk.IsValid());
         tokens=AddTokenCCInputs(cpTokens, mtx, mypk, tokenid, funds, 64);       
     }
-    else amount=AddNormalinputs(mtx,mypk,funds+txfee+2*CC_MARKER_VALUE,64);
+    else amount=AddNormalinputs(mtx,mypk,funds+txfee+2*CC_MARKER_VALUE,64,pk.IsValid());
     if (amount+tokens >= funds+txfee+2*CC_MARKER_VALUE)
     {
         hentropy = DiceHashEntropy(entropy,mtx.vin[0].prevout.hash,mtx.vin[0].prevout.n,1);
@@ -497,14 +502,12 @@ std::string ChannelOpen(uint64_t txfee,CPubKey destpub,int32_t numpayments,int64
         mtx.vout.push_back(MakeCC1vout(EVAL_CHANNELS,CC_MARKER_VALUE,mypk));
         mtx.vout.push_back(MakeCC1vout(EVAL_CHANNELS,CC_MARKER_VALUE,destpub));
         if (tokenid!=zeroid && tokens>funds) mtx.vout.push_back(MakeCC1vout(EVAL_TOKENS,tokens-funds,mypk));
-        return(FinalizeCCTx(0,cp,mtx,mypk,txfee,EncodeChannelsOpRet('O',tokenid,zeroid,mypk,destpub,numpayments,payment,hashchain)));
+        return(FinalizeCCTxExt(pk.IsValid(),0,cp,mtx,mypk,txfee,EncodeChannelsOpRet('O',tokenid,zeroid,mypk,destpub,numpayments,payment,hashchain)));
     }
-    CCerror = strprintf("error adding funds");
-    LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-    return("");
+    CCERR_RESULT("channelscc",CCLOG_INFO, stream << "error adding funds");
 }
 
-std::string ChannelPayment(uint64_t txfee,uint256 opentxid,int64_t amount, uint256 secret)
+UniValue ChannelPayment(const CPubKey& pk, uint64_t txfee,uint256 opentxid,int64_t amount, uint256 secret)
 {
     CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
     CPubKey mypk,srcpub,destpub; uint256 txid,hashchain,gensecret,hashblock,entropy,hentropy,prevtxid,param3,tokenid;
@@ -516,60 +519,35 @@ std::string ChannelPayment(uint64_t txfee,uint256 opentxid,int64_t amount, uint2
     cp = CCinit(&C,EVAL_CHANNELS);
     if ( txfee == 0 )
         txfee = 10000;
-    mypk = pubkey2pk(Mypubkey());
-    if (GetTransaction(opentxid,channelOpenTx,hashblock,false) == 0)
-    {
-        CCerror = strprintf("invalid channel open txid");
-        LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
+    mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
+    if (amount <1)
+        CCERR_RESULT("channelscc",CCLOG_INFO, stream << "invalid payment amount, must be greater than 0");
+    if (myGetTransaction(opentxid,channelOpenTx,hashblock) == 0) 
+        CCERR_RESULT("channelscc",CCLOG_INFO, stream << "invalid channel open txid");
     if ((numvouts=channelOpenTx.vout.size()) > 0 && DecodeChannelsOpRet(channelOpenTx.vout[numvouts-1].scriptPubKey, tokenid, txid, srcpub, destpub, totalnumpayments, payment, hashchain)=='O')
     {
-        if (mypk != srcpub && mypk != destpub)
-        {
-            CCerror = strprintf("this is not our channel");
-            LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-            return("");
-        }
+        if (mypk != srcpub && mypk != destpub) 
+            CCERR_RESULT("channelscc",CCLOG_INFO, stream << "this is not our channel");
         else if (amount % payment != 0 || amount<payment)
-        {
-            CCerror = strprintf("invalid amount, not a magnitude of payment size");
-            LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-            return ("");
-        }
+            CCERR_RESULT("channelscc",CCLOG_INFO, stream << "invalid amount, not a magnitude of payment size");
+        else if (mypk == destpub && secret==zeroid) CCERR_RESULT("channelscc",CCLOG_INFO, stream << "invalid secret, secret is necessary when making payment from destination");
     }
-    else
-    {
-        CCerror = strprintf("invalid channel open tx");
-        LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return ("");
-    }
-    if (komodo_txnotarizedconfirmed(opentxid)==false)
-    {
-        CCerror = strprintf("channelsopen tx not yet confirmed/notarized");
-        LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
-    if (AddNormalinputs(mtx,mypk,txfee+CC_MARKER_VALUE,3) > 0)
+    else 
+        CCERR_RESULT("channelscc",CCLOG_INFO, stream << "invalid channel open tx");
+    if (komodo_txnotarizedconfirmed(opentxid)==false) CCERR_RESULT("channelscc",CCLOG_INFO, stream << "channelsopen tx not yet confirmed/notarized");
+    if (AddNormalinputs(mtx,mypk,txfee+CC_MARKER_VALUE,3,pk.IsValid()) > 0)
     {
         if ((funds=AddChannelsInputs(cp,mtx,channelOpenTx,prevtxid,mypk)) !=0 && (change=funds-amount)>=0)
         {            
             numpayments=amount/payment;
-            if (GetTransaction(prevtxid,prevTx,hashblock,false) != 0 && (numvouts=prevTx.vout.size()) > 0 &&
+            if (myGetTransaction(prevtxid,prevTx,hashblock) != 0 && (numvouts=prevTx.vout.size()) > 0 &&
                 ((funcid = DecodeChannelsOpRet(prevTx.vout[numvouts-1].scriptPubKey, tokenid, txid, srcpub, destpub, prevdepth, param2, param3)) != 0) &&
                 (funcid == 'P' || funcid=='O'))
             {
                 if (numpayments > prevdepth)
-                {
-                    CCerror = strprintf("not enough funds in channel for that amount");
-                    LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-                    return ("");
-                } else if (numpayments == 0)
-                {
-                    CCerror = strprintf("invalid amount");
-                    LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-                    return ("");
-                }
+                    CCERR_RESULT("channelscc",CCLOG_INFO, stream << "not enough funds in channel for that amount");
+                else if (numpayments == 0)
+                    CCERR_RESULT("channelscc",CCLOG_INFO, stream << "invalid amount");
                 if (secret!=zeroid)
                 {
                     endiancpy(hash, (uint8_t * ) & secret, 32);
@@ -579,12 +557,7 @@ std::string ChannelPayment(uint64_t txfee,uint256 opentxid,int64_t amount, uint2
                         memcpy(hash, hashdest, 32);
                     }
                     endiancpy((uint8_t * ) & gensecret, hashdest, 32);
-                    if (gensecret!=hashchain)
-                    {
-                        CCerror = strprintf("invalid secret supplied");
-                        LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-                        return("");
-                    }
+                    if (gensecret!=hashchain) CCERR_RESULT("channelscc",CCLOG_INFO, stream << "invalid secret supplied");
                 }
                 else
                 {
@@ -602,33 +575,23 @@ std::string ChannelPayment(uint64_t txfee,uint256 opentxid,int64_t amount, uint2
                     else endiancpy((uint8_t * ) & secret, (uint8_t * ) & hentropy, 32);
                 }
             }
-            else
-            {
-                CCerror = strprintf("invalid previous tx");
-                LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-                return("");
-            }            
+            else 
+                CCERR_RESULT("channelscc",CCLOG_INFO, stream << "invalid previous tx");
             if (tokenid!=zeroid) mtx.vout.push_back(MakeTokensCC1of2vout(EVAL_CHANNELS, change, srcpub, destpub));
             else mtx.vout.push_back(MakeCC1of2vout(EVAL_CHANNELS, change, srcpub, destpub));
             mtx.vout.push_back(MakeCC1vout(EVAL_CHANNELS,CC_MARKER_VALUE,srcpub));
             mtx.vout.push_back(MakeCC1vout(EVAL_CHANNELS,CC_MARKER_VALUE,destpub));
             if (tokenid!=zeroid) mtx.vout.push_back(MakeCC1vout(EVAL_TOKENS, amount, destpub));
             else mtx.vout.push_back(CTxOut(amount, CScript() << ParseHex(HexStr(destpub)) << OP_CHECKSIG));
-            return (FinalizeCCTx(0, cp, mtx, mypk, txfee, EncodeChannelsOpRet('P', tokenid, opentxid, srcpub, destpub, prevdepth-numpayments, numpayments, secret)));
-        }
-        else
-        {
-            CCerror = strprintf("error adding CC inputs");
-            LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-            return("");
+            return (FinalizeCCTxExt(pk.IsValid(), 0, cp, mtx, mypk, txfee, EncodeChannelsOpRet('P', tokenid, opentxid, srcpub, destpub, prevdepth-numpayments, numpayments, secret)));
         }
+        else 
+            CCERR_RESULT("channelscc",CCLOG_INFO, stream << "error adding CC inputs");
     }
-    CCerror = strprintf("error adding normal inputs");
-    LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-    return("");
+    CCERR_RESULT("channelscc",CCLOG_INFO, stream << "error adding normal inputs");
 }
 
-std::string ChannelClose(uint64_t txfee,uint256 opentxid)
+UniValue ChannelClose(const CPubKey& pk, uint64_t txfee,uint256 opentxid)
 {
     CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
     CPubKey mypk,srcpub,destpub; struct CCcontract_info *cp,C;
@@ -641,32 +604,16 @@ std::string ChannelClose(uint64_t txfee,uint256 opentxid)
     cp = CCinit(&C,EVAL_CHANNELS);
     if ( txfee == 0 )
         txfee = 10000;
-    mypk = pubkey2pk(Mypubkey());
-    if (GetTransaction(opentxid,channelOpenTx,hashblock,false) == 0)
-    {
-        CCerror = strprintf("invalid channel open txid");
-        LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return ("");
-    }
+    mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
+    if (myGetTransaction(opentxid,channelOpenTx,hashblock) == 0) 
+        CCERR_RESULT("channelscc",CCLOG_INFO, stream << "invalid channel open txid");
     if ((numvouts=channelOpenTx.vout.size()) < 1 || DecodeChannelsOpRet(channelOpenTx.vout[numvouts-1].scriptPubKey,tokenid,tmp_txid,srcpub,destpub,numpayments,payment,hashchain)!='O')
-    {
-        CCerror = strprintf("invalid channel open tx");
-        LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return ("");
-    }
+        CCERR_RESULT("channelscc",CCLOG_INFO, stream << "invalid channel open tx");
     if (komodo_txnotarizedconfirmed(opentxid)==false)
-    {
-        CCerror = strprintf("channelsopen tx not yet confirmed/notarized");
-        LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
+        CCERR_RESULT("channelscc",CCLOG_INFO, stream <<"channelsopen tx not yet confirmed/notarized");
     if (mypk != srcpub)
-    {
-        CCerror = strprintf("cannot close, you are not channel owner");
-        LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
-    if ( AddNormalinputs(mtx,mypk,txfee+CC_MARKER_VALUE,3) > 0 )
+        CCERR_RESULT("channelscc",CCLOG_INFO, stream << "cannot close, you are not channel owner");
+    if ( AddNormalinputs(mtx,mypk,txfee+CC_MARKER_VALUE,3,pk.IsValid()) > 0 )
     {
         if ((funds=AddChannelsInputs(cp,mtx,channelOpenTx,prevtxid,mypk)) !=0 && funds>0)
         {
@@ -677,18 +624,12 @@ std::string ChannelClose(uint64_t txfee,uint256 opentxid)
             return(FinalizeCCTx(0,cp,mtx,mypk,txfee,EncodeChannelsOpRet('C',tokenid,opentxid,mypk,destpub,funds/payment,payment,zeroid)));
         }
         else
-        {
-            CCerror = strprintf("error adding CC inputs");
-            LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-            return("");
-        }
+            CCERR_RESULT("channelscc",CCLOG_INFO, stream << "error adding CC inputs");
     }
-    CCerror = strprintf("error adding normal inputs");
-    LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-    return("");
+    CCERR_RESULT("channelscc",CCLOG_INFO, stream << "error adding normal inputs");
 }
 
-std::string ChannelRefund(uint64_t txfee,uint256 opentxid,uint256 closetxid)
+UniValue ChannelRefund(const CPubKey& pk, uint64_t txfee,uint256 opentxid,uint256 closetxid)
 {
     CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
     CPubKey mypk; struct CCcontract_info *cp,C; int64_t funds,payment,param2;
@@ -701,60 +642,28 @@ std::string ChannelRefund(uint64_t txfee,uint256 opentxid,uint256 closetxid)
     cp = CCinit(&C,EVAL_CHANNELS);
     if ( txfee == 0 )
         txfee = 10000;
-    mypk = pubkey2pk(Mypubkey());
-    if (GetTransaction(closetxid,channelCloseTx,hashblock,false) == 0)
-    {
-        CCerror = strprintf("invalid channel close txid");
-        LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return ("");
-    }
+    mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
+    if (myGetTransaction(closetxid,channelCloseTx,hashblock) == 0)
+        CCERR_RESULT("channelscc",CCLOG_INFO, stream << "invalid channel close txid");
     if ((numvouts=channelCloseTx.vout.size()) < 1 || DecodeChannelsOpRet(channelCloseTx.vout[numvouts-1].scriptPubKey,tokenid,txid,srcpub,destpub,param1,param2,param3)!='C')
-    {
-        CCerror = strprintf("invalid channel close tx");
-        LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return ("");
-    }
+        CCERR_RESULT("channelscc",CCLOG_INFO, stream << "invalid channel close tx");
     if (komodo_txnotarizedconfirmed(closetxid)==false)
-    {
-        CCerror = strprintf("channelsclose tx not yet confirmed/notarized");
-        LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
+        CCERR_RESULT("channelscc",CCLOG_INFO, stream << "channelsclose tx not yet confirmed/notarized");
     if (txid!=opentxid)
-    {
-        CCerror = strprintf("open and close txid are not from same channel");
-        LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return ("");
-    }
-    if (GetTransaction(opentxid,channelOpenTx,hashblock,false) == 0)
-    {
-        CCerror = strprintf("invalid channel open txid");
-        LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return ("");
-    }
+        CCERR_RESULT("channelscc",CCLOG_INFO, stream << "open and close txid are not from same channel");
+    if (myGetTransaction(opentxid,channelOpenTx,hashblock) == 0)
+        CCERR_RESULT("channelscc",CCLOG_INFO, stream << "invalid channel open txid");
     if (komodo_txnotarizedconfirmed(opentxid)==false)
-    {
-        CCerror = strprintf("channelsopen tx not yet confirmed/notarized");
-        LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
+        CCERR_RESULT("channelscc",CCLOG_INFO, stream << "channelsopen tx not yet confirmed/notarized");
     if ((numvouts=channelOpenTx.vout.size()) < 1 || DecodeChannelsOpRet(channelOpenTx.vout[numvouts-1].scriptPubKey,tokenid,txid,srcpub,destpub,numpayments,payment,hashchain)!='O')
-    {
-        CCerror = strprintf("invalid channel open tx");
-        LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return ("");
-    }
+        CCERR_RESULT("channelscc",CCLOG_INFO, stream << "invalid channel open tx");
     if (mypk != srcpub)
-    {
-        CCerror = strprintf("cannot refund, you are not the channel owner");
-        LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
-    if ( AddNormalinputs(mtx,mypk,txfee+CC_MARKER_VALUE,3) > 0 )
+        CCERR_RESULT("channelscc",CCLOG_INFO, stream << "cannot refund, you are not the channel owner");
+    if ( AddNormalinputs(mtx,mypk,txfee+CC_MARKER_VALUE,3,pk.IsValid()) > 0 )
     {
         if ((funds=AddChannelsInputs(cp,mtx,channelOpenTx,prevtxid,mypk)) !=0 && funds>0)
         {
-            if ((GetTransaction(prevtxid,prevTx,hashblock,false) != 0) && (numvouts=prevTx.vout.size()) > 0 &&
+            if ((myGetTransaction(prevtxid,prevTx,hashblock) != 0) && (numvouts=prevTx.vout.size()) > 0 &&
                 DecodeChannelsOpRet(prevTx.vout[numvouts-1].scriptPubKey, tokenid, txid, srcpub, destpub, param1, param2, param3) != 0)
             {
                 mtx.vout.push_back(MakeCC1vout(EVAL_CHANNELS,CC_MARKER_VALUE,mypk));
@@ -764,47 +673,34 @@ std::string ChannelRefund(uint64_t txfee,uint256 opentxid,uint256 closetxid)
                 return(FinalizeCCTx(0,cp,mtx,mypk,txfee,EncodeChannelsOpRet('R',tokenid,opentxid,mypk,destpub,funds/payment,payment,closetxid)));
             }
             else
-            {
-                CCerror = strprintf("previous tx is invalid");
-                LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-                return("");
-            }
+                CCERR_RESULT("channelscc",CCLOG_INFO, stream << "previous tx is invalid");
         }
         else
-        {
-            CCerror = strprintf("error adding CC inputs");
-            LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-            return("");
-        }
+            CCERR_RESULT("channelscc",CCLOG_INFO, stream << "error adding CC inputs");
     }
-    CCerror = strprintf("error adding normal inputs");
-    LOGSTREAM("channelscc",CCLOG_INFO, stream << CCerror << std::endl);
-    return("");
+    CCERR_RESULT("channelscc",CCLOG_INFO, stream << "error adding normal inputs");
 }
 
-UniValue ChannelsList()
+UniValue ChannelsList(const CPubKey& pk)
 {
-    UniValue result(UniValue::VOBJ); std::vector<std::pair<CAddressIndexKey, CAmount> > txids; struct CCcontract_info *cp,C; uint256 txid,hashBlock,tmp_txid,param3,tokenid;
-    CTransaction tx; char myCCaddr[65],addr[65],str[256]; CPubKey mypk,srcpub,destpub; int32_t vout,numvouts,param1;
+    UniValue result(UniValue::VOBJ); std::vector<uint256> txids; struct CCcontract_info *cp,C; uint256 txid,hashBlock,tmp_txid,param3,tokenid;
+    CTransaction tx; char myCCaddr[65],str[512],pub[34]; CPubKey mypk,srcpub,destpub; int32_t vout,numvouts,param1;
     int64_t nValue,param2;
 
     cp = CCinit(&C,EVAL_CHANNELS);
-    mypk = pubkey2pk(Mypubkey());
+    mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
     GetCCaddress(cp,myCCaddr,mypk);
-    SetCCtxids(txids,myCCaddr,true);
+    SetCCtxids(txids,myCCaddr,true,EVAL_CHANNELS,zeroid,'O');
     result.push_back(Pair("result","success"));
     result.push_back(Pair("name","Channels List"));
-    for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=txids.begin(); it!=txids.end(); it++)
+    for (std::vector<uint256>::const_iterator it=txids.begin(); it!=txids.end(); it++)
     {
-        txid = it->first.txhash;
-        vout = (int32_t)it->first.index;
-        nValue = (int64_t)it->second;
-        if ( (vout == 1 || vout == 2) && nValue == CC_MARKER_VALUE && GetTransaction(txid,tx,hashBlock,false) != 0 && (numvouts= tx.vout.size()) > 0 )
+        txid = *it;
+        if ( myGetTransaction(txid,tx,hashBlock) != 0 && (numvouts= tx.vout.size()) > 0 )
         {
             if (DecodeChannelsOpRet(tx.vout[numvouts-1].scriptPubKey,tokenid,tmp_txid,srcpub,destpub,param1,param2,param3) == 'O')
             {                
-                GetCCaddress1of2(cp,addr,srcpub,destpub);
-                sprintf(str,"%s - %lld payments of %lld satoshi",addr,(long long)param1,(long long)param2);                
+                sprintf(str,"%lld payments of %lld satoshi to %s",(long long)param1,(long long)param2,pubkey33_str(pub,(uint8_t *)&destpub));                
                 result.push_back(Pair(txid.GetHex().data(),str));
             }
         }
@@ -812,20 +708,20 @@ UniValue ChannelsList()
     return(result);
 }
 
-UniValue ChannelsInfo(uint256 channeltxid)
+UniValue ChannelsInfo(const CPubKey& pk,uint256 channeltxid)
 {
-    UniValue result(UniValue::VOBJ),array(UniValue::VARR); CTransaction tx,opentx; uint256 txid,tmp_txid,hashBlock,param3,opentxid,hashchain,prevtxid,tokenid;
+    UniValue result(UniValue::VOBJ),array(UniValue::VARR); CTransaction tx,opentx; uint256 txid,tmp_txid,hashBlock,param3,opentxid,hashchain,tokenid;
     struct CCcontract_info *cp,C; char CCaddr[65],addr[65],str[512]; int32_t vout,numvouts,param1,numpayments;
     int64_t param2,payment; CPubKey srcpub,destpub,mypk;
-    std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex; std::vector<uint256> txids;
+    std::vector<uint256> txids; std::vector<CTransaction> txs;
     
     cp = CCinit(&C,EVAL_CHANNELS);
-    mypk = pubkey2pk(Mypubkey());
+    mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
     
-    if (GetTransaction(channeltxid,tx,hashBlock,false) != 0 && (numvouts= tx.vout.size()) > 0 &&
+    if (myGetTransaction(channeltxid,tx,hashBlock) != 0 && (numvouts= tx.vout.size()) > 0 &&
         (DecodeChannelsOpRet(tx.vout[numvouts-1].scriptPubKey,tokenid,opentxid,srcpub,destpub,param1,param2,param3) == 'O'))
     {    
-        GetCCaddress(cp,CCaddr,mypk);
+        GetCCaddress1of2(cp,CCaddr,srcpub,destpub);
         Getscriptaddress(addr,CScript() << ParseHex(HexStr(destpub)) << OP_CHECKSIG);
         result.push_back(Pair("result","success"));
         result.push_back(Pair("Channel CC address",CCaddr));
@@ -841,40 +737,41 @@ UniValue ChannelsInfo(uint256 channeltxid)
         {
             result.push_back(Pair("Denomination (satoshi)",i64tostr(param2)));
             result.push_back(Pair("Amount (satoshi)",i64tostr(param1*param2)));
-        }        
-        SetCCtxids(addressIndex,CCaddr,true);                      
-        for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=addressIndex.begin(); it!=addressIndex.end(); it++)
+        }
+        GetCCaddress(cp,CCaddr,mypk);
+        SetCCtxids(txids,CCaddr,true,EVAL_CHANNELS,channeltxid,0);                      
+        for (std::vector<uint256>::const_iterator it=txids.begin(); it!=txids.end(); it++)
         {
-            if (GetTransaction(it->first.txhash,tx,hashBlock,false) != 0 && (numvouts= tx.vout.size()) > 0 )
-                if (DecodeChannelsOpRet(tx.vout[numvouts-1].scriptPubKey,tokenid,tmp_txid,srcpub,destpub,param1,param2,param3)!=0 && (tmp_txid==channeltxid || tx.GetHash()==channeltxid))
-                    txids.push_back(it->first.txhash);               
+            if (myGetTransaction(*it,tx,hashBlock) != 0 && (numvouts= tx.vout.size()) > 0 &&
+                DecodeChannelsOpRet(tx.vout[numvouts-1].scriptPubKey,tokenid,tmp_txid,srcpub,destpub,param1,param2,param3)!=0 && (tmp_txid==channeltxid || tx.GetHash()==channeltxid))
+                    txs.push_back(tx);               
         }
-        BOOST_FOREACH(const CTxMemPoolEntry &e, mempool.mapTx)
+        std::vector<CTransaction> tmp_txs;
+        myGet_mempool_txs(tmp_txs,EVAL_CHANNELS,'P');
+        for (std::vector<CTransaction>::const_iterator it=tmp_txs.begin(); it!=tmp_txs.end(); it++)
         {
-            const CTransaction &txmempool = e.GetTx();
-            const uint256 &hash = txmempool.GetHash();
+            const CTransaction &txmempool = *it;
 
             if ((numvouts=txmempool.vout.size()) > 0 && DecodeChannelsOpRet(txmempool.vout[numvouts-1].scriptPubKey,tokenid,tmp_txid,srcpub,destpub,param1,param2,param3) == 'P' && tmp_txid==channeltxid)
-                txids.push_back(hash);                
+                txs.push_back(txmempool);                
         }
-        prevtxid=zeroid; 
-        for (std::vector<uint256>::const_iterator it=txids.begin(); it!=txids.end(); it++)
+        for (std::vector<CTransaction>::const_iterator it=txs.begin(); it!=txs.end(); it++)
         {
-            txid=*it;
-            if (txid!=prevtxid && GetTransaction(txid,tx,hashBlock,false) != 0 && (numvouts= tx.vout.size()) > 0 )
+            tx=*it;
+            if ((numvouts= tx.vout.size()) > 0 )
             {
                 UniValue obj(UniValue::VOBJ);               
                 if (DecodeChannelsOpRet(tx.vout[numvouts-1].scriptPubKey,tokenid,tmp_txid,srcpub,destpub,param1,param2,param3) == 'O' && tx.GetHash()==channeltxid)
                 {
-                    obj.push_back(Pair("Open",txid.GetHex().data()));
+                    obj.push_back(Pair("Open",tx.GetHash().GetHex().data()));
                 }
                 else if (DecodeChannelsOpRet(tx.vout[numvouts-1].scriptPubKey,tokenid,opentxid,srcpub,destpub,param1,param2,param3) == 'P' && opentxid==channeltxid)
                 {
-                    if (GetTransaction(opentxid,opentx,hashBlock,false) != 0 && (numvouts=opentx.vout.size()) > 0 &&
+                    if (myGetTransaction(opentxid,opentx,hashBlock) != 0 && (numvouts=opentx.vout.size()) > 0 &&
                             DecodeChannelsOpRet(opentx.vout[numvouts-1].scriptPubKey,tokenid,tmp_txid,srcpub,destpub,numpayments,payment,hashchain) == 'O')
                     {
                         Getscriptaddress(str,tx.vout[3].scriptPubKey);  
-                        obj.push_back(Pair("Payment",txid.GetHex().data()));
+                        obj.push_back(Pair("Payment",tx.GetHash().GetHex().data()));
                         obj.push_back(Pair("Number of payments",param2));
                         obj.push_back(Pair("Amount",param2*payment));
                         obj.push_back(Pair("Destination",str));
@@ -884,18 +781,17 @@ UniValue ChannelsInfo(uint256 channeltxid)
                 }
                 else if (DecodeChannelsOpRet(tx.vout[numvouts-1].scriptPubKey,tokenid,opentxid,srcpub,destpub,param1,param2,param3) == 'C' && opentxid==channeltxid)
                 {
-                    obj.push_back(Pair("Close",txid.GetHex().data()));
+                    obj.push_back(Pair("Close",tx.GetHash().GetHex().data()));
                 }
                 else if (DecodeChannelsOpRet(tx.vout[numvouts-1].scriptPubKey,tokenid,opentxid,srcpub,destpub,param1,param2,param3) == 'R' && opentxid==channeltxid)
                 {
                     Getscriptaddress(str,tx.vout[2].scriptPubKey);                        
-                    obj.push_back(Pair("Refund",txid.GetHex().data()));                        
+                    obj.push_back(Pair("Refund",tx.GetHash().GetHex().data()));                        
                     obj.push_back(Pair("Amount",param1*param2));
                     obj.push_back(Pair("Destination",str));
                 }
                 array.push_back(obj);
             }
-            prevtxid=txid;
         }        
         result.push_back(Pair("Transactions",array));
     }
diff --git a/src/cc/crypto777/OS_portable.h b/src/cc/crypto777/OS_portable.h
index aeb45bc3..e0b185cb 100644
--- a/src/cc/crypto777/OS_portable.h
+++ b/src/cc/crypto777/OS_portable.h
@@ -206,12 +206,12 @@ void OS_nonportable_randombytes(uint8_t *x,long xlen);
 int32_t OS_nonportable_init();
 #endif
 
-void OS_portable_init();
-void OS_init();
+void OS_portable_init(void);
+void OS_init(void);
 int32_t sortds(double *buf,uint32_t num,int32_t size);
 int32_t revsortds(double *buf,uint32_t num,int32_t size);
 
-double OS_portable_milliseconds();
+double OS_portable_milliseconds(void);
 void OS_portable_randombytes(uint8_t *x,long xlen);
 int32_t OS_portable_truncate(char *fname,long filesize);
 char *OS_portable_path(char *str);
@@ -256,7 +256,7 @@ int32_t OS_removefile(char *fname,int32_t scrubflag);
 void *OS_mapfile(char *fname,long *filesizep,int32_t enablewrite);
 int32_t OS_releasemap(void *ptr,unsigned long filesize);
 
-double OS_milliseconds();
+double OS_milliseconds(void);
 void OS_randombytes(uint8_t *x,long xlen);
 
 //int32_t OS_syncmap(struct OS_mappedptr *mp,long len);
@@ -313,7 +313,7 @@ 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();
+char *OS_mvstr(void);
 
 long _stripwhite(char *buf,int accept);
 int32_t is_DST(int32_t datenum);
@@ -381,7 +381,7 @@ double dxblend(double *destp,double val,double decay);
 uint64_t calc_ipbits(char *ip_port);
 void expand_ipbits(char *ipaddr,uint64_t ipbits);
 void escape_code(char *escaped,char *str);
-void SaM_PrepareIndices();
+void SaM_PrepareIndices(void);
 
 // iguana_serdes.c
 #ifndef IGUANA_LOG2PACKETSIZE
diff --git a/src/cc/customcc.cpp b/src/cc/customcc.cpp
index bd738c43..8ea1ab7f 100644
--- a/src/cc/customcc.cpp
+++ b/src/cc/customcc.cpp
@@ -62,7 +62,7 @@ UniValue custom_func1(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
     if ( txfee == 0 )
         txfee = CUSTOM_TXFEE;
     mypk = pubkey2pk(Mypubkey());
-    if ( AddNormalinputs(mtx,mypk,COIN+txfee,64) >= COIN+txfee ) // add utxo to mtx
+    if ( AddNormalinputs2(mtx,COIN+txfee,64) >= COIN+txfee ) // add utxo to mtx
     {
         // make op_return payload as normal. 
         CScript opret = custom_opret('1',mypk);
diff --git a/src/cc/dapps/cJSON.c b/src/cc/dapps/cJSON.c
index 62f46444..e1d7801a 100644
--- a/src/cc/dapps/cJSON.c
+++ b/src/cc/dapps/cJSON.c
@@ -40,7 +40,10 @@ long stripquotes(char *str)
         return(0);
     len = strlen(str);
     if ( str[0] == '"' && str[len-1] == '"' )
-        str[len-1] = 0, offset = 1;
+    {
+        str[len-1] = 0;
+        offset = 1;
+    }
     else offset = 0;
     return(offset);
 }
diff --git a/src/cc/dapps/zmigrate.c b/src/cc/dapps/zmigrate.c
index ea808582..f7d9e3fe 100644
--- a/src/cc/dapps/zmigrate.c
+++ b/src/cc/dapps/zmigrate.c
@@ -1041,6 +1041,7 @@ int32_t itemvalid(char *refcoin,int64_t *refundedp,int64_t *waitingp,struct clai
     *refundedp = *waitingp = 0;
     if ( item->refundvalue < 0 )
         return(-1);
+    // change "kmd" -> %s, tolowerstr(refcoin)
     sprintf(url,"https://kmd.explorer.dexstats.info/insight-api-komodo/addr/%s",item->destaddr);
     if ( (retstr= send_curl(url,"/tmp/itemvalid")) != 0 )
     {
@@ -1061,7 +1062,7 @@ int32_t itemvalid(char *refcoin,int64_t *refundedp,int64_t *waitingp,struct clai
             }
             free_json(curljson);
         }
-        //printf("%s\n",retstr);
+        printf("%s\n",retstr);
         free(retstr);
     }
     if ( item->approved != 0 )
@@ -1086,18 +1087,19 @@ void scan_claims(int32_t issueflag,char *refcoin,int32_t batchid)
     else if ( batchid == 2 )
     {
         batchmin = 1;//777 * SATOSHIDEN;
-        batchmax = 77777 * SATOSHIDEN;
+        batchmax = 5000 * SATOSHIDEN;
     }
     else if ( batchid == 3 )
     {
-        batchmin = 77777 * SATOSHIDEN;
-        batchmax = 1000000 * SATOSHIDEN;
+        batchmin = 1;//117777 * SATOSHIDEN;
+        batchmax = 10000000 * SATOSHIDEN;
     }
     for (i=0; i<NUM_CLAIMS; i++)
     {
         item = &CLAIMS[i];
         if ( item->refundvalue < batchmin || item->refundvalue >= batchmax )
             continue;
+        printf("check.%d %s %.8f vs refund %.8f -> %s\n",batchid,item->oldaddr,dstr(item->total),dstr(item->refundvalue),item->destaddr);
         if ( itemvalid(refcoin,&refunded,&waiting,item) < 0 )
         {
             if ( refunded != 0 )
@@ -1170,7 +1172,7 @@ int32_t update_claimvalue(int32_t *disputedp,char *addr,int64_t amount,bits256 t
             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));
+                printf("disputed.%d (%s) %s claimed %.8f vs %.8f\n",item->disputed,item->username,addr,dstr(item->total),dstr(amount));
             item->txid = txid;
             if ( item->disputed != 0 )
                 *disputedp = 1;
@@ -1183,6 +1185,7 @@ int32_t update_claimvalue(int32_t *disputedp,char *addr,int64_t amount,bits256 t
 int64_t update_claimstats(char *username,char *oldaddr,char *destaddr,int64_t amount)
 {
     int32_t i; struct claimitem *item;
+    printf("claim user.(%s) (%s) -> (%s) %.8f\n",username,oldaddr,destaddr,dstr(amount));
     for (i=0; i<NUM_CLAIMS; i++)
     {
         if ( strcmp(oldaddr,CLAIMS[i].oldaddr) == 0 )
@@ -1191,7 +1194,7 @@ int64_t update_claimstats(char *username,char *oldaddr,char *destaddr,int64_t am
             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);
+                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;
@@ -1258,14 +1261,14 @@ int64_t sum_of_vins(char *refcoin,int32_t *totalvinsp,int32_t *uniqaddrsp,bits25
     return(total);
 }
 
-void reconcile_claims(char *fname)
+void reconcile_claims(char *refcoin,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);
+            printf("%d.(%s)\n",numlines,buf);
             str = buf;
             n = i = 0;
             memset(fields,0,sizeof(fields));
@@ -1277,7 +1280,7 @@ void reconcile_claims(char *fname)
                     i = 0;
                     if ( n > 1 )
                     {
-                        //printf("(%16s) ",fields[n]);
+                        printf("(%16s) ",fields[n]);
                     }
                     n++;
                     if ( *str == '\n' || *str == '\r' )
@@ -1287,8 +1290,8 @@ void reconcile_claims(char *fname)
                     str++;
                 else fields[n][i++] = *str++;
             }
-            //printf("%s\n",fields[0]);
-            total += update_claimstats(fields[1],fields[3],fields[6],atof(fields[4])*SATOSHIDEN + 0.0000000049);
+            printf("%s\n",fields[1]);
+            total += update_claimstats(fields[1],fields[3],fields[5 + (strcmp("KMD",refcoin)==0)],atof(fields[4])*SATOSHIDEN + 0.0000000049);
             numlines++;
         }
         fclose(fp);
@@ -1326,7 +1329,7 @@ int32_t main(int32_t argc,char **argv)
     if ( 1 )//strcmp(coinstr,"KMD") == 0 )
     {
         sprintf(buf,"%s-Claims.csv",coinstr);
-        reconcile_claims(buf);
+        reconcile_claims(coinstr,buf);
         for (i=0; i<NUM_CLAIMS; i++)
         {
             if ( CLAIMS[i].disputed != 0 )
@@ -1393,8 +1396,8 @@ int32_t main(int32_t argc,char **argv)
         }
         //scan_claims(0,coinstr,0);
         //scan_claims(0,coinstr,1);
-        scan_claims(0,coinstr,2);
-        //scan_claims(0,coinstr,3);
+        //scan_claims(0,coinstr,2);
+        scan_claims(1,coinstr,3);
     }
     else if ( (retjson= get_listunspent(coinstr,acstr)) != 0 )
     {
diff --git a/src/cc/dice.cpp b/src/cc/dice.cpp
index 4ceb4b7c..c2333941 100644
--- a/src/cc/dice.cpp
+++ b/src/cc/dice.cpp
@@ -610,6 +610,7 @@ uint256 DiceHashEntropy(uint256 &entropy,uint256 _txidpriv,int32_t vout,int32_t
             LogPrintf("%02x",ssecret2.bytes[i]);
         LogPrintf(" ssecret2 dont match\n");
     }
+    memset(tmp256.bytes,0,32);
     //char str[65],str2[65];
     //LogPrintf("generated house hentropy.%s <- entropy.%s\n",uint256_str(str,hentropy),uint256_str(str2,entropy));
     return(hentropy);
@@ -1246,9 +1247,9 @@ int64_t DicePlanFunds(uint64_t &entropyval,uint256 &entropytxid,uint64_t refsbit
 bool DicePlanExists(CScript &fundingPubKey,uint256 &fundingtxid,struct CCcontract_info *cp,uint64_t refsbits,CPubKey dicepk,int64_t &minbet,int64_t &maxbet,int64_t &maxodds,int64_t &timeoutblocks)
 {
     char CCaddr[64]; uint64_t sbits=0; uint256 txid,hashBlock; CTransaction tx;
-    std::vector<std::pair<CAddressIndexKey, CAmount> > txids;
+    std::vector<uint256> txids;
     GetCCaddress(cp,CCaddr,dicepk);
-    SetCCtxids(txids,cp->normaladdr,false);
+    SetCCtxids(txids,cp->normaladdr,false,cp->evalcode,zeroid,'F');
     if ( fundingtxid != zeroid ) // avoid scan unless creating new funding plan
     {
         //LogPrintf("check fundingtxid\n");
@@ -1262,10 +1263,9 @@ bool DicePlanExists(CScript &fundingPubKey,uint256 &fundingtxid,struct CCcontrac
         } else LogPrintf("couldnt get funding tx\n");
         return(false);
     }
-    for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=txids.begin(); it!=txids.end(); it++)
+    for (std::vector<uint256>::const_iterator it=txids.begin(); it!=txids.end(); it++)
     {
-        //int height = it->first.blockHeight;
-        txid = it->first.txhash;
+        txid = *it;
         if ( fundingtxid != zeroid && txid != fundingtxid )
             continue;
         if ( myGetTransaction(txid,tx,hashBlock) != 0 && tx.vout.size() > 0 && ConstrainVout(tx.vout[0],1,CCaddr,0) != 0 )
@@ -1342,12 +1342,12 @@ UniValue DiceInfo(uint256 diceid)
 
 UniValue DiceList()
 {
-    UniValue result(UniValue::VARR); std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex; struct CCcontract_info *cp,C; uint256 txid,hashBlock; CTransaction vintx; uint64_t sbits; int64_t minbet,maxbet,maxodds,timeoutblocks; char str[65];
+    UniValue result(UniValue::VARR); std::vector<uint256> txids; struct CCcontract_info *cp,C; uint256 txid,hashBlock; CTransaction vintx; uint64_t sbits; int64_t minbet,maxbet,maxodds,timeoutblocks; char str[65];
     cp = CCinit(&C,EVAL_DICE);
-    SetCCtxids(addressIndex,cp->normaladdr,false);
-    for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=addressIndex.begin(); it!=addressIndex.end(); it++)
+    SetCCtxids(txids,cp->normaladdr,false,cp->evalcode,zeroid,'F');
+    for (std::vector<uint256>::const_iterator it=txids.begin(); it!=txids.end(); it++)
     {
-        txid = it->first.txhash;
+        txid = *it;
         if ( myGetTransaction(txid,vintx,hashBlock) != 0 )
         {
             if ( vintx.vout.size() > 0 && DecodeDiceFundingOpRet(vintx.vout[vintx.vout.size()-1].scriptPubKey,sbits,minbet,maxbet,maxodds,timeoutblocks) != 0 )
diff --git a/src/cc/dilithium.c b/src/cc/dilithium.c
index 475557c2..35c64aea 100644
--- a/src/cc/dilithium.c
+++ b/src/cc/dilithium.c
@@ -3148,6 +3148,8 @@ UniValue dilithium_keypair(uint64_t txfee,struct CCcontract_info *cp,cJSON *para
     if ( externalflag == 0 )
         result.push_back(Pair("warning","test mode using privkey for -pubkey, only for testing. there is no point using quantum secure signing if you are using a privkey with a known secp256k1 pubkey!!"));
     result.push_back(Pair("result","success"));
+    memset(seed,0,32);
+    memset(sk,0,sizeof(sk));
     return(result);
 }
 
@@ -3194,9 +3196,23 @@ UniValue dilithium_register(uint64_t txfee,struct CCcontract_info *cp,cJSON *par
                 if ( CCchange != 0 )
                     mtx.vout.push_back(MakeCC1vout(cp->evalcode,CCchange,dilithiumpk));
                 rawtx = FinalizeCCTx(0,cp,mtx,mypk,txfee,dilithium_registeropret(handle,mypk,bigpub));
+                memset(seed,0,32);
+                memset(sk,0,sizeof(sk));
                 return(musig_rawtxresult(result,rawtx));
-            } else return(cclib_error(result,"couldnt find enough funds"));
-        } else return(cclib_error(result,"not enough parameters"));
+            }
+            else
+            {
+                memset(seed,0,32);
+                memset(sk,0,sizeof(sk));
+                return(cclib_error(result,"couldnt find enough funds"));
+            }
+        }
+        else
+        {
+            memset(seed,0,32);
+            memset(sk,0,sizeof(sk));
+            return(cclib_error(result,"not enough parameters"));
+        }
     } else return(cclib_error(result,"not dilithiumpk funds"));
 }
 
@@ -3222,9 +3238,23 @@ UniValue dilithium_sign(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
             result.push_back(Pair("signature",dilithium_hexstr(str,sm,smlen)));
             calc_rmd160_sha256(rmd160,sm,smlen);
             result.push_back(Pair("sighash",dilithium_hexstr(str,rmd160,20)));
+            memset(seed,0,32);
+            memset(sk,0,sizeof(sk));
             return(result);
-        } else return(cclib_error(result,"unexpected signed message len"));
-    } else return(cclib_error(result,"not enough parameters"));
+        }
+        else
+        {
+            memset(seed,0,32);
+            memset(sk,0,sizeof(sk));
+            return(cclib_error(result,"unexpected signed message len"));
+        }
+    }
+    else
+    {
+        memset(seed,0,32);
+        memset(sk,0,sizeof(sk));
+        return(cclib_error(result,"not enough parameters"));
+    }
 }
 
 UniValue dilithium_verify(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
@@ -3289,7 +3319,7 @@ UniValue dilithium_send(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
 UniValue dilithium_spend(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
 {
     CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
-    UniValue result(UniValue::VOBJ); std::string rawtx; CPubKey mypk,destpub33; CTransaction vintx; uint256 prevhash,hashBlock,destpubtxid; int32_t i,smlen,n,numvouts; char str[129],*scriptstr; CTxOut vout; std::string handle; uint8_t pk[CRYPTO_PUBLICKEYBYTES],pk2[CRYPTO_PUBLICKEYBYTES],sk[CRYPTO_SECRETKEYBYTES],msg[32],seed[32]; std::vector<uint8_t> sig;
+    UniValue result(UniValue::VOBJ); std::string rawtx; CPubKey mypk,destpub33; CTransaction vintx; uint256 prevhash,hashBlock,destpubtxid; int32_t i,smlen,n,numvouts; char str[129],*scriptstr,*retstr=""; CTxOut vout; std::string handle; uint8_t pk[CRYPTO_PUBLICKEYBYTES],pk2[CRYPTO_PUBLICKEYBYTES],sk[CRYPTO_SECRETKEYBYTES],msg[32],seed[32]; std::vector<uint8_t> sig;
     if ( txfee == 0 )
         txfee = DILITHIUM_TXFEE;
     mypk = pubkey2pk(Mypubkey());
@@ -3317,23 +3347,31 @@ UniValue dilithium_spend(uint64_t txfee,struct CCcontract_info *cp,cJSON *params
                 if ( dilithium_sendopretdecode(destpubtxid,vintx.vout[numvouts-1].scriptPubKey) == 'x' )
                 {
                     if ( dilithium_bigpubget(handle,destpub33,pk2,destpubtxid) < 0 )
-                        return(cclib_error(result,"couldnt get bigpub"));
+                        retstr = (char *)"couldnt get bigpub";
                     else if ( memcmp(pk,pk2,sizeof(pk)) != 0 )
-                        return(cclib_error(result,"dilithium bigpub mismatch"));
+                        retstr = (char *)"dilithium bigpub mismatch";
                     else if ( destpub33 != mypk )
-                        return(cclib_error(result,"destpub33 is not for this -pubkey"));
+                        retstr = (char *)"destpub33 is not for this -pubkey";
                     else if ( _dilithium_sign(&sig[0],&smlen,msg,32,sk) < 0 )
-                        return(cclib_error(result,"dilithium signing error"));
+                        retstr = (char *)"dilithium signing error";
                     else if ( smlen != 32+CRYPTO_BYTES )
-                        return(cclib_error(result,"siglen error"));
-                    mtx.vin.push_back(CTxIn(prevhash,0));
-                    mtx.vout.push_back(vout);
-                    rawtx = FinalizeCCTx(0,cp,mtx,mypk,txfee,dilithium_spendopret(destpubtxid,sig));
-                    return(dilithium_rawtxresult(result,rawtx));
-                } else return(cclib_error(result,"couldnt decode send opret"));
-            } else return(cclib_error(result,"couldnt find vin0"));
-        } else return(cclib_error(result,"script or bad destpubtxid is not hex"));
-    } else return(cclib_error(result,"need to have exactly 2 params sendtxid, scriptPubKey"));
+                        retstr = (char *)"siglen error";
+                    else
+                    {
+                        mtx.vin.push_back(CTxIn(prevhash,0));
+                        mtx.vout.push_back(vout);
+                        rawtx = FinalizeCCTx(0,cp,mtx,mypk,txfee,dilithium_spendopret(destpubtxid,sig));
+                        memset(seed,0,32);
+                        memset(sk,0,sizeof(sk));
+                        return(dilithium_rawtxresult(result,rawtx));
+                    }
+                } else retstr = (char *)"couldnt decode send opret";
+            } else retstr = (char *)"couldnt find vin0";
+        } else retstr = (char *)"script or bad destpubtxid is not hex";
+    } else retstr = (char *)"need to have exactly 2 params sendtxid, scriptPubKey";
+    memset(seed,0,32);
+    memset(sk,0,sizeof(sk));
+    return(cclib_error(result,retstr));
 }
 
 int64_t dilithium_inputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPubKey pk,uint256 destpubtxid,int64_t total,int32_t maxinputs,char *cmpaddr)
@@ -3354,7 +3392,7 @@ int64_t dilithium_inputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPu
         //char str[65]; LogPrintf("%s check %s/v%d %.8f vs %.8f\n",coinaddr,uint256_str(str,txid),vout,(double)it->second.satoshis/COIN,(double)threshold/COIN);
         if ( it->second.satoshis < threshold || it->second.satoshis == DILITHIUM_TXFEE )
             continue;
-        if ( GetTransaction(txid,vintx,hashBlock,false) != 0 && (numvouts= vintx.vout.size()) > 1 )
+        if ( myGetTransaction(txid,vintx,hashBlock) != 0 && (numvouts= vintx.vout.size()) > 1 )
         {
             if ( (nValue= IsCClibvout(cp,vintx,vout,cmpaddr)) > DILITHIUM_TXFEE && myIsutxo_spentinmempool(ignoretxid,ignorevin,txid,vout) == 0 )
             {
@@ -3377,7 +3415,7 @@ int64_t dilithium_inputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPu
 UniValue dilithium_Qsend(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
 {
     CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
-    UniValue result(UniValue::VOBJ); std::string rawtx; CPubKey mypk,destpub33; CTransaction tx,vintx; uint256 prevhash,mypubtxid,hashBlock,destpubtxid; int64_t amount,inputsum,outputsum,change; int32_t i,smlen,n,numvouts; char str[129],myCCaddr[64],*scriptstr; CTxOut vout; std::string handle; uint8_t pk[CRYPTO_PUBLICKEYBYTES],pk2[CRYPTO_PUBLICKEYBYTES],sk[CRYPTO_SECRETKEYBYTES],msg[32],seed[32]; std::vector<uint8_t> sig; std::vector<uint256> voutpubtxids;
+    UniValue result(UniValue::VOBJ); std::string rawtx; CPubKey mypk,destpub33; CTransaction tx,vintx; uint256 prevhash,mypubtxid,hashBlock,destpubtxid; int64_t amount,inputsum,outputsum,change; int32_t i,smlen,n,numvouts; char str[129],myCCaddr[64],*scriptstr,*retstr=""; CTxOut vout; std::string handle; uint8_t pk[CRYPTO_PUBLICKEYBYTES],pk2[CRYPTO_PUBLICKEYBYTES],sk[CRYPTO_SECRETKEYBYTES],msg[32],seed[32]; std::vector<uint8_t> sig; std::vector<uint256> voutpubtxids;
     if ( txfee == 0 )
         txfee = DILITHIUM_TXFEE;
     mypk = pubkey2pk(Mypubkey());
@@ -3402,6 +3440,8 @@ UniValue dilithium_Qsend(uint64_t txfee,struct CCcontract_info *cp,cJSON *params
                 if ( dilithium_bigpubget(handle,destpub33,pk2,prevhash) < 0 )
                 {
                     result.push_back(Pair("destpubtxid",prevhash.GetHex().c_str()));
+                    memset(seed,0,32);
+                    memset(sk,0,sizeof(sk));
                     return(cclib_error(result,"couldnt find bigpub at destpubtxid"));
                 }
                 else
@@ -3437,19 +3477,27 @@ UniValue dilithium_Qsend(uint64_t txfee,struct CCcontract_info *cp,cJSON *params
             //LogPrintf(" msg\n");
             sig.resize(32+CRYPTO_BYTES);
             if ( dilithium_bigpubget(handle,destpub33,pk2,mypubtxid) < 0 )
-                return(cclib_error(result,"couldnt get bigpub"));
+                retstr = (char *)"couldnt get bigpub";
             else if ( memcmp(pk,pk2,sizeof(pk)) != 0 )
-                return(cclib_error(result,"dilithium bigpub mismatch"));
+                retstr = (char *)"dilithium bigpub mismatch";
             else if ( destpub33 != mypk )
-                return(cclib_error(result,"destpub33 is not for this -pubkey"));
+                retstr = (char *)"destpub33 is not for this -pubkey";
             else if ( _dilithium_sign(&sig[0],&smlen,msg,32,sk) < 0 )
-                return(cclib_error(result,"dilithium signing error"));
+                retstr = (char *)"dilithium signing error";
             else if ( smlen != 32+CRYPTO_BYTES )
-                return(cclib_error(result,"siglen error"));
-            rawtx = FinalizeCCTx(0,cp,mtx,mypk,txfee,dilithium_Qsendopret(mypubtxid,sig,voutpubtxids));
-            return(dilithium_rawtxresult(result,rawtx));
-        } else return(cclib_error(result,"Q couldnt find enough Q or x inputs"));
-    } else return(cclib_error(result,"need to have exactly 2 params sendtxid, scriptPubKey"));
+                retstr = (char *)"siglen error";
+            else
+            {
+                rawtx = FinalizeCCTx(0,cp,mtx,mypk,txfee,dilithium_Qsendopret(mypubtxid,sig,voutpubtxids));
+                memset(seed,0,32);
+                memset(sk,0,sizeof(sk));
+                return(dilithium_rawtxresult(result,rawtx));
+            }
+        } else retstr = (char *)"Q couldnt find enough Q or x inputs";
+    } else retstr = (char *)"need to have exactly 2 params sendtxid, scriptPubKey";
+    memset(seed,0,32);
+    memset(sk,0,sizeof(sk));
+    return(cclib_error(result,retstr));
 }
 
 bool dilithium_Qvalidate(struct CCcontract_info *cp,int32_t height,Eval *eval,const CTransaction tx)
@@ -3532,16 +3580,16 @@ int32_t dilithium_registrationpub33(char *pkaddr,CPubKey &pub33,uint256 txid)
 void dilithium_handleinit(struct CCcontract_info *cp)
 {
     static int32_t didinit;
-    std::vector<std::pair<CAddressIndexKey, CAmount> > txids; struct dilithium_handle *hashstr; CPubKey dilithiumpk,pub33; uint256 txid,hashBlock; CTransaction txi; int32_t numvouts; std::vector<uint8_t> bigpub; std::string handle; char CCaddr[64];
+    std::vector<uint256> txids; struct dilithium_handle *hashstr; CPubKey dilithiumpk,pub33; uint256 txid,hashBlock; CTransaction txi; int32_t numvouts; std::vector<uint8_t> bigpub; std::string handle; char CCaddr[64];
     if ( didinit != 0 )
         return;
     pthread_mutex_init(&DILITHIUM_MUTEX,NULL);
     dilithiumpk = GetUnspendable(cp,0);
     GetCCaddress(cp,CCaddr,dilithiumpk);
-    SetCCtxids(txids,CCaddr,true);
-    for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=txids.begin(); it!=txids.end(); it++)
+    SetCCtxids(txids,CCaddr,true,cp->evalcode,zeroid,'R');
+    for (std::vector<uint256>::const_iterator it=txids.begin(); it!=txids.end(); it++)
     {
-        txid = it->first.txhash;
+        txid = *it;
         if ( myGetTransaction(txid,txi,hashBlock) != 0 && (numvouts= txi.vout.size()) > 1 )
         {
             if ( dilithium_registeropretdecode(handle,pub33,bigpub,txi.vout[numvouts-1].scriptPubKey) == 'R' )
diff --git a/src/cc/eval.cpp b/src/cc/eval.cpp
index f9d85786..e9b4fa7a 100644
--- a/src/cc/eval.cpp
+++ b/src/cc/eval.cpp
@@ -129,7 +129,7 @@ bool Eval::GetTxUnconfirmed(const uint256 &hash, CTransaction &txOut, uint256 &h
 {
     return(myGetTransaction(hash, txOut,hashBlock));
     /*if (!myGetTransaction(hash, txOut,hashBlock)) {
-        return(GetTransaction(hash, txOut,hashBlock));
+        return(myGetTransaction(hash, txOut,hashBlock));
     } else return(true);*/
 }
 
diff --git a/src/cc/faucet.cpp b/src/cc/faucet.cpp
index 37c2bc24..274e4520 100644
--- a/src/cc/faucet.cpp
+++ b/src/cc/faucet.cpp
@@ -35,6 +35,7 @@ int64_t IsFaucetvout(struct CCcontract_info *cp,const CTransaction& tx,int32_t v
     {
         if ( Getscriptaddress(destaddr,tx.vout[v].scriptPubKey) > 0 && strcmp(destaddr,cp->unspendableCCaddr) == 0 )
             return(tx.vout[v].nValue);
+        //else fprintf(stderr,"dest.%s vs (%s)\n",destaddr,cp->unspendableCCaddr);
     }
     return(0);
 }
@@ -159,7 +160,7 @@ int64_t AddFaucetInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPub
             continue;
         //char str[65]; LogPrintf("check %s/v%d %.8f`\n",uint256_str(str,txid),vout,(double)it->second.satoshis/COIN);
         // no need to prevent dup
-        if ( GetTransaction(txid,vintx,hashBlock,false) != 0 )
+        if ( myGetTransaction(txid,vintx,hashBlock) != 0 )
         {
             if ( (nValue= IsFaucetvout(cp,vintx,vout)) > 1000000 && myIsutxo_spentinmempool(ignoretxid,ignorevin,txid,vout) == 0 )
             {
@@ -170,21 +171,21 @@ int64_t AddFaucetInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPub
                 n++;
                 if ( (total > 0 && totalinputs >= total) || (maxinputs > 0 && n >= maxinputs) )
                     break;
-            } else LogPrintf("nValue too small or already spent in mempool\n");
-        } else LogPrintf("couldnt get tx\n");
+            } else LogPrintf("vout.%d nValue %.8f too small or already spent in mempool\n",vout,(double)nValue/COIN);
+        } else LogPrintf("couldn't get tx\n");
     }
     return(totalinputs);
 }
 
-std::string FaucetGet(uint64_t txfee)
+UniValue FaucetGet(const CPubKey& pk, uint64_t txfee)
 {
     CMutableTransaction tmpmtx,mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
-    CPubKey mypk,faucetpk; int64_t inputs,CCchange=0,nValue=FAUCETSIZE; struct CCcontract_info *cp,C; std::string rawhex; uint32_t j; int32_t i,len; uint8_t buf[32768]; bits256 hash;
+    CPubKey faucetpk; int64_t inputs,CCchange=0,nValue=FAUCETSIZE; struct CCcontract_info *cp,C; std::string rawhex; uint32_t j; int32_t i,len; uint8_t buf[32768]; bits256 hash;
     cp = CCinit(&C,EVAL_FAUCET);
     if ( txfee == 0 )
         txfee = 10000;
     faucetpk = GetUnspendable(cp,0);
-    mypk = pubkey2pk(Mypubkey());
+    CPubKey mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
     if ( (inputs= AddFaucetInputs(cp,mtx,faucetpk,nValue+txfee,60)) > 0 )
     {
         if ( inputs > nValue )
@@ -197,41 +198,40 @@ std::string FaucetGet(uint64_t txfee)
         for (i=0; i<1000000; i++,j++)
         {
             tmpmtx = mtx;
-            rawhex = FinalizeCCTx(-1LL,cp,tmpmtx,mypk,txfee,CScript() << OP_RETURN << E_MARSHAL(ss << (uint8_t)EVAL_FAUCET << (uint8_t)'G' << j));
-            if ( (len= (int32_t)rawhex.size()) > 0 && len < 65536 )
+            UniValue result = FinalizeCCTxExt(pk.IsValid (),-1LL,cp,tmpmtx,mypk,txfee,CScript() << OP_RETURN << E_MARSHAL(ss << (uint8_t)EVAL_FAUCET << (uint8_t)'G' << j));
+            if ( (len= (int32_t)result[JSON_HEXTX].getValStr().size()) > 0 && len < 65536 )
             {
                 len >>= 1;
-                decode_hex(buf,len,(char *)rawhex.c_str());
+                decode_hex(buf,len,(char *)result[JSON_HEXTX].getValStr().c_str());
                 hash = bits256_doublesha256(0,buf,len);
                 if ( (hash.bytes[0] & 0xff) == 0 && (hash.bytes[31] & 0xff) == 0 )
                 {
                     LogPrintf("found valid txid after %d iterations %u\n",i,(uint32_t)time(NULL));
-                    return(rawhex);
+                    return result;
                 }
                 //LogPrintf("%02x%02x ",hash.bytes[0],hash.bytes[31]);
             }
         }
-        LogPrintf("couldnt generate valid txid %u\n",(uint32_t)time(NULL));
-        return("");
-    } else LogPrintf("cant find faucet inputs\n");
-    return("");
+        CCERR_RESULT("faucet",CCLOG_ERROR, stream << "couldn't generate valid txid " << (uint32_t)time(NULL));
+    } else CCERR_RESULT("faucet",CCLOG_ERROR, stream << "can't find faucet inputs");
 }
 
-std::string FaucetFund(uint64_t txfee,int64_t funds)
+UniValue FaucetFund(const CPubKey& pk, uint64_t txfee,int64_t funds)
 {
     CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
-    CPubKey mypk,faucetpk; CScript opret; struct CCcontract_info *cp,C;
+    CPubKey faucetpk; CScript opret; struct CCcontract_info *cp,C;
+
     cp = CCinit(&C,EVAL_FAUCET);
     if ( txfee == 0 )
         txfee = 10000;
-    mypk = pubkey2pk(Mypubkey());
+    CPubKey mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
     faucetpk = GetUnspendable(cp,0);
-    if ( AddNormalinputs(mtx,mypk,funds+txfee,64) > 0 )
+    if ( AddNormalinputs(mtx,mypk,funds+txfee,64,pk.IsValid()) > 0 )
     {
         mtx.vout.push_back(MakeCC1vout(EVAL_FAUCET,funds,faucetpk));
-        return(FinalizeCCTx(0,cp,mtx,mypk,txfee,opret));
+        return(FinalizeCCTxExt(pk.IsValid(),0,cp,mtx,mypk,txfee,opret));
     }
-    return("");
+    CCERR_RESULT("faucet",CCLOG_ERROR, stream << "can't find normal inputs");
 }
 
 UniValue FaucetInfo()
diff --git a/src/cc/fsm.cpp b/src/cc/fsm.cpp
index 8b00e8ac..d786b621 100644
--- a/src/cc/fsm.cpp
+++ b/src/cc/fsm.cpp
@@ -42,7 +42,7 @@ bool FSMExactAmounts(struct CCcontract_info *cp,Eval* eval,const CTransaction &t
     numvouts = tx.vout.size();
     for (i=0; i<numvins; i++)
     {
-        //LogPrintf("vini.%d\n",i);
+        //fprintf(stderr,"vini.%d\n",i);
         if ( (*cp->ismyvin)(tx.vin[i].scriptSig) != 0 )
         {
             //LogPrintf("vini.%d check mempool\n",i);
@@ -133,7 +133,7 @@ int64_t AddFSMInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPubKey
         // prevent dup
         if ( it->second.satoshis < 1000000 )
             continue;
-        if ( GetTransaction(txid,vintx,hashBlock,false) != 0 )
+        if ( myGetTransaction(txid,vintx,hashBlock) != 0 )
         {
             if ( (nValue= IsFSMvout(cp,vintx,(int32_t)it->first.index)) > 0 )
             {
diff --git a/src/cc/gamescc.cpp b/src/cc/gamescc.cpp
index 92b7329e..92e7e50c 100644
--- a/src/cc/gamescc.cpp
+++ b/src/cc/gamescc.cpp
@@ -39,7 +39,7 @@ uint64_t _games_rngnext(uint64_t initseed)
 gamesevent games_revendian(gamesevent revx)
 {
     int32_t i; gamesevent x = 0;
-    //LogPrintf("%04x -> ",revx);
+    //fprintf(stderr,"%04x -> ",revx);
     for (i=0; i<sizeof(gamesevent); i++)
         ((uint8_t *)&x)[i] = ((uint8_t *)&revx)[sizeof(gamesevent)-1-i];
     //LogPrintf("%04x\n",x);
@@ -411,7 +411,7 @@ UniValue games_rng(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
 int32_t games_eventsign(uint32_t &timestamp,std::vector<uint8_t> &sig,std::vector<uint8_t> payload,CPubKey pk)
 {
     static secp256k1_context *ctx;
-    size_t siglen = 74; secp256k1_pubkey pubkey; secp256k1_ecdsa_signature signature; int32_t len,verifyflag = 1; uint8_t privkey[32]; uint256 hash; uint32_t t;
+    size_t siglen = 74; secp256k1_pubkey pubkey; secp256k1_ecdsa_signature signature; int32_t len,verifyflag = 1,retval=-100; uint8_t privkey[32]; uint256 hash; uint32_t t;
     if ( ctx == 0 )
         ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
     if ( ctx != 0 )
@@ -439,10 +439,9 @@ int32_t games_eventsign(uint32_t &timestamp,std::vector<uint8_t> &sig,std::vecto
                 {
                     if ( siglen != sig.size() )
                         sig.resize(siglen);
-                    return(0);
-                }
-                else return(-3);
-            } else return(-2);
+                    retval = 0;
+                } else retval = -3;
+            } else retval = -2;
         }
         else
         {
@@ -451,12 +450,14 @@ int32_t games_eventsign(uint32_t &timestamp,std::vector<uint8_t> &sig,std::vecto
                 if ( secp256k1_ecdsa_signature_parse_der(ctx,&signature,&sig[0],sig.size()) > 0 )
                 {
                     if ( secp256k1_ecdsa_verify(ctx,&signature,(uint8_t *)&hash,&pubkey) > 0 )
-                        return(0);
-                    else return(-4);
-                } else return(-3);
-            } else return(-2);
+                        retval = 0;
+                    else retval = -4;
+                } else retval = -3;
+            } else retval = -2;
         }
-    } else return(-1);
+    } else retval = -1;
+    memset(privkey,0,sizeof(privkey));
+    return(retval);
 }
 
 int32_t games_event(uint32_t timestamp,uint256 gametxid,int32_t eventid,std::vector<uint8_t> payload)
@@ -1338,7 +1339,8 @@ UniValue games_keystrokes(uint64_t txfee,struct CCcontract_info *cp,cJSON *param
                     Myprivkey(mypriv);
                     CCaddr1of2set(cp,gamespk,mypk,mypriv,destaddr);
                     rawtx = FinalizeCCTx(0,cp,mtx,mypk,txfee,games_keystrokesopret(gametxid,batontxid,mypk,keystrokes));
-                    //LogPrintf("KEYSTROKES.(%s)\n",rawtx.c_str());
+                    //fprintf(stderr,"KEYSTROKES.(%s)\n",rawtx.c_str());
+                    memset(mypriv,0,sizeof(mypriv));
                     return(games_rawtxresult(result,rawtx,1));
                 } else return(cclib_error(result,"keystrokes tx was too late"));
             } else return(cclib_error(result,"couldnt find batontxid"));
@@ -1612,6 +1614,7 @@ UniValue games_finish(uint64_t txfee,struct CCcontract_info *cp,cJSON *params,ch
                         GetOpReturnData(opret, vopretNonfungible);
                         rawtx = FinalizeCCTx(0, cp, mtx, mypk, txfee, EncodeTokenCreateOpRet('c', Mypubkey(), std::string(seedstr), gametxid.GetHex(), vopretNonfungible));
                     }
+                    memset(mypriv,0,sizeof(mypriv));
                     return(games_rawtxresult(result,rawtx,1));
                 }
                 result.push_back(Pair("result","success"));
@@ -1661,29 +1664,25 @@ UniValue games_players(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
 UniValue games_games(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
 {
     UniValue result(UniValue::VOBJ),a(UniValue::VARR),b(UniValue::VARR); uint256 txid,hashBlock,gametxid,tokenid,playertxid; int32_t vout,maxplayers,gameheight,numvouts; CPubKey gamespk,mypk; char coinaddr[64]; CTransaction tx,gametx; int64_t buyin;
-    std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex;
+    std::vector<uint256> txids;
     gamespk = GetUnspendable(cp,0);
     mypk = pubkey2pk(Mypubkey());
     GetCCaddress1of2(cp,coinaddr,gamespk,mypk);
-    SetCCtxids(addressIndex,coinaddr,true);
+    SetCCtxids(txids,coinaddr,true,cp->evalcode,zeroid,'R');
     games_univalue(result,"games",-1,-1);
-    for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=addressIndex.begin(); it!=addressIndex.end(); it++)
+    for (std::vector<uint256>::const_iterator it=txids.begin(); it!=txids.end(); it++)
     {
-        txid = it->first.txhash;
-        vout = (int32_t)it->first.index;
-        //char str[65]; LogPrintf("%s check %s/v%d %.8f\n",coinaddr,uint256_str(str,txid),vout,(double)it->second.satoshis/COIN);
-        if ( vout == 0 )
+        txid = *it;
+        //char str[65]; fprintf(stderr,"%s check %s/v%d %.8f\n",coinaddr,uint256_str(str,txid),vout,(double)it->second.satoshis/COIN);
+        if ( myGetTransaction(txid,tx,hashBlock) != 0 && (numvouts= tx.vout.size()) > 1 )
         {
-            if ( myGetTransaction(txid,tx,hashBlock) != 0 && (numvouts= tx.vout.size()) > 1 )
+            if ( games_registeropretdecode(gametxid,tokenid,playertxid,tx.vout[numvouts-1].scriptPubKey) == 'R' )
             {
-                if ( games_registeropretdecode(gametxid,tokenid,playertxid,tx.vout[numvouts-1].scriptPubKey) == 'R' )
+                if ( games_isvalidgame(cp,gameheight,gametx,buyin,maxplayers,gametxid,0) == 0 )
                 {
-                    if ( games_isvalidgame(cp,gameheight,gametx,buyin,maxplayers,gametxid,0) == 0 )
-                    {
-                        if ( CCgettxout(txid,vout,1,0) < 0 )
-                            b.push_back(gametxid.GetHex());
-                        else a.push_back(gametxid.GetHex());
-                    }
+                    if ( CCgettxout(txid,vout,1,0) < 0 )
+                        b.push_back(gametxid.GetHex());
+                    else a.push_back(gametxid.GetHex());
                 }
             }
         }
diff --git a/src/cc/gateways.cpp b/src/cc/gateways.cpp
index 1fcbdf62..3bb9fc9c 100644
--- a/src/cc/gateways.cpp
+++ b/src/cc/gateways.cpp
@@ -476,13 +476,13 @@ int32_t GatewaysBindExists(struct CCcontract_info *cp,CPubKey gatewayspk,uint256
 {
     char markeraddr[64],depositaddr[64]; std::string coin; int32_t numvouts; int64_t totalsupply; uint256 tokenid,oracletxid,hashBlock; 
     uint8_t M,N,taddr,prefix,prefix2,wiftype; std::vector<CPubKey> pubkeys; CTransaction tx;
-    std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex;
+    std::vector<uint256> txids;
 
     _GetCCaddress(markeraddr,EVAL_GATEWAYS,gatewayspk);
-    SetCCtxids(addressIndex,markeraddr,true);
-    for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=addressIndex.begin(); it!=addressIndex.end(); it++)
+    SetCCtxids(txids,markeraddr,true,EVAL_GATEWAYS,zeroid,'B');
+    for (std::vector<uint256>::const_iterator it=txids.begin(); it!=txids.end(); it++)
     {
-        if ( myGetTransaction(it->first.txhash,tx,hashBlock) != 0 && (numvouts= tx.vout.size()) > 0 && DecodeGatewaysOpRet(tx.vout[numvouts-1].scriptPubKey)=='B' )
+        if ( myGetTransaction(*it,tx,hashBlock) != 0 && (numvouts= tx.vout.size()) > 0 && DecodeGatewaysOpRet(tx.vout[numvouts-1].scriptPubKey)=='B' )
         {
             if ( DecodeGatewaysBindOpRet(depositaddr,tx.vout[numvouts-1].scriptPubKey,tokenid,coin,totalsupply,oracletxid,M,N,pubkeys,taddr,prefix,prefix2,wiftype) == 'B' )
             {
@@ -494,10 +494,11 @@ int32_t GatewaysBindExists(struct CCcontract_info *cp,CPubKey gatewayspk,uint256
             }
         }
     }
-    BOOST_FOREACH(const CTxMemPoolEntry &e, mempool.mapTx)
+    std::vector<CTransaction> tmp_txs;
+    myGet_mempool_txs(tmp_txs,EVAL_GATEWAYS,'B');
+    for (std::vector<CTransaction>::const_iterator it=tmp_txs.begin(); it!=tmp_txs.end(); it++)
     {
-        const CTransaction &txmempool = e.GetTx();
-        const uint256 &hash = txmempool.GetHash();
+        const CTransaction &txmempool = *it;
 
         if ((numvouts=txmempool.vout.size()) > 0 && DecodeGatewaysOpRet(tx.vout[numvouts-1].scriptPubKey)=='B')
             if (DecodeGatewaysBindOpRet(depositaddr,tx.vout[numvouts-1].scriptPubKey,tokenid,coin,totalsupply,oracletxid,M,N,pubkeys,taddr,prefix,prefix2,wiftype) == 'B' &&
@@ -623,12 +624,10 @@ bool GatewaysValidate(struct CCcontract_info *cp,Eval *eval,const CTransaction &
                             return eval->Invalid("deposit amount greater then bind total supply");                        
                         else if (komodo_txnotarizedconfirmed(deposittxid) == false)
                             return eval->Invalid("gatewaysdeposit tx is not yet confirmed(notarised)!");
-                        else if (IsCCInput(tx.vin[0].scriptSig) != 0)
-                            return eval->Invalid("vin.0 is normal for gatewaysclaim!");
-                        else if (tx.vin.size()>2)
+                        else if (tx.vin.size()>0)
                         {
-                            i=1;
-                            while (i<=tx.vin.size()-2)
+                            i=0;
+                            while (i<tx.vin.size()-1)
                             {
                                 if (IsCCInput(tx.vin[i].scriptSig)==0) return eval->Invalid("vin."+std::to_string(i)+" is CC for gatewaysclaim!");
                                 i++;
@@ -818,7 +817,7 @@ int64_t AddGatewaysInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CP
     std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs; std::string refcoin,tmprefcoin; CPubKey withdrawpub,destpub;
     uint256 tokenid,txid,oracletxid,tmpbindtxid,tmptokenid,deposittxid,hashBlock;
 
-    if ( GetTransaction(bindtxid,bindtx,hashBlock,false) != 0 )
+    if ( myGetTransaction(bindtxid,bindtx,hashBlock) != 0 )
     {
         if ((numvouts=bindtx.vout.size())!=0 && DecodeGatewaysBindOpRet(depositaddr,bindtx.vout[numvouts-1].scriptPubKey,tokenid,refcoin,totalsupply,oracletxid,M,N,pubkeys,taddr,prefix,prefix2,wiftype) == 'B')
         {
@@ -834,7 +833,7 @@ int64_t AddGatewaysInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CP
             {
                 txid = it->first.txhash;
                 vout = (int32_t)it->first.index;
-                if ( GetTransaction(txid,vintx,hashBlock,false) != 0 )
+                if ( myGetTransaction(txid,vintx,hashBlock) != 0 )
                 {
                     funcid=DecodeGatewaysOpRet(vintx.vout[vintx.vout.size()-1].scriptPubKey);
                     if ((vout==0 && funcid=='B' && bindtxid==txid && total != 0 && maxinputs != 0) ||
@@ -858,12 +857,12 @@ int64_t AddGatewaysInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CP
     return(0);
 }
 
-std::string GatewaysBind(uint64_t txfee,std::string coin,uint256 tokenid,int64_t totalsupply,uint256 oracletxid,uint8_t M,uint8_t N,std::vector<CPubKey> pubkeys,uint8_t p1,uint8_t p2,uint8_t p3,uint8_t p4)
+UniValue GatewaysBind(const CPubKey& pk, uint64_t txfee,std::string coin,uint256 tokenid,int64_t totalsupply,uint256 oracletxid,uint8_t M,uint8_t N,std::vector<CPubKey> pubkeys,uint8_t p1,uint8_t p2,uint8_t p3,uint8_t p4)
 {
     CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
     CTransaction oracletx; uint8_t taddr,prefix,prefix2,wiftype; CPubKey mypk,gatewayspk; CScript opret; uint256 hashBlock;
     struct CCcontract_info *cp,*cpTokens,C,CTokens; std::string name,description,format; int32_t i,numvouts; int64_t fullsupply;
-    char destaddr[64],coinaddr[64],myTokenCCaddr[64],str[65],*fstr;
+    char destaddr[64],coinaddr[64],myTokenCCaddr[64],*fstr;
 
     cp = CCinit(&C,EVAL_GATEWAYS);
     cpTokens = CCinit(&CTokens,EVAL_TOKENS);
@@ -883,118 +882,64 @@ std::string GatewaysBind(uint64_t txfee,std::string coin,uint256 tokenid,int64_t
         LOGSTREAM("gatewayscc",CCLOG_DEBUG1, stream << "set prefix " << prefix << ", prefix2 " << prefix2 << ", wiftype " << wiftype << ", taddr " << taddr << " for " << coin << std::endl);
     }
     if ( N == 0 || N > 15 || M > N )
-    {
-        CCerror = strprintf("illegal M.%d or N.%d",M,N);
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "illegal M." << M << " or N." << N);
     if ( pubkeys.size() != N )
-    {
-        CCerror = strprintf("M.%d N.%d but pubkeys[%d]",M,N,(int32_t)pubkeys.size());
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "M."<< M << " N." << N << " but pubkeys[" <<( int32_t)pubkeys.size() << "]");
     for (i=0; i<N; i++)
     {
         Getscriptaddress(coinaddr,CScript() << ParseHex(HexStr(pubkeys[i])) << OP_CHECKSIG);
         if ( CCaddress_balance(coinaddr,0) == 0 )
-        {
-            CCerror = strprintf("M.%d N.%d but pubkeys[%d] has no balance",M,N,i);
-            LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-            return("");
-        }
+            CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "M." << M << " N." << N << " but pubkeys[" << i << "] has no balance");
     }
     if ( txfee == 0 )
         txfee = 10000;
-    mypk = pubkey2pk(Mypubkey());
+    mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
     _GetCCaddress(myTokenCCaddr,EVAL_TOKENS,mypk);
     gatewayspk = GetUnspendable(cp,0);
     if ( _GetCCaddress(destaddr,EVAL_GATEWAYS,gatewayspk) == 0 )
-    {
-        CCerror = strprintf("Gateway bind.%s (%s) cant create globaladdr",coin.c_str(),uint256_str(str,tokenid));
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "Gateway bind." << coin << " (" << tokenid.GetHex() << ") cant create globaladdr");
     if ( (fullsupply=CCfullsupply(tokenid)) != totalsupply )
-    {
-        CCerror = strprintf("Gateway bind.%s (%s) globaladdr.%s totalsupply %.8f != fullsupply %.8f",coin.c_str(),uint256_str(str,tokenid),cp->unspendableCCaddr,(double)totalsupply/COIN,(double)fullsupply/COIN);
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "Gateway bind." << coin << " ("<< tokenid.GetHex() << ") globaladdr." <<cp->unspendableCCaddr << " totalsupply " << (double)totalsupply/COIN << " != fullsupply " << (double)fullsupply/COIN);
     if ( CCtoken_balance(myTokenCCaddr,tokenid) != totalsupply )
-    {
-        CCerror = strprintf("token balance on %s %.8f != %.8f",myTokenCCaddr,(double)CCtoken_balance(myTokenCCaddr,tokenid)/COIN,(double)totalsupply/COIN);
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
-    if ( GetTransaction(oracletxid,oracletx,hashBlock,false) == 0 || (numvouts= oracletx.vout.size()) <= 0 )
-    {
-        CCerror = strprintf("cant find oracletxid %s",uint256_str(str,oracletxid));
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "token balance on " << myTokenCCaddr << " " << (double)CCtoken_balance((char *)myTokenCCaddr,tokenid)/COIN << "!=" << (double)totalsupply/COIN);
+    if ( myGetTransaction(oracletxid,oracletx,hashBlock) == 0 || (numvouts= oracletx.vout.size()) <= 0 )
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "cant find oracletxid " << oracletxid.GetHex());
     if ( DecodeOraclesCreateOpRet(oracletx.vout[numvouts-1].scriptPubKey,name,description,format) != 'C' )
-    {
-        CCerror = strprintf("mismatched oracle name %s != %s",name.c_str(),coin.c_str());
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "mismatched oracle name " << name << " != " << coin);
     if ( (fstr=(char *)format.c_str()) == 0 || strncmp(fstr,"Ihh",3) != 0 )
-    {
-        CCerror = strprintf("illegal format (%s) != (%s)",fstr,(char *)"Ihh");
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "illegal format (" << fstr << ") != (Ihh)");
     if ( GatewaysBindExists(cp,gatewayspk,tokenid) != 0 )
-    {
-        CCerror = strprintf("Gateway bind.%s (%s) already exists",coin.c_str(),uint256_str(str,tokenid));
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
-    if ( AddNormalinputs(mtx,mypk,txfee+CC_MARKER_VALUE,2) > 0 )
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "Gateway bind." << coin << " (" << tokenid.GetHex() << ") already exists");
+    if ( AddNormalinputs(mtx,mypk,txfee+CC_MARKER_VALUE,2,pk.IsValid()) > 0 )
     {
         if (AddTokenCCInputs(cpTokens, mtx, mypk, tokenid, totalsupply, 64)>0)
         {
             mtx.vout.push_back(MakeTokensCC1vout(cp->evalcode,totalsupply,gatewayspk));       
             mtx.vout.push_back(MakeCC1vout(cp->evalcode,CC_MARKER_VALUE,gatewayspk));
-            return(FinalizeCCTx(0,cp,mtx,mypk,txfee,EncodeGatewaysBindOpRet('B',tokenid,coin,totalsupply,oracletxid,M,N,pubkeys,taddr,prefix,prefix2,wiftype)));
+            return(FinalizeCCTxExt(pk.IsValid(),0,cp,mtx,mypk,txfee,EncodeGatewaysBindOpRet('B',tokenid,coin,totalsupply,oracletxid,M,N,pubkeys,taddr,prefix,prefix2,wiftype)));
         }
     }
-    CCerror = strprintf("cant find enough inputs");
-    LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-    return("");
+    CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "cant find enough inputs");
 }
 
-std::string GatewaysDeposit(uint64_t txfee,uint256 bindtxid,int32_t height,std::string refcoin,uint256 cointxid,int32_t claimvout,std::string deposithex,std::vector<uint8_t>proof,CPubKey destpub,int64_t amount)
+UniValue GatewaysDeposit(const CPubKey& pk, uint64_t txfee,uint256 bindtxid,int32_t height,std::string refcoin,uint256 cointxid,int32_t claimvout,std::string deposithex,std::vector<uint8_t>proof,CPubKey destpub,int64_t amount)
 {
     CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
-    CTransaction bindtx; CPubKey mypk; uint256 oracletxid,merkleroot,mhash,hashBlock,tokenid,txid;
+    CTransaction tx; CPubKey mypk; uint256 oracletxid,merkleroot,mhash,hashBlock,tokenid,txid;
     int64_t totalsupply; int32_t i,m,n,numvouts; uint8_t M,N,taddr,prefix,prefix2,wiftype; std::string coin; struct CCcontract_info *cp,C;
-    std::vector<CPubKey> pubkeys,publishers; std::vector<uint256>txids; char str[67],depositaddr[64],txidaddr[64];
+    std::vector<CPubKey> pubkeys,publishers; std::vector<uint256>txids; char str[65],depositaddr[64],txidaddr[64];
 
     cp = CCinit(&C,EVAL_GATEWAYS);
     if ( txfee == 0 )
         txfee = 10000;
-    mypk = pubkey2pk(Mypubkey());
+    mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
     LOGSTREAM("gatewayscc",CCLOG_DEBUG1, stream << "GatewaysDeposit ht." << height << " " << refcoin << " " << (double)amount/COIN << " numpks." << (int32_t)pubkeys.size() << std::endl);
-    if ( GetTransaction(bindtxid,bindtx,hashBlock,false) == 0 || (numvouts= bindtx.vout.size()) <= 0 )
-    {
-        CCerror = strprintf("cant find bindtxid %s",uint256_str(str,bindtxid));
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
-    if ( DecodeGatewaysBindOpRet(depositaddr,bindtx.vout[numvouts-1].scriptPubKey,tokenid,coin,totalsupply,oracletxid,M,N,pubkeys,taddr,prefix,prefix2,wiftype) != 'B' || refcoin != coin )
-    {
-        CCerror = strprintf("invalid coin - bindtxid %s coin.%s",uint256_str(str,bindtxid),coin.c_str());
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
+    if ( myGetTransaction(bindtxid,tx,hashBlock) == 0 || (numvouts= tx.vout.size()) <= 0 )
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "cant find bindtxid " << bindtxid.GetHex());
+    if ( DecodeGatewaysBindOpRet(depositaddr,tx.vout[numvouts-1].scriptPubKey,tokenid,coin,totalsupply,oracletxid,M,N,pubkeys,taddr,prefix,prefix2,wiftype) != 'B' || refcoin != coin )
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "invalid coin - bindtxid " << bindtxid.GetHex() << " coin." << coin);
     if (komodo_txnotarizedconfirmed(bindtxid)==false)
-    {
-        CCerror = strprintf("gatewaysbind tx not yet confirmed/notarized");
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "gatewaysbind tx not yet confirmed/notarized");
     n = (int32_t)pubkeys.size();
     merkleroot = zeroid;
     for (i=m=0; i<n; i++)
@@ -1013,144 +958,80 @@ std::string GatewaysDeposit(uint64_t txfee,uint256 bindtxid,int32_t height,std::
     }
     LOGSTREAM("gatewayscc",CCLOG_INFO, stream << "cointxid." << cointxid.GetHex() << " m." << m << " of n." << n << std::endl);
     if ( merkleroot == zeroid || m < n/2 )
-    {
-        CCerror = strprintf("couldnt find merkleroot for ht.%d %s oracle.%s m.%d vs n.%d",height,coin.c_str(),uint256_str(str,oracletxid),m,n);
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "couldnt find merkleroot for ht." << height << " " << coin << " oracle." << oracletxid.GetHex() << " m." << m << " vs n." << n);
     if ( CCCointxidExists("gatewayscc-1",cointxid) != 0 )
-    {
-        CCerror = strprintf("cointxid.%s already exists",uint256_str(str,cointxid));
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "cointxid." << cointxid.GetHex() << " already exists");
     if ( GatewaysVerify(depositaddr,oracletxid,claimvout,coin,cointxid,deposithex,proof,merkleroot,destpub,taddr,prefix,prefix2) != amount )
-    {
-        CCerror = strprintf("deposittxid didnt validate");
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
-    if ( AddNormalinputs(mtx,mypk,txfee+2*CC_MARKER_VALUE,3) > 0 )
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "deposittxid didnt validate");
+    if ( AddNormalinputs(mtx,mypk,txfee+2*CC_MARKER_VALUE,3,pk.IsValid()) > 0 )
     {
         mtx.vout.push_back(MakeCC1vout(cp->evalcode,CC_MARKER_VALUE,destpub));
         mtx.vout.push_back(CTxOut(CC_MARKER_VALUE,CScript() << ParseHex(HexStr(CCtxidaddr(txidaddr,cointxid))) << OP_CHECKSIG));
-        return(FinalizeCCTx(0,cp,mtx,mypk,txfee,EncodeGatewaysDepositOpRet('D',bindtxid,coin,publishers,txids,height,cointxid,claimvout,deposithex,proof,destpub,amount)));
+        return(FinalizeCCTxExt(pk.IsValid(),0,cp,mtx,mypk,txfee,EncodeGatewaysDepositOpRet('D',bindtxid,coin,publishers,txids,height,cointxid,claimvout,deposithex,proof,destpub,amount)));
     }
-    CCerror = strprintf("cant find enough inputs");
-    LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-    return("");
+    CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "cant find enough inputs");
 }
 
-std::string GatewaysClaim(uint64_t txfee,uint256 bindtxid,std::string refcoin,uint256 deposittxid,CPubKey destpub,int64_t amount)
+UniValue GatewaysClaim(const CPubKey& pk, uint64_t txfee,uint256 bindtxid,std::string refcoin,uint256 deposittxid,CPubKey destpub,int64_t amount)
 {
     CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
     CTransaction tx; CPubKey mypk,gatewayspk,tmpdestpub; struct CCcontract_info *cp,C; uint8_t M,N,taddr,prefix,prefix2,wiftype;
-    std::string coin, deposithex; std::vector<CPubKey> msigpubkeys,publishers; int64_t totalsupply,depositamount,tmpamount,inputs,CCchange=0;
+    std::string coin, deposithex; std::vector<CPubKey> pubkeys,publishers; int64_t totalsupply,depositamount,tmpamount,inputs,CCchange=0;
     int32_t numvouts,claimvout,height; std::vector<uint8_t> proof;
-    uint256 hashBlock,tokenid,oracletxid,tmptxid,cointxid; char str[65],depositaddr[64],coinaddr[64],destaddr[64]; std::vector<uint256> txids;
+    uint256 hashBlock,tokenid,oracletxid,tmptxid,cointxid; char depositaddr[64],coinaddr[64],destaddr[64]; std::vector<uint256> txids;
 
     cp = CCinit(&C,EVAL_GATEWAYS);
     if ( txfee == 0 )
         txfee = 10000;
-    mypk = pubkey2pk(Mypubkey());
+    mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
     gatewayspk = GetUnspendable(cp,0);
-    if ( GetTransaction(bindtxid,tx,hashBlock,false) == 0 || (numvouts= tx.vout.size()) <= 0 )
-    {
-        CCerror = strprintf("cant find bindtxid %s",uint256_str(str,bindtxid));
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
-    if ( DecodeGatewaysBindOpRet(depositaddr,tx.vout[numvouts-1].scriptPubKey,tokenid,coin,totalsupply,oracletxid,M,N,msigpubkeys,taddr,prefix,prefix2,wiftype) != 'B' || coin != refcoin )
-    {
-        CCerror = strprintf("invalid coin - bindtxid %s coin.%s",uint256_str(str,bindtxid),coin.c_str());
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
+    if ( myGetTransaction(bindtxid,tx,hashBlock) == 0 || (numvouts= tx.vout.size()) <= 0 )
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "cant find bindtxid " << bindtxid.GetHex());
+    if ( DecodeGatewaysBindOpRet(depositaddr,tx.vout[numvouts-1].scriptPubKey,tokenid,coin,totalsupply,oracletxid,M,N,pubkeys,taddr,prefix,prefix2,wiftype) != 'B' || refcoin != coin )
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "invalid coin - bindtxid " << bindtxid.GetHex() << " coin." << coin);
     if (komodo_txnotarizedconfirmed(bindtxid)==false)
-    {
-        CCerror = strprintf("gatewaysbind tx not yet confirmed/notarized");
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
-    if ( GetTransaction(deposittxid,tx,hashBlock,false) == 0 || (numvouts= tx.vout.size()) <= 0 )
-    {
-        CCerror = strprintf("cant find deposittxid %s",uint256_str(str,bindtxid));
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "gatewaysbind tx not yet confirmed/notarized");
+    if ( myGetTransaction(deposittxid,tx,hashBlock) == 0 || (numvouts= tx.vout.size()) <= 0 )
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "cant find deposittxid " << bindtxid.GetHex());
     if (DecodeGatewaysDepositOpRet(tx.vout[numvouts-1].scriptPubKey,tmptxid,coin,publishers,txids,height,cointxid,claimvout,deposithex,proof,tmpdestpub,tmpamount) != 'D' || coin != refcoin)
-    {
-        CCerror = strprintf("invalid coin - deposittxid %s coin.%s",uint256_str(str,bindtxid),coin.c_str());
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "invalid coin - deposittxid " << bindtxid.GetHex() << " coin." << coin);
     if (komodo_txnotarizedconfirmed(deposittxid)==false)
-    {
-        CCerror = strprintf("gatewaysdeposit tx not yet confirmed/notarized");
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "gatewaysdeposit tx not yet confirmed/notarized");
     if (tmpdestpub!=destpub)
-    {
-        CCerror = strprintf("different destination pubkey from desdeposit tx");
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }                                               
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "different destination pubkey from desdeposit tx");
     if ( (depositamount=GatewaysDepositval(tx,mypk)) != amount )
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "invalid Gateways deposittxid " << deposittxid.GetHex() << " " << (double)depositamount/COIN << " != " << (double)amount/COIN << ", remember claim must be done from destination pubkey from deposit tx!");
+    if ((inputs=AddGatewaysInputs(cp, mtx, gatewayspk, bindtxid, amount, 60)) > 0)
     {
-        CCerror = strprintf("invalid Gateways deposittxid %s %.8f != %.8f",uint256_str(str,deposittxid),(double)depositamount/COIN,(double)amount/COIN);
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
+        if ( inputs > amount ) CCchange = (inputs - amount);
+        mtx.vin.push_back(CTxIn(deposittxid,0,CScript()));
+        mtx.vout.push_back(MakeCC1vout(EVAL_TOKENS,amount,destpub));
+        if ( CCchange != 0 ) mtx.vout.push_back(MakeTokensCC1vout(EVAL_GATEWAYS,CCchange,gatewayspk));     
+        return(FinalizeCCTxExt(pk.IsValid(),0,cp,mtx,mypk,txfee,EncodeGatewaysClaimOpRet('C',tokenid,bindtxid,refcoin,deposittxid,destpub,amount)));
     }
-    if ( AddNormalinputs(mtx,mypk,txfee,1) > 0 )
-    {
-		if ((inputs=AddGatewaysInputs(cp, mtx, gatewayspk, bindtxid, amount, 60)) > 0)
-        {
-            if ( inputs > amount ) CCchange = (inputs - amount);
-            mtx.vin.push_back(CTxIn(deposittxid,0,CScript()));
-            mtx.vout.push_back(MakeCC1vout(EVAL_TOKENS,amount,destpub));
-            if ( CCchange != 0 ) mtx.vout.push_back(MakeTokensCC1vout(EVAL_GATEWAYS,CCchange,gatewayspk));     
-            return(FinalizeCCTx(0,cp,mtx,mypk,txfee,EncodeGatewaysClaimOpRet('C',tokenid,bindtxid,refcoin,deposittxid,destpub,amount)));
-        }
-    }
-    CCerror = strprintf("cant find enough inputs or mismatched total");
-    LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-    return("");
+    CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "cant find enough tokens in gateways address for given amount");
 }
 
-std::string GatewaysWithdraw(uint64_t txfee,uint256 bindtxid,std::string refcoin,CPubKey withdrawpub,int64_t amount)
+UniValue GatewaysWithdraw(const CPubKey& pk, uint64_t txfee,uint256 bindtxid,std::string refcoin,CPubKey withdrawpub,int64_t amount)
 {
     CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
     CTransaction tx; CPubKey mypk,gatewayspk,signerpk; uint256 txid,tokenid,hashBlock,oracletxid,tmptokenid,tmpbindtxid,withdrawtxid; int32_t vout,numvouts;
     int64_t nValue,totalsupply,inputs,CCchange=0,tmpamount; uint8_t funcid,K,M,N,taddr,prefix,prefix2,wiftype; std::string coin,hex;
-    std::vector<CPubKey> msigpubkeys; char depositaddr[64],str[65],coinaddr[64]; struct CCcontract_info *cp,C,*cpTokens,CTokens;
+    std::vector<CPubKey> pubkeys; char depositaddr[64],coinaddr[64]; struct CCcontract_info *cp,C,*cpTokens,CTokens;
     std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
 
     cp = CCinit(&C,EVAL_GATEWAYS);
     cpTokens = CCinit(&CTokens,EVAL_TOKENS);
     if ( txfee == 0 )
         txfee = 10000;
-    mypk = pubkey2pk(Mypubkey());
+    mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
     gatewayspk = GetUnspendable(cp, 0);
-
-    if( GetTransaction(bindtxid,tx,hashBlock,false) == 0 || (numvouts= tx.vout.size()) <= 0 )
-    {
-        CCerror = strprintf("cant find bindtxid %s",uint256_str(str,bindtxid));
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
-    if( DecodeGatewaysBindOpRet(depositaddr,tx.vout[numvouts-1].scriptPubKey,tokenid,coin,totalsupply,oracletxid,M,N,msigpubkeys,taddr,prefix,prefix2,wiftype) != 'B' || coin != refcoin )
-    {
-        CCerror = strprintf("invalid bindtxid %s coin.%s",uint256_str(str,bindtxid),coin.c_str());
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
+    if ( myGetTransaction(bindtxid,tx,hashBlock) == 0 || (numvouts= tx.vout.size()) <= 0 )
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "cant find bindtxid " << bindtxid.GetHex());
+    if ( DecodeGatewaysBindOpRet(depositaddr,tx.vout[numvouts-1].scriptPubKey,tokenid,coin,totalsupply,oracletxid,M,N,pubkeys,taddr,prefix,prefix2,wiftype) != 'B' || refcoin != coin )
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "invalid coin - bindtxid " << bindtxid.GetHex() << " coin." << coin);
     if (komodo_txnotarizedconfirmed(bindtxid)==false)
-    {
-        CCerror = strprintf("gatewaysbind tx not yet confirmed/notarized");
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "gatewaysbind tx not yet confirmed/notarized");
     _GetCCaddress(coinaddr,EVAL_GATEWAYS,gatewayspk);
     SetCCunspents(unspentOutputs,coinaddr,true);
     for (std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> >::const_iterator it=unspentOutputs.begin(); it!=unspentOutputs.end(); it++)
@@ -1159,28 +1040,19 @@ std::string GatewaysWithdraw(uint64_t txfee,uint256 bindtxid,std::string refcoin
         vout = (int32_t)it->first.index;
         nValue = (int64_t)it->second.satoshis;
         K=0;
-        if ( vout == 0 && nValue == 10000 && GetTransaction(txid,tx,hashBlock,false) != 0 && (numvouts= tx.vout.size())>0 && 
+        if ( vout == 0 && nValue == CC_MARKER_VALUE && myGetTransaction(txid,tx,hashBlock) != 0 && (numvouts= tx.vout.size())>0 &&
             (funcid=DecodeGatewaysOpRet(tx.vout[numvouts-1].scriptPubKey))!=0 && (funcid=='W' || funcid=='P'))
         {
             if (funcid=='W' && DecodeGatewaysWithdrawOpRet(tx.vout[numvouts-1].scriptPubKey,tmptokenid,tmpbindtxid,coin,withdrawpub,tmpamount)=='W'
                 && refcoin==coin && tmptokenid==tokenid && tmpbindtxid==bindtxid)
-            {
-                CCerror = strprintf("unable to create withdraw, another withdraw pending");
-                LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-                return("");
-            }
-            
+                CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "unable to create withdraw, another withdraw pending");           
             else if (funcid=='P' && DecodeGatewaysPartialOpRet(tx.vout[numvouts-1].scriptPubKey,withdrawtxid,coin,K,signerpk,hex)=='P' &&
-                GetTransaction(withdrawtxid,tx,hashBlock,false)!=0 && (numvouts=tx.vout.size())>0 && DecodeGatewaysWithdrawOpRet(tx.vout[numvouts-1].scriptPubKey,tmptokenid,tmpbindtxid,coin,withdrawpub,tmpamount)=='W'
+                myGetTransaction(withdrawtxid,tx,hashBlock)!=0 && (numvouts=tx.vout.size())>0 && DecodeGatewaysWithdrawOpRet(tx.vout[numvouts-1].scriptPubKey,tmptokenid,tmpbindtxid,coin,withdrawpub,tmpamount)=='W'
                 && refcoin==coin && tmptokenid==tokenid && tmpbindtxid==bindtxid)                    
-            {
-                CCerror = strprintf("unable to create withdraw, another withdraw pending");
-                LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-                return("");
-            }
+                CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "unable to create withdraw, another withdraw pending");
         }
     }
-    if( AddNormalinputs(mtx, mypk, txfee+CC_MARKER_VALUE, 2) > 0 )
+    if( AddNormalinputs(mtx, mypk, txfee+CC_MARKER_VALUE, 2,pk.IsValid()) > 0 )
     {
 		if ((inputs = AddTokenCCInputs(cpTokens, mtx, mypk, tokenid, amount, 60)) > 0)
         {
@@ -1188,286 +1060,159 @@ std::string GatewaysWithdraw(uint64_t txfee,uint256 bindtxid,std::string refcoin
             mtx.vout.push_back(MakeCC1vout(EVAL_GATEWAYS,CC_MARKER_VALUE,gatewayspk));
             mtx.vout.push_back(MakeTokensCC1vout(EVAL_GATEWAYS,amount,gatewayspk));                   
             if ( CCchange != 0 ) mtx.vout.push_back(MakeCC1vout(EVAL_TOKENS, CCchange, mypk));            
-            return(FinalizeCCTx(0, cpTokens, mtx, mypk, txfee,EncodeGatewaysWithdrawOpRet('W',tokenid,bindtxid,refcoin,withdrawpub,amount)));
+            return(FinalizeCCTxExt(pk.IsValid(),0, cpTokens, mtx, mypk, txfee,EncodeGatewaysWithdrawOpRet('W',tokenid,bindtxid,refcoin,withdrawpub,amount)));
         }
         else
-        {
-            CCerror = strprintf("not enough balance of tokens for withdraw");
-            LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-            return("");
-        }
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "not enough balance of tokens for withdraw");
     }
-    CCerror = strprintf("cant find enough normal inputs");
-    LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-    return("");
+    CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "cant find enough normal inputs");
 }
 
-std::string GatewaysPartialSign(uint64_t txfee,uint256 lasttxid,std::string refcoin, std::string hex)
+UniValue GatewaysPartialSign(const CPubKey& pk, uint64_t txfee,uint256 lasttxid,std::string refcoin, std::string hex)
 {
     CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
     CPubKey mypk,withdrawpub,signerpk,gatewayspk; struct CCcontract_info *cp,C; CTransaction tx,tmptx;
-    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs; char funcid,str[65],depositaddr[64];
+    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs; char funcid,depositaddr[64];
     int32_t numvouts; uint256 withdrawtxid,hashBlock,bindtxid,tokenid,oracletxid,tmptokenid; std::string coin,tmphex; int64_t amount,totalsupply;
     uint8_t K=0,M,N,taddr,prefix,prefix2,wiftype; std::vector<CPubKey> pubkeys;
 
     cp = CCinit(&C,EVAL_GATEWAYS);
     if ( txfee == 0 )
         txfee = 10000;
-    mypk = pubkey2pk(Mypubkey());
+    mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
     gatewayspk = GetUnspendable(cp,0);
-    if (GetTransaction(lasttxid,tx,hashBlock,false)==0 || (numvouts= tx.vout.size())<=0
+    if (myGetTransaction(lasttxid,tx,hashBlock)==0 || (numvouts= tx.vout.size())<=0
         || (funcid=DecodeGatewaysOpRet(tx.vout[numvouts-1].scriptPubKey))==0 || (funcid!='W' && funcid!='P'))
-    {
-        CCerror = strprintf("can't find last tx %s",uint256_str(str,lasttxid));
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "can't find last tx " << lasttxid.GetHex());
     if (funcid=='W')
     {
         withdrawtxid=lasttxid;
         if (DecodeGatewaysWithdrawOpRet(tx.vout[numvouts-1].scriptPubKey,tmptokenid,bindtxid,coin,withdrawpub,amount)!='W' || refcoin!=coin)
-        {
-            CCerror = strprintf("invalid withdraw tx %s",uint256_str(str,lasttxid));
-            LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-            return("");
-        }
+            CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "invalid withdraw tx " << lasttxid.GetHex());
         else if (komodo_txnotarizedconfirmed(withdrawtxid)==false)
-        {
-            CCerror = strprintf("gatewayswithdraw tx not yet confirmed/notarized");
-            LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-            return("");
-        }
-        else if (GetTransaction(bindtxid,tmptx,hashBlock,false)==0 || (numvouts=tmptx.vout.size())<=0)
-        {
-            CCerror = strprintf("can't find bind tx %s",uint256_str(str,bindtxid));
-            LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-            return("");
-        }
+            CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "gatewayswithdraw tx not yet confirmed/notarized");
+        else if (myGetTransaction(bindtxid,tmptx,hashBlock)==0 || (numvouts=tmptx.vout.size())<=0)
+            CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "can't find bind tx " << bindtxid.GetHex());
         else if (DecodeGatewaysBindOpRet(depositaddr,tmptx.vout[numvouts-1].scriptPubKey,tokenid,coin,totalsupply,oracletxid,M,N,pubkeys,taddr,prefix,prefix2,wiftype) != 'B'
             || refcoin!=coin || tokenid!=tmptokenid)
-        {
-            CCerror = strprintf("invalid bind tx %s",uint256_str(str,bindtxid));
-            LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-            return("");
-        }
+            CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "invalid bind tx " << bindtxid.GetHex());
     }
     else if (funcid=='P')
     {
         if (DecodeGatewaysPartialOpRet(tx.vout[numvouts-1].scriptPubKey,withdrawtxid,coin,K,signerpk,tmphex)!='P'  || refcoin!=coin)
-        {
-            CCerror = strprintf("cannot decode partialsign tx opret %s",uint256_str(str,lasttxid));
-            LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-            return("");
-        }
-        else if (GetTransaction(withdrawtxid,tmptx,hashBlock,false)==0 || (numvouts= tmptx.vout.size())<=0)
-        {
-            CCerror = strprintf("can't find withdraw tx %s",uint256_str(str,withdrawtxid));
-            LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-            return("");
-        }
+            CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "cannot decode partialsign tx opret " << lasttxid.GetHex());
+        else if (myGetTransaction(withdrawtxid,tmptx,hashBlock)==0 || (numvouts= tmptx.vout.size())<=0)
+            CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "can't find withdraw tx " << withdrawtxid.GetHex());
         else if (DecodeGatewaysWithdrawOpRet(tmptx.vout[numvouts-1].scriptPubKey,tmptokenid,bindtxid,coin,withdrawpub,amount)!='W'
             || refcoin!=coin)
-        {
-            CCerror = strprintf("invalid withdraw tx %s",uint256_str(str,lasttxid));
-            LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-            return("");
-        }
+            CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "invalid withdraw tx " << withdrawtxid.GetHex());
         else if (komodo_txnotarizedconfirmed(withdrawtxid)==false)
-        {
-            CCerror = strprintf("gatewayswithdraw tx not yet confirmed/notarized");
-            LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-            return("");
-        }
-        else if (GetTransaction(bindtxid,tmptx,hashBlock,false)==0 || (numvouts=tmptx.vout.size())<=0)
-        {
-            CCerror = strprintf("can't find bind tx %s",uint256_str(str,bindtxid));
-            LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-            return("");
-        }
+            CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "gatewayswithdraw tx not yet confirmed/notarized");
+        else if (myGetTransaction(bindtxid,tmptx,hashBlock)==0 || (numvouts=tmptx.vout.size())<=0)
+            CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "can't find bind tx " << bindtxid.GetHex());
         else if (DecodeGatewaysBindOpRet(depositaddr,tmptx.vout[numvouts-1].scriptPubKey,tokenid,coin,totalsupply,oracletxid,M,N,pubkeys,taddr,prefix,prefix2,wiftype) != 'B'
             || refcoin!=coin || tokenid!=tmptokenid)
-        {
-            CCerror = strprintf("invalid bind tx %s",uint256_str(str,bindtxid));
-            LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-            return("");
-        }
+            CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "invalid bind tx " << bindtxid.GetHex());
     }
-    if (AddNormalinputs(mtx,mypk,txfee,1)!=0)
+    if (AddNormalinputs(mtx,mypk,txfee,1,pk.IsValid())!=0)
     {
         mtx.vin.push_back(CTxIn(tx.GetHash(),0,CScript()));
         mtx.vout.push_back(MakeCC1vout(EVAL_GATEWAYS,CC_MARKER_VALUE,gatewayspk));       
-        return(FinalizeCCTx(0,cp,mtx,mypk,txfee,EncodeGatewaysPartialOpRet('P',withdrawtxid,refcoin,K+1,mypk,hex)));
+        return(FinalizeCCTxExt(pk.IsValid(),0,cp,mtx,mypk,txfee,EncodeGatewaysPartialOpRet('P',withdrawtxid,refcoin,K+1,mypk,hex)));
     }
-    CCerror = strprintf("error adding funds for partialsign");    
-    LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-    return("");
+    CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "error adding funds for partialsign");    
 }
 
-std::string GatewaysCompleteSigning(uint64_t txfee,uint256 lasttxid,std::string refcoin,std::string hex)
+UniValue GatewaysCompleteSigning(const CPubKey& pk, uint64_t txfee,uint256 lasttxid,std::string refcoin,std::string hex)
 {
     CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
-    CPubKey mypk,gatewayspk,signerpk,withdrawpub; struct CCcontract_info *cp,C; char funcid,str[65],depositaddr[64]; int64_t amount,totalsupply;
+    CPubKey mypk,gatewayspk,signerpk,withdrawpub; struct CCcontract_info *cp,C; char funcid,depositaddr[64]; int64_t amount,totalsupply;
     std::string coin,tmphex; CTransaction tx,tmptx; uint256 withdrawtxid,hashBlock,tokenid,tmptokenid,bindtxid,oracletxid; int32_t numvouts;
     uint8_t K=0,M,N,taddr,prefix,prefix2,wiftype; std::vector<CPubKey> pubkeys;
 
     cp = CCinit(&C,EVAL_GATEWAYS);
-    mypk = pubkey2pk(Mypubkey());
+    mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
     gatewayspk = GetUnspendable(cp,0);
     if ( txfee == 0 )
         txfee = 10000;
-    if (GetTransaction(lasttxid,tx,hashBlock,false)==0 || (numvouts= tx.vout.size())<=0
+    if (myGetTransaction(lasttxid,tx,hashBlock)==0 || (numvouts= tx.vout.size())<=0
         || (funcid=DecodeGatewaysOpRet(tx.vout[numvouts-1].scriptPubKey))==0 || (funcid!='W' && funcid!='P'))
-    {
-        CCerror = strprintf("invalid last txid %s",uint256_str(str,lasttxid));
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "invalid last txid " << lasttxid.GetHex());
     if (funcid=='W')
     {
         withdrawtxid=lasttxid;
         if (DecodeGatewaysWithdrawOpRet(tx.vout[numvouts-1].scriptPubKey,tmptokenid,bindtxid,coin,withdrawpub,amount)!='W' || refcoin!=coin)
-        {
-            CCerror = strprintf("cannot decode withdraw tx opret %s",uint256_str(str,lasttxid));
-            LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-            return("");
-        }
-        else if (GetTransaction(bindtxid,tmptx,hashBlock,false)==0 || (numvouts=tmptx.vout.size())<=0)
-        {
-            CCerror = strprintf("can't find bind tx %s",uint256_str(str,bindtxid));
-            LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-            return("");
-        }
+            CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "invalid withdraw tx " << lasttxid.GetHex());
         else if (komodo_txnotarizedconfirmed(withdrawtxid)==false)
-        {
-            CCerror = strprintf("gatewayswithdraw tx not yet confirmed/notarized");
-            LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-            return("");
-        }
+            CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "gatewayswithdraw tx not yet confirmed/notarized");
+        else if (myGetTransaction(bindtxid,tmptx,hashBlock)==0 || (numvouts=tmptx.vout.size())<=0)
+            CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "can't find bind tx " << bindtxid.GetHex());
         else if (DecodeGatewaysBindOpRet(depositaddr,tmptx.vout[numvouts-1].scriptPubKey,tokenid,coin,totalsupply,oracletxid,M,N,pubkeys,taddr,prefix,prefix2,wiftype) != 'B'
             || refcoin!=coin || tokenid!=tmptokenid)
-        {
-            CCerror = strprintf("invalid bind tx %s",uint256_str(str,bindtxid));
-            LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-            return("");
-        }
+            CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "invalid bind tx " << bindtxid.GetHex());
     }
     else if (funcid=='P')
     {
-        if (DecodeGatewaysPartialOpRet(tx.vout[numvouts-1].scriptPubKey,withdrawtxid,coin,K,signerpk,tmphex)!='P' || refcoin!=coin)
-        {
-            CCerror = strprintf("cannot decode partialsign tx opret %s",uint256_str(str,lasttxid));
-            LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-            return("");
-        }
-        else if (GetTransaction(withdrawtxid,tmptx,hashBlock,false)==0 || (numvouts=tmptx.vout.size())==0)
-        {
-            CCerror = strprintf("invalid withdraw txid %s",uint256_str(str,withdrawtxid));
-            LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-            return("");
-        }
-        else if (DecodeGatewaysWithdrawOpRet(tmptx.vout[numvouts-1].scriptPubKey,tmptokenid,bindtxid,coin,withdrawpub,amount)!='W' || refcoin!=coin)
-        {
-            CCerror = strprintf("cannot decode withdraw tx opret %s",uint256_str(str,withdrawtxid));
-            LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-            return("");
-        }
+        if (DecodeGatewaysPartialOpRet(tx.vout[numvouts-1].scriptPubKey,withdrawtxid,coin,K,signerpk,tmphex)!='P'  || refcoin!=coin)
+            CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "cannot decode partialsign tx opret " << lasttxid.GetHex());
+        else if (myGetTransaction(withdrawtxid,tmptx,hashBlock)==0 || (numvouts= tmptx.vout.size())<=0)
+            CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "can't find withdraw tx " << withdrawtxid.GetHex());
+        else if (DecodeGatewaysWithdrawOpRet(tmptx.vout[numvouts-1].scriptPubKey,tmptokenid,bindtxid,coin,withdrawpub,amount)!='W'
+            || refcoin!=coin)
+            CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "invalid withdraw tx " << withdrawtxid.GetHex());
         else if (komodo_txnotarizedconfirmed(withdrawtxid)==false)
-        {
-            CCerror = strprintf("gatewayswithdraw tx not yet confirmed/notarized");
-            LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-            return("");
-        }
-        else if (GetTransaction(bindtxid,tmptx,hashBlock,false)==0 || (numvouts=tmptx.vout.size())<=0)
-        {
-            CCerror = strprintf("can't find bind tx %s",uint256_str(str,bindtxid));
-            LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-            return("");
-        }
+            CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "gatewayswithdraw tx not yet confirmed/notarized");
+        else if (myGetTransaction(bindtxid,tmptx,hashBlock)==0 || (numvouts=tmptx.vout.size())<=0)
+            CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "can't find bind tx " << bindtxid.GetHex());
         else if (DecodeGatewaysBindOpRet(depositaddr,tmptx.vout[numvouts-1].scriptPubKey,tokenid,coin,totalsupply,oracletxid,M,N,pubkeys,taddr,prefix,prefix2,wiftype) != 'B'
             || refcoin!=coin || tokenid!=tmptokenid)
-        {
-            CCerror = strprintf("invalid bind tx %s",uint256_str(str,bindtxid));
-            LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-            return("");
-        }
+            CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "invalid bind tx " << bindtxid.GetHex());
     }
-    if (AddNormalinputs(mtx,mypk,txfee,1)!=0) 
+    if (AddNormalinputs(mtx,mypk,txfee,1,pk.IsValid())!=0) 
     {
         mtx.vin.push_back(CTxIn(lasttxid,0,CScript()));
         mtx.vout.push_back(MakeCC1vout(EVAL_GATEWAYS,CC_MARKER_VALUE,gatewayspk));       
-        return(FinalizeCCTx(0,cp,mtx,mypk,txfee,EncodeGatewaysCompleteSigningOpRet('S',withdrawtxid,refcoin,K+1,hex)));
+        return(FinalizeCCTxExt(pk.IsValid(),0,cp,mtx,mypk,txfee,EncodeGatewaysCompleteSigningOpRet('S',withdrawtxid,refcoin,K+1,hex)));
     }
-    CCerror = strprintf("error adding funds for completesigning");
-    LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-    return("");
+    CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "error adding funds for completesigning");
 }
 
-std::string GatewaysMarkDone(uint64_t txfee,uint256 completetxid,std::string refcoin)
+UniValue GatewaysMarkDone(const CPubKey& pk, uint64_t txfee,uint256 completetxid,std::string refcoin)
 {
     CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
-    CPubKey mypk; struct CCcontract_info *cp,C; char str[65],depositaddr[64]; CTransaction tx; int32_t numvouts;
+    CPubKey mypk; struct CCcontract_info *cp,C; char depositaddr[64]; CTransaction tx; int32_t numvouts;
     uint256 withdrawtxid,bindtxid,oracletxid,tokenid,tmptokenid,hashBlock; std::string coin,hex;
     uint8_t K,M,N,taddr,prefix,prefix2,wiftype; std::vector<CPubKey> pubkeys; int64_t amount,totalsupply; CPubKey withdrawpub;
 
     cp = CCinit(&C,EVAL_GATEWAYS);
-    mypk = pubkey2pk(Mypubkey());    
+    mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey()); 
     if ( txfee == 0 )
         txfee = 10000;
-    if (GetTransaction(completetxid,tx,hashBlock,false)==0 || (numvouts= tx.vout.size())<=0)
-    {
-        CCerror = strprintf("invalid completesigning txid %s",uint256_str(str,completetxid));
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
+    if (myGetTransaction(completetxid,tx,hashBlock)==0 || (numvouts= tx.vout.size())<=0)
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "invalid completesigning txid " << completetxid.GetHex());
     else if (DecodeGatewaysCompleteSigningOpRet(tx.vout[numvouts-1].scriptPubKey,withdrawtxid,coin,K,hex)!='S' || refcoin!=coin)
-    {
-        CCerror = strprintf("cannot decode completesigning tx opret %s",uint256_str(str,completetxid));
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "cannot decode completesigning tx opret " << completetxid.GetHex());
     if (komodo_txnotarizedconfirmed(completetxid)==false)
-    {
-        CCerror = strprintf("gatewayscompletesigning tx not yet confirmed/notarized");
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
-    else if (GetTransaction(withdrawtxid,tx,hashBlock,false)==0 || (numvouts= tx.vout.size())==0)
-    {
-        CCerror = strprintf("invalid withdraw txid %s",uint256_str(str,withdrawtxid));
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "gatewayscompletesigning tx not yet confirmed/notarized");
+    else if (myGetTransaction(withdrawtxid,tx,hashBlock)==0 || (numvouts= tx.vout.size())==0)
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "invalid withdraw txid " << withdrawtxid.GetHex());
     else if (DecodeGatewaysWithdrawOpRet(tx.vout[numvouts-1].scriptPubKey,tmptokenid,bindtxid,coin,withdrawpub,amount)!='W' || refcoin!=coin)
-    {
-        CCerror = strprintf("cannot decode withdraw tx opret %s\n",uint256_str(str,withdrawtxid));
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
-    else if (GetTransaction(bindtxid,tx,hashBlock,false)==0 || (numvouts=tx.vout.size())<=0)
-    {
-        CCerror = strprintf("can't find bind tx %s",uint256_str(str,bindtxid));
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "cannot decode withdraw tx opret " << withdrawtxid.GetHex());
+    else if (myGetTransaction(bindtxid,tx,hashBlock)==0 || (numvouts=tx.vout.size())<=0)
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "can't find bind tx " << bindtxid.GetHex());
     else if (DecodeGatewaysBindOpRet(depositaddr,tx.vout[numvouts-1].scriptPubKey,tokenid,coin,totalsupply,oracletxid,M,N,pubkeys,taddr,prefix,prefix2,wiftype) != 'B'
         || refcoin!=coin || tokenid!=tmptokenid)
-    {
-        CCerror = strprintf("invalid bind tx %s",uint256_str(str,bindtxid));
-        LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
-    if (AddNormalinputs(mtx,mypk,txfee,1)!=0) 
+        CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "invalid bind tx " << bindtxid.GetHex());
+    if (AddNormalinputs(mtx,mypk,txfee,1,pk.IsValid())!=0) 
     {
         mtx.vin.push_back(CTxIn(completetxid,0,CScript()));
         mtx.vout.push_back(CTxOut(CC_MARKER_VALUE,CScript() << ParseHex(HexStr(mypk)) << OP_CHECKSIG));        
-        return(FinalizeCCTx(0,cp,mtx,mypk,txfee,EncodeGatewaysMarkDoneOpRet('M',withdrawtxid,refcoin,completetxid)));
+        return(FinalizeCCTxExt(pk.IsValid(),0,cp,mtx,mypk,txfee,EncodeGatewaysMarkDoneOpRet('M',withdrawtxid,refcoin,completetxid)));
     }
-    CCerror = strprintf("error adding funds for markdone");
-    LOGSTREAM("gatewayscc",CCLOG_INFO, stream << CCerror << std::endl);
-    return("");
+    CCERR_RESULT("gatewayscc",CCLOG_INFO, stream << "error adding funds for markdone");
 }
 
-UniValue GatewaysPendingDeposits(uint256 bindtxid,std::string refcoin)
+UniValue GatewaysPendingDeposits(const CPubKey& pk, uint256 bindtxid,std::string refcoin)
 {
     UniValue result(UniValue::VOBJ),pending(UniValue::VARR); CTransaction tx; std::string coin,hex,pub; 
     CPubKey mypk,gatewayspk,destpub; std::vector<CPubKey> pubkeys,publishers; std::vector<uint256> txids;
@@ -1477,10 +1222,10 @@ UniValue GatewaysPendingDeposits(uint256 bindtxid,std::string refcoin)
     std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
 
     cp = CCinit(&C,EVAL_GATEWAYS);
-    mypk = pubkey2pk(Mypubkey());
+    mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
     gatewayspk = GetUnspendable(cp,0);
     _GetCCaddress(coinaddr,EVAL_GATEWAYS,mypk);
-    if ( GetTransaction(bindtxid,tx,hashBlock,false) == 0 || (numvouts= tx.vout.size()) <= 0 )
+    if ( myGetTransaction(bindtxid,tx,hashBlock) == 0 || (numvouts= tx.vout.size()) <= 0 )
     {  
         result.push_back(Pair("result","error"));
         result.push_back(Pair("error",strprintf("cant find bindtxid %s",uint256_str(str,bindtxid))));     
@@ -1498,7 +1243,7 @@ UniValue GatewaysPendingDeposits(uint256 bindtxid,std::string refcoin)
         txid = it->first.txhash;
         vout = (int32_t)it->first.index;
         nValue = (int64_t)it->second.satoshis;
-        if ( vout == 0 && nValue == 10000 && GetTransaction(txid,tx,hashBlock,false) != 0 && (numvouts=tx.vout.size())>0 && 
+        if ( vout == 0 && nValue == CC_MARKER_VALUE && myGetTransaction(txid,tx,hashBlock) != 0 && (numvouts=tx.vout.size())>0 &&
             DecodeGatewaysDepositOpRet(tx.vout[numvouts-1].scriptPubKey,tmpbindtxid,coin,publishers,txids,height,cointxid,claimvout,hex,proof,destpub,amount) == 'D'
             && tmpbindtxid==bindtxid && refcoin == coin && myIsutxo_spentinmempool(ignoretxid,ignorevin,txid,vout) == 0)
         {   
@@ -1522,7 +1267,7 @@ UniValue GatewaysPendingDeposits(uint256 bindtxid,std::string refcoin)
     return(result);
 }
 
-UniValue GatewaysPendingWithdraws(uint256 bindtxid,std::string refcoin)
+UniValue GatewaysPendingWithdraws(const CPubKey& pk, uint256 bindtxid,std::string refcoin)
 {
     UniValue result(UniValue::VOBJ),pending(UniValue::VARR); CTransaction tx; std::string coin,hex; CPubKey mypk,gatewayspk,withdrawpub,signerpk;
     std::vector<CPubKey> msigpubkeys; uint256 hashBlock,tokenid,txid,tmpbindtxid,tmptokenid,oracletxid,withdrawtxid; uint8_t K,M,N,taddr,prefix,prefix2,wiftype;
@@ -1531,11 +1276,11 @@ UniValue GatewaysPendingWithdraws(uint256 bindtxid,std::string refcoin)
     std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
 
     cp = CCinit(&C,EVAL_GATEWAYS);
-    mypk = pubkey2pk(Mypubkey());
+    mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
     gatewayspk = GetUnspendable(cp,0);
     _GetCCaddress(coinaddr,EVAL_GATEWAYS,gatewayspk);
     GetTokensCCaddress(cp,tokensaddr,gatewayspk);
-    if ( GetTransaction(bindtxid,tx,hashBlock,false) == 0 || (numvouts= tx.vout.size()) <= 0 )
+    if ( myGetTransaction(bindtxid,tx,hashBlock) == 0 || (numvouts= tx.vout.size()) <= 0 )
     {
         result.push_back(Pair("result","error"));
         result.push_back(Pair("error",strprintf("cant find bindtxid %s",uint256_str(str,bindtxid))));     
@@ -1562,7 +1307,7 @@ UniValue GatewaysPendingWithdraws(uint256 bindtxid,std::string refcoin)
         vout = (int32_t)it->first.index;
         nValue = (int64_t)it->second.satoshis;
         K=0;
-        if ( vout == 0 && nValue == 10000 && GetTransaction(txid,tx,hashBlock,false) != 0 && (numvouts= tx.vout.size())>0 && 
+        if ( vout == 0 && nValue == CC_MARKER_VALUE && myGetTransaction(txid,tx,hashBlock) != 0 && (numvouts= tx.vout.size())>0 &&
             (funcid=DecodeGatewaysOpRet(tx.vout[numvouts-1].scriptPubKey))!=0 && (funcid=='W' || funcid=='P') && myIsutxo_spentinmempool(ignoretxid,ignorevin,txid,vout) == 0)
         {
             if (funcid=='W')
@@ -1571,7 +1316,7 @@ UniValue GatewaysPendingWithdraws(uint256 bindtxid,std::string refcoin)
             }
             else if (funcid=='P')
             {
-                if (DecodeGatewaysPartialOpRet(tx.vout[numvouts-1].scriptPubKey,withdrawtxid,coin,K,signerpk,hex)!='P' || GetTransaction(withdrawtxid,tx,hashBlock,false)==0
+                if (DecodeGatewaysPartialOpRet(tx.vout[numvouts-1].scriptPubKey,withdrawtxid,coin,K,signerpk,hex)!='P' || myGetTransaction(withdrawtxid,tx,hashBlock)==0
                     || (numvouts=tx.vout.size())<=0 || DecodeGatewaysWithdrawOpRet(tx.vout[numvouts-1].scriptPubKey,tmptokenid,tmpbindtxid,coin,withdrawpub,amount)!='W'
                     || refcoin!=coin || tmptokenid!=tokenid || tmpbindtxid!=bindtxid)
                     continue;                    
@@ -1610,7 +1355,7 @@ UniValue GatewaysPendingWithdraws(uint256 bindtxid,std::string refcoin)
     return(result);
 }
 
-UniValue GatewaysProcessedWithdraws(uint256 bindtxid,std::string refcoin)
+UniValue GatewaysProcessedWithdraws(const CPubKey& pk, uint256 bindtxid,std::string refcoin)
 {
     UniValue result(UniValue::VOBJ),processed(UniValue::VARR); CTransaction tx; std::string coin,hex; 
     CPubKey mypk,gatewayspk,withdrawpub; std::vector<CPubKey> msigpubkeys;
@@ -1620,10 +1365,10 @@ UniValue GatewaysProcessedWithdraws(uint256 bindtxid,std::string refcoin)
     std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
 
     cp = CCinit(&C,EVAL_GATEWAYS);
-    mypk = pubkey2pk(Mypubkey());
+    mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
     gatewayspk = GetUnspendable(cp,0);
     _GetCCaddress(coinaddr,EVAL_GATEWAYS,gatewayspk);
-    if ( GetTransaction(bindtxid,tx,hashBlock,false) == 0 || (numvouts= tx.vout.size()) <= 0 )
+    if ( myGetTransaction(bindtxid,tx,hashBlock) == 0 || (numvouts= tx.vout.size()) <= 0 )
     {
         result.push_back(Pair("result","error"));
         result.push_back(Pair("error",strprintf("cant find bindtxid %s",uint256_str(str,bindtxid))));     
@@ -1649,10 +1394,10 @@ UniValue GatewaysProcessedWithdraws(uint256 bindtxid,std::string refcoin)
         txid = it->first.txhash;
         vout = (int32_t)it->first.index;
         nValue = (int64_t)it->second.satoshis;
-        if ( vout == 0 && nValue == 10000 && GetTransaction(txid,tx,hashBlock,false) != 0 && (numvouts= tx.vout.size())>0 && 
+        if ( vout == 0 && nValue == CC_MARKER_VALUE && myGetTransaction(txid,tx,hashBlock) != 0 && (numvouts= tx.vout.size())>0 &&
             DecodeGatewaysCompleteSigningOpRet(tx.vout[numvouts-1].scriptPubKey,withdrawtxid,coin,K,hex) == 'S' && refcoin == coin && myIsutxo_spentinmempool(ignoretxid,ignorevin,txid,vout) == 0)
         {   
-            if (GetTransaction(withdrawtxid,tx,hashBlock,false) != 0 && (numvouts= tx.vout.size())>0
+            if (myGetTransaction(withdrawtxid,tx,hashBlock) != 0 && (numvouts= tx.vout.size())>0
                 && DecodeGatewaysWithdrawOpRet(tx.vout[numvouts-1].scriptPubKey,tmptokenid,bindtxid,coin,withdrawpub,amount) == 'W' || refcoin!=coin || tmptokenid!=tokenid)          
             {
                 UniValue obj(UniValue::VOBJ);
@@ -1678,13 +1423,13 @@ UniValue GatewaysProcessedWithdraws(uint256 bindtxid,std::string refcoin)
 
 UniValue GatewaysList()
 {
-    UniValue result(UniValue::VARR); std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex; struct CCcontract_info *cp,C; uint256 txid,hashBlock,oracletxid,tokenid; CTransaction vintx; std::string coin; int64_t totalsupply; char str[65],depositaddr[64]; uint8_t M,N,taddr,prefix,prefix2,wiftype; std::vector<CPubKey> pubkeys;
+    UniValue result(UniValue::VARR); std::vector<uint256> txids; struct CCcontract_info *cp,C; uint256 txid,hashBlock,oracletxid,tokenid; CTransaction vintx; std::string coin; int64_t totalsupply; char str[65],depositaddr[64]; uint8_t M,N,taddr,prefix,prefix2,wiftype; std::vector<CPubKey> pubkeys;
     cp = CCinit(&C,EVAL_GATEWAYS);
-    SetCCtxids(addressIndex,cp->unspendableCCaddr,true);
-    for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=addressIndex.begin(); it!=addressIndex.end(); it++)
+    SetCCtxids(txids,cp->unspendableCCaddr,true,EVAL_GATEWAYS,zeroid,'B');
+    for (std::vector<uint256>::const_iterator it=txids.begin(); it!=txids.end(); it++)
     {
-        txid = it->first.txhash;
-        if ( GetTransaction(txid,vintx,hashBlock,false) != 0 )
+        txid = *it;
+        if ( myGetTransaction(txid,vintx,hashBlock) != 0 )
         {
             if ( vintx.vout.size() > 0 && DecodeGatewaysBindOpRet(depositaddr,vintx.vout[vintx.vout.size()-1].scriptPubKey,tokenid,coin,totalsupply,oracletxid,M,N,pubkeys,taddr,prefix,prefix2,wiftype) != 0 )
             {
@@ -1701,7 +1446,7 @@ UniValue GatewaysExternalAddress(uint256 bindtxid,CPubKey pubkey)
     std::string coin; int64_t numvouts,totalsupply; char str[65],addr[65],depositaddr[65]; uint8_t M,N,taddr,prefix,prefix2,wiftype; std::vector<CPubKey> msigpubkeys;
     
     cp = CCinit(&C,EVAL_GATEWAYS);
-    if ( GetTransaction(bindtxid,tx,hashBlock,false) == 0 || (numvouts= tx.vout.size()) <= 0 )
+    if ( myGetTransaction(bindtxid,tx,hashBlock) == 0 || (numvouts= tx.vout.size()) <= 0 )
     {    
         result.push_back(Pair("result","error"));
         result.push_back(Pair("error",strprintf("cant find bindtxid %s",uint256_str(str,bindtxid))));     
@@ -1725,7 +1470,7 @@ UniValue GatewaysDumpPrivKey(uint256 bindtxid,CKey key)
     std::string coin,priv; int64_t numvouts,totalsupply; char str[65],addr[65],depositaddr[65]; uint8_t M,N,taddr,prefix,prefix2,wiftype; std::vector<CPubKey> msigpubkeys;
     
     cp = CCinit(&C,EVAL_GATEWAYS);
-    if ( GetTransaction(bindtxid,tx,hashBlock,false) == 0 || (numvouts= tx.vout.size()) <= 0 )
+    if ( myGetTransaction(bindtxid,tx,hashBlock) == 0 || (numvouts= tx.vout.size()) <= 0 )
     {      
         result.push_back(Pair("result","error"));
         result.push_back(Pair("error",strprintf("cant find bindtxid %s",uint256_str(str,bindtxid))));     
@@ -1754,7 +1499,7 @@ UniValue GatewaysInfo(uint256 bindtxid)
     cp = CCinit(&C,EVAL_GATEWAYS);
     Gatewayspk = GetUnspendable(cp,0);
     GetTokensCCaddress(cp,gatewaystokens,Gatewayspk);
-    if ( GetTransaction(bindtxid,tx,hashBlock,false) == 0 || (numvouts= tx.vout.size()) <= 0 )
+    if ( myGetTransaction(bindtxid,tx,hashBlock) == 0 || (numvouts= tx.vout.size()) <= 0 )
     {   
         result.push_back(Pair("result","error"));
         result.push_back(Pair("error",strprintf("cant find bindtxid %s",uint256_str(str,bindtxid))));     
@@ -1766,7 +1511,7 @@ UniValue GatewaysInfo(uint256 bindtxid)
         result.push_back(Pair("error",strprintf("invalid bindtxid %s coin.%s",uint256_str(str,bindtxid),coin.c_str())));     
         return(result);
     }
-    if ( GetTransaction(bindtxid,tx,hashBlock,false) != 0 )
+    if ( myGetTransaction(bindtxid,tx,hashBlock) != 0 )
     {
         result.push_back(Pair("result","success"));
         result.push_back(Pair("name","Gateways"));
diff --git a/src/cc/heir.cpp b/src/cc/heir.cpp
index 95ad699f..21b29d9a 100644
--- a/src/cc/heir.cpp
+++ b/src/cc/heir.cpp
@@ -531,7 +531,7 @@ template <class Helper> int64_t Add1of2AddressInputs(struct CCcontract_info* cp,
         
         //std::cerr << "Add1of2AddressInputs() txid=" << txid.GetHex() << std::endl;
         
-        if (GetTransaction(txid, heirtx, hashBlock, false) != 0) {
+        if (myGetTransaction(txid, heirtx, hashBlock) != 0) {
             uint256 tokenid;
             uint256 fundingTxidInOpret;
             uint8_t hasHeirSpendingBegunDummy;
@@ -579,7 +579,7 @@ template <class Helper> int64_t LifetimeHeirContractFunds(struct CCcontract_info
         CTransaction heirtx;
         
         // TODO: check all funding tx should contain unspendable markers
-        if (GetTransaction(txid, heirtx, hashBlock, false) && heirtx.vout.size() > 0) {
+        if (myGetTransaction(txid, heirtx, hashBlock) && heirtx.vout.size() > 0) {
             uint256 tokenid;
             uint256 fundingTxidInOpret;
             uint8_t hasHeirSpendingBegunDummy;
@@ -628,72 +628,79 @@ template <typename Helper> UniValue _HeirFund(int64_t txfee, int64_t amount, std
         
     CPubKey myPubkey = pubkey2pk(Mypubkey());
     
-    if (AddNormalinputs(mtx, myPubkey, markerfee, 3) > 0) { 
-        int64_t inputs, change;
+    if (!tokenid.IsNull())  // add normals only for tokens
+    {
+        if (AddNormalinputs(mtx, myPubkey, txfee + markerfee, 4) < txfee + markerfee)
+        {
+            std::cerr << "HeirFund() could not find normal inputs for txfee" << std::endl;
+            result.push_back(Pair("result", "error"));
+            result.push_back(Pair("error", "could not find normal inputs for txfee"));
+            return result;
+        }
+    }
         
-        if ((inputs=Helper::addOwnerInputs(tokenid, mtx, myPubkey, amount, (int32_t)64)) > 0) { 
-
-			mtx.vout.push_back(Helper::make1of2Vout(amount, myPubkey, heirPubkey));
+    int64_t inputs;
+    int64_t addAmount = tokenid.IsNull() ? (txfee + markerfee + amount) : amount;   // for coins add txfee markerfee amount in one call
+    if ((inputs=Helper::addOwnerInputs(tokenid, mtx, myPubkey, addAmount, (int32_t)64)) >= addAmount) 
+    { 
+		mtx.vout.push_back(Helper::make1of2Vout(amount, myPubkey, heirPubkey));
             
-            // add a marker for finding all plans in HeirList()
-            // TODO: change marker either to cc or normal txidaddr unspendable
-			struct CCcontract_info *cpHeir, heirC;  
-			cpHeir = CCinit(&heirC, EVAL_HEIR);
-            CPubKey heirUnspendablePubKey = GetUnspendable(cpHeir, 0);
-            // mtx.vout.push_back(CTxOut(txfee, CScript() << ParseHex(HexStr(heirUnspendablePubKey)) << OP_CHECKSIG));  <-- bad marker cause it was spendable by anyone
-			mtx.vout.push_back(MakeCC1vout(EVAL_HEIR, markerfee, heirUnspendablePubKey));		// this marker spending is disabled in the validation code
+        // add a marker for finding all plans in HeirList()
+        // TODO: change marker either to cc or normal txidaddr unspendable
+		struct CCcontract_info *cpHeir, heirC;  
+		cpHeir = CCinit(&heirC, EVAL_HEIR);
+        CPubKey heirUnspendablePubKey = GetUnspendable(cpHeir, 0);
+        // mtx.vout.push_back(CTxOut(txfee, CScript() << ParseHex(HexStr(heirUnspendablePubKey)) << OP_CHECKSIG));  <-- bad marker cause it was spendable by anyone
+		mtx.vout.push_back(MakeCC1vout(EVAL_HEIR, markerfee, heirUnspendablePubKey));		// this marker spending is disabled in the validation code
             
-            // calc and add change vout:
+        if (!tokenid.IsNull()) 
+        {
+            int64_t ccChange = 0;
+            // calc and add token change vout:
             if (inputs > amount)
-                change = (inputs - amount); //  -txfee <-- txfee pays user
-            
+                ccChange = (inputs - amount); //  -txfee <-- txfee pays user
+
             //std::cerr << "HeirFund() inputs=" << inputs << " amount=" << amount << " txfee=" << txfee << " change=" << change << '\n';
-            
-            if (change != 0) {	// vout[1]
-                mtx.vout.push_back(Helper::makeUserVout(change, myPubkey));
-            }
 
-			// check owner pubkey in vins
-			bool hasMypubkey = false;
-			bool hasNotMypubkey = false;
+            if (ccChange != 0)
+                mtx.vout.push_back(Helper::makeUserVout(ccChange, myPubkey));
+        }
 
-			CheckVinPubkey(mtx.vin, myPubkey, hasMypubkey, hasNotMypubkey);
+		// check owner pubkey in vins
+		bool hasMypubkey = false;
+		bool hasNotMypubkey = false;
 
-			// for initial funding do not allow to sign by non-owner key:
-			if (hasNotMypubkey) {
-				result.push_back(Pair("result", "error"));
-				result.push_back(Pair("error", "using non-owner inputs not allowed"));
-				return result;
-			}
+		CheckVinPubkey(mtx.vin, myPubkey, hasMypubkey, hasNotMypubkey);
 
-            // add 1of2 vout validation pubkeys:
-            std::vector<CPubKey> voutTokenPubkeys;
-            voutTokenPubkeys.push_back(myPubkey);
-            voutTokenPubkeys.push_back(heirPubkey);
+		// for initial funding do not allow to sign by non-owner key:
+		if (hasNotMypubkey) {
+			result.push_back(Pair("result", "error"));
+			result.push_back(Pair("error", "using non-owner inputs not allowed"));
+			return result;
+		}
+
+        // add 1of2 vout token validation pubkeys - used only for tokens
+        std::vector<CPubKey> voutTokenPubkeys;
+        voutTokenPubkeys.push_back(myPubkey);
+        voutTokenPubkeys.push_back(heirPubkey);
             
-            // add change for txfee and opreturn vouts and sign tx:
-            std::string rawhextx = FinalizeCCTx(0, cp, mtx, myPubkey, txfee,
-                                                Helper::makeCreateOpRet(tokenid, voutTokenPubkeys, myPubkey, heirPubkey, inactivityTimeSec, heirName, memo));
-            if (!rawhextx.empty()) {
-                result.push_back(Pair("result", "success"));
-                result.push_back(Pair("hex", rawhextx));
-            }
-            else {
-                std::cerr << "HeirAdd error in FinalizeCCtx" << std::endl;
-                result.push_back(Pair("result", "error"));
-                result.push_back(Pair("error", "sign error"));
-            }
+        // add change for txfee and opreturn vouts and sign tx:
+        std::string rawhextx = FinalizeCCTx(0, cp, mtx, myPubkey, txfee,
+                                            Helper::makeCreateOpRet(tokenid, voutTokenPubkeys, myPubkey, heirPubkey, inactivityTimeSec, heirName, memo));
+        if (!rawhextx.empty()) {
+            result.push_back(Pair("result", "success"));
+            result.push_back(Pair("hex", rawhextx));
         }
-        else {  // TODO: need result return unification with heiradd and claim
-            std::cerr << "HeirFund() could not find owner cc inputs" << std::endl;
+        else {
+            std::cerr << "HeirAdd error in FinalizeCCtx" << std::endl;
             result.push_back(Pair("result", "error"));
-            result.push_back(Pair("error", "could not find owner cc inputs"));
+            result.push_back(Pair("error", "sign error"));
         }
     }
-    else {
-        std::cerr << "HeirFund() could not find normal inputs" << std::endl;
+    else {  // TODO: need result return unification with heiradd and claim
+        std::cerr << "HeirFund() could not find owner inputs for amount (normal inputs for coins, cc inputs for tokens)" << std::endl;
         result.push_back(Pair("result", "error"));
-        result.push_back(Pair("error", "could not find normal inputs"));
+        result.push_back(Pair("error", "could not find owner inputs"));
     }
     return result;
 }
@@ -716,7 +723,6 @@ template <class Helper> UniValue _HeirAdd(uint256 fundingtxid, int64_t txfee, in
 {
     UniValue result(UniValue::VOBJ);
     CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
-    int64_t inputs, CCchange = 0;
     struct CCcontract_info *cp, C;
     std::string rawhex;
     
@@ -736,89 +742,93 @@ template <class Helper> UniValue _HeirAdd(uint256 fundingtxid, int64_t txfee, in
         return result;
     }
     
-    if (AddNormalinputs(mtx, myPubkey, markerfee, 3) > 0) { // some for marker
-        
-        int64_t inputs, change;
-        
-        if ((inputs = Helper::addOwnerInputs(tokenid, mtx, myPubkey, amount, 64)) > 0) { // TODO: why 64 max inputs?
+    if (!tokenid.IsNull())  // add normals only for tokens
+    {
+        if (AddNormalinputs(mtx, myPubkey, txfee + markerfee, 4) < txfee + markerfee)
+        {
+            std::cerr << "HeirFund() could not find normal inputs for txfee" << std::endl;
+            result.push_back(Pair("result", "error"));
+            result.push_back(Pair("error", "could not find normal inputs for txfee"));
+            return result;
+        }
+    }
+
+    int64_t inputs;
+    int64_t addAmount = tokenid.IsNull() ? (txfee + markerfee + amount) : amount;  // for coins add txfee markerfee amount in one call
+    if ((inputs = Helper::addOwnerInputs(tokenid, mtx, myPubkey, addAmount, 64)) >= addAmount) { // TODO: why 64 max inputs?
             
-            // we do not use markers anymore - storing data in opreturn is better
-            // add marker vout:
-            /* char markeraddr[64];
-             CPubKey markerpubkey = CCtxidaddr(markeraddr, fundingtxid);
-             mtx.vout.push_back(CTxOut(txfee, CScript() << ParseHex(HexStr(markerpubkey)) << OP_CHECKSIG)); // txfee 1, txfee 2 - for miners
-             std::cerr << "HeirAdd() adding markeraddr=" << markeraddr << '\n'; */
+        // we do not use markers anymore - storing data in opreturn is better
+        // add marker vout:
+        /* char markeraddr[64];
+            CPubKey markerpubkey = CCtxidaddr(markeraddr, fundingtxid);
+            mtx.vout.push_back(CTxOut(txfee, CScript() << ParseHex(HexStr(markerpubkey)) << OP_CHECKSIG)); // txfee 1, txfee 2 - for miners
+            std::cerr << "HeirAdd() adding markeraddr=" << markeraddr << '\n'; */
             
-            // add cryptocondition to spend this funded amount for either pk
-            mtx.vout.push_back(Helper::make1of2Vout(amount, ownerPubkey, heirPubkey));
+        // add cryptocondition to spend this funded amount for either pk
+        mtx.vout.push_back(Helper::make1of2Vout(amount, ownerPubkey, heirPubkey));
 
-			char markeraddr[64];
-			CPubKey markerPubkey = CCtxidaddr(markeraddr, fundingtxid);
-			mtx.vout.push_back(CTxOut(markerfee, CScript() << ParseHex(HexStr(markerPubkey)) << OP_CHECKSIG));		// marker to prevent archiving of the funds add vouts
+		char markeraddr[64];
+		CPubKey markerPubkey = CCtxidaddr(markeraddr, fundingtxid);
+		mtx.vout.push_back(CTxOut(markerfee, CScript() << ParseHex(HexStr(markerPubkey)) << OP_CHECKSIG));		// marker to prevent archiving of the funds add vouts
+
+        if (!tokenid.IsNull())
+        {
+            int64_t ccChange = 0;
 
             if (inputs > amount)
-                change = (inputs - amount); //  -txfee <-- txfee pays user
-            
+                ccChange = (inputs - amount); //  -txfee <-- txfee pays user
             //std::cerr << "HeirAdd() inputs=" << inputs << " amount=" << amount << " txfee=" << txfee << " change=" << change << '\n';
-            
-            if (change != 0) {																		// vout[1]
-                mtx.vout.push_back(Helper::makeUserVout(change, myPubkey));
-            }
 
-			// check owner pubkey in vins
-			bool hasMypubkey = false;
-			bool hasNotMypubkey = false;
+            if (ccChange != 0) 
+                mtx.vout.push_back(Helper::makeUserVout(ccChange, myPubkey));
+        }
 
-			CheckVinPubkey(mtx.vin, myPubkey, hasMypubkey, hasNotMypubkey);
+		// check owner pubkey in vins
+		bool hasMypubkey = false;
+		bool hasNotMypubkey = false;
 
-			// for additional funding do not allow to sign by both owner and non-owner keys (is this a donation or not?):
-			if (hasMypubkey && hasNotMypubkey) {
-				result.push_back(Pair("result", "error"));
-				result.push_back(Pair("error", "using both owner and non-owner inputs is not allowed"));
-				return result;
-			}
+		CheckVinPubkey(mtx.vin, myPubkey, hasMypubkey, hasNotMypubkey);
+
+		// for additional funding do not allow to sign by both owner and non-owner keys (is this a donation or not?):
+		if (hasMypubkey && hasNotMypubkey) {
+			result.push_back(Pair("result", "error"));
+			result.push_back(Pair("error", "using both owner and non-owner inputs is not allowed"));
+			return result;
+		}
             
-			// warn the user he's making a donation if this is all non-owner keys:
-			if (hasNotMypubkey) {
-				result.push_back(Pair("result", "warning"));
-				result.push_back(Pair("warning", "you are about to make a donation to heir fund"));
-			}
-			else	{
-				result.push_back(Pair("result", "success"));
-			}
+		// warn the user he's making a donation if this is all non-owner keys:
+		if (hasNotMypubkey) {
+			result.push_back(Pair("result", "warning"));
+			result.push_back(Pair("warning", "you are about to make a donation to heir fund"));
+		}
+		else	{
+			result.push_back(Pair("result", "success"));
+		}
 
-            // add 1of2 vout validation pubkeys - needed only for tokens:
-            std::vector<CPubKey> voutTokenPubkeys;
-            voutTokenPubkeys.push_back(ownerPubkey);
-            voutTokenPubkeys.push_back(heirPubkey);
+        // add 1of2 vout validation pubkeys - needed only for tokens:
+        std::vector<CPubKey> voutTokenPubkeys;
+        voutTokenPubkeys.push_back(ownerPubkey);
+        voutTokenPubkeys.push_back(heirPubkey);
             
-            // add opreturn 'A'  and sign tx:						// this txfee ignored
-            std::string rawhextx = (FinalizeCCTx(0, cp, mtx, myPubkey, txfee,
-                                                 Helper::makeAddOpRet(tokenid, voutTokenPubkeys, fundingtxid, hasHeirSpendingBegun)));
-            
-            if (!rawhextx.empty()) {
-                result.push_back(Pair("hex", rawhextx));
-            }
-            else	{
-                std::cerr << "HeirAdd error in FinalizeCCtx" << std::endl;
-				result.clear();
-                result.push_back(Pair("result", "error"));
-                result.push_back(Pair("error", "sign error"));
-            }
+        // add opreturn 'A'  and sign tx:						
+        std::string rawhextx = (FinalizeCCTx(0, cp, mtx, myPubkey, txfee,
+                                                Helper::makeAddOpRet(tokenid, voutTokenPubkeys, fundingtxid, hasHeirSpendingBegun)));
             
+        if (!rawhextx.empty()) {
+            result.push_back(Pair("hex", rawhextx));
         }
-        else {
-            std::cerr << "HeirAdd cannot find owner cc inputs" << std::endl;
+        else	{
+            std::cerr << "HeirAdd error in FinalizeCCtx" << std::endl;
+			result.clear();
             result.push_back(Pair("result", "error"));
-            result.push_back(Pair("error", "can't find owner cc inputs"));
+            result.push_back(Pair("error", "sign error"));
         }
     }
     else {
-        std::cerr << "HeirAdd cannot find normal inputs for tx fee" << std::endl;
+        std::cerr << "HeirAdd cannot find owner inputs for amount (normal inputs for coins, cc inputs for tokens)" << std::endl;
         result.push_back(Pair("result", "error"));
-        result.push_back(Pair("error", "can't find normal inputs for tx fee"));
-    }
-    
+        result.push_back(Pair("error", "can't find owner inputs"));
+    }    
     return result;
 }
 
@@ -833,10 +843,12 @@ UniValue HeirAddCaller(uint256 fundingtxid, int64_t txfee, std::string strAmount
     std::string heirName, memo;
     uint8_t hasHeirSpendingBegun = 0;
     
-    if ((latesttxid = FindLatestFundingTx(fundingtxid, funcId, tokenid, ownerPubkey, heirPubkey, inactivityTimeSec, heirName, memo, hasHeirSpendingBegun)) != zeroid) {
+    // get latest tx to see if it is a token or coin
+    if ((latesttxid = FindLatestFundingTx(fundingtxid, funcId, tokenid, ownerPubkey, heirPubkey, inactivityTimeSec, heirName, memo, hasHeirSpendingBegun)) != zeroid) 
+    {
 		if (tokenid == zeroid) {
-			int64_t amount = (int64_t)(atof(strAmount.c_str()) * COIN);
-			if (amount <= 0) {
+			int64_t amount = 0;
+			if (!ParseFixedPoint(strAmount, 8, &amount) || amount <= 0 ) {
 				UniValue result(UniValue::VOBJ);
 				result.push_back(Pair("result", "error"));
 				result.push_back(Pair("error", "invalid amount"));
@@ -844,7 +856,8 @@ UniValue HeirAddCaller(uint256 fundingtxid, int64_t txfee, std::string strAmount
 			}
 			return _HeirAdd<CoinHelper>(fundingtxid, txfee, amount, latesttxid, funcId, tokenid, ownerPubkey, heirPubkey, inactivityTimeSec, hasHeirSpendingBegun);
 		}
-		else {
+		else 
+        {
 			int64_t amount = atoll(strAmount.c_str());
 			if (amount <= 0) {
 				UniValue result(UniValue::VOBJ);
@@ -967,6 +980,7 @@ template <typename Helper>UniValue _HeirClaim(uint256 fundingtxid, int64_t txfee
             std::string rawhextx = FinalizeCCTx(0, cp, mtx, myPubkey, txfee,
                                                 Helper::makeClaimOpRet(tokenid, voutTokenPubkeys, fundingtxid, (myPubkey == heirPubkey) ? 1 : hasHeirSpendingBegun)); // forward isHeirSpending to the next latest tx
             
+            memset(myprivkey,0,sizeof(myprivkey));
             if (!rawhextx.empty()) {
                 result.push_back(Pair("result", "success"));
                 result.push_back(Pair("hex", rawhextx));
@@ -1002,15 +1016,18 @@ UniValue HeirClaimCaller(uint256 fundingtxid, int64_t txfee, std::string strAmou
     std::string heirName, memo;
     uint8_t hasHeirSpendingBegun = 0;
     
-    if ((latesttxid = FindLatestFundingTx(fundingtxid, funcId, tokenid, ownerPubkey, heirPubkey, inactivityTimeSec, heirName, memo, hasHeirSpendingBegun)) != zeroid) {
-		if (tokenid == zeroid) {
-			int64_t amount = (int64_t)(atof(strAmount.c_str()) * COIN);
-			if (amount < 0) {
-				UniValue result(UniValue::VOBJ);
-				result.push_back(Pair("result", "error"));
-				result.push_back(Pair("error", "invalid amount"));
-				return result;
-			}
+    // find latest tx to see if it is a token or coin:
+    if ((latesttxid = FindLatestFundingTx(fundingtxid, funcId, tokenid, ownerPubkey, heirPubkey, inactivityTimeSec, heirName, memo, hasHeirSpendingBegun)) != zeroid) 
+    {
+		if (tokenid == zeroid) 
+        {
+            int64_t amount = 0;
+            if (!ParseFixedPoint(strAmount, 8, &amount) || amount <= 0) {  // using ParseFixedPoint instead atof to avoid round errors
+                UniValue result(UniValue::VOBJ);
+                result.push_back(Pair("result", "error"));
+                result.push_back(Pair("error", "invalid amount"));
+                return result;
+            }
 			return _HeirClaim<CoinHelper>(fundingtxid, txfee, amount, latesttxid, funcId, tokenid, ownerPubkey, heirPubkey, inactivityTimeSec, hasHeirSpendingBegun);
 		}
 		else {
@@ -1232,7 +1249,7 @@ void _HeirList(struct CCcontract_info *cp, UniValue &result)
         //std::cerr << "HeirList() checking txid=" << txid.GetHex() << " vout=" << vout << '\n';
         
         CTransaction fundingtx;
-        if (GetTransaction(txid, fundingtx, hashBlock, false)) {
+        if (myGetTransaction(txid, fundingtx, hashBlock)) {
             CPubKey ownerPubkey, heirPubkey;
             std::string heirName, memo;
             int64_t inactivityTimeSec;
diff --git a/src/cc/heir_validate.h b/src/cc/heir_validate.h
index a27dc334..768390aa 100644
--- a/src/cc/heir_validate.h
+++ b/src/cc/heir_validate.h
@@ -56,6 +56,7 @@ class CoinHelper {
         uint8_t mypriv[32];
         Myprivkey(mypriv);
         CCaddr1of2set(cp, ownerPubkey, heirPubkey,mypriv, coinaddr);
+        memset(mypriv,0,sizeof(mypriv));
     }
 };
 
@@ -98,8 +99,10 @@ class TokenHelper {
     }
     
     static void CCaddrCoinsOrTokens1of2set(struct CCcontract_info *cp, CPubKey ownerPubkey, CPubKey heirPubkey, char *coinaddr) {
-        
-        CCaddrTokens1of2set(cp, ownerPubkey, heirPubkey, coinaddr);
+        uint8_t mypriv[32];
+        Myprivkey(mypriv);
+        CCaddrTokens1of2set(cp, ownerPubkey, heirPubkey, mypriv, coinaddr);
+        memset(mypriv,0,sizeof(mypriv));
     }
 };
 
diff --git a/src/cc/hempcoin_notes.txt b/src/cc/hempcoin_notes.txt
index 2fd72c89..04bf0e9a 100644
--- a/src/cc/hempcoin_notes.txt
+++ b/src/cc/hempcoin_notes.txt
@@ -1,6 +1,6 @@
 How this works:
-    - earlytxid must be a transaction included in the chain before block 100. The chain MUST not have any other of these type of tx before block 100, or someone may be able to change it and mess things up.
-    - When it gets to block 100, it takes the txid specified by the -earlytxid param (does not affect magic) 
+    - earlytxid must be a transaction included in the chain before block KOMODO_EARLYTXID_HEIGHT. The chain MUST not have any other of these type of tx before block KOMODO_EARLYTXID_HEIGHT, or someone may be able to change it and mess things up.
+    - When it gets to block KOMODO_EARLYTXID_HEIGHT, it takes the txid specified by the -earlytxid param (does not affect magic)
     - Looks up the transaction searches for the opreturn, then permenantly appends it to the end of ac_script in RAM.
     - After every daemon restart, the first time the daemon mines a block, or receives a block that pays ac_script it will look up the op_return and save it again. 
     - this enables it to always reach consensus but doesnt need to constantly keep looking up the tx in the chain.
diff --git a/src/cc/import.cpp b/src/cc/import.cpp
index 54247584..0a76a01e 100644
--- a/src/cc/import.cpp
+++ b/src/cc/import.cpp
@@ -367,7 +367,7 @@ int32_t CheckGATEWAYimport(CTransaction importTx,CTransaction burnTx,std::string
         return(-1);
     }
     // check for valid burn from external coin blockchain and if valid return(0);
-    if (GetTransaction(bindtxid, bindtx, hashBlock, false) == 0 || (numvouts = bindtx.vout.size()) <= 0)
+    if (myGetTransaction(bindtxid, bindtx, hashBlock) == 0 || (numvouts = bindtx.vout.size()) <= 0)
     {
         LOGSTREAM("importgateway", CCLOG_INFO, stream << "CheckGATEWAYimport cant find bindtxid=" << bindtxid.GetHex() << std::endl);
         return(-1);
@@ -397,7 +397,7 @@ int32_t CheckGATEWAYimport(CTransaction importTx,CTransaction burnTx,std::string
         LOGSTREAM("importgateway", CCLOG_INFO, stream << "CheckGATEWAYimport bindtx not yet confirmed/notarized" << std::endl);
         return(-1);
     }
-    else if (GetTransaction(oracletxid, oracletx, hashBlock, false) == 0 || (numvouts = oracletx.vout.size()) <= 0)
+    else if (myGetTransaction(oracletxid, oracletx, hashBlock) == 0 || (numvouts = oracletx.vout.size()) <= 0)
     {
         LOGSTREAM("importgateway", CCLOG_INFO, stream << "CheckGATEWAYimport cant find oracletxid=" << oracletxid.GetHex() << std::endl);
         return(-1);
@@ -417,7 +417,7 @@ int32_t CheckGATEWAYimport(CTransaction importTx,CTransaction burnTx,std::string
     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 && regtx.vout.size() > 0
+        if ( myGetTransaction(txid,regtx,hashBlock) != 0 && regtx.vout.size() > 0
             && DecodeOraclesOpRet(regtx.vout[regtx.vout.size()-1].scriptPubKey,tmporacletxid,regpk,datafee) == 'R' && oracletxid == tmporacletxid )
         {
             pubkeys.push_back(regpk);
@@ -682,7 +682,7 @@ bool Eval::ImportCoin(const std::vector<uint8_t> params, const CTransaction &imp
         return Invalid("invalid-params");
     // Control all aspects of this transaction
     // It should not be at all malleable
-    if (MakeImportCoinTransaction(proof, burnTx, payouts, importTx.nExpiryHeight).GetHash() != importTx.GetHash())  // ExistsImportTombstone prevents from duplication
+    if (ASSETCHAINS_SELFIMPORT!="PEGSCC" && MakeImportCoinTransaction(proof, burnTx, payouts, importTx.nExpiryHeight).GetHash() != importTx.GetHash())  // ExistsImportTombstone prevents from duplication
         return Invalid("non-canonical");
 
     // burn params
@@ -738,10 +738,17 @@ bool Eval::ImportCoin(const std::vector<uint8_t> params, const CTransaction &imp
             else if ( UnmarshalBurnTx(burnTx,srcaddr,receipt)==0 || CheckCODAimport(importTx,burnTx,payouts,srcaddr,receipt) < 0 )
                 return Invalid("CODA-import-failure");
         }
+        else if ( targetSymbol == "PEGSCC" )
+        {
+            if ( ASSETCHAINS_SELFIMPORT != "PEGSCC" )
+                return Invalid("PEGSCC-import-when-not PEGSCC");
+            // else if ( CheckPUBKEYimport(merkleBranchProof,rawproof,burnTx,payouts) < 0 )
+            //     return Invalid("PEGSCC-import-failure");
+        }
         else if ( targetSymbol == "PUBKEY" )
         {
             if ( ASSETCHAINS_SELFIMPORT != "PUBKEY" )
-                return Invalid("PUBKEY-import-when-notPUBKEY");
+                return Invalid("PUBKEY-import-when-not PUBKEY");
             else if ( CheckPUBKEYimport(merkleBranchProof,rawproof,burnTx,payouts) < 0 )
                 return Invalid("PUBKEY-import-failure");
         }
@@ -749,7 +756,7 @@ bool Eval::ImportCoin(const std::vector<uint8_t> params, const CTransaction &imp
         {
             if ( targetSymbol != ASSETCHAINS_SELFIMPORT )
                 return Invalid("invalid-gateway-import-coin");
-             else if ( UnmarshalBurnTx(burnTx,bindtxid,publishers,txids,burntxid,height,burnvout,rawburntx,destpub,amount)==0 || CheckGATEWAYimport(importTx,burnTx,targetSymbol,rawproof,bindtxid,publishers,txids,burntxid,height,burnvout,rawburntx,destpub,amount) < 0 )
+            else if ( UnmarshalBurnTx(burnTx,bindtxid,publishers,txids,burntxid,height,burnvout,rawburntx,destpub,amount)==0 || CheckGATEWAYimport(importTx,burnTx,targetSymbol,rawproof,bindtxid,publishers,txids,burntxid,height,burnvout,rawburntx,destpub,amount) < 0 )
                 return Invalid("GATEWAY-import-failure");
         }
     }
diff --git a/src/cc/importgateway.cpp b/src/cc/importgateway.cpp
index 4ae5f979..7e4b6195 100644
--- a/src/cc/importgateway.cpp
+++ b/src/cc/importgateway.cpp
@@ -260,13 +260,13 @@ int32_t ImportGatewayBindExists(struct CCcontract_info *cp,CPubKey importgateway
 {
     char markeraddr[64],burnaddr[64]; std::string coin; int32_t numvouts; int64_t totalsupply; uint256 tokenid,oracletxid,hashBlock; 
     uint8_t M,N,taddr,prefix,prefix2,wiftype; std::vector<CPubKey> pubkeys; CTransaction tx;
-    std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex;
+    std::vector<uint256> txids;
 
     _GetCCaddress(markeraddr,EVAL_IMPORTGATEWAY,importgatewaypk);
-    SetCCtxids(addressIndex,markeraddr,true);
-    for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=addressIndex.begin(); it!=addressIndex.end(); it++)
+    SetCCtxids(txids,markeraddr,true,cp->evalcode,zeroid,'B');
+    for (std::vector<uint256>::const_iterator it=txids.begin(); it!=txids.end(); it++)
     {
-        if ( myGetTransaction(it->first.txhash,tx,hashBlock) != 0 && (numvouts= tx.vout.size()) > 0 && DecodeImportGatewayOpRet(tx.vout[numvouts-1].scriptPubKey)=='B' )
+        if ( myGetTransaction(*it,tx,hashBlock) != 0 && (numvouts= tx.vout.size()) > 0 && DecodeImportGatewayOpRet(tx.vout[numvouts-1].scriptPubKey)=='B' )
         {
             if ( DecodeImportGatewayBindOpRet(burnaddr,tx.vout[numvouts-1].scriptPubKey,coin,oracletxid,M,N,pubkeys,taddr,prefix,prefix2,wiftype) == 'B' )
             {
@@ -278,10 +278,11 @@ int32_t ImportGatewayBindExists(struct CCcontract_info *cp,CPubKey importgateway
             }
         }
     }
-    BOOST_FOREACH(const CTxMemPoolEntry &e, mempool.mapTx)
+    std::vector<CTransaction> tmp_txs;
+    myGet_mempool_txs(tmp_txs,EVAL_IMPORTGATEWAY,'B');
+    for (std::vector<CTransaction>::const_iterator it=tmp_txs.begin(); it!=tmp_txs.end(); it++)
     {
-        const CTransaction &txmempool = e.GetTx();
-        const uint256 &hash = txmempool.GetHash();
+        const CTransaction &txmempool = *it;
 
         if ((numvouts=txmempool.vout.size()) > 0 && DecodeImportGatewayOpRet(tx.vout[numvouts-1].scriptPubKey)=='B')
             if (DecodeImportGatewayBindOpRet(burnaddr,tx.vout[numvouts-1].scriptPubKey,coin,oracletxid,M,N,pubkeys,taddr,prefix,prefix2,wiftype) == 'B')
@@ -525,7 +526,7 @@ std::string ImportGatewayBind(uint64_t txfee,std::string coin,uint256 oracletxid
         LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
         return("");
     }
-    if ( GetTransaction(oracletxid,oracletx,hashBlock,false) == 0 || (numvouts= oracletx.vout.size()) <= 0 )
+    if ( myGetTransaction(oracletxid,oracletx,hashBlock) == 0 || (numvouts= oracletx.vout.size()) <= 0 )
     {
         CCerror = strprintf("cant find oracletxid %s",uint256_str(str,oracletxid));
         LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
@@ -568,7 +569,7 @@ std::string ImportGatewayDeposit(uint64_t txfee,uint256 bindtxid,int32_t height,
 
     if (KOMODO_EARLYTXID!=zeroid && bindtxid!=KOMODO_EARLYTXID)
     {
-        CCerror = strprintf("CheckGATEWAYimport invalid import gateway. On this chain only valid import gateway is %s",KOMODO_EARLYTXID.GetHex());
+        CCerror = strprintf("invalid import gateway. On this chain only valid import gateway is %s",KOMODO_EARLYTXID.GetHex());
         LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
         return("");
     }
@@ -581,7 +582,7 @@ std::string ImportGatewayDeposit(uint64_t txfee,uint256 bindtxid,int32_t height,
         return std::string("");
     }
     LOGSTREAM("importgateway",CCLOG_DEBUG1, stream << "ImportGatewayDeposit ht." << height << " " << refcoin << " " << (double)amount/COIN << " numpks." << (int32_t)pubkeys.size() << std::endl);
-    if ( GetTransaction(bindtxid,bindtx,hashBlock,false) == 0 || (numvouts= bindtx.vout.size()) <= 0 )
+    if ( myGetTransaction(bindtxid,bindtx,hashBlock) == 0 || (numvouts= bindtx.vout.size()) <= 0 )
     {
         CCerror = strprintf("cant find bindtxid %s",uint256_str(str,bindtxid));
         LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
@@ -645,13 +646,19 @@ std::string ImportGatewayWithdraw(uint64_t txfee,uint256 bindtxid,std::string re
     std::vector<CPubKey> msigpubkeys; char burnaddr[64],str[65],coinaddr[64]; struct CCcontract_info *cp,C;
     std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
 
+    if (KOMODO_EARLYTXID!=zeroid && bindtxid!=KOMODO_EARLYTXID)
+    {
+        CCerror = strprintf("invalid import gateway. On this chain only valid import gateway is %s",KOMODO_EARLYTXID.GetHex());
+        LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
+        return("");
+    }
     cp = CCinit(&C,EVAL_IMPORTGATEWAY);
     if ( txfee == 0 )
         txfee = 10000;
     mypk = pubkey2pk(Mypubkey());
     importgatewaypk = GetUnspendable(cp, 0);
 
-    if( GetTransaction(bindtxid,tx,hashBlock,false) == 0 || (numvouts= tx.vout.size()) <= 0 )
+    if( myGetTransaction(bindtxid,tx,hashBlock) == 0 || (numvouts= tx.vout.size()) <= 0 )
     {
         CCerror = strprintf("cant find bindtxid %s",uint256_str(str,bindtxid));
         LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
@@ -677,7 +684,7 @@ std::string ImportGatewayWithdraw(uint64_t txfee,uint256 bindtxid,std::string re
         vout = (int32_t)it->first.index;
         nValue = (int64_t)it->second.satoshis;
         K=0;
-        if ( vout == 0 && nValue == 10000 && GetTransaction(txid,tx,hashBlock,false) != 0 && (numvouts= tx.vout.size())>0 && 
+        if ( vout == 0 && nValue == CC_MARKER_VALUE && myGetTransaction(txid,tx,hashBlock) != 0 && (numvouts= tx.vout.size())>0 &&
             (funcid=DecodeImportGatewayOpRet(tx.vout[numvouts-1].scriptPubKey))!=0 && (funcid=='W' || funcid=='P'))
         {
             if (funcid=='W' && DecodeImportGatewayWithdrawOpRet(tx.vout[numvouts-1].scriptPubKey,tmpbindtxid,coin,withdrawpub,tmpamount)=='W'
@@ -689,7 +696,7 @@ std::string ImportGatewayWithdraw(uint64_t txfee,uint256 bindtxid,std::string re
             }
             
             else if (funcid=='P' && DecodeImportGatewayPartialOpRet(tx.vout[numvouts-1].scriptPubKey,withdrawtxid,coin,K,signerpk,hex)=='P' &&
-                GetTransaction(withdrawtxid,tx,hashBlock,false)!=0 && (numvouts=tx.vout.size())>0 && DecodeImportGatewayWithdrawOpRet(tx.vout[numvouts-1].scriptPubKey,tmpbindtxid,coin,withdrawpub,tmpamount)=='W'
+                myGetTransaction(withdrawtxid,tx,hashBlock)!=0 && (numvouts=tx.vout.size())>0 && DecodeImportGatewayWithdrawOpRet(tx.vout[numvouts-1].scriptPubKey,tmpbindtxid,coin,withdrawpub,tmpamount)=='W'
                 && refcoin==coin && tmpbindtxid==bindtxid)                    
             {
                 CCerror = strprintf("unable to create withdraw, another withdraw pending");
@@ -701,7 +708,7 @@ std::string ImportGatewayWithdraw(uint64_t txfee,uint256 bindtxid,std::string re
     if( AddNormalinputs(mtx, mypk, txfee+CC_MARKER_VALUE+amount, 64) > 0 )
     {
         mtx.vout.push_back(MakeCC1vout(EVAL_IMPORTGATEWAY,CC_MARKER_VALUE,importgatewaypk));
-        mtx.vout.push_back(MakeCC1vout(EVAL_IMPORTGATEWAY,amount,importgatewaypk));                   
+        mtx.vout.push_back(MakeCC1vout(EVAL_IMPORTGATEWAY,amount,CCtxidaddr(str,bindtxid)));                   
         return(FinalizeCCTx(0, cp, mtx, mypk, txfee,EncodeImportGatewayWithdrawOpRet('W',bindtxid,refcoin,withdrawpub,amount)));
     }
     CCerror = strprintf("cant find enough normal inputs");
@@ -722,7 +729,7 @@ std::string ImportGatewayPartialSign(uint64_t txfee,uint256 lasttxid,std::string
         txfee = 10000;
     mypk = pubkey2pk(Mypubkey());
     importgatewaypk = GetUnspendable(cp,0);
-    if (GetTransaction(lasttxid,tx,hashBlock,false)==0 || (numvouts= tx.vout.size())<=0
+    if (myGetTransaction(lasttxid,tx,hashBlock)==0 || (numvouts= tx.vout.size())<=0
         || (funcid=DecodeImportGatewayOpRet(tx.vout[numvouts-1].scriptPubKey))==0 || (funcid!='W' && funcid!='P'))
     {
         CCerror = strprintf("can't find last tx %s",uint256_str(str,lasttxid));
@@ -738,13 +745,19 @@ std::string ImportGatewayPartialSign(uint64_t txfee,uint256 lasttxid,std::string
             LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
             return("");
         }
+        else if (KOMODO_EARLYTXID!=zeroid && bindtxid!=KOMODO_EARLYTXID)
+        {
+            CCerror = strprintf("invalid import gateway. On this chain only valid import gateway is %s",KOMODO_EARLYTXID.GetHex());
+            LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
+            return("");
+        }
         else if (komodo_txnotarizedconfirmed(withdrawtxid)==false)
         {
             CCerror = strprintf("gatewayswithdraw tx not yet confirmed/notarized");
             LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
             return("");
         }
-        else if (GetTransaction(bindtxid,tmptx,hashBlock,false)==0 || (numvouts=tmptx.vout.size())<=0)
+        else if (myGetTransaction(bindtxid,tmptx,hashBlock)==0 || (numvouts=tmptx.vout.size())<=0)
         {
             CCerror = strprintf("can't find bind tx %s",uint256_str(str,bindtxid));
             LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
@@ -766,7 +779,7 @@ std::string ImportGatewayPartialSign(uint64_t txfee,uint256 lasttxid,std::string
             LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
             return("");
         }
-        else if (GetTransaction(withdrawtxid,tmptx,hashBlock,false)==0 || (numvouts= tmptx.vout.size())<=0)
+        else if (myGetTransaction(withdrawtxid,tmptx,hashBlock)==0 || (numvouts= tmptx.vout.size())<=0)
         {
             CCerror = strprintf("can't find withdraw tx %s",uint256_str(str,withdrawtxid));
             LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
@@ -779,13 +792,19 @@ std::string ImportGatewayPartialSign(uint64_t txfee,uint256 lasttxid,std::string
             LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
             return("");
         }
+        else if (KOMODO_EARLYTXID!=zeroid && bindtxid!=KOMODO_EARLYTXID)
+        {
+            CCerror = strprintf("invalid import gateway. On this chain only valid import gateway is %s",KOMODO_EARLYTXID.GetHex());
+            LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
+            return("");
+        }
         else if (komodo_txnotarizedconfirmed(withdrawtxid)==false)
         {
             CCerror = strprintf("gatewayswithdraw tx not yet confirmed/notarized");
             LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
             return("");
         }
-        else if (GetTransaction(bindtxid,tmptx,hashBlock,false)==0 || (numvouts=tmptx.vout.size())<=0)
+        else if (myGetTransaction(bindtxid,tmptx,hashBlock)==0 || (numvouts=tmptx.vout.size())<=0)
         {
             CCerror = strprintf("can't find bind tx %s",uint256_str(str,bindtxid));
             LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
@@ -822,7 +841,7 @@ std::string ImportGatewayCompleteSigning(uint64_t txfee,uint256 lasttxid,std::st
     importgatewaypk = GetUnspendable(cp,0);
     if ( txfee == 0 )
         txfee = 10000;
-    if (GetTransaction(lasttxid,tx,hashBlock,false)==0 || (numvouts= tx.vout.size())<=0
+    if (myGetTransaction(lasttxid,tx,hashBlock)==0 || (numvouts= tx.vout.size())<=0
         || (funcid=DecodeImportGatewayOpRet(tx.vout[numvouts-1].scriptPubKey))==0 || (funcid!='W' && funcid!='P'))
     {
         CCerror = strprintf("invalid last txid %s",uint256_str(str,lasttxid));
@@ -838,18 +857,30 @@ std::string ImportGatewayCompleteSigning(uint64_t txfee,uint256 lasttxid,std::st
             LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
             return("");
         }
-        else if (GetTransaction(bindtxid,tmptx,hashBlock,false)==0 || (numvouts=tmptx.vout.size())<=0)
+        else if (myGetTransaction(bindtxid,tmptx,hashBlock)==0 || (numvouts=tmptx.vout.size())<=0)
         {
             CCerror = strprintf("can't find bind tx %s",uint256_str(str,bindtxid));
             LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
             return("");
         }
+        else if (KOMODO_EARLYTXID!=zeroid && bindtxid!=KOMODO_EARLYTXID)
+        {
+            CCerror = strprintf("invalid import gateway. On this chain only valid import gateway is %s",KOMODO_EARLYTXID.GetHex());
+            LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
+            return("");
+        }
         else if (komodo_txnotarizedconfirmed(withdrawtxid)==false)
         {
             CCerror = strprintf("gatewayswithdraw tx not yet confirmed/notarized");
             LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
             return("");
         }
+        else if (GetTransaction(bindtxid,tmptx,hashBlock,false)==0 || (numvouts=tmptx.vout.size())<=0)
+        {
+            CCerror = strprintf("can't find bind tx %s",uint256_str(str,bindtxid));
+            LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
+            return("");
+        }
         else if (DecodeImportGatewayBindOpRet(burnaddr,tmptx.vout[numvouts-1].scriptPubKey,coin,oracletxid,M,N,pubkeys,taddr,prefix,prefix2,wiftype) != 'B'
             || refcoin!=coin)
         {
@@ -866,7 +897,7 @@ std::string ImportGatewayCompleteSigning(uint64_t txfee,uint256 lasttxid,std::st
             LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
             return("");
         }
-        else if (GetTransaction(withdrawtxid,tmptx,hashBlock,false)==0 || (numvouts=tmptx.vout.size())==0)
+        else if (myGetTransaction(withdrawtxid,tmptx,hashBlock)==0 || (numvouts=tmptx.vout.size())==0)
         {
             CCerror = strprintf("invalid withdraw txid %s",uint256_str(str,withdrawtxid));
             LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
@@ -878,13 +909,19 @@ std::string ImportGatewayCompleteSigning(uint64_t txfee,uint256 lasttxid,std::st
             LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
             return("");
         }
+        else if (KOMODO_EARLYTXID!=zeroid && bindtxid!=KOMODO_EARLYTXID)
+        {
+            CCerror = strprintf("invalid import gateway. On this chain only valid import gateway is %s",KOMODO_EARLYTXID.GetHex());
+            LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
+            return("");
+        }
         else if (komodo_txnotarizedconfirmed(withdrawtxid)==false)
         {
             CCerror = strprintf("gatewayswithdraw tx not yet confirmed/notarized");
             LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
             return("");
         }
-        else if (GetTransaction(bindtxid,tmptx,hashBlock,false)==0 || (numvouts=tmptx.vout.size())<=0)
+        else if (myGetTransaction(bindtxid,tmptx,hashBlock)==0 || (numvouts=tmptx.vout.size())<=0)
         {
             CCerror = strprintf("can't find bind tx %s",uint256_str(str,bindtxid));
             LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
@@ -920,7 +957,7 @@ std::string ImportGatewayMarkDone(uint64_t txfee,uint256 completetxid,std::strin
     mypk = pubkey2pk(Mypubkey());    
     if ( txfee == 0 )
         txfee = 10000;
-    if (GetTransaction(completetxid,tx,hashBlock,false)==0 || (numvouts= tx.vout.size())<=0)
+    if (myGetTransaction(completetxid,tx,hashBlock)==0 || (numvouts= tx.vout.size())<=0)
     {
         CCerror = strprintf("invalid completesigning txid %s",uint256_str(str,completetxid));
         LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
@@ -938,7 +975,7 @@ std::string ImportGatewayMarkDone(uint64_t txfee,uint256 completetxid,std::strin
         LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
         return("");
     }
-    else if (GetTransaction(withdrawtxid,tx,hashBlock,false)==0 || (numvouts= tx.vout.size())==0)
+    else if (myGetTransaction(withdrawtxid,tx,hashBlock)==0 || (numvouts= tx.vout.size())==0)
     {
         CCerror = strprintf("invalid withdraw txid %s",uint256_str(str,withdrawtxid));
         LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
@@ -950,7 +987,13 @@ std::string ImportGatewayMarkDone(uint64_t txfee,uint256 completetxid,std::strin
         LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
         return("");
     }
-    else if (GetTransaction(bindtxid,tx,hashBlock,false)==0 || (numvouts=tx.vout.size())<=0)
+    else if (KOMODO_EARLYTXID!=zeroid && bindtxid!=KOMODO_EARLYTXID)
+    {
+        CCerror = strprintf("invalid import gateway. On this chain only valid import gateway is %s",KOMODO_EARLYTXID.GetHex());
+        LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
+        return("");
+    }
+    else if (myGetTransaction(bindtxid,tx,hashBlock)==0 || (numvouts=tx.vout.size())<=0)
     {
         CCerror = strprintf("can't find bind tx %s",uint256_str(str,bindtxid));
         LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
@@ -974,61 +1017,6 @@ std::string ImportGatewayMarkDone(uint64_t txfee,uint256 completetxid,std::strin
     return("");
 }
 
-UniValue ImportGatewayPendingDeposits(uint256 bindtxid,std::string refcoin)
-{
-    UniValue result(UniValue::VOBJ),pending(UniValue::VARR); CTransaction tx; std::string coin,hex,pub; 
-    CPubKey mypk,importgatewaypk,destpub; std::vector<CPubKey> pubkeys,publishers; std::vector<uint256> txids;
-    uint256 tmpbindtxid,hashBlock,txid,oracletxid,burntxid; uint8_t M,N,taddr,prefix,prefix2,wiftype;
-    char burnaddr[65],coinaddr[65],str[65],destaddr[65],txidaddr[65]; std::vector<uint8_t> proof;
-    int32_t numvouts,vout,claimvout,height; int64_t nValue,amount; struct CCcontract_info *cp,C;
-    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
-
-    cp = CCinit(&C,EVAL_IMPORTGATEWAY);
-    mypk = pubkey2pk(Mypubkey());
-    importgatewaypk = GetUnspendable(cp,0);
-    _GetCCaddress(coinaddr,EVAL_IMPORTGATEWAY,mypk);
-    if ( GetTransaction(bindtxid,tx,hashBlock,false) == 0 || (numvouts= tx.vout.size()) <= 0 )
-    {        
-        CCerror = strprintf("cant find bindtxid %s",uint256_str(str,bindtxid));
-        LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }
-    if ( DecodeImportGatewayBindOpRet(burnaddr,tx.vout[numvouts-1].scriptPubKey,coin,oracletxid,M,N,pubkeys,taddr,prefix,prefix2,wiftype) != 'B' || refcoin != coin)
-    {
-        CCerror = strprintf("invalid bindtxid %s coin.%s",uint256_str(str,bindtxid),coin.c_str());
-        LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
-        return("");
-    }  
-    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 = (int64_t)it->second.satoshis;
-        if ( vout == 0 && nValue == 10000 && GetTransaction(txid,tx,hashBlock,false) != 0 && (numvouts=tx.vout.size())>0 && 
-            DecodeImportGatewayDepositOpRet(tx.vout[numvouts-1].scriptPubKey,tmpbindtxid,coin,publishers,txids,height,burntxid,claimvout,hex,proof,destpub,amount) == 'D'
-            && tmpbindtxid==bindtxid && refcoin == coin && myIsutxo_spentinmempool(ignoretxid,ignorevin,txid,vout) == 0)
-        {   
-            UniValue obj(UniValue::VOBJ);
-            obj.push_back(Pair("burntxid",uint256_str(str,burntxid)));
-            obj.push_back(Pair("deposittxid",uint256_str(str,txid)));  
-            CCtxidaddr(txidaddr,txid);
-            obj.push_back(Pair("deposittxidaddr",txidaddr));              
-            _GetCCaddress(destaddr,EVAL_TOKENS,destpub);
-            obj.push_back(Pair("depositaddr",burnaddr));
-            obj.push_back(Pair("tokens_destination_address",destaddr));
-            pub=HexStr(destpub);
-            obj.push_back(Pair("claim_pubkey",pub));
-            obj.push_back(Pair("amount",(double)amount/COIN));
-            obj.push_back(Pair("confirmed_or_notarized",komodo_txnotarizedconfirmed(txid)));        
-            pending.push_back(obj);
-        }
-    }
-    result.push_back(Pair("coin",refcoin));
-    result.push_back(Pair("pending",pending));
-    return(result);
-}
-
 UniValue ImportGatewayPendingWithdraws(uint256 bindtxid,std::string refcoin)
 {
     UniValue result(UniValue::VOBJ),pending(UniValue::VARR); CTransaction tx; std::string coin,hex; CPubKey mypk,importgatewaypk,withdrawpub,signerpk;
@@ -1041,7 +1029,7 @@ UniValue ImportGatewayPendingWithdraws(uint256 bindtxid,std::string refcoin)
     mypk = pubkey2pk(Mypubkey());
     importgatewaypk = GetUnspendable(cp,0);
     _GetCCaddress(coinaddr,EVAL_IMPORTGATEWAY,importgatewaypk);
-    if ( GetTransaction(bindtxid,tx,hashBlock,false) == 0 || (numvouts= tx.vout.size()) <= 0 )
+    if ( myGetTransaction(bindtxid,tx,hashBlock) == 0 || (numvouts= tx.vout.size()) <= 0 )
     {
         CCerror = strprintf("cant find bindtxid %s",uint256_str(str,bindtxid));
         LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
@@ -1068,7 +1056,7 @@ UniValue ImportGatewayPendingWithdraws(uint256 bindtxid,std::string refcoin)
         vout = (int32_t)it->first.index;
         nValue = (int64_t)it->second.satoshis;
         K=0;
-        if ( vout == 0 && nValue == 10000 && GetTransaction(txid,tx,hashBlock,false) != 0 && (numvouts= tx.vout.size())>0 && 
+        if ( vout == 0 && nValue == CC_MARKER_VALUE && myGetTransaction(txid,tx,hashBlock) != 0 && (numvouts= tx.vout.size())>0 &&
             (funcid=DecodeImportGatewayOpRet(tx.vout[numvouts-1].scriptPubKey))!=0 && (funcid=='W' || funcid=='P') && myIsutxo_spentinmempool(ignoretxid,ignorevin,txid,vout) == 0)
         {
             if (funcid=='W')
@@ -1077,7 +1065,7 @@ UniValue ImportGatewayPendingWithdraws(uint256 bindtxid,std::string refcoin)
             }
             else if (funcid=='P')
             {
-                if (DecodeImportGatewayPartialOpRet(tx.vout[numvouts-1].scriptPubKey,withdrawtxid,coin,K,signerpk,hex)!='P' || GetTransaction(withdrawtxid,tx,hashBlock,false)==0
+                if (DecodeImportGatewayPartialOpRet(tx.vout[numvouts-1].scriptPubKey,withdrawtxid,coin,K,signerpk,hex)!='P' || myGetTransaction(withdrawtxid,tx,hashBlock)==0
                     || (numvouts=tx.vout.size())<=0 || DecodeImportGatewayWithdrawOpRet(tx.vout[numvouts-1].scriptPubKey,tmpbindtxid,coin,withdrawpub,amount)!='W'
                     || refcoin!=coin || tmpbindtxid!=bindtxid)
                     continue;                    
@@ -1129,7 +1117,7 @@ UniValue ImportGatewayProcessedWithdraws(uint256 bindtxid,std::string refcoin)
     mypk = pubkey2pk(Mypubkey());
     importgatewaypk = GetUnspendable(cp,0);
     _GetCCaddress(coinaddr,EVAL_IMPORTGATEWAY,importgatewaypk);
-    if ( GetTransaction(bindtxid,tx,hashBlock,false) == 0 || (numvouts= tx.vout.size()) <= 0 )
+    if ( myGetTransaction(bindtxid,tx,hashBlock) == 0 || (numvouts= tx.vout.size()) <= 0 )
     {        
         CCerror = strprintf("cant find bindtxid %s",uint256_str(str,bindtxid));
         LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
@@ -1155,10 +1143,10 @@ UniValue ImportGatewayProcessedWithdraws(uint256 bindtxid,std::string refcoin)
         txid = it->first.txhash;
         vout = (int32_t)it->first.index;
         nValue = (int64_t)it->second.satoshis;
-        if ( vout == 0 && nValue == 10000 && GetTransaction(txid,tx,hashBlock,false) != 0 && (numvouts= tx.vout.size())>0 && 
+        if ( vout == 0 && nValue == CC_MARKER_VALUE && myGetTransaction(txid,tx,hashBlock) != 0 && (numvouts= tx.vout.size())>0 &&
             DecodeImportGatewayCompleteSigningOpRet(tx.vout[numvouts-1].scriptPubKey,withdrawtxid,coin,K,hex) == 'S' && refcoin == coin && myIsutxo_spentinmempool(ignoretxid,ignorevin,txid,vout) == 0)
         {   
-            if (GetTransaction(withdrawtxid,tx,hashBlock,false) != 0 && (numvouts= tx.vout.size())>0
+            if (myGetTransaction(withdrawtxid,tx,hashBlock) != 0 && (numvouts= tx.vout.size())>0
                 && DecodeImportGatewayWithdrawOpRet(tx.vout[numvouts-1].scriptPubKey,bindtxid,coin,withdrawpub,amount) == 'W' || refcoin!=coin)          
             {
                 UniValue obj(UniValue::VOBJ);
@@ -1184,15 +1172,15 @@ UniValue ImportGatewayProcessedWithdraws(uint256 bindtxid,std::string refcoin)
 
 UniValue ImportGatewayList()
 {
-    UniValue result(UniValue::VARR); std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex;
+    UniValue result(UniValue::VARR); std::vector<uint256> txids;
     struct CCcontract_info *cp,C; uint256 txid,hashBlock,oracletxid; CTransaction vintx; std::string coin;
     char str[65],burnaddr[64]; uint8_t M,N,taddr,prefix,prefix2,wiftype; std::vector<CPubKey> pubkeys;
     cp = CCinit(&C,EVAL_IMPORTGATEWAY);
-    SetCCtxids(addressIndex,cp->unspendableCCaddr,true);
-    for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=addressIndex.begin(); it!=addressIndex.end(); it++)
+    SetCCtxids(txids,cp->unspendableCCaddr,true,cp->evalcode,zeroid,'B');
+    for (std::vector<uint256>::const_iterator it=txids.begin(); it!=txids.end(); it++)
     {
-        txid = it->first.txhash;
-        if ( GetTransaction(txid,vintx,hashBlock,false) != 0 )
+        txid = *it;
+        if ( myGetTransaction(txid,vintx,hashBlock) != 0 )
         {
             if ( vintx.vout.size() > 0 && DecodeImportGatewayBindOpRet(burnaddr,vintx.vout[vintx.vout.size()-1].scriptPubKey,coin,oracletxid,M,N,pubkeys,taddr,prefix,prefix2,wiftype) != 0 )
             {
@@ -1209,7 +1197,7 @@ UniValue ImportGatewayExternalAddress(uint256 bindtxid,CPubKey pubkey)
     std::string coin; int64_t numvouts; char str[65],addr[65],burnaddr[65]; uint8_t M,N,taddr,prefix,prefix2,wiftype; std::vector<CPubKey> msigpubkeys;
     
     cp = CCinit(&C,EVAL_IMPORTGATEWAY);
-    if ( GetTransaction(bindtxid,tx,hashBlock,false) == 0 || (numvouts= tx.vout.size()) <= 0 )
+    if ( myGetTransaction(bindtxid,tx,hashBlock) == 0 || (numvouts= tx.vout.size()) <= 0 )
     {        
         CCerror = strprintf("cant find bindtxid %s",uint256_str(str,bindtxid));
         LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
@@ -1233,7 +1221,7 @@ UniValue ImportGatewayDumpPrivKey(uint256 bindtxid,CKey key)
     std::string coin,priv; int64_t numvouts; char str[65],addr[65],burnaddr[65]; uint8_t M,N,taddr,prefix,prefix2,wiftype; std::vector<CPubKey> msigpubkeys;
     
     cp = CCinit(&C,EVAL_IMPORTGATEWAY);
-    if ( GetTransaction(bindtxid,tx,hashBlock,false) == 0 || (numvouts= tx.vout.size()) <= 0 )
+    if ( myGetTransaction(bindtxid,tx,hashBlock) == 0 || (numvouts= tx.vout.size()) <= 0 )
     {        
         CCerror = strprintf("cant find bindtxid %s",uint256_str(str,bindtxid));
         LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
@@ -1262,7 +1250,7 @@ UniValue ImportGatewayInfo(uint256 bindtxid)
     cp = CCinit(&C,EVAL_IMPORTGATEWAY);
     ImportGatewaypk = GetUnspendable(cp,0);
     GetTokensCCaddress(cp,gatewaystokens,ImportGatewaypk);
-    if ( GetTransaction(bindtxid,tx,hashBlock,false) == 0 || (numvouts= tx.vout.size()) <= 0 )
+    if ( myGetTransaction(bindtxid,tx,hashBlock) == 0 || (numvouts= tx.vout.size()) <= 0 )
     {        
         CCerror = strprintf("cant find bindtxid %s",uint256_str(str,bindtxid));
         LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
@@ -1274,7 +1262,7 @@ UniValue ImportGatewayInfo(uint256 bindtxid)
         LOGSTREAM("importgateway",CCLOG_INFO, stream << CCerror << std::endl);
         return("");
     }
-    if ( GetTransaction(bindtxid,tx,hashBlock,false) != 0 )
+    if ( myGetTransaction(bindtxid,tx,hashBlock) != 0 )
     {
         result.push_back(Pair("result","success"));
         result.push_back(Pair("name","ImportGateway"));
diff --git a/src/cc/includes/curve25519.h b/src/cc/includes/curve25519.h
index 19abe8d1..657fab4d 100644
--- a/src/cc/includes/curve25519.h
+++ b/src/cc/includes/curve25519.h
@@ -48,7 +48,7 @@ bits320 crecip(const bits320 z);
 bits256 curve25519(bits256 mysecret,bits256 basepoint);
 void OS_randombytes(unsigned char *x,long xlen);
 bits256 rand256(int32_t privkeyflag);
-bits256 curve25519_basepoint9();
+bits256 curve25519_basepoint9(void);
 bits256 curve25519_keypair(bits256 *pubkeyp);
 
 void vcalc_sha256(char hashstr[(256 >> 3) * 2 + 1],uint8_t hash[256 >> 3],uint8_t *src,int32_t len);
diff --git a/src/cc/lotto.cpp b/src/cc/lotto.cpp
index 46e5561c..7427fe9b 100644
--- a/src/cc/lotto.cpp
+++ b/src/cc/lotto.cpp
@@ -173,7 +173,7 @@ int64_t AddLottoInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPubK
         // prevent dup
         if ( it->second.satoshis < COIN )
             continue;
-        if ( GetTransaction(txid,vintx,hashBlock,false) != 0 )
+        if ( myGetTransaction(txid,vintx,hashBlock) != 0 )
         {
             if ( (nValue= IsLottovout(cp,vintx,(int32_t)it->first.index)) > 0 )
             {
@@ -214,7 +214,7 @@ int64_t LottoPlanFunds(uint64_t refsbits,struct CCcontract_info *cp,CPubKey pk,u
     {
         txid = it->first.txhash;
         vout = (int32_t)it->first.index;
-        if ( GetTransaction(txid,tx,hashBlock,false) != 0 && tx.vout[vout].scriptPubKey.IsPayToCryptoCondition() != 0 )
+        if ( myGetTransaction(txid,tx,hashBlock) != 0 && tx.vout[vout].scriptPubKey.IsPayToCryptoCondition() != 0 )
         {
             // need to implement this! if ( (funcid= DecodeLottoOpRet(txid,tx.vout[tx.vout.size()-1].scriptPubKey,sbits,fundingtxid)) == 'F' || funcid == 'T' )
             {
@@ -233,7 +233,7 @@ int64_t LottoPlanFunds(uint64_t refsbits,struct CCcontract_info *cp,CPubKey pk,u
 UniValue LottoInfo(uint256 lottoid)
 {
     UniValue result(UniValue::VOBJ); uint256 hashBlock,hentropy; CTransaction vintx; uint64_t lockedfunds,sbits; int32_t ticketsize,odds,firstheight,period; CPubKey lottopk; struct CCcontract_info *cp,C; char str[67],numstr[65];
-    if ( GetTransaction(lottoid,vintx,hashBlock,false) == 0 )
+    if ( myGetTransaction(lottoid,vintx,hashBlock) == 0 )
     {
         LogPrintf("cant find lottoid\n");
         result.push_back(Pair("result","error"));
@@ -264,13 +264,13 @@ UniValue LottoInfo(uint256 lottoid)
 
 UniValue LottoList()
 {
-    UniValue result(UniValue::VARR); std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex; struct CCcontract_info *cp,C; uint256 txid,hashBlock,hentropy; CTransaction vintx; uint64_t sbits; int32_t ticketsize,odds,firstheight,period; char str[65];
+    UniValue result(UniValue::VARR); std::vector<uint256> txids; struct CCcontract_info *cp,C; uint256 txid,hashBlock,hentropy; CTransaction vintx; uint64_t sbits; int32_t ticketsize,odds,firstheight,period; char str[65];
     cp = CCinit(&C,EVAL_LOTTO);
-    SetCCtxids(addressIndex,cp->normaladdr,true);
-    for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=addressIndex.begin(); it!=addressIndex.end(); it++)
+    SetCCtxids(txids,cp->normaladdr,true,cp->evalcode,zeroid,'F');
+    for (std::vector<uint256>::const_iterator it=txids.begin(); it!=txids.end(); it++)
     {
-        txid = it->first.txhash;
-        if ( GetTransaction(txid,vintx,hashBlock,false) != 0 )
+        txid = *it;
+        if ( myGetTransaction(txid,vintx,hashBlock) != 0 )
         {
             if ( vintx.vout.size() > 0 && DecodeLottoFundingOpRet(vintx.vout[vintx.vout.size()-1].scriptPubKey,sbits,ticketsize,odds,firstheight,period,hentropy) == 'F' )
             {
diff --git a/src/cc/marmara.cpp b/src/cc/marmara.cpp
index 312835f7..1aec50e5 100644
--- a/src/cc/marmara.cpp
+++ b/src/cc/marmara.cpp
@@ -359,8 +359,8 @@ int64_t AddMarmaraCoinbases(struct CCcontract_info *cp,CMutableTransaction &mtx,
     {
         txid = it->first.txhash;
         vout = (int32_t)it->first.index;
-        //LogPrintf("txid.%s/v%d\n",txid.GetHex().c_str(),vout);
-        if ( GetTransaction(txid,vintx,hashBlock,false) != 0 )
+        //fprintf(stderr,"txid.%s/v%d\n",txid.GetHex().c_str(),vout);
+        if ( myGetTransaction(txid,vintx,hashBlock) != 0 )
         {
             if ( vintx.IsCoinBase() != 0 && vintx.vout.size() == 2 && vintx.vout[1].nValue == 0 )
             {
@@ -399,7 +399,7 @@ int64_t AddMarmarainputs(CMutableTransaction &mtx,std::vector<CPubKey> &pubkeys,
         vout = (int32_t)it->first.index;
         if ( it->second.satoshis < threshold )
             continue;
-        if ( GetTransaction(txid,tx,hashBlock,false) != 0 && (numvouts= tx.vout.size()) > 0 && vout < numvouts && tx.vout[vout].scriptPubKey.IsPayToCryptoCondition() != 0 && myIsutxo_spentinmempool(ignoretxid,ignorevin,txid,vout) == 0 )
+        if ( myGetTransaction(txid,tx,hashBlock) != 0 && (numvouts= tx.vout.size()) > 0 && vout < numvouts && tx.vout[vout].scriptPubKey.IsPayToCryptoCondition() != 0 && myIsutxo_spentinmempool(ignoretxid,ignorevin,txid,vout) == 0 )
         {
             if ( (funcid= DecodeMaramaraCoinbaseOpRet(tx.vout[numvouts-1].scriptPubKey,pk,ht,unlockht)) == 'C' || funcid == 'P' || funcid == 'L' )
             {
@@ -468,7 +468,7 @@ UniValue MarmaraLock(uint64_t txfee,int64_t amount,int32_t height)
             vout = (int32_t)it->first.index;
             if ( (nValue= it->second.satoshis) < threshold )
                 continue;
-            if ( GetTransaction(txid,tx,hashBlock,false) != 0 && (numvouts= tx.vout.size()) > 0 && vout < numvouts && tx.vout[vout].scriptPubKey.IsPayToCryptoCondition() != 0 && myIsutxo_spentinmempool(ignoretxid,ignorevin,txid,vout) == 0 )
+            if ( myGetTransaction(txid,tx,hashBlock) != 0 && (numvouts= tx.vout.size()) > 0 && vout < numvouts && tx.vout[vout].scriptPubKey.IsPayToCryptoCondition() != 0 && myIsutxo_spentinmempool(ignoretxid,ignorevin,txid,vout) == 0 )
             {
                 if ( (funcid= DecodeMaramaraCoinbaseOpRet(tx.vout[numvouts-1].scriptPubKey,pk,ht,unlockht)) == 'C' || funcid == 'P' || funcid == 'L' )
                 {
@@ -488,6 +488,7 @@ UniValue MarmaraLock(uint64_t txfee,int64_t amount,int32_t height)
                 }
             }
         }
+        memset(mypriv,0,sizeof(mypriv));
     }
     if ( inputsum >= amount+txfee )
     {
@@ -516,7 +517,7 @@ int32_t MarmaraSignature(uint8_t *utxosig,CMutableTransaction &mtx)
     uint256 txid,hashBlock; uint8_t *ptr; int32_t i,siglen,vout,numvouts; CTransaction tx; std::string rawtx; CPubKey mypk; std::vector<CPubKey> pubkeys; struct CCcontract_info *cp,C; uint64_t txfee;
     txfee = 10000;
     vout = mtx.vin[0].prevout.n;
-    if ( GetTransaction(mtx.vin[0].prevout.hash,tx,hashBlock,false) != 0 && (numvouts= tx.vout.size()) > 1 && vout < numvouts )
+    if ( myGetTransaction(mtx.vin[0].prevout.hash,tx,hashBlock) != 0 && (numvouts= tx.vout.size()) > 1 && vout < numvouts )
     {
         cp = CCinit(&C,EVAL_MARMARA);
         mypk = pubkey2pk(Mypubkey());
@@ -553,7 +554,7 @@ UniValue MarmaraSettlement(uint64_t txfee,uint256 refbatontxid)
     height = chainActive.LastTip()->GetHeight();
     if ( (n= MarmaraGetbatontxid(creditloop,batontxid,refbatontxid)) > 0 )
     {
-        if ( GetTransaction(batontxid,batontx,hashBlock,false) != 0 && (numvouts= batontx.vout.size()) > 1 )
+        if ( myGetTransaction(batontxid,batontx,hashBlock) != 0 && (numvouts= batontx.vout.size()) > 1 )
         {
             if ( (funcid= MarmaraDecodeLoopOpret(batontx.vout[numvouts-1].scriptPubKey,refcreatetxid,pk,refamount,refmatures,refcurrency)) != 0 )
             {
@@ -593,7 +594,7 @@ UniValue MarmaraSettlement(uint64_t txfee,uint256 refbatontxid)
                     pubkeys.push_back(mypk);
                     for (i=1; i<n; i++)
                     {
-                        if ( GetTransaction(creditloop[i],tx,hashBlock,false) != 0 && (numvouts= tx.vout.size()) > 1 )
+                        if ( myGetTransaction(creditloop[i],tx,hashBlock) != 0 && (numvouts= tx.vout.size()) > 1 )
                         {
                             if ( (funcid= MarmaraDecodeLoopOpret(tx.vout[numvouts-1].scriptPubKey,createtxid,pk,amount,matures,currency)) != 0 )
                             {
@@ -673,8 +674,8 @@ int32_t MarmaraGetCreditloops(int64_t &totalamount,std::vector<uint256> &issuanc
     {
         txid = it->first.txhash;
         vout = (int32_t)it->first.index;
-        //LogPrintf("txid.%s/v%d\n",txid.GetHex().c_str(),vout);
-        if ( vout == 1 && GetTransaction(txid,tx,hashBlock,false) != 0 )
+        //fprintf(stderr,"txid.%s/v%d\n",txid.GetHex().c_str(),vout);
+        if ( vout == 1 && myGetTransaction(txid,tx,hashBlock) != 0 )
         {
             if ( tx.IsCoinBase() == 0 && (numvouts= tx.vout.size()) > 2 && tx.vout[numvouts - 1].nValue == 0 )
             {
@@ -814,7 +815,7 @@ UniValue MarmaraCreditloop(uint256 txid)
     cp = CCinit(&C,EVAL_MARMARA);
     if ( (n= MarmaraGetbatontxid(creditloop,batontxid,txid)) > 0 )
     {
-        if ( GetTransaction(batontxid,tx,hashBlock,false) != 0 && (numvouts= tx.vout.size()) > 1 )
+        if ( myGetTransaction(batontxid,tx,hashBlock) != 0 && (numvouts= tx.vout.size()) > 1 )
         {
             result.push_back(Pair("result",(char *)"success"));
             Getscriptaddress(coinaddr,CScript() << ParseHex(HexStr(Mypubkey())) << OP_CHECKSIG);
@@ -886,7 +887,7 @@ UniValue MarmaraCreditloop(uint256 txid)
                 }
                 for (i=0; i<n; i++)
                 {
-                    if ( GetTransaction(creditloop[i],tx,hashBlock,false) != 0 && (numvouts= tx.vout.size()) > 1 )
+                    if ( myGetTransaction(creditloop[i],tx,hashBlock) != 0 && (numvouts= tx.vout.size()) > 1 )
                     {
                         if ( (funcid= MarmaraDecodeLoopOpret(tx.vout[numvouts-1].scriptPubKey,createtxid,pk,amount,matures,currency)) != 0 )
                         {
diff --git a/src/cc/musig.cpp b/src/cc/musig.cpp
index 62728663..e117da23 100644
--- a/src/cc/musig.cpp
+++ b/src/cc/musig.cpp
@@ -482,10 +482,12 @@ UniValue musig_session(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
                 MUSIG[musiglocation]->numcommits = 1;
             result.push_back(Pair("commitment",str));
             result.push_back(Pair("result","success"));
+            memset(privkey,0,sizeof(privkey));
             return(result);
         }
         else
         {
+            memset(privkey,0,sizeof(privkey));
             memset(session,0,sizeof(session));
             return(cclib_error(result,"couldnt initialize session"));
         }
diff --git a/src/cc/oracles.cpp b/src/cc/oracles.cpp
index 69aa07bf..42dc88a9 100644
--- a/src/cc/oracles.cpp
+++ b/src/cc/oracles.cpp
@@ -92,7 +92,7 @@
  vout.n-1: opreturn with oracletxid, prevbatontxid and data in proper format
 
 */
-extern int32_t komodo_currentheight();
+extern int32_t komodo_get_current_height();
 #define PUBKEY_SPOOFING_FIX_ACTIVATION 1563148800
 #define CC_MARKER_VALUE 10000
 
@@ -193,6 +193,7 @@ CPubKey OracleBatonPk(char *batonaddr,struct CCcontract_info *cp)
         //LogPrintf("batonpk.(%s) -> %s\n",(char *)HexStr(batonpk).c_str(),batonaddr);
         strcpy(cp->unspendableaddr2,batonaddr);
     } else LogPrintf("error creating pubkey\n");
+    memset(priv,0,sizeof(priv));
     return(batonpk);
 }
 
@@ -246,9 +247,11 @@ int64_t OracleDatafee(CScript &scriptPubKey,uint256 oracletxid,CPubKey publisher
 
 static uint256 myIs_baton_spentinmempool(uint256 batontxid,int32_t batonvout)
 {
-    BOOST_FOREACH(const CTxMemPoolEntry &e,mempool.mapTx)
+    std::vector<CTransaction> tmp_txs;
+    myGet_mempool_txs(tmp_txs,EVAL_ORACLES,'D');
+    for (std::vector<CTransaction>::const_iterator it=tmp_txs.begin(); it!=tmp_txs.end(); it++)
     {
-        const CTransaction &tx = e.GetTx();
+        const CTransaction &tx = *it;
         if ( tx.vout.size() > 0 && tx.vin.size() > 1 && batontxid == tx.vin[1].prevout.hash && batonvout == tx.vin[1].prevout.n )
         {
             const uint256 &txid = tx.GetHash();
@@ -636,18 +639,15 @@ bool OraclesDataValidate(struct CCcontract_info *cp,Eval* eval,const CTransactio
     else return(true);
 }
 
-int32_t GetLatestTimestamp(int32_t height)
+/*nt32_t GetLatestTimestamp(int32_t height)
 {
-    uint256 blockHash; CBlock block; CBlockIndex* pindex;
-
-    blockHash = chainActive[height]->GetBlockHash();
-    pindex = mapBlockIndex[blockHash];
-    return(pindex->nTime);
-}
+    if ( KOMODO_NSPV_SUPERLITE ) return (NSPV_blocktime(height));
+    return(komodo_heightstamp(height));
+} */
 
 bool OraclesValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx, uint32_t nIn)
 {
-    uint256 oracletxid,batontxid; uint64_t txfee=10000; int32_t numvins,numvouts,preventCCvins,preventCCvouts; int64_t amount; uint256 hashblock;
+    uint256 oracletxid,batontxid,txid; 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;
 
@@ -702,10 +702,16 @@ bool OraclesValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &t
                             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
+                        else if ((*cp->ismyvin)(tx.vin[1].scriptSig) == 0 && (*cp->ismyvin)(tx.vin[tx.vin.size()-1].scriptSig) == 0)
+                            return eval->Invalid("there is no CC vin from oraclesfund tx");
+                        else if ((*cp->ismyvin)(tx.vin[1].scriptSig) == 1 && (myGetTransaction(tx.vin[1].prevout.hash,tmptx,hashblock)==0 || DecodeOraclesOpRet(tmptx.vout[tmptx.vout.size()-1].scriptPubKey,txid,tmppk,amount)!='F'
+                                || tmptx.vout[tx.vin[1].prevout.n].nValue!=CC_MARKER_VALUE || !Getscriptaddress(vinaddress,tmptx.vout[tx.vin[1].prevout.n].scriptPubKey)
+                                || !GetCCaddress(cp,tmpaddress,tmppk) || strcmp(tmpaddress,vinaddress)!=0) || oracletxid!=txid)
+                            return eval->Invalid("invalid vin.1 for oraclesregister, it must be CC vin or pubkey not same as vin pubkey, register and fund tx must be done from owner of pubkey that registers to oracle!!");    
+                        else if ((*cp->ismyvin)(tx.vin[tx.vin.size()-1].scriptSig) == 1 && (myGetTransaction(tx.vin[tx.vin.size()-1].prevout.hash,tmptx,hashblock)==0 || DecodeOraclesOpRet(tmptx.vout[tmptx.vout.size()-1].scriptPubKey,txid,tmppk,amount)!='F'
                                 || 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!!");
+                                || !GetCCaddress(cp,tmpaddress,tmppk) || strcmp(tmpaddress,vinaddress)!=0) || oracletxid!=txid)
+                            return eval->Invalid("invalid vin."+std::to_string(tx.vin.size()-1)+" for oraclesregister, it must be CC vin or pubkey not same as vin pubkey, register and fund tx 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)
@@ -762,8 +768,8 @@ int64_t AddOracleInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,uint
     {
         txid = it->first.txhash;
         vout = (int32_t)it->first.index;
-        //char str[65]; LogPrintf("oracle check %s/v%d\n",uint256_str(str,txid),vout);
-        if ( GetTransaction(txid,vintx,hashBlock,false) != 0 && (numvouts=vintx.vout.size()-1)>0)
+        //char str[65]; fprintf(stderr,"oracle check %s/v%d\n",uint256_str(str,txid),vout);
+        if ( myGetTransaction(txid,vintx,hashBlock) != 0 && (numvouts=vintx.vout.size()-1)>0)
         {
             if ((funcid=DecodeOraclesOpRet(vintx.vout[numvouts].scriptPubKey,tmporacletxid,tmppk,tmpnum))!=0 && (funcid=='S' || funcid=='D'))
             {
@@ -792,14 +798,14 @@ int64_t AddOracleInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,uint
 int64_t LifetimeOraclesFunds(struct CCcontract_info *cp,uint256 oracletxid,CPubKey publisher)
 {
     char coinaddr[64]; CPubKey pk; int64_t total=0,num; uint256 txid,hashBlock,subtxid; CTransaction subtx;
-    std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex;
+    std::vector<uint256> txids;
     GetCCaddress(cp,coinaddr,publisher);
-    SetCCtxids(addressIndex,coinaddr,true);
-    //LogPrintf("scan lifetime of %s\n",coinaddr);
-    for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=addressIndex.begin(); it!=addressIndex.end(); it++)
+    SetCCtxids(txids,coinaddr,true,cp->evalcode,oracletxid,'S');
+    //fprintf(stderr,"scan lifetime of %s\n",coinaddr);
+    for (std::vector<uint256>::const_iterator it=txids.begin(); it!=txids.end(); it++)
     {
-        txid = it->first.txhash;
-        if ( GetTransaction(txid,subtx,hashBlock,false) != 0 )
+        txid = *it;
+        if ( myGetTransaction(txid,subtx,hashBlock) != 0 )
         {
             if ( subtx.vout.size() > 0 && DecodeOraclesOpRet(subtx.vout[subtx.vout.size()-1].scriptPubKey,subtxid,pk,num) == 'S' && subtxid == oracletxid && pk == publisher )
             {
@@ -822,7 +828,7 @@ int64_t AddMyOraclesFunds(struct CCcontract_info *cp,CMutableTransaction &mtx,CP
         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 ( myGetTransaction(txid,vintx,hashBlock) != 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)
@@ -833,9 +839,11 @@ int64_t AddMyOraclesFunds(struct CCcontract_info *cp,CMutableTransaction &mtx,CP
         } else LogPrintf("couldnt find transaction\n");
     }
 
-    BOOST_FOREACH(const CTxMemPoolEntry &e, mempool.mapTx)
+    std::vector<CTransaction> tmp_txs;
+    myGet_mempool_txs(tmp_txs,EVAL_ORACLES,'F');
+    for (std::vector<CTransaction>::const_iterator it=tmp_txs.begin(); it!=tmp_txs.end(); it++)
     {
-        const CTransaction &txmempool = e.GetTx();
+        const CTransaction &txmempool = *it;
         const uint256 &hash = txmempool.GetHash();
         nValue=txmempool.vout[0].nValue;
 
@@ -849,18 +857,20 @@ int64_t AddMyOraclesFunds(struct CCcontract_info *cp,CMutableTransaction &mtx,CP
     return (0);
 }
 
-std::string OracleCreate(int64_t txfee,std::string name,std::string description,std::string format)
+UniValue OracleCreate(const CPubKey& pk, int64_t txfee,std::string name,std::string description,std::string format)
 {
     CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
-    CPubKey mypk,Oraclespk; struct CCcontract_info *cp,C; char fmt;
+    CPubKey mypk,Oraclespk; struct CCcontract_info *cp,C; char fmt; 
 
     cp = CCinit(&C,EVAL_ORACLES);
-    if ( name.size() > 32 || description.size() > 4096 || format.size() > 4096 )
-    {
-        CCerror = strprintf("name.%d or description.%d is too big",(int32_t)name.size(),(int32_t)description.size());
-        LogPrintf("%s\n", CCerror.c_str() );
-        return("");
-    }    
+    if ( name.size() > 32)
+        CCERR_RESULT("oraclescc",CCLOG_INFO, stream << "name."<< (int32_t)name.size() << " must be less then 32");   
+    if (description.size() > 4096)
+        CCERR_RESULT("oraclescc",CCLOG_INFO, stream << "description."<< (int32_t)description.size() << " must be less then 4096");
+    if (format.size() > 4096 )
+        CCERR_RESULT("oraclescc",CCLOG_INFO, stream << "format."<< (int32_t)format.size() << " must be less then 4096");
+    if ( name.size() == 0 )
+        CCERR_RESULT("oraclescc",CCLOG_INFO, stream << "name must not be empty");   
     for(int i = 0; i < format.size(); i++)
     {
         fmt=format[i];
@@ -870,154 +880,125 @@ std::string OracleCreate(int64_t txfee,std::string name,std::string description,
             case 'c': case 'C': case 't': case 'T':
             case 'i': case 'I': case 'l': case 'L':
             case 'h': break;
-            default: CCerror = strprintf("invalid format type");
-                     LogPrintf("%s\n", CCerror.c_str() );
-                     return("");
+            default: CCERR_RESULT("oraclescc",CCLOG_INFO, stream << "invalid format type");
         }
     }    
     if ( txfee == 0 )
         txfee = 10000;
-    mypk = pubkey2pk(Mypubkey());
+    mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
     Oraclespk = GetUnspendable(cp,0);
-    if ( AddNormalinputs(mtx,mypk,2*txfee,3) > 0 )
+    if ( AddNormalinputs(mtx,mypk,2*txfee,3,pk.IsValid()) > 0 )
     {
         mtx.vout.push_back(CTxOut(txfee,CScript() << ParseHex(HexStr(Oraclespk)) << OP_CHECKSIG));
-        return(FinalizeCCTx(0,cp,mtx,mypk,txfee,EncodeOraclesCreateOpRet('C',name,description,format)));
+        return(FinalizeCCTxExt(pk.IsValid(),0,cp,mtx,mypk,txfee,EncodeOraclesCreateOpRet('C',name,description,format)));
     }
-    CCerror = strprintf("error adding normal inputs");
-    LogPrintf("%s\n", CCerror.c_str() );
-    return("");
+    CCERR_RESULT("oraclescc",CCLOG_INFO, stream << "error adding normal inputs");
 }
 
-std::string OracleFund(int64_t txfee,uint256 oracletxid)
+UniValue OracleFund(const CPubKey& pk, int64_t txfee,uint256 oracletxid)
 {
-    CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
-    CPubKey mypk,oraclespk; struct CCcontract_info *cp,C;
+    CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight()); CTransaction tx;
+    CPubKey mypk,oraclespk; struct CCcontract_info *cp,C; std::string name,desc,format; int32_t numvouts; uint256 hashBlock;
 
     if (GetLatestTimestamp(komodo_currentheight())<PUBKEY_SPOOFING_FIX_ACTIVATION)
-    {
-        CCerror = strprintf("oraclesfund not active yet, activation scheduled for July 15th");
-        LogPrintf("%s\n", CCerror.c_str() );
-        return("");
-    }
+        CCERR_RESULT("oraclescc",CCLOG_INFO, stream << "oraclesfund not active yet, activation scheduled for July 15th");
+    if (myGetTransaction(oracletxid,tx,hashBlock)==0 || (numvouts=tx.vout.size())<=0)
+        CCERR_RESULT("oraclecc",CCLOG_INFO, stream << "cant find oracletxid " << oracletxid.GetHex());
+    if (DecodeOraclesCreateOpRet(tx.vout[numvouts-1].scriptPubKey,name,desc,format)!='C')
+        CCERR_RESULT("oraclecc",CCLOG_INFO, stream << "invalid oracletxid " << oracletxid.GetHex());
     cp = CCinit(&C,EVAL_ORACLES);
     if ( txfee == 0 )
         txfee = 10000;
-    mypk = pubkey2pk(Mypubkey());
-    if (AddNormalinputs(mtx,mypk,txfee+CC_MARKER_VALUE,2))    
+    mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
+    if (AddNormalinputs(mtx,mypk,txfee+CC_MARKER_VALUE,2,pk.IsValid()))    
     {
         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)));
+        return(FinalizeCCTxExt(pk.IsValid(),0,cp,mtx,mypk,txfee,EncodeOraclesOpRet('F',oracletxid,mypk,CC_MARKER_VALUE)));
     }
-    CCerror = strprintf("error adding normal inputs");
-    LogPrintf("%s\n", CCerror.c_str() );
-    return("");
+    CCERR_RESULT("oraclescc",CCLOG_INFO, stream << "error adding normal inputs");
 }
 
-std::string OracleRegister(int64_t txfee,uint256 oracletxid,int64_t datafee)
+UniValue OracleRegister(const CPubKey& pk, int64_t txfee,uint256 oracletxid,int64_t datafee)
 {
     CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
     CPubKey mypk,markerpubkey,batonpk,oraclespk; struct CCcontract_info *cp,C; char markeraddr[64],batonaddr[64];
+    std::string name,desc,format; int32_t numvouts; uint256 hashBlock; CTransaction tx;
 
     cp = CCinit(&C,EVAL_ORACLES);
     if ( txfee == 0 )
         txfee = 10000;
+    if (myGetTransaction(oracletxid,tx,hashBlock)==0 || (numvouts=tx.vout.size())<=0)
+        CCERR_RESULT("oraclecc",CCLOG_INFO, stream << "cant find oracletxid " << oracletxid.GetHex());
+    if (DecodeOraclesCreateOpRet(tx.vout[numvouts-1].scriptPubKey,name,desc,format)!='C')
+        CCERR_RESULT("oraclecc",CCLOG_INFO, stream << "invalid oracletxid " << oracletxid.GetHex());
     if ( datafee < txfee )
-    {
-        CCerror = strprintf("datafee must be txfee or more");
-        LogPrintf("%s\n", CCerror.c_str() );
-        return("");
-    }
-    mypk = pubkey2pk(Mypubkey());
+        CCERR_RESULT("oraclescc",CCLOG_INFO, stream << "datafee must be txfee or more");
+    mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
     oraclespk = GetUnspendable(cp,0);
     batonpk = OracleBatonPk(batonaddr,cp);
     markerpubkey = CCtxidaddr(markeraddr,oracletxid);
-    if (AddNormalinputs(mtx,mypk,3*txfee,4))
+    if (AddNormalinputs(mtx,mypk,3*txfee,4,pk.IsValid()))
     {
         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!");
-            LogPrintf("%s\n", CCerror.c_str() );
-            return("");
-        }            
+            CCERR_RESULT("oraclescc",CCLOG_INFO, stream << "error adding inputs from your Oracles CC address, please fund it first with oraclesfund rpc!");
         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)));
+        if (GetLatestTimestamp(komodo_get_current_height())>PUBKEY_SPOOFING_FIX_ACTIVATION) mtx.vout.push_back(CTxOut(txfee,CScript() << ParseHex(HexStr(mypk)) << OP_CHECKSIG));
+        return(FinalizeCCTxExt(pk.IsValid(),0,cp,mtx,mypk,txfee,EncodeOraclesOpRet('R',oracletxid,mypk,datafee)));
     }
-    CCerror = strprintf("error adding normal inputs");
-    LogPrintf("%s\n", CCerror.c_str() );
-    return("");
+    CCERR_RESULT("oraclescc",CCLOG_INFO, stream << "error adding normal inputs");
 }
 
-std::string OracleSubscribe(int64_t txfee,uint256 oracletxid,CPubKey publisher,int64_t amount)
+UniValue OracleSubscribe(const CPubKey& pk, int64_t txfee,uint256 oracletxid,CPubKey publisher,int64_t amount)
 {
-    CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
-    CPubKey mypk,markerpubkey; struct CCcontract_info *cp,C; char markeraddr[64];
+    CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight()); CTransaction tx;
+    CPubKey mypk,markerpubkey; struct CCcontract_info *cp,C; char markeraddr[64]; std::string name,desc,format; int32_t numvouts; uint256 hashBlock;
     cp = CCinit(&C,EVAL_ORACLES);
     if ( txfee == 0 )
         txfee = 10000;
-    mypk = pubkey2pk(Mypubkey());
+    if (myGetTransaction(oracletxid,tx,hashBlock)==0 || (numvouts=tx.vout.size())<=0)
+        CCERR_RESULT("oraclecc",CCLOG_INFO, stream << "cant find oracletxid " << oracletxid.GetHex());
+    if (DecodeOraclesCreateOpRet(tx.vout[numvouts-1].scriptPubKey,name,desc,format)!='C')
+        CCERR_RESULT("oraclecc",CCLOG_INFO, stream << "invalid oracletxid " << oracletxid.GetHex());
+    mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
     markerpubkey = CCtxidaddr(markeraddr,oracletxid);
-    if ( AddNormalinputs(mtx,mypk,amount + 2*txfee,64) > 0 )
+    if ( AddNormalinputs(mtx,mypk,amount + 2*txfee,64,pk.IsValid()) > 0 )
     {
         mtx.vout.push_back(MakeCC1vout(cp->evalcode,amount,publisher));
         mtx.vout.push_back(CTxOut(txfee,CScript() << ParseHex(HexStr(markerpubkey)) << OP_CHECKSIG));
-        return(FinalizeCCTx(0,cp,mtx,mypk,txfee,EncodeOraclesOpRet('S',oracletxid,mypk,amount)));
+        return(FinalizeCCTxExt(pk.IsValid(),0,cp,mtx,mypk,txfee,EncodeOraclesOpRet('S',oracletxid,mypk,amount)));
     }
-    CCerror = strprintf("error adding normal inputs");
-    LogPrintf("%s\n", CCerror.c_str() );
-    return("");
+    CCERR_RESULT("oraclescc",CCLOG_INFO, stream << "error adding normal inputs");
 }
 
-std::string OracleData(int64_t txfee,uint256 oracletxid,std::vector <uint8_t> data)
+UniValue OracleData(const CPubKey& pk, int64_t txfee,uint256 oracletxid,std::vector <uint8_t> data)
 {
     CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
     CScript pubKey; CPubKey mypk,batonpk; int64_t offset,datafee,inputs,CCchange = 0; struct CCcontract_info *cp,C; uint256 batontxid,hashBlock;
     char coinaddr[64],batonaddr[64]; std::vector <uint8_t> prevdata; CTransaction tx; std::string name,description,format; int32_t len,numvouts;
 
     cp = CCinit(&C,EVAL_ORACLES);
-    mypk = pubkey2pk(Mypubkey());
+    mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
     if ( data.size() > 8192 )
-    {
-        CCerror = strprintf("datasize %d is too big",(int32_t)data.size());
-        LogPrintf("%s\n", CCerror.c_str() );
-        return("");
-    }
+        CCERR_RESULT("oraclescc",CCLOG_INFO, stream << "datasize " << (int32_t)data.size() << " is too big");
     if ( (datafee= OracleDatafee(pubKey,oracletxid,mypk)) <= 0 )
-    {
-        CCerror = strprintf("datafee %.8f is illegal",(double)datafee/COIN);
-        LogPrintf("%s\n", CCerror.c_str() );
-        return("");
-    }
-    if ( GetTransaction(oracletxid,tx,hashBlock,false) != 0 && (numvouts=tx.vout.size()) > 0 )
+        CCERR_RESULT("oraclescc",CCLOG_INFO, stream << "datafee " << (double)datafee/COIN << "is illegal");
+    if ( myGetTransaction(oracletxid,tx,hashBlock) != 0 && (numvouts=tx.vout.size()) > 0 )
     {
         if ( DecodeOraclesCreateOpRet(tx.vout[numvouts-1].scriptPubKey,name,description,format) == 'C' )
         {
             if (oracle_parse_data_format(data,format)==0)
-            {
-                CCerror = strprintf("data does not match length or content format specification");
-                LogPrintf("%s\n", CCerror.c_str() );
-                return("");
-            }
+                CCERR_RESULT("oraclescc",CCLOG_INFO, stream << "data does not match length or content format specification");
         }
         else
-        {
-            CCerror = strprintf("invalid oracle txid opret data");
-            LogPrintf("%s\n", CCerror.c_str() );
-            return("");
-        }
+            CCERR_RESULT("oraclescc",CCLOG_INFO, stream << "invalid oracle txid opret data");
     }
     else
-    {
-        CCerror = strprintf("invalid oracle txid");
-        LogPrintf("%s\n", CCerror.c_str() );
-        return("");
-    }
+        CCERR_RESULT("oraclescc",CCLOG_INFO, stream << "invalid oracle txid");
     if ( txfee == 0 )
         txfee = 10000;
     GetCCaddress(cp,coinaddr,mypk);
-    if ( AddNormalinputs(mtx,mypk,2*txfee,3) > 0 ) // have enough funds even if baton utxo not there
+    if ( AddNormalinputs(mtx,mypk,2*txfee,3,pk.IsValid()) > 0 ) // have enough funds even if baton utxo not there
     {
         batonpk = OracleBatonPk(batonaddr,cp);
         batontxid = OracleBatonUtxo(txfee,cp,oracletxid,batonaddr,mypk,prevdata);
@@ -1029,18 +1010,13 @@ std::string OracleData(int64_t txfee,uint256 oracletxid,std::vector <uint8_t> da
             if ( inputs > datafee )
                 CCchange = (inputs - datafee);
             mtx.vout.push_back(MakeCC1vout(cp->evalcode,CCchange,mypk));
-            mtx.vout.push_back(MakeCC1vout(cp->evalcode,txfee,batonpk));
+            mtx.vout.push_back(MakeCC1vout(cp->evalcode,CC_MARKER_VALUE,batonpk));
             mtx.vout.push_back(CTxOut(datafee,CScript() << ParseHex(HexStr(mypk)) << OP_CHECKSIG));
-            return(FinalizeCCTx(0,cp,mtx,mypk,txfee,EncodeOraclesData('D',oracletxid,batontxid,mypk,data)));
-        } else {
-            CCerror = strprintf("couldnt find enough oracle inputs %s, limit 1 per utxo\n",coinaddr);
-            LogPrintf("%s\n", CCerror.c_str() );
-        }
-    } else {
-        CCerror = strprintf("couldnt add normal inputs");
-        LogPrintf("%s\n", CCerror.c_str() );
+            return(FinalizeCCTxExt(pk.IsValid(),0,cp,mtx,mypk,txfee,EncodeOraclesData('D',oracletxid,batontxid,mypk,data)));
+        } else
+            CCERR_RESULT("oraclescc",CCLOG_INFO, stream << "couldnt find enough oracle inputs " << coinaddr << ", limit 1 per utxo");
     }
-    return("");
+    CCERR_RESULT("oraclescc",CCLOG_INFO, stream << "couldnt add normal inputs");
 }
 
 UniValue OracleFormat(uint8_t *data,int32_t datalen,char *format,int32_t formatlen)
@@ -1059,23 +1035,59 @@ UniValue OracleFormat(uint8_t *data,int32_t datalen,char *format,int32_t formatl
     return(obj);
 }
 
+UniValue OracleDataSample(uint256 reforacletxid,uint256 txid)
+{
+    UniValue result(UniValue::VOBJ); CTransaction tx,oracletx; uint256 hashBlock,btxid,oracletxid;  std::string error;
+    CPubKey pk; std::string name,description,format; int32_t numvouts; std::vector<uint8_t> data; char str[67], *formatstr = 0;
+    
+    result.push_back(Pair("result","success"));
+    if ( myGetTransaction(reforacletxid,oracletx,hashBlock) != 0 && (numvouts=oracletx.vout.size()) > 0 )
+    {
+        if ( DecodeOraclesCreateOpRet(oracletx.vout[numvouts-1].scriptPubKey,name,description,format) == 'C' )
+        {
+            if ( myGetTransaction(txid,tx,hashBlock) != 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 *)"";                    
+                    result.push_back(Pair("txid",uint256_str(str,txid)));
+                    result.push_back(Pair("data",OracleFormat((uint8_t *)data.data(),(int32_t)data.size(),formatstr,(int32_t)format.size())));
+                    return(result);                  
+                }
+                else error="invalid data tx";
+            }
+            else error="cannot find data txid";
+        }
+        else error="invalid oracles txid";
+    }
+    else error="cannot find oracles txid";
+    result.push_back(Pair("result","error")); 
+    result.push_back(Pair("error",error));    
+    return(result);
+}
+
 UniValue OracleDataSamples(uint256 reforacletxid,char* batonaddr,int32_t num)
 {
     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;
+    CPubKey pk; std::string name,description,format; int32_t numvouts,n=0,vout; std::vector<uint8_t> data; char *formatstr = 0, addr[64];
+    std::vector<uint256> txids; int64_t nValue;
     
     result.push_back(Pair("result","success"));
-    if ( GetTransaction(reforacletxid,oracletx,hashBlock,false) != 0 && (numvouts=oracletx.vout.size()) > 0 )
+    if ( myGetTransaction(reforacletxid,oracletx,hashBlock) != 0 && (numvouts=oracletx.vout.size()) > 0 )
     {
         if ( DecodeOraclesCreateOpRet(oracletx.vout[numvouts-1].scriptPubKey,name,description,format) == 'C' )
         {
-            BOOST_FOREACH(const CTxMemPoolEntry &e, mempool.mapTx)
+            std::vector<CTransaction> tmp_txs;
+            myGet_mempool_txs(tmp_txs,EVAL_ORACLES,'D');
+            for (std::vector<CTransaction>::const_iterator it=tmp_txs.begin(); it!=tmp_txs.end(); it++)
             {
-                const CTransaction &txmempool = e.GetTx();
+                const CTransaction &txmempool = *it;
                 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 ((numvouts=txmempool.vout.size())>0 && txmempool.vout[1].nValue==CC_MARKER_VALUE && DecodeOraclesData(txmempool.vout[numvouts-1].scriptPubKey,oracletxid,btxid,pk,data) == 'D' && reforacletxid == oracletxid )
                 {
+                    Getscriptaddress(addr,txmempool.vout[1].scriptPubKey);
+                    if (strcmp(addr,batonaddr)!=0) continue;
                     if ( (formatstr= (char *)format.c_str()) == 0 )
                         formatstr = (char *)"";
                     UniValue a(UniValue::VOBJ);
@@ -1083,20 +1095,21 @@ UniValue OracleDataSamples(uint256 reforacletxid,char* batonaddr,int32_t num)
                     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;
+                    {
+                        result.push_back(Pair("samples",b));
+                        return(result);
+                    }
                 }
             }
-            SetCCtxids(addressIndex,batonaddr,true);
-            if (addressIndex.size()>0)
+            SetCCtxids(txids,batonaddr,true,EVAL_ORACLES,reforacletxid,'D');
+            if (txids.size()>0)
             {
-                for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=addressIndex.end()-1; it!=addressIndex.begin(); it--)
+                for (std::vector<uint256>::const_iterator it=txids.end()-1; it!=txids.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 )
+                    txid=*it;
+                    if (myGetTransaction(txid,tx,hashBlock) != 0 && (numvouts=tx.vout.size()) > 0 )
                     {
-                        if ( DecodeOraclesData(tx.vout[numvouts-1].scriptPubKey,oracletxid,btxid,pk,data) == 'D' && reforacletxid == oracletxid )
+                        if ( tx.vout[1].nValue==CC_MARKER_VALUE && DecodeOraclesData(tx.vout[numvouts-1].scriptPubKey,oracletxid,btxid,pk,data) == 'D' && reforacletxid == oracletxid )
                         {
                             if ( (formatstr= (char *)format.c_str()) == 0 )
                                 formatstr = (char *)"";
@@ -1105,13 +1118,20 @@ UniValue OracleDataSamples(uint256 reforacletxid,char* batonaddr,int32_t num)
                             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;
+                            {
+                                result.push_back(Pair("samples",b));
+                                return(result);
+                            }
                         }
                     }
                 }
             }
         }
+        else
+            CCERR_RESULT("pegscc",CCLOG_INFO, stream << "invalid oracletxid " << oracletxid.GetHex());
     }
+    else
+        CCERR_RESULT("oraclescc",CCLOG_INFO, stream << "cant find oracletxid " << oracletxid.GetHex());
     result.push_back(Pair("samples",b));
     return(result);
 }
@@ -1127,14 +1147,14 @@ UniValue OracleInfo(uint256 origtxid)
 
     cp = CCinit(&C,EVAL_ORACLES);
     CCtxidaddr(markeraddr,origtxid);
-    if ( GetTransaction(origtxid,tx,hashBlock,false) == 0 )
+    if ( myGetTransaction(origtxid,tx,hashBlock) == 0 )
     {
         LogPrintf("cant find oracleid\n");
         result.push_back(Pair("result","error"));
         result.push_back(Pair("error","cant find oracleid"));
         return(result);
     }
-    if ( GetTransaction(origtxid,tx,hashBlock,false) != 0 )
+    if ( myGetTransaction(origtxid,tx,hashBlock) != 0 )
     {
         if ( tx.vout.size() > 0 && DecodeOraclesCreateOpRet(tx.vout[tx.vout.size()-1].scriptPubKey,name,description,format) == 'C' )
         {
@@ -1149,7 +1169,7 @@ UniValue OracleInfo(uint256 origtxid)
             {
                 txid = it->first.txhash;
                 height = (int32_t)it->second.blockHeight;
-                if ( GetTransaction(txid,tx,hashBlock,false) != 0 && tx.vout.size() > 0 &&
+                if ( myGetTransaction(txid,tx,hashBlock) != 0 && tx.vout.size() > 0 &&
                     DecodeOraclesOpRet(tx.vout[tx.vout.size()-1].scriptPubKey,oracletxid,pk,datafee) == 'R' && oracletxid == origtxid )
                 {
                     if (publishers.find(pk)==publishers.end() || height>publishers[pk].second)
@@ -1161,7 +1181,7 @@ UniValue OracleInfo(uint256 origtxid)
             }
             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')
+                if ( myGetTransaction(it->second.first,tx,hashBlock) != 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())));
@@ -1182,19 +1202,23 @@ UniValue OracleInfo(uint256 origtxid)
             }
             result.push_back(Pair("registered",a));
         }
+        else
+            CCERR_RESULT("pegscc",CCLOG_INFO, stream << "invalid oracletxid " << oracletxid.GetHex());
     }
+    else
+        CCERR_RESULT("oraclescc",CCLOG_INFO, stream << "cant find oracletxid " << oracletxid.GetHex());
     return(result);
 }
 
 UniValue OraclesList()
 {
-    UniValue result(UniValue::VARR); std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex; struct CCcontract_info *cp,C; uint256 txid,hashBlock; CTransaction createtx; std::string name,description,format; char str[65];
+    UniValue result(UniValue::VARR); std::vector<uint256> txids; struct CCcontract_info *cp,C; uint256 txid,hashBlock; CTransaction createtx; std::string name,description,format; char str[65];
     cp = CCinit(&C,EVAL_ORACLES);
-    SetCCtxids(addressIndex,cp->normaladdr,false);
-    for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=addressIndex.begin(); it!=addressIndex.end(); it++)
+    SetCCtxids(txids,cp->normaladdr,false,cp->evalcode,zeroid,'C');
+    for (std::vector<uint256>::const_iterator it=txids.begin(); it!=txids.end(); it++)
     {
-        txid = it->first.txhash;
-        if ( GetTransaction(txid,createtx,hashBlock,false) != 0 )
+        txid = *it;
+        if ( myGetTransaction(txid,createtx,hashBlock) != 0 )
         {
             if ( createtx.vout.size() > 0 && DecodeOraclesCreateOpRet(createtx.vout[createtx.vout.size()-1].scriptPubKey,name,description,format) == 'C' )
             {
diff --git a/src/cc/payments.cpp b/src/cc/payments.cpp
index eee43879..1717af10 100644
--- a/src/cc/payments.cpp
+++ b/src/cc/payments.cpp
@@ -77,6 +77,25 @@
 
 // start of consensus code
 
+void mpz_set_lli( mpz_t rop, long long op )
+{
+   mpz_import(rop, 1, 1, sizeof(op), 0, 0, &op);
+}
+
+int64_t mpz_get_si2( mpz_t op )
+{
+    int64_t ret = 0;
+    mpz_export(&ret, NULL, 1, sizeof(ret), 0, 0, op);
+    return ret;
+}
+
+uint64_t mpz_get_ui2( mpz_t op )
+{
+    uint64_t ret = 0;
+    mpz_export(&ret, NULL, 1, sizeof(ret), 0, 0, op);
+    return ret;
+}
+
 CScript EncodePaymentsTxidOpRet(int64_t allocation,std::vector<uint8_t> scriptPubKey,std::vector<uint8_t> destopret)
 {
     CScript opret; uint8_t evalcode = EVAL_PAYMENTS;
@@ -277,7 +296,7 @@ int32_t payments_getallocations(int32_t top, int32_t bottom, const std::vector<s
             //LogPrintf( "address: %s nValue.%li \n", CBitcoinAddress(address.second).ToString().c_str(), address.first);
             scriptPubKeys.push_back(scriptPubKey);
             allocations.push_back(address.first);
-            mpz_set_si(mpzAllocation,address.first);
+            mpz_set_lli(mpzAllocation,address.first);
             mpz_add(mpzTotalAllocations,mpzTotalAllocations,mpzAllocation); 
             mpz_clear(mpzAllocation);
         }
@@ -314,7 +333,9 @@ bool PaymentsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &
             fIsMerge = true;
         else if ( DecodePaymentsReleaseOpRet(ccopret,createtxid,amountReleased) != 'R' )
             return(eval->Invalid("could not decode ccopret"));
-        mpz_set_si(mpzCheckamount,amountReleased); 
+        if ( tx.vout.back().scriptPubKey.IsOpReturn() )
+            fHasOpret = true;
+        mpz_set_lli(mpzCheckamount,amountReleased); 
     } else return(eval->Invalid("could not decode ccopret"));
     
     // use the createtxid to fetch the tx and all of the plans info.
@@ -380,7 +401,7 @@ bool PaymentsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &
                     //LogPrintf( "totalallocations.%li checkallocations.%li\n",totalallocations, checkallocations);
                     if ( totalallocations != checkallocations )
                         return(eval->Invalid("allocation missmatch"));
-                    mpz_set_si(mpzTotalAllocations,totalallocations);
+                    mpz_set_lli(mpzTotalAllocations,totalallocations);
                 }
                 else if ( funcid == 'S' || funcid == 'O' )
                 {
@@ -436,16 +457,16 @@ bool PaymentsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &
                     else 
                     {
                         mpz_init(mpzAllocation); 
-                        mpz_set_si(mpzAllocation,allocations[n]);
+                        mpz_set_lli(mpzAllocation,allocations[n]);
                         mpz_mul(mpzAllocation,mpzAllocation,mpzCheckamount);
                         mpz_tdiv_q(mpzAllocation,mpzAllocation,mpzTotalAllocations);
-                        test = mpz_get_si(mpzAllocation);
+                        test = mpz_get_si2(mpzAllocation);
                         mpz_clear(mpzAllocation);
                     }
-                    //LogPrintf( "vout %i test.%li nValue.%li\n", i, test, tx.vout[i].nValue);
+                    //fprintf(stderr, "vout.%i test.%lli vs nVlaue.%lli\n",i, (long long)test, (long long)tx.vout[i].nValue);
                     if ( test != tx.vout[i].nValue ) 
                     {
-                        LogPrintf( "vout.%i test.%li vs nVlaue.%li\n",i, test, tx.vout[i].nValue);
+                        LogPrintf("vout.%i test.%lli vs nVlaue.%lli\n",i, (long long)test, (long long)tx.vout[i].nValue);
                         return(eval->Invalid("amounts do not match"));
                     }
                     if ( test < minimum )
@@ -461,11 +482,11 @@ bool PaymentsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &
                 {
                     // need to check that the next allocation was less than minimum, otherwise ppl can truncate the tx at any place not paying all elegible addresses. 
                     mpz_init(mpzAllocation); 
-                    mpz_set_si(mpzAllocation,allocations[n+1]);
+                    mpz_set_lli(mpzAllocation,allocations[n+1]);
                     mpz_mul(mpzAllocation,mpzAllocation,mpzCheckamount);
                     mpz_tdiv_q(mpzAllocation,mpzAllocation,mpzTotalAllocations);
-                    int64_t test = mpz_get_si(mpzAllocation);
-                    //LogPrintf( "check next vout pays under min: test.%li > minimuim.%i\n", test, minimum);
+                    int64_t test = mpz_get_si2(mpzAllocation);
+                    //fprintf(stderr, "check next vout pays under min: test.%li > minimuim.%i\n", test, minimum);
                     if ( test > minimum )
                         return(eval->Invalid("next allocation was not under minimum"));
                 }
@@ -556,8 +577,8 @@ int64_t AddPaymentsInputs(bool fLockedBlocks,int8_t GetBalance,struct CCcontract
         {
             txid = it->first.txhash;
             vout = (int32_t)it->first.index;
-            //LogPrintf("iter.%d %s/v%d %s\n",iter,txid.GetHex().c_str(),vout,coinaddr);
-            if ( GetTransaction(txid,vintx,hashBlock,false) != 0 )
+            //fprintf(stderr,"iter.%d %s/v%d %s\n",iter,txid.GetHex().c_str(),vout,coinaddr);
+            if ( myGetTransaction(txid,vintx,hashBlock) != 0 )
             {
                 if ( (nValue= IsPaymentsvout(cp,vintx,vout,coinaddr,ccopret)) > PAYMENTS_TXFEE && nValue >= threshold && myIsutxo_spentinmempool(ignoretxid,ignorevin,txid,vout) == 0 )
                 {
@@ -783,7 +804,7 @@ UniValue PaymentsRelease(struct CCcontract_info *cp,char *jsonstr)
                         return(result);
                     }
                     // set totalallocations to a mpz_t bignum, for amounts calculation later. 
-                    mpz_set_si(mpzTotalAllocations,totalallocations);
+                    mpz_set_lli(mpzTotalAllocations,totalallocations);
                 }
                 else if ( funcid == 'S' || funcid == 'O' )
                 {
@@ -850,7 +871,7 @@ UniValue PaymentsRelease(struct CCcontract_info *cp,char *jsonstr)
                 }
                 newamount = amount;
                 int64_t totalamountsent = 0;
-                mpz_t mpzAmount; mpz_init(mpzAmount); mpz_set_si(mpzAmount,amount);
+                mpz_t mpzAmount; mpz_init(mpzAmount); mpz_set_lli(mpzAmount,amount);
                 for (i=0; i<m; i++)
                 {
                     mpz_t mpzValue; mpz_init(mpzValue);
@@ -858,11 +879,11 @@ UniValue PaymentsRelease(struct CCcontract_info *cp,char *jsonstr)
                         mtx.vout[i+1].nValue = amount / (top-bottom);
                     else 
                     {
-                        mpz_set_si(mpzValue,mtx.vout[i+1].nValue);
+                        mpz_set_lli(mpzValue,mtx.vout[i+1].nValue);
                         mpz_mul(mpzValue,mpzValue,mpzAmount); 
                         mpz_tdiv_q(mpzValue,mpzValue,mpzTotalAllocations); 
                         if ( mpz_fits_slong_p(mpzValue) ) 
-                            mtx.vout[i+1].nValue = mpz_get_si(mpzValue);
+                            mtx.vout[i+1].nValue = mpz_get_si2(mpzValue);
                         else
                         {
                             result.push_back(Pair("result","error"));
@@ -895,8 +916,8 @@ UniValue PaymentsRelease(struct CCcontract_info *cp,char *jsonstr)
                     totalamountsent += mtx.vout[i+1].nValue;
                 } 
                 if ( totalamountsent < amount ) newamount = totalamountsent;
-                //int64_t temptst = mpz_get_si(mpzTotalAllocations);
-                //LogPrintf( "checkamount RPC.%li totalallocations.%li\n",totalamountsent, temptst);
+                //int64_t temptst = mpz_get_si2(mpzTotalAllocations);
+                //fprintf(stderr, "checkamount RPC.%li totalallocations.%li\n",totalamountsent, temptst);
                 mpz_clear(mpzAmount); mpz_clear(mpzTotalAllocations);
             }
             else
diff --git a/src/cc/pegs.cpp b/src/cc/pegs.cpp
index 3bed3a14..4e6b4dd1 100644
--- a/src/cc/pegs.cpp
+++ b/src/cc/pegs.cpp
@@ -14,6 +14,10 @@
  ******************************************************************************/
 
 #include "CCPegs.h"
+#include "../importcoin.h"
+#include "key_io.h"
+#include <gmp.h>
+
 
 /*
 pegs CC is able to create a coin backed (by any supported coin with gateways CC deposits) and pegged to any synthetic price that is able to be calculated based on prices CC
@@ -84,6 +88,200 @@ pegs CC is able to create a coin backed (by any supported coin with gateways CC
  */
 
 // start of consensus code
+#ifndef PEGS_THRESHOLDS
+#define PEGS_THRESHOLDS
+#define PEGS_ACCOUNT_MAX_DEBT 80
+#define PEGS_GLOBAL_RED_ZONE 60
+#define PEGS_ACCOUNT_YELLOW_ZONE 60
+#define PEGS_ACCOUNT_RED_ZONE 90
+#endif // PEGS_THRESHOLDS
+#define CC_MARKER_VALUE 10000
+
+extern uint64_t ASSETCHAINS_PEGSCCPARAMS[3];
+
+extern uint8_t DecodeGatewaysBindOpRet(char *depositaddr,const CScript &scriptPubKey,uint256 &tokenid,std::string &coin,int64_t &totalsupply,uint256 &oracletxid,uint8_t &M,uint8_t &N,std::vector<CPubKey> &gatewaypubkeys,uint8_t &taddr,uint8_t &prefix,uint8_t &prefix2,uint8_t &wiftype);
+extern int64_t GetTokenBalance(CPubKey pk, uint256 tokenid);
+extern int32_t komodo_currentheight();
+extern int32_t prices_syntheticvec(std::vector<uint16_t> &vec, std::vector<std::string> synthetic);
+extern int64_t prices_syntheticprice(std::vector<uint16_t> vec, int32_t height, int32_t minmax, int16_t leverage);
+
+CScript EncodePegsCreateOpRet(std::vector<uint256> bindtxids)
+{
+    CScript opret; uint8_t evalcode = EVAL_PEGS;
+    opret << OP_RETURN << E_MARSHAL(ss << evalcode << 'C' << bindtxids);        
+    return(opret);
+}
+
+uint8_t DecodePegsCreateOpRet(const CScript &scriptPubKey,std::vector<uint256> &bindtxids)
+{
+    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_PEGS && E_UNMARSHAL(vopret,ss >> e; ss >> f; ss >> bindtxids) != 0 )
+    {
+        return(f);
+    }
+    return(0);
+}
+
+CScript EncodePegsFundOpRet(uint256 tokenid,uint256 pegstxid,CPubKey srcpub,int64_t amount,std::pair <int64_t,int64_t> account)
+{
+    CScript opret; uint8_t evalcode=EVAL_PEGS,funcid='F'; struct CCcontract_info *cp,C; CPubKey pegspk;
+    std::vector<CPubKey> pubkeys; vscript_t vopret;
+
+    cp = CCinit(&C,EVAL_PEGS);
+    pegspk = GetUnspendable(cp,0);
+    pubkeys.push_back(srcpub);
+    pubkeys.push_back(pegspk);
+    LOGSTREAM("pegscc", CCLOG_DEBUG1, stream  << "EncodePegsFundOpRet [" << account.first << "," << account.second << "]" << std::endl);
+    vopret = E_MARSHAL(ss << evalcode << funcid << pegstxid << srcpub << amount << account);        
+    return(EncodeTokenOpRet(tokenid,pubkeys,make_pair(OPRETID_PEGSDATA, vopret)));
+}
+
+uint8_t DecodePegsFundOpRet(const CScript &scriptPubKey,uint256 &tokenid,uint256 &pegstxid,CPubKey &srcpub,int64_t &amount,std::pair <int64_t,int64_t> &account)
+{
+    std::vector<std::pair<uint8_t, vscript_t>>  oprets;
+    std::vector<uint8_t> vopret,vOpretExtra; uint8_t *script,e,f,tokenevalcode; std::vector<CPubKey> pubkeys;
+
+    if (DecodeTokenOpRet(scriptPubKey,tokenevalcode,tokenid,pubkeys, oprets)!=0 && GetOpretBlob(oprets, OPRETID_PEGSDATA, vOpretExtra) && tokenevalcode==EVAL_TOKENS && vOpretExtra.size()>0)
+    {
+        vopret=vOpretExtra;
+    }
+    else GetOpReturnData(scriptPubKey, vopret);
+    script = (uint8_t *)vopret.data();
+    if ( vopret.size() > 2 && script[0] == EVAL_PEGS && E_UNMARSHAL(vopret, ss >> e; ss >> f; ss >> pegstxid; ss >> srcpub; ss >> amount; ss >> account) != 0 )
+    {
+        return(f);
+    }
+    return(0);
+}
+
+uint8_t DecodePegsGetOpRet(const CTransaction tx,uint256& pegstxid,uint256 &tokenid,CPubKey &srcpub,int64_t &amount,std::pair<int64_t,int64_t> &account)
+{
+    std::vector<uint8_t> vopret; uint8_t *script; 
+    ImportProof proof; CTransaction burntx; std::vector<CTxOut> payouts;
+
+    GetOpReturnData(tx.vout[tx.vout.size()-1].scriptPubKey, vopret);
+    
+    script = (uint8_t *)vopret.data();
+    if ( vopret.size() > 2 && script[0] == EVAL_IMPORTCOIN && UnmarshalImportTx(tx,proof,burntx,payouts) && UnmarshalBurnTx(burntx,pegstxid,tokenid,srcpub,amount,account))
+    {
+        return('G');
+    }
+    return(0);
+}
+
+CScript EncodePegsReedemOpRet(uint256 tokenid,uint256 pegstxid,CPubKey srcpub,int64_t amount,std::pair <int64_t,int64_t> account)
+{
+    CScript opret; uint8_t evalcode=EVAL_PEGS,funcid='R'; struct CCcontract_info *cp,C;
+    std::vector<CPubKey> pubkeys; vscript_t vopret;
+
+    cp = CCinit(&C,EVAL_PEGS);
+    pubkeys.push_back(srcpub);
+    vopret = E_MARSHAL(ss << evalcode << funcid << pegstxid << srcpub << amount << account);        
+    return(EncodeTokenOpRet(tokenid,pubkeys,make_pair(OPRETID_PEGSDATA, vopret)));
+}
+
+uint8_t DecodePegsRedeemOpRet(const CScript &scriptPubKey,uint256 &tokenid,uint256 &pegstxid,CPubKey &srcpub,int64_t &amount,std::pair <int64_t,int64_t> &account)
+{
+    std::vector<std::pair<uint8_t, vscript_t>>  oprets;
+    std::vector<uint8_t> vopret,vOpretExtra; uint8_t *script,e,f,tokenevalcode; std::vector<CPubKey> pubkeys;
+
+    if (DecodeTokenOpRet(scriptPubKey,tokenevalcode,tokenid,pubkeys, oprets)!=0 && GetOpretBlob(oprets, OPRETID_PEGSDATA, vOpretExtra) && tokenevalcode==EVAL_TOKENS && vOpretExtra.size()>0)
+    {
+        vopret=vOpretExtra;
+    }
+    else GetOpReturnData(scriptPubKey, vopret);
+    script = (uint8_t *)vopret.data();
+    if ( vopret.size() > 2 && script[0] == EVAL_PEGS && E_UNMARSHAL(vopret, ss >> e; ss >> f; ss >> pegstxid; ss >> srcpub; ss >> amount; ss >> account) != 0 )
+    {
+        return(f);
+    }
+    return(0);
+}
+
+CScript EncodePegsExchangeOpRet(uint256 tokenid,uint256 pegstxid,CPubKey pk1,CPubKey pk2,int64_t amount,std::pair <int64_t,int64_t> account)
+{
+    CScript opret; uint8_t evalcode=EVAL_PEGS,funcid='E'; struct CCcontract_info *cp,C;
+    std::vector<CPubKey> pubkeys; vscript_t vopret; CPubKey pegspk;
+
+    cp = CCinit(&C,EVAL_PEGS);
+    pegspk = GetUnspendable(cp,0);
+    pubkeys.push_back(pk1);
+    pubkeys.push_back(pk2);
+    vopret = E_MARSHAL(ss << evalcode << funcid << pegstxid << pk1 << amount << account);        
+    return(EncodeTokenOpRet(tokenid,pubkeys,make_pair(OPRETID_PEGSDATA, vopret)));
+}
+
+uint8_t DecodePegsExchangeOpRet(const CScript &scriptPubKey,uint256 &tokenid,uint256 &pegstxid,CPubKey &srcpub,int64_t &amount,std::pair <int64_t,int64_t> &account)
+{
+    std::vector<std::pair<uint8_t, vscript_t>>  oprets;
+    std::vector<uint8_t> vopret,vOpretExtra; uint8_t *script,e,f,tokenevalcode; std::vector<CPubKey> pubkeys;
+
+    if (DecodeTokenOpRet(scriptPubKey,tokenevalcode,tokenid,pubkeys, oprets)!=0 && GetOpretBlob(oprets, OPRETID_PEGSDATA, vOpretExtra) && tokenevalcode==EVAL_TOKENS && vOpretExtra.size()>0)
+    {
+        vopret=vOpretExtra;
+    }
+    else GetOpReturnData(scriptPubKey, vopret);
+    script = (uint8_t *)vopret.data();
+    if ( vopret.size() > 2 && script[0] == EVAL_PEGS && E_UNMARSHAL(vopret, ss >> e; ss >> f; ss >> pegstxid; ss >> srcpub; ss >> amount; ss >> account) != 0 )
+    {
+        return(f);
+    }
+    return(0);
+}
+
+CScript EncodePegsLiquidateOpRet(uint256 tokenid,uint256 pegstxid,CPubKey srcpub,int64_t amount,std::pair <int64_t,int64_t> account)
+{
+    CScript opret; uint8_t evalcode=EVAL_PEGS,funcid='L'; struct CCcontract_info *cp,C;
+    std::vector<CPubKey> pubkeys; vscript_t vopret;
+
+    cp = CCinit(&C,EVAL_PEGS);
+    pubkeys.push_back(srcpub);
+    vopret = E_MARSHAL(ss << evalcode << funcid << pegstxid << srcpub << amount << account);        
+    return(EncodeTokenOpRet(tokenid,pubkeys,make_pair(OPRETID_PEGSDATA, vopret)));
+}
+
+uint8_t DecodePegsLiquidateOpRet(const CScript &scriptPubKey,uint256 &tokenid,uint256 &pegstxid,CPubKey &srcpub,int64_t &amount,std::pair <int64_t,int64_t> &account)
+{
+    std::vector<std::pair<uint8_t, vscript_t>>  oprets;
+    std::vector<uint8_t> vopret,vOpretExtra; uint8_t *script,e,f,tokenevalcode; std::vector<CPubKey> pubkeys;
+
+    if (DecodeTokenOpRet(scriptPubKey,tokenevalcode,tokenid,pubkeys, oprets)!=0 && GetOpretBlob(oprets, OPRETID_PEGSDATA, vOpretExtra) && tokenevalcode==EVAL_TOKENS && vOpretExtra.size()>0)
+    {
+        vopret=vOpretExtra;
+    }
+    else GetOpReturnData(scriptPubKey, vopret);
+    script = (uint8_t *)vopret.data();
+    if ( vopret.size() > 2 && script[0] == EVAL_PEGS && E_UNMARSHAL(vopret, ss >> e; ss >> f; ss >> pegstxid; ss >> srcpub; ss >> amount; ss >> account) != 0 )
+    {
+        return(f);
+    }
+    return(0);
+}
+
+uint8_t DecodePegsOpRet(CTransaction tx,uint256& pegstxid,uint256& tokenid)
+{
+    std::vector<std::pair<uint8_t, vscript_t>>  oprets; int32_t numvouts=tx.vout.size();
+    std::vector<uint8_t> vopret,vOpretExtra; uint8_t *script,e,f,tokenevalcode; std::vector<CPubKey> pubkeys;
+    ImportProof proof; CTransaction burntx; std::vector<CTxOut> payouts; uint256 tmppegstxid; CPubKey srcpub; int64_t amount; std::pair<int64_t,int64_t> account;
+
+    if (DecodeTokenOpRet(tx.vout[numvouts-1].scriptPubKey,tokenevalcode,tokenid,pubkeys, oprets)!=0 && GetOpretBlob(oprets, OPRETID_PEGSDATA, vOpretExtra) && tokenevalcode==EVAL_TOKENS && vOpretExtra.size()>0)
+    {
+        vopret=vOpretExtra;
+    }
+    else GetOpReturnData(tx.vout[numvouts-1].scriptPubKey, vopret);
+    script = (uint8_t *)vopret.data();
+    if (tx.IsPegsImport())
+        return(DecodePegsGetOpRet(tx,pegstxid,tokenid,srcpub,amount,account));
+    else if ( vopret.size() > 2 && script[0] == EVAL_PEGS)
+    {
+        E_UNMARSHAL(vopret, ss >> e; ss >> f; ss >> pegstxid);
+        return(f);
+    }
+    return(0);
+}
 
 int64_t IsPegsvout(struct CCcontract_info *cp,const CTransaction& tx,int32_t v)
 {
@@ -137,7 +335,7 @@ bool PegsExactAmounts(struct CCcontract_info *cp,Eval* eval,const CTransaction &
 bool PegsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx, uint32_t nIn)
 {
     int32_t numvins,numvouts,preventCCvins,preventCCvouts,i,numblocks; bool retval; uint256 txid; uint8_t hash[32]; char str[65],destaddr[64];
-    return eval->Invalid("no validation yet");
+    return (true);
     std::vector<std::pair<CAddressIndexKey, CAmount> > txids;
     numvins = tx.vin.size();
     numvouts = tx.vout.size();
@@ -175,21 +373,54 @@ bool PegsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &tx,
 
 // helper functions for rpc calls in rpcwallet.cpp
 
-int64_t AddPegsInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPubKey pk,int64_t total,int32_t maxinputs)
+int64_t AddPegsInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPubKey pk1,CPubKey pk2,int64_t total,int32_t maxinputs)
 {
     // add threshold check
     char coinaddr[64]; int64_t nValue,price,totalinputs = 0; uint256 txid,hashBlock; std::vector<uint8_t> origpubkey; CTransaction vintx; int32_t vout,n = 0;
     std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
-    GetCCaddress(cp,coinaddr,pk);
+
+    if (pk2.IsValid()) GetCCaddress1of2(cp,coinaddr,pk1,pk2);
+    else GetCCaddress(cp,coinaddr,pk1);
+    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;
+        // no need to prevent dup
+        if ( myGetTransaction(txid,vintx,hashBlock) != 0 )
+        {
+            if (myIsutxo_spentinmempool(ignoretxid,ignorevin,txid,vout) == 0 )
+            {
+                if ( total != 0 && maxinputs != 0 )
+                    mtx.vin.push_back(CTxIn(txid,vout,CScript()));
+                nValue = it->second.satoshis;
+                totalinputs += nValue;
+                n++;
+                if ( (total > 0 && totalinputs >= total) || (maxinputs > 0 && n >= maxinputs) )
+                    break;
+            }
+        }
+    }
+    return(totalinputs);
+}
+
+int64_t AddPegsTokenInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,uint256 pegstxid, uint256 tokenid, CPubKey pk1,CPubKey pk2, int64_t total,int32_t maxinputs)
+{
+    // add threshold check
+    char coinaddr[64]; int64_t nValue,price,totalinputs = 0; uint256 txid,hashBlock; std::vector<uint8_t> origpubkey; CTransaction vintx; int32_t vout,n = 0;
+    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs; uint256 tmppegstxid,tmptokenid; CPubKey mypk;
+
+    if (pk2.IsValid()) GetTokensCCaddress1of2(cp,coinaddr,pk1,pk2);
+    else GetTokensCCaddress(cp,coinaddr,pk1);
     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;
         // no need to prevent dup
-        if ( GetTransaction(txid,vintx,hashBlock,false) != 0 )
+        if ( myGetTransaction(txid,vintx,hashBlock) != 0 )
         {
-            if ( (nValue= IsPegsvout(cp,vintx,vout)) > 1000000 && myIsutxo_spentinmempool(ignoretxid,ignorevin,txid,vout) == 0 )
+            if (myIsutxo_spentinmempool(ignoretxid,ignorevin,txid,vout) == 0 && DecodePegsOpRet(vintx,tmppegstxid,tmptokenid)!=0 && tmppegstxid==pegstxid && tmptokenid==tokenid)
             {
                 if ( total != 0 && maxinputs != 0 )
                     mtx.vin.push_back(CTxIn(txid,vout,CScript()));
@@ -201,79 +432,853 @@ int64_t AddPegsInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPubKe
             }
         }
     }
+    if (pk2.IsValid())
+    {
+        mypk = pubkey2pk(Mypubkey());
+        if (mypk!=pk1 && mypk!=pk2)
+        {
+            CCaddrTokens1of2set(cp,pk1,pk2,cp->CCpriv,coinaddr);
+        } 
+        else
+        {
+            uint8_t mypriv[32];
+            Myprivkey(mypriv);
+            CCaddrTokens1of2set(cp,pk1,pk2,mypriv,coinaddr);
+            memset(mypriv,0,sizeof(mypriv));
+    }
+    }
     return(totalinputs);
 }
 
-std::string PegsGet(uint64_t txfee,int64_t nValue)
+std::string PegsDecodeAccountTx(CTransaction tx,CPubKey& pk,int64_t &amount,std::pair<int64_t,int64_t> &account)
+{
+    uint256 hashBlock,tokenid,pegstxid; int32_t numvouts=tx.vout.size(); char funcid;
+
+    if ((funcid=DecodePegsOpRet(tx,pegstxid,tokenid))!=0)
+    {
+        switch(funcid)
+        {            
+            case 'F': if (DecodePegsFundOpRet(tx.vout[numvouts-1].scriptPubKey,tokenid,pegstxid,pk,amount,account)=='F') return("fund");
+                      break;
+            case 'G': if (DecodePegsGetOpRet(tx,pegstxid,tokenid,pk,amount,account)=='G') return("get");
+                      break;
+            case 'R': if (DecodePegsRedeemOpRet(tx.vout[numvouts-1].scriptPubKey,tokenid,pegstxid,pk,amount,account)=='R') return("redeem");
+                      break;
+            case 'E': if (DecodePegsExchangeOpRet(tx.vout[numvouts-1].scriptPubKey,tokenid,pegstxid,pk,amount,account)=='R') return("exchange");
+                      break;
+            case 'L': if (DecodePegsLiquidateOpRet(tx.vout[numvouts-1].scriptPubKey,tokenid,pegstxid,pk,amount,account)=='L') return("liquidate");
+                      break;
+        }
+    }
+    return ("");
+}
+
+char PegsFindAccount(struct CCcontract_info *cp,CPubKey pk,uint256 pegstxid, uint256 tokenid, uint256 &accounttxid, std::pair<int64_t,int64_t> &account)
 {
-    CMutableTransaction tmpmtx,mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
-    CPubKey mypk,Pegspk; int64_t inputs,CCchange=0; struct CCcontract_info *cp,C; std::string rawhex; uint32_t j; int32_t i,len; uint8_t buf[32768]; bits256 hash;
+    char coinaddr[64]; int64_t nValue,tmpamount; uint256 txid,spenttxid,hashBlock,tmptokenid,tmppegstxid;
+    CTransaction tx,acctx; int32_t numvouts,vout,ratio; char funcid,f; CPubKey pegspk,tmppk;
+    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
+    ImportProof proof; CTransaction burntx; std::vector<CTxOut> payouts;
+
+    accounttxid=zeroid;
+    pegspk = GetUnspendable(cp,0);
+    GetCCaddress1of2(cp,coinaddr,pk,pegspk);
+    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 = (int64_t)it->second.satoshis;
+        LOGSTREAM("pegscc",CCLOG_DEBUG2, stream << "txid=" << txid.GetHex() << ", vout=" << vout << ", nValue=" << nValue << std::endl);
+        if (vout == 1 && nValue == CC_MARKER_VALUE && myGetTransaction(txid,tx,hashBlock) != 0 && (numvouts=tx.vout.size())>0 &&
+            (f=DecodePegsOpRet(tx,tmppegstxid,tmptokenid))!=0 && pegstxid==tmppegstxid && tokenid==tmptokenid)
+        {            
+            accounttxid=txid;
+            funcid=f;
+            acctx=tx;
+        }
+    }
+    if (accounttxid!=zeroid && myIsutxo_spentinmempool(spenttxid,ignorevin,accounttxid,1) != 0)
+    {
+        accounttxid=zeroid;
+        if (myGetTransaction(spenttxid,tx,hashBlock)!=0 && (numvouts=tx.vout.size()) > 0 &&
+            (f=DecodePegsOpRet(tx,tmppegstxid,tmptokenid))!=0 && pegstxid==tmppegstxid && tokenid==tmptokenid)
+        {
+            funcid=f;
+            accounttxid=spenttxid;
+            acctx=tx;          
+        }
+    }
+    if (accounttxid!=zeroid)
+    {
+        PegsDecodeAccountTx(acctx,tmppk,tmpamount,account);
+        return(funcid);
+    }
+    else return(0);
+}
+
+int64_t PegsGetTokenPrice(uint256 tokenid)
+{
+    int64_t price; CTransaction tokentx; uint256 hashBlock; std::vector<uint16_t> exp;
+    std::string name,desc; std::vector<uint8_t> vorigpubkey; int32_t numvouts;
+
+    if (myGetTransaction(tokenid,tokentx,hashBlock)!=0 && (numvouts=tokentx.vout.size())>0 && DecodeTokenCreateOpRet(tokentx.vout[numvouts-1].scriptPubKey,vorigpubkey,name,desc)=='c')
+    {
+        std::vector<std::string> vexpr;
+        SplitStr(desc, vexpr);
+        if (prices_syntheticvec(exp, vexpr)>=0 && (price = prices_syntheticprice(exp, komodo_currentheight(), 0, 1))>=0)
+            return (price);
+    }
+    return (0);
+}
+
+std::string PegsGetTokenName(uint256 tokenid)
+{
+    CTransaction tokentx; uint256 hashBlock; std::string name,desc; std::vector<uint8_t> vorigpubkey; int32_t numvouts;
+
+    if (myGetTransaction(tokenid,tokentx,hashBlock)!=0 && (numvouts=tokentx.vout.size())>0 && DecodeTokenCreateOpRet(tokentx.vout[numvouts-1].scriptPubKey,vorigpubkey,name,desc)=='c')
+    {
+        return (name);
+    }
+    CCerror = strprintf("cant find token create or invalid tokenid %s",tokenid.GetHex());
+    LOGSTREAM("pegscc",CCLOG_INFO, stream << CCerror << std::endl);
+    return("");
+}
+
+int64_t PegsGetTokensAmountPerPrice(int64_t amount,uint256 tokenid)
+{      
+    mpz_t res,a,b;
+    mpz_init(res);
+    mpz_init(a);
+    mpz_init(b);
+    mpz_set_si(a, amount);
+    mpz_set_si(b, COIN);
+    mpz_mul(res, a, b);
+    mpz_set_si(a, PegsGetTokenPrice(tokenid));   
+    mpz_tdiv_q(res, res, a);
+    return (mpz_get_si(res));           
+}
+
+double PegsGetRatio(uint256 tokenid,std::pair<int64_t,int64_t> account)
+{      
+    mpz_t res,a,b;
+    mpz_init(res);
+    mpz_init(a);
+    mpz_init(b);
+    mpz_set_si(a, account.first);
+    mpz_set_si(b, PegsGetTokenPrice(tokenid));
+    mpz_mul(res, a, b);
+    mpz_set_si(a, COIN);
+    mpz_tdiv_q(res, res, a);
+    return ((double)account.second)*100/mpz_get_si(res);           
+}
+
+double PegsGetAccountRatio(uint256 pegstxid,uint256 tokenid,uint256 accounttxid)
+{
+    int64_t amount; uint256 hashBlock,tmptokenid,tmppegstxid;
+    CTransaction tx; int32_t numvouts; char funcid; CPubKey pk;
+    std::pair<int64_t,int64_t> account; struct CCcontract_info *cp,C;
+
     cp = CCinit(&C,EVAL_PEGS);
+    if (myGetTransaction(accounttxid,tx,hashBlock) != 0 && (numvouts=tx.vout.size())>0 &&
+        (funcid=DecodePegsOpRet(tx,tmppegstxid,tmptokenid))!=0 && pegstxid==tmppegstxid && tokenid==tmptokenid)
+    {  
+        PegsDecodeAccountTx(tx,pk,amount,account);           
+        return PegsGetRatio(tokenid,account);        
+    }
+    return (0);
+}
+
+double PegsGetGlobalRatio(uint256 pegstxid)
+{
+    char coinaddr[64]; int64_t nValue,amount,globaldebt=0; uint256 txid,accounttxid,hashBlock,tmppegstxid,tokenid;
+    CTransaction tx; int32_t numvouts,vout; char funcid; CPubKey mypk,pegspk,pk;
+    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs; std::pair<int64_t,int64_t> account;
+    std::map<uint256,std::pair<int64_t,int64_t>> globalaccounts;
+    struct CCcontract_info *cp,C;
+
+    cp = CCinit(&C,EVAL_PEGS);
+    pegspk = GetUnspendable(cp,0);
+    GetCCaddress1of2(cp,coinaddr,pegspk,pegspk);
+    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 = (int64_t)it->second.satoshis;
+        if (vout == 0 && nValue == CC_MARKER_VALUE && myGetTransaction(txid,tx,hashBlock) != 0 && (numvouts=tx.vout.size())>0 &&
+            (funcid=DecodePegsOpRet(tx,tmppegstxid,tokenid))!=0 && pegstxid==tmppegstxid && (funcid=='F' || funcid=='G' || funcid=='E'))
+        {              
+            PegsDecodeAccountTx(tx,pk,amount,account);
+            globalaccounts[tokenid].first+=account.first;
+            globalaccounts[tokenid].second+=account.second;
+        }
+    }
+    unspentOutputs.clear();
+    GetTokensCCaddress(cp,coinaddr,pegspk);
+    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 = (int64_t)it->second.satoshis;
+        if (myGetTransaction(txid,tx,hashBlock) != 0 && (numvouts=tx.vout.size())>0 && DecodePegsOpRet(tx,tmppegstxid,tokenid)!=0 && pegstxid==tmppegstxid)
+        {
+            globalaccounts[tokenid].first+=nValue;
+        }
+    }
+    mpz_t res,globaldeposit,a,b;
+    mpz_init(res);
+    mpz_init(globaldeposit);
+    mpz_init(a);
+    mpz_init(b);
+    mpz_set_si(globaldeposit, 0);
+    for (std::map<uint256,std::pair<int64_t,int64_t>>::iterator it = globalaccounts.begin(); it != globalaccounts.end(); ++it)
+    {
+        mpz_set_si(res, 0);
+        mpz_set_si(a, globalaccounts[it->first].first);
+        mpz_set_si(b, PegsGetTokenPrice(it->first));
+        mpz_mul(res,a,b);
+        mpz_add(globaldeposit,globaldeposit,res);
+        globaldebt+=globalaccounts[it->first].second;
+    }
+    if (globaldebt>0)
+    {       
+        mpz_set_si(res, 0);
+        mpz_set_si(a, COIN);
+        mpz_tdiv_q(res, globaldeposit, a);
+        printf("%lu %lu\n",globaldebt,mpz_get_si(res));
+        return ((double)globaldebt)*100/mpz_get_si(res); 
+    }
+    return (0);
+}
+
+std::string PegsFindBestAccount(struct CCcontract_info *cp,uint256 pegstxid, uint256 tokenid, int64_t tokenamount,uint256 &accounttxid, std::pair<int64_t,int64_t> &account)
+{
+    char coinaddr[64]; int64_t nValue,tmpamount; uint256 txid,hashBlock,tmptokenid,tmppegstxid;
+    CTransaction tx,acctx; int32_t numvouts,vout; char funcid,f; CPubKey pegspk,tmppk;
+    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
+    ImportProof proof; CTransaction burntx; std::vector<CTxOut> payouts; double ratio,maxratio=0;
+    std::pair<int64_t,int64_t> tmpaccount;
+
+    accounttxid=zeroid;
+    pegspk = GetUnspendable(cp,0);
+    GetCCaddress1of2(cp,coinaddr,pegspk,pegspk);
+    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 = (int64_t)it->second.satoshis;
+        LOGSTREAM("pegscc",CCLOG_DEBUG2, stream << "txid=" << txid.GetHex() << ", vout=" << vout << ", nValue=" << nValue << std::endl);
+        if (vout == 0 && nValue == CC_MARKER_VALUE && myIsutxo_spentinmempool(ignoretxid,ignorevin,txid,0) == 0 &&
+            (ratio=PegsGetAccountRatio(pegstxid,tokenid,txid))>(ASSETCHAINS_PEGSCCPARAMS[2]?ASSETCHAINS_PEGSCCPARAMS[2]:PEGS_ACCOUNT_YELLOW_ZONE) && ratio>maxratio)
+        {   
+            if (myGetTransaction(txid,tx,hashBlock)!=0 && !PegsDecodeAccountTx(tx,tmppk,tmpamount,tmpaccount).empty() && tmpaccount.first>=tokenamount)
+            {
+                accounttxid=txid;
+                acctx=tx;
+                maxratio=ratio;
+            }
+        }
+    }
+    if (accounttxid!=zeroid)
+    {
+        return(PegsDecodeAccountTx(acctx,tmppk,tmpamount,account));
+    }
+    else return("");
+}
+
+UniValue PegsCreate(const CPubKey& pk,uint64_t txfee,int64_t amount, std::vector<uint256> bindtxids)
+{
+    CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
+    CPubKey mypk,pegspk; struct CCcontract_info *cp,C; CTransaction tx; int32_t numvouts; int64_t totalsupply; std::string coin;
+    char depositaddr[64]; uint256 txid,hashBlock,tmptokenid,oracletxid; uint8_t M,N,taddr,prefix,prefix2,wiftype; std::vector<CPubKey> pubkeys;
+
+    cp = CCinit(&C,EVAL_PEGS);
+    if ( txfee == 0 )
+        txfee = 10000;
+    mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
+    pegspk = GetUnspendable(cp,0);
+    for(auto txid : bindtxids)
+    {
+        if (myGetTransaction(txid,tx,hashBlock)==0 || (numvouts=tx.vout.size())<=0)
+            CCERR_RESULT("pegscc",CCLOG_INFO, stream << "cant find bindtxid " << txid.GetHex());
+        if (DecodeGatewaysBindOpRet(depositaddr,tx.vout[numvouts-1].scriptPubKey,tmptokenid,coin,totalsupply,oracletxid,M,N,pubkeys,taddr,prefix,prefix2,wiftype)!='B')
+            CCERR_RESULT("pegscc",CCLOG_INFO, stream << "invalid bindtxid " << txid.GetHex());
+    }
+    if ( AddNormalinputs(mtx,mypk,amount,64,pk.IsValid()) >= amount )
+    {
+        for (int i=0; i<100; i++) mtx.vout.push_back(MakeCC1vout(EVAL_PEGS,(amount-txfee)/100,pegspk));
+        return(FinalizeCCTxExt(pk.IsValid(),0,cp,mtx,mypk,txfee,EncodePegsCreateOpRet(bindtxids)));
+    }
+    CCERR_RESULT("pegscc",CCLOG_INFO, stream << "error adding normal inputs");
+}
+
+UniValue PegsFund(const CPubKey& pk,uint64_t txfee,uint256 pegstxid, uint256 tokenid,int64_t amount)
+{
+    CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight()); std::string coin;
+    CTransaction pegstx,tx; int32_t numvouts; int64_t totalsupply,balance=0,funds=0,tokenfunds=0; uint256 accounttxid=zeroid,hashBlock,txid,tmptokenid,oracletxid;
+    CPubKey mypk,pegspk,tmppk; struct CCcontract_info *cp,*cpTokens,CTokens,C; char depositaddr[64],coinaddr[64]; std::pair <int64_t,int64_t> account(0,0);
+    uint8_t M,N,taddr,prefix,prefix2,wiftype,mypriv[32]; std::vector<CPubKey> pubkeys; bool found=false; std::vector<uint256> bindtxids;
+
+    cp = CCinit(&C,EVAL_PEGS);
+    cpTokens = CCinit(&CTokens,EVAL_TOKENS);
     if ( txfee == 0 )
         txfee = 10000;
-    Pegspk = GetUnspendable(cp,0);
-    mypk = pubkey2pk(Mypubkey());
-    if ( (inputs= AddPegsInputs(cp,mtx,Pegspk,nValue+txfee,60)) > 0 )
-    {
-        if ( inputs > nValue )
-            CCchange = (inputs - nValue - txfee);
-        if ( CCchange != 0 )
-            mtx.vout.push_back(MakeCC1vout(EVAL_PEGS,CCchange,Pegspk));
-        mtx.vout.push_back(CTxOut(nValue,CScript() << ParseHex(HexStr(mypk)) << OP_CHECKSIG));
-        LogPrintf("start at %u\n",(uint32_t)time(NULL));
-        j = rand() & 0xfffffff;
-        for (i=0; i<1000000; i++,j++)
+    mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
+    pegspk = GetUnspendable(cp,0);
+    if (myGetTransaction(pegstxid,tx,hashBlock)==0 || (numvouts=tx.vout.size())<=0)
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "cant find pegstxid " << pegstxid.GetHex());
+    if (DecodePegsCreateOpRet(tx.vout[numvouts-1].scriptPubKey,bindtxids)!='C')
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "invalid pegstxid " << pegstxid.GetHex());
+    for(auto txid : bindtxids)
+    {
+        if (myGetTransaction(txid,tx,hashBlock)==0 || (numvouts=tx.vout.size())<=0)
+            CCERR_RESULT("pegscc",CCLOG_INFO, stream << "cant find bindtxid " << txid.GetHex());
+        if (DecodeGatewaysBindOpRet(depositaddr,tx.vout[numvouts-1].scriptPubKey,tmptokenid,coin,totalsupply,oracletxid,M,N,pubkeys,taddr,prefix,prefix2,wiftype)!='B')
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "invalid bindtxid " << txid.GetHex());
+        if (tmptokenid==tokenid)
         {
-            tmpmtx = mtx;
-            rawhex = FinalizeCCTx(-1LL,cp,tmpmtx,mypk,txfee,CScript() << OP_RETURN << E_MARSHAL(ss << (uint8_t)EVAL_PEGS << (uint8_t)'G' << j));
-            if ( (len= (int32_t)rawhex.size()) > 0 && len < 65536 )
+            found=true;
+            break;
+        }
+    }
+    if (!found)
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "invalid tokenid " << tokenid.GetHex());
+    if ((balance=GetTokenBalance(mypk,tokenid))>=amount)
+    {
+        PegsFindAccount(cp,mypk,pegstxid,tokenid,accounttxid,account);
+        LOGSTREAM("pegscc",CCLOG_DEBUG2, stream << "current accounttxid=" << accounttxid.GetHex() << " [deposit=" << account.first << ",debt=" << account.second << "]" << std::endl);
+        if (accounttxid!=zeroid && myIsutxo_spentinmempool(ignoretxid,ignorevin,accounttxid,1) != 0)
+            CCERR_RESULT("pegscc",CCLOG_INFO, stream << "previous account tx not yet confirmed");
+        if (accounttxid!=zeroid && (funds=AddPegsInputs(cp,mtx,pegspk,CPubKey(),txfee,1))>=txfee)
+        {
+            funds+=2*CC_MARKER_VALUE;
+            mtx.vin.push_back(CTxIn(accounttxid,0,CScript()));
+            Myprivkey(mypriv);
+            mtx.vin.push_back(CTxIn(accounttxid,1,CScript()));
+            GetCCaddress1of2(cp,coinaddr,mypk,pegspk);
+            CCaddr1of2set(cp,mypk,pegspk,mypriv,coinaddr);
+            memset(mypriv,0,sizeof(mypriv));
+        }
+        else funds=AddPegsInputs(cp,mtx,pegspk,CPubKey(),txfee+2*CC_MARKER_VALUE,3);
+        if (funds>=txfee+2*CC_MARKER_VALUE)
+        {
+            if ((tokenfunds=AddTokenCCInputs(cpTokens,mtx,mypk,tokenid,amount,64))>=amount)
+            {
+                mtx.vout.push_back(MakeCC1of2vout(EVAL_PEGS,CC_MARKER_VALUE,pegspk,pegspk));
+                mtx.vout.push_back(MakeCC1of2vout(EVAL_PEGS,CC_MARKER_VALUE,mypk,pegspk));
+                mtx.vout.push_back(MakeTokensCC1of2vout(EVAL_PEGS,amount,mypk,pegspk));
+                if (tokenfunds-amount>0) mtx.vout.push_back(MakeTokensCC1vout(EVAL_TOKENS,tokenfunds-amount,mypk));
+                if (funds>txfee+2*CC_MARKER_VALUE) mtx.vout.push_back(MakeCC1vout(EVAL_PEGS,funds-(txfee+2*CC_MARKER_VALUE),pegspk));
+                account.first+=amount;
+                LOGSTREAM("pegscc",CCLOG_DEBUG2, stream << "new account [deposit=" << account.first << ",debt=" << account.second << "]" << std::endl);        
+                return(FinalizeCCTxExt(pk.IsValid(),0,cp,mtx,mypk,txfee,EncodePegsFundOpRet(tokenid,pegstxid,mypk,amount,account)));
+            }
+        }
+        else
+            CCERR_RESULT("pegscc",CCLOG_INFO, stream <<"not enough balance in pegs global CC address");
+    }
+    CCERR_RESULT("pegscc",CCLOG_INFO, stream << "not enough balance (" << balance << ") for this amount of tokens " << amount);
+}
+
+UniValue PegsGet(const CPubKey& pk,uint64_t txfee,uint256 pegstxid, uint256 tokenid, int64_t amount)
+{
+    CMutableTransaction burntx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight()),mtx;
+    CTransaction pegstx,tx; int32_t numvouts; int64_t funds=0; uint256 accounttxid=zeroid,hashBlock,pricestxid; char coinaddr[64];
+    CPubKey mypk,pegspk,tmppk; struct CCcontract_info *cp,C; std::pair <int64_t,int64_t> account(0,0); uint8_t mypriv[32];
+    std::vector<uint8_t> dummyproof; std::vector<CTxOut> vouts;  std::vector<uint256> bindtxids; CScript opret;
+
+    cp = CCinit(&C,EVAL_PEGS);
+    if ( txfee == 0 )
+        txfee = 10000;
+    mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
+    pegspk = GetUnspendable(cp,0);
+    if (myGetTransaction(pegstxid,tx,hashBlock)==0 || (numvouts=tx.vout.size())<=0)
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "cant find pegstxid " << pegstxid.GetHex());
+    if (DecodePegsCreateOpRet(tx.vout[numvouts-1].scriptPubKey,bindtxids)!='C')
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "invalid pegstxid " << pegstxid.GetHex());
+    if (PegsFindAccount(cp,mypk,pegstxid,tokenid,accounttxid,account)==0)
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "cannot find account from which to issue coins, fund account first with pegsfund!");
+    if (accounttxid!=zeroid && myIsutxo_spentinmempool(ignoretxid,ignorevin,accounttxid,1) != 0)
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "previous account tx not yet confirmed");
+    LOGSTREAM("pegscc",CCLOG_DEBUG2, stream << "current accounttxid=" << accounttxid.GetHex() << " [deposit=" << account.first << ",debt=" << account.second << "]" << std::endl);
+    // spending markers
+    vouts.push_back(MakeCC1of2vout(EVAL_PEGS,CC_MARKER_VALUE,pegspk,pegspk));                
+    vouts.push_back(MakeCC1of2vout(EVAL_PEGS,CC_MARKER_VALUE,mypk,pegspk));
+    // coin issue
+    vouts.push_back(CTxOut(amount,CScript() << ParseHex(HexStr(mypk)) << OP_CHECKSIG));
+    account.second+=amount;
+    if (PegsGetRatio(tokenid,account)>PEGS_ACCOUNT_MAX_DEBT)
+    {
+        CCerror = strprintf("not possible to take more than %d%% of the deposit",PEGS_ACCOUNT_MAX_DEBT);
+        LOGSTREAM("pegscc",CCLOG_INFO, stream << CCerror << std::endl);
+        return(""); 
+    }
+    LOGSTREAM("pegscc",CCLOG_DEBUG2, stream << "new account [deposit=" << account.first << ",debt=" << account.second << "]" << std::endl);
+    // burn tx does not exist in pegs method but it must be created in order for import validation to pass
+    // fictive burntx input of previous account state tx
+    burntx.vin.push_back(CTxIn(accounttxid,0,CScript()));
+    // fictive output of coins in burn tx
+    burntx.vout.push_back(MakeBurnOutput(amount,0xffffffff,"PEGSCC",vouts,dummyproof,pegstxid,tokenid,mypk,amount,account));
+    std::vector<uint256> leaftxids;
+    BitcoinGetProofMerkleRoot(dummyproof, leaftxids);
+    MerkleBranch newBranch(0, leaftxids);
+    TxProof txProof = std::make_pair(burntx.GetHash(), newBranch);
+    mtx=MakePegsImportCoinTransaction(txProof,burntx,vouts);
+    Myprivkey(mypriv);
+    GetCCaddress1of2(cp,coinaddr,mypk,pegspk);
+    CCaddr1of2set(cp,mypk,pegspk,mypriv,coinaddr);
+    UniValue retstr = FinalizeCCTxExt(pk.IsValid(),0,cp,mtx,mypk,txfee,opret);
+    memset(mypriv,0,sizeof(mypriv));
+    return(retstr);
+}
+
+UniValue PegsRedeem(const CPubKey& pk,uint64_t txfee,uint256 pegstxid, uint256 tokenid)
+{
+    CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight()); std::string coin;
+    CTransaction pegstx,tx; int32_t numvouts; int64_t totalsupply,pegsfunds=0,funds=0,tokenfunds=0,amount; uint256 accounttxid=zeroid,hashBlock,txid,tmptokenid,oracletxid;
+    CPubKey mypk,pegspk,tmppk; struct CCcontract_info *cp,*cpTokens,CTokens,C; char depositaddr[64],coinaddr[64]; std::pair <int64_t,int64_t> account(0,0);
+    uint8_t M,N,taddr,prefix,prefix2,wiftype,mypriv[32]; std::vector<CPubKey> pubkeys; bool found=false; std::vector<uint256> bindtxids;
+
+    cp = CCinit(&C,EVAL_PEGS);
+    cpTokens = CCinit(&CTokens,EVAL_TOKENS);
+    if ( txfee == 0 )
+        txfee = 10000;
+    mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
+    pegspk = GetUnspendable(cp,0);
+    if (myGetTransaction(pegstxid,tx,hashBlock)==0 || (numvouts=tx.vout.size())<=0)
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "cant find pegstxid " << pegstxid.GetHex());
+    if (DecodePegsCreateOpRet(tx.vout[numvouts-1].scriptPubKey,bindtxids)!='C')
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "invalid pegstxid " << pegstxid.GetHex());
+    for(auto txid : bindtxids)
+    {
+        if (myGetTransaction(txid,tx,hashBlock)==0 || (numvouts=tx.vout.size())<=0)
+            CCERR_RESULT("pegscc",CCLOG_INFO, stream << "cant find bindtxid " << txid.GetHex());
+        if (DecodeGatewaysBindOpRet(depositaddr,tx.vout[numvouts-1].scriptPubKey,tmptokenid,coin,totalsupply,oracletxid,M,N,pubkeys,taddr,prefix,prefix2,wiftype)!='B')
+            CCERR_RESULT("pegscc",CCLOG_INFO, stream << "invalid bindtxid " << txid.GetHex());
+        if (tmptokenid==tokenid)
+        {
+            found=true;
+            break;
+        }
+    }
+    if (!found)
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "invalid tokenid " << tokenid.GetHex());
+    if (PegsFindAccount(cp,mypk,pegstxid,tokenid,accounttxid,account)==0)
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "cannot find account from which to redeem tokens!");
+    if (accounttxid!=zeroid && myIsutxo_spentinmempool(ignoretxid,ignorevin,accounttxid,1) != 0)
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "previous account tx not yet confirmed");
+    LOGSTREAM("pegscc",CCLOG_DEBUG2, stream << "current accounttxid=" << accounttxid.GetHex() << " [deposit=" << account.first << ",debt=" << account.second << "]" << std::endl);
+    if ((funds=AddNormalinputs(mtx,mypk,account.second,64,pk.IsValid()))>=account.second )
+    { 
+        if (accounttxid!=zeroid && (pegsfunds=AddPegsInputs(cp,mtx,pegspk,CPubKey(),txfee,1))>=txfee)
+        {
+            pegsfunds+=2*CC_MARKER_VALUE;
+            mtx.vin.push_back(CTxIn(accounttxid,0,CScript()));
+            mtx.vin.push_back(CTxIn(accounttxid,1,CScript()));
+            Myprivkey(mypriv);
+            GetCCaddress1of2(cp,coinaddr,mypk,pegspk);
+            CCaddr1of2set(cp,mypk,pegspk,mypriv,coinaddr);
+            amount=account.first;
+            if ((tokenfunds=AddPegsTokenInputs(cp,mtx,pegstxid,tokenid,mypk,pegspk,amount,64))>=amount)
             {
-                len >>= 1;
-                decode_hex(buf,len,(char *)rawhex.c_str());
-                hash = bits256_doublesha256(0,buf,len);
-                if ( (hash.bytes[0] & 0xff) == 0 && (hash.bytes[31] & 0xff) == 0 )
+                if (pegsfunds>=txfee+2*CC_MARKER_VALUE)
+                {        
+                    mtx.vout.push_back(MakeCC1of2vout(EVAL_PEGS,CC_MARKER_VALUE,pegspk,pegspk));
+                    mtx.vout.push_back(MakeCC1of2vout(EVAL_PEGS,CC_MARKER_VALUE,mypk,pegspk));
+                    mtx.vout.push_back(MakeTokensCC1vout(EVAL_TOKENS,amount,mypk));
+                    mtx.vout.push_back(CTxOut(account.second,CScript() << ParseHex(HexStr(CCtxidaddr(coinaddr,pegstxid))) << OP_CHECKSIG));
+                    if (pegsfunds>txfee+2*CC_MARKER_VALUE) mtx.vout.push_back(MakeCC1vout(EVAL_PEGS,pegsfunds-(txfee+2*CC_MARKER_VALUE),pegspk));
+                    account.first=0;
+                    account.second=0;
+                    LOGSTREAM("pegscc",CCLOG_DEBUG2, stream << "new account [deposit=" << account.first << ",debt=" << account.second << "]" << std::endl);
+                    UniValue retstr = FinalizeCCTxExt(pk.IsValid(),0,cp,mtx,mypk,txfee,EncodePegsReedemOpRet(tokenid,pegstxid,mypk,amount,account));
+                    memset(mypriv,0,32);
+                    return(retstr);
+                }
+                else
                 {
-                    LogPrintf("found valid txid after %d iterations %u\n",i,(uint32_t)time(NULL));
-                    return(rawhex);
+                    memset(mypriv,0,32);
+                    CCERR_RESULT("pegscc",CCLOG_INFO, stream << "not enough balance in pegs global CC address");
                 }
-                //LogPrintf("%02x%02x ",hash.bytes[0],hash.bytes[31]);
             }
+            memset(mypriv,0,32);
+            CCERR_RESULT("pegscc",CCLOG_INFO, stream << "not enough tokens in pegs account (" << tokenfunds << ") to redeem this amount of tokens " << account.first);
         }
-        LogPrintf("couldnt generate valid txid %u\n",(uint32_t)time(NULL));
-        return("");
-    } else LogPrintf("cant find Pegs inputs\n");
-    return("");
+        else
+        {
+            memset(mypriv,0,32);
+            CCERR_RESULT("pegscc",CCLOG_INFO, stream << "not enough balance in pegs global CC address");
+        }        
+    }
+    memset(mypriv,0,32);
+    CCERR_RESULT("pegscc",CCLOG_INFO, stream << "to redeem from account and close it you must redeem full debt ammount " << account.second << " instead of " << funds);
 }
 
-std::string PegsFund(uint64_t txfee,int64_t funds)
+
+UniValue PegsExchange(const CPubKey& pk,uint64_t txfee,uint256 pegstxid, uint256 tokenid, int64_t amount)
 {
-    CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
-    CPubKey mypk,Pegspk; CScript opret; struct CCcontract_info *cp,C;
+    CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight()); std::string coin;
+    CTransaction pegstx,tx; int32_t numvouts; int64_t totalsupply,pegsfunds=0,funds=0,tokenfunds=0,tokenamount,tmpamount; uint256 accounttxid=zeroid,hashBlock,txid,tmptokenid,oracletxid;
+    CPubKey mypk,pegspk,tmppk; struct CCcontract_info *cp,*cpTokens,CTokens,C; char depositaddr[64],coinaddr[64]; std::pair <int64_t,int64_t> account(0,0);
+    uint8_t M,N,taddr,prefix,prefix2,wiftype,mypriv[32]; std::vector<CPubKey> pubkeys; bool found=false; std::vector<uint256> bindtxids;
+
     cp = CCinit(&C,EVAL_PEGS);
+    cpTokens = CCinit(&CTokens,EVAL_TOKENS);
     if ( txfee == 0 )
         txfee = 10000;
-    mypk = pubkey2pk(Mypubkey());
-    Pegspk = GetUnspendable(cp,0);
-    if ( AddNormalinputs(mtx,mypk,funds+txfee,64) > 0 )
+    mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
+    pegspk = GetUnspendable(cp,0);
+    if (myGetTransaction(pegstxid,tx,hashBlock)==0 || (numvouts=tx.vout.size())<=0)
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "cant find pegstxid " << pegstxid.GetHex());
+    if (DecodePegsCreateOpRet(tx.vout[numvouts-1].scriptPubKey,bindtxids)!='C')
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "invalid pegstxid " << pegstxid.GetHex());
+    for(auto txid : bindtxids)
     {
-        mtx.vout.push_back(MakeCC1vout(EVAL_PEGS,funds,Pegspk));
-        return(FinalizeCCTx(0,cp,mtx,mypk,txfee,opret));
+        if (myGetTransaction(txid,tx,hashBlock)==0 || (numvouts=tx.vout.size())<=0)
+            CCERR_RESULT("pegscc",CCLOG_INFO, stream << "cant find bindtxid " << txid.GetHex());
+        if (DecodeGatewaysBindOpRet(depositaddr,tx.vout[numvouts-1].scriptPubKey,tmptokenid,coin,totalsupply,oracletxid,M,N,pubkeys,taddr,prefix,prefix2,wiftype)!='B')
+            CCERR_RESULT("pegscc",CCLOG_INFO, stream << "invalid bindtxid " << txid.GetHex());
+        if (tmptokenid==tokenid)
+        {
+            found=true;
+            break;
+        }
     }
-    return("");
+    if (!found)
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "invalid tokenid " << tokenid.GetHex());
+    if (PegsFindAccount(cp,mypk,pegstxid,tokenid,accounttxid,account)!=0)
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "you have active account, please close account first before exchanging other coins!");
+    if ((funds=AddNormalinputs(mtx,mypk,amount,64,pk.IsValid()))>=amount )
+    { 
+        if ((pegsfunds=AddPegsInputs(cp,mtx,pegspk,CPubKey(),txfee,1))>=txfee)
+        {
+            tokenamount=PegsGetTokensAmountPerPrice(amount,tokenid); 
+            tokenfunds=AddPegsTokenInputs(cp,mtx,pegstxid,tokenid,pegspk,CPubKey(),tokenamount,64);
+            if (tokenfunds<tokenamount)
+            {
+                if (PegsFindBestAccount(cp,pegstxid,tokenid,tokenamount-tokenfunds,accounttxid,account).empty())
+                    CCERR_RESULT("pegscc",CCLOG_INFO, stream << "cannot find account from which to get tokens for exchange!");
+                if (accounttxid!=zeroid && myGetTransaction(accounttxid,tx,hashBlock)==0 || (numvouts=tx.vout.size())<=0 || PegsDecodeAccountTx(tx,tmppk,tmpamount,account).empty())
+                    CCERR_RESULT("pegscc",CCLOG_INFO, stream << "invalid account tx from which to exchange coins to tokens " << accounttxid.GetHex());
+                if (accounttxid!=zeroid && myIsutxo_spentinmempool(ignoretxid,ignorevin,accounttxid,1) != 0)
+                    CCERR_RESULT("pegscc",CCLOG_INFO, stream << "previous account tx not yet confirmed");
+                tokenfunds+=AddPegsTokenInputs(cp,mtx,pegstxid,tokenid,tmppk,pegspk,tokenamount,64);
+                mtx.vin.push_back(CTxIn(accounttxid,0,CScript()));
+                mtx.vin.push_back(CTxIn(accounttxid,1,CScript()));
+                GetCCaddress1of2(cp,coinaddr,tmppk,pegspk);
+                CCaddr1of2set(cp,tmppk,pegspk,cp->CCpriv,coinaddr);
+                pegsfunds+=2*CC_MARKER_VALUE;
+            }
+            if (tokenfunds>=tokenamount)
+            {
+                if (accounttxid!=zeroid)
+                {        
+                    mtx.vout.push_back(MakeCC1of2vout(EVAL_PEGS,CC_MARKER_VALUE,pegspk,pegspk));
+                    mtx.vout.push_back(MakeCC1of2vout(EVAL_PEGS,CC_MARKER_VALUE,tmppk,pegspk));
+                }
+                if ((accounttxid!=zeroid && pegsfunds>=txfee+2*CC_MARKER_VALUE) || pegsfunds>=txfee)
+                {
+                    mtx.vout.push_back(MakeTokensCC1vout(EVAL_TOKENS,tokenamount,mypk));
+                    mtx.vout.push_back(CTxOut(amount,CScript() << ParseHex(HexStr(CCtxidaddr(coinaddr,pegstxid))) << OP_CHECKSIG));
+                    if (tokenfunds>tokenamount) mtx.vout.push_back(MakeTokensCC1of2vout(EVAL_PEGS,tokenfunds-tokenamount,tmppk,pegspk));
+                    if (accounttxid!=zeroid)
+                    {
+                        if (pegsfunds>txfee+2*CC_MARKER_VALUE) mtx.vout.push_back(MakeCC1vout(EVAL_PEGS,pegsfunds-(txfee+2*CC_MARKER_VALUE),pegspk));
+                        account.first=account.first-tokenamount;
+                        account.second=account.second-amount;
+                    }
+                    else if (pegsfunds>txfee) mtx.vout.push_back(MakeCC1vout(EVAL_PEGS,pegsfunds-txfee,pegspk));
+                    LOGSTREAM("pegscc",CCLOG_DEBUG2, stream << "modified account [deposit=" << account.first << ",debt=" << account.second << "]" << std::endl);
+                    return(FinalizeCCTxExt(pk.IsValid(),0,cp,mtx,mypk,txfee,EncodePegsExchangeOpRet(tokenid,pegstxid,mypk,tmppk,amount,account)));
+                }
+                else
+                    CCERR_RESULT("pegscc",CCLOG_INFO, stream << "not enough balance in pegs global CC address");
+            }
+            CCERR_RESULT("pegscc",CCLOG_INFO, stream << "not enough tokens in pegs account (" << tokenfunds << ") to exchange to this amount of tokens " << tokenamount);
+        }
+        else
+            CCERR_RESULT("pegscc",CCLOG_INFO, stream << "not enough balance in pegs global CC address");
+    }
+    CCERR_RESULT("pegscc",CCLOG_INFO, stream << "not enough funds to exchange " << amount << " coins to tokens - balance " << funds);
 }
 
-UniValue PegsInfo()
+UniValue PegsLiquidate(const CPubKey& pk,uint64_t txfee,uint256 pegstxid, uint256 tokenid, uint256 liquidatetxid)
 {
-    UniValue result(UniValue::VOBJ); char numstr[64];
-    CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
-    CPubKey Pegspk; struct CCcontract_info *cp,C; int64_t funding;
+    CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight()); std::string coin;
+    CTransaction pegstx,tx; int32_t numvouts; int64_t totalsupply,pegsfunds=0,funds=0,tokenfunds=0,amount,tmpamount,tokenamount,burnamount;
+    CPubKey mypk,pegspk,tmppk; struct CCcontract_info *cp,*cpTokens,CTokens,C; char depositaddr[64],coinaddr[64]; std::pair <int64_t,int64_t> account(0,0),myaccount(0,0);
+    uint8_t M,N,taddr,prefix,prefix2,wiftype; std::vector<CPubKey> pubkeys; bool found=false; std::vector<uint256> bindtxids;
+    uint256 hashBlock,txid,tmptokenid,oracletxid,accounttxid;
+
+    cp = CCinit(&C,EVAL_PEGS);
+    cpTokens = CCinit(&CTokens,EVAL_TOKENS);
+    if ( txfee == 0 )
+        txfee = 10000;
+    mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
+    pegspk = GetUnspendable(cp,0);
+    if (myGetTransaction(pegstxid,tx,hashBlock)==0 || (numvouts=tx.vout.size())<=0)
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "cant find pegstxid " << pegstxid.GetHex());
+    if (DecodePegsCreateOpRet(tx.vout[numvouts-1].scriptPubKey,bindtxids)!='C')
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "invalid pegstxid " << pegstxid.GetHex());
+   for(auto txid : bindtxids)
+    {
+        if (myGetTransaction(txid,tx,hashBlock)==0 || (numvouts=tx.vout.size())<=0)
+            CCERR_RESULT("pegscc",CCLOG_INFO, stream << "cant find bindtxid " << txid.GetHex());
+        if (DecodeGatewaysBindOpRet(depositaddr,tx.vout[numvouts-1].scriptPubKey,tmptokenid,coin,totalsupply,oracletxid,M,N,pubkeys,taddr,prefix,prefix2,wiftype)!='B')
+            CCERR_RESULT("pegscc",CCLOG_INFO, stream << "invalid bindtxid " << txid.GetHex());
+        if (tmptokenid==tokenid)
+        {
+            found=true;
+            break;
+        }
+    }
+    if (!found)
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "invalid tokenid " << tokenid.GetHex());
+    if (PegsFindAccount(cp,mypk,pegstxid,tokenid,accounttxid,myaccount)==0)
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "cannot find account, you must have an account to liquidate another account!");
+    if (accounttxid!=zeroid && myIsutxo_spentinmempool(ignoretxid,ignorevin,accounttxid,1) != 0)
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "previous account tx not yet confirmed");
+    if (PegsGetAccountRatio(pegstxid,tokenid,liquidatetxid)<(ASSETCHAINS_PEGSCCPARAMS[0]?ASSETCHAINS_PEGSCCPARAMS[0]:PEGS_ACCOUNT_RED_ZONE) || PegsGetGlobalRatio(pegstxid)<(ASSETCHAINS_PEGSCCPARAMS[1]?ASSETCHAINS_PEGSCCPARAMS[1]:PEGS_ACCOUNT_RED_ZONE))
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "not able to liquidate account until account ratio > " << (ASSETCHAINS_PEGSCCPARAMS[0]?ASSETCHAINS_PEGSCCPARAMS[0]:PEGS_ACCOUNT_RED_ZONE) << "% and global ratio > " << (ASSETCHAINS_PEGSCCPARAMS[1]?ASSETCHAINS_PEGSCCPARAMS[1]:PEGS_ACCOUNT_RED_ZONE) << "%");
+    if (liquidatetxid!=zeroid && myGetTransaction(liquidatetxid,tx,hashBlock)==0 || (numvouts=tx.vout.size())<=0 || PegsDecodeAccountTx(tx,tmppk,amount,account).empty())
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "cannot find account to liquidate or invalid tx " << liquidatetxid.GetHex());
+    if (liquidatetxid!=zeroid && myIsutxo_spentinmempool(ignoretxid,ignorevin,liquidatetxid,1) != 0)
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "previous liquidate account tx not yet confirmed");
+    LOGSTREAM("pegscc",CCLOG_DEBUG2, stream << "current accounttxid=" << accounttxid.GetHex() << " [deposit=" << account.first << ",debt=" << account.second << "]" << std::endl);
+    tokenamount=account.first;
+    burnamount=account.second;
+    tmpamount=PegsGetTokensAmountPerPrice(burnamount,tokenid)*105/100;
+    amount=tmpamount+((tokenamount-tmpamount)*10/100);
+    if ((funds=AddNormalinputs(mtx,mypk,account.second,64))>=burnamount)
+    { 
+        if (liquidatetxid!=zeroid && (pegsfunds=AddPegsInputs(cp,mtx,pegspk,CPubKey(),txfee,1))>=txfee)
+        {
+            pegsfunds+=2*CC_MARKER_VALUE;
+            mtx.vin.push_back(CTxIn(liquidatetxid,0,CScript()));
+            mtx.vin.push_back(CTxIn(liquidatetxid,1,CScript()));
+            GetCCaddress1of2(cp,coinaddr,tmppk,pegspk);
+            CCaddr1of2set(cp,tmppk,pegspk,cp->CCpriv,coinaddr);            
+            if ((tokenfunds=AddPegsTokenInputs(cp,mtx,pegstxid,tokenid,tmppk,pegspk,tokenamount,64))==tokenamount)
+            {
+                if (pegsfunds>=txfee+2*CC_MARKER_VALUE)
+                {        
+                    mtx.vout.push_back(MakeCC1of2vout(EVAL_PEGS,CC_MARKER_VALUE,pegspk,pegspk));
+                    mtx.vout.push_back(MakeCC1of2vout(EVAL_PEGS,CC_MARKER_VALUE,tmppk,pegspk));
+                    mtx.vout.push_back(MakeTokensCC1vout(EVAL_TOKENS,amount,mypk));
+                    mtx.vout.push_back(MakeTokensCC1vout(EVAL_PEGS,tokenamount-amount,pegspk));
+                    mtx.vout.push_back(CTxOut(burnamount,CScript() << ParseHex(HexStr(CCtxidaddr(coinaddr,pegstxid))) << OP_CHECKSIG));
+                    if (pegsfunds>txfee+2*CC_MARKER_VALUE) mtx.vout.push_back(MakeCC1vout(EVAL_PEGS,pegsfunds-(txfee+2*CC_MARKER_VALUE),pegspk));
+                    account.first=0;
+                    account.second=0;
+                    LOGSTREAM("pegscc",CCLOG_DEBUG2, stream << "new account [deposit=" << account.first << ",debt=" << account.second << "]" << std::endl);
+                    return(FinalizeCCTxExt(pk.IsValid(),0,cp,mtx,mypk,txfee,EncodePegsLiquidateOpRet(tokenid,pegstxid,mypk,amount,account)));
+                }
+                CCERR_RESULT("pegscc",CCLOG_INFO, stream << "not enough balance in pegs global CC address");
+            }
+            CCERR_RESULT("pegscc",CCLOG_INFO, stream << "tokens amount in pegs account " << tokenfunds << " not matching amount in account " << account.first); // this shouldn't happen
+        }
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "not enough balance in pegs global CC address");
+    }
+    CCERR_RESULT("pegscc",CCLOG_INFO, stream << "not enough funds to liquidate account, you must liquidate full debt ammount " << txfee+account.second << " instead of " << funds);
+}
+
+UniValue PegsAccountHistory(const CPubKey& pk,uint256 pegstxid)
+{
+    char coinaddr[64]; int64_t nValue,amount; uint256 txid,accounttxid,hashBlock,tmptokenid,tmppegstxid;
+    CTransaction tx; int32_t numvouts,vout; char funcid; CPubKey mypk,pegspk,tmppk; std::map<uint256,std::pair<int64_t,int64_t>> accounts;
+    std::vector<uint256> txids; std::pair<int64_t,int64_t> account; std::vector<uint256> bindtxids;
+    UniValue result(UniValue::VOBJ),acc(UniValue::VARR); struct CCcontract_info *cp,C;
+
+    if (myGetTransaction(pegstxid,tx,hashBlock)==0 || (numvouts=tx.vout.size())<=0)
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "cant find pegstxid " << pegstxid.GetHex());
+    if (DecodePegsCreateOpRet(tx.vout[numvouts-1].scriptPubKey,bindtxids)!='C')
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "invalid pegstxid " << pegstxid.GetHex());
+    result.push_back(Pair("result","success"));
+    result.push_back(Pair("name","pegsaccounthistory"));
+    cp = CCinit(&C,EVAL_PEGS);
+    mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
+    pegspk = GetUnspendable(cp,0);
+    GetCCaddress1of2(cp,coinaddr,mypk,pegspk);
+    SetCCtxids(txids,coinaddr,true,EVAL_PEGS,pegstxid,0);
+    for (std::vector<uint256>::const_iterator it=txids.begin(); it!=txids.end(); it++)
+    {
+        txid = *it;
+        if (myGetTransaction(txid,tx,hashBlock) != 0 && (numvouts=tx.vout.size())>0 &&
+            (funcid=DecodePegsOpRet(tx,tmppegstxid,tmptokenid))!=0 && pegstxid==tmppegstxid)
+        {
+            UniValue obj(UniValue::VOBJ);
+            obj.push_back(Pair("action",PegsDecodeAccountTx(tx,tmppk,amount,account)));
+            obj.push_back(Pair("amount",amount));
+            obj.push_back(Pair("accounttxid",txid.GetHex()));
+            obj.push_back(Pair("token",PegsGetTokenName(tmptokenid)));                
+            obj.push_back(Pair("deposit",account.first));
+            obj.push_back(Pair("debt",account.second));
+            acc.push_back(obj);         
+        }
+    }
+    result.push_back(Pair("account history",acc));    
+    return(result);
+}
+
+UniValue PegsAccountInfo(const CPubKey& pk,uint256 pegstxid)
+{
+    char coinaddr[64]; int64_t nValue,amount; uint256 txid,accounttxid,hashBlock,tmptokenid,tmppegstxid; std::map<uint256,std::pair<int64_t,int64_t>> accounts;
+    CTransaction tx; int32_t numvouts,vout; char funcid; CPubKey mypk,pegspk,tmppk; std::vector<uint256> bindtxids;
+    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs; std::pair<int64_t,int64_t> account; 
+    UniValue result(UniValue::VOBJ),acc(UniValue::VARR); struct CCcontract_info *cp,C;
+
+    if (myGetTransaction(pegstxid,tx,hashBlock)==0 || (numvouts=tx.vout.size())<=0)
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "cant find pegstxid " << pegstxid.GetHex());
+    if (DecodePegsCreateOpRet(tx.vout[numvouts-1].scriptPubKey,bindtxids)!='C')
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "invalid pegstxid " << pegstxid.GetHex());
+    result.push_back(Pair("result","success"));
+    result.push_back(Pair("name","pegsaccountinfo"));
+    cp = CCinit(&C,EVAL_PEGS);
+    mypk = pk.IsValid()?pk:pubkey2pk(Mypubkey());
+    pegspk = GetUnspendable(cp,0);
+    GetCCaddress1of2(cp,coinaddr,mypk,pegspk);
+    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 = (int64_t)it->second.satoshis;
+        //LOGSTREAM("pegscc",CCLOG_DEBUG2, stream << "txid=" << txid.GetHex() << ", vout=" << vout << ", nValue=" << nValue << std::endl);
+        if (vout == 1 && nValue == CC_MARKER_VALUE && myGetTransaction(txid,tx,hashBlock) != 0 && (numvouts=tx.vout.size())>0 &&
+            (funcid=DecodePegsOpRet(tx,tmppegstxid,tmptokenid))!=0 && pegstxid==tmppegstxid)
+        {
+            //LOGSTREAM("pegscc",CCLOG_DEBUG2, stream << "txid=" << txid.GetHex() << ", vout=" << vout << ", nValue=" << nValue << ", tokenid=" << tmptokenid.GetHex() << std::endl);
+            PegsDecodeAccountTx(tx,tmppk,amount,account);           
+            accounts[tmptokenid].first=account.first;
+            accounts[tmptokenid].second=account.second;
+        }
+    }
+    for (std::map<uint256,std::pair<int64_t,int64_t>>::iterator it = accounts.begin(); it != accounts.end(); ++it)
+    {
+        UniValue obj(UniValue::VOBJ);
+        obj.push_back(Pair("token",PegsGetTokenName(it->first)));
+        obj.push_back(Pair("deposit",accounts[it->first].first));
+        obj.push_back(Pair("debt",accounts[it->first].second));
+        if (accounts[it->first].first==0 || accounts[it->first].second==0 || PegsGetTokenPrice(it->first)<=0) obj.push_back(Pair("ratio",0));
+        else obj.push_back(Pair("ratio",strprintf("%.2f%%",PegsGetRatio(it->first,accounts[it->first]))));         
+        acc.push_back(obj);
+    }
+    result.push_back(Pair("account info",acc));    
+    return(result);
+}
+
+UniValue PegsWorstAccounts(uint256 pegstxid)
+{
+    char coinaddr[64]; int64_t nValue,amount; uint256 txid,accounttxid,hashBlock,tmppegstxid,tokenid,prev;
+    CTransaction tx; int32_t numvouts,vout; char funcid; CPubKey pegspk,pk; double ratio; std::vector<uint256> bindtxids;
+    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs; std::pair<int64_t,int64_t> account;
+    UniValue result(UniValue::VOBJ),acc(UniValue::VARR); struct CCcontract_info *cp,C; std::multimap<uint256,UniValue> map;
+
+    if (myGetTransaction(pegstxid,tx,hashBlock)==0 || (numvouts=tx.vout.size())<=0)
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "cant find pegstxid " << pegstxid.GetHex());
+    if (DecodePegsCreateOpRet(tx.vout[numvouts-1].scriptPubKey,bindtxids)!='C')
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "invalid pegstxid " << pegstxid.GetHex());
     result.push_back(Pair("result","success"));
-    result.push_back(Pair("name","Pegs"));
+    result.push_back(Pair("name","pegsworstaccounts"));
     cp = CCinit(&C,EVAL_PEGS);
-    Pegspk = GetUnspendable(cp,0);
-    funding = AddPegsInputs(cp,mtx,Pegspk,0,0);
-    sprintf(numstr,"%.8f",(double)funding/COIN);
-    result.push_back(Pair("funding",numstr));
+    pegspk = GetUnspendable(cp,0);
+    GetCCaddress1of2(cp,coinaddr,pegspk,pegspk);
+    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 = (int64_t)it->second.satoshis;
+        if (vout == 0 && nValue == CC_MARKER_VALUE && myGetTransaction(txid,tx,hashBlock) != 0 && (numvouts=tx.vout.size())>0 &&
+            (funcid=DecodePegsOpRet(tx,tmppegstxid,tokenid))!=0 && pegstxid==tmppegstxid)
+        {               
+            PegsDecodeAccountTx(tx,pk,amount,account);
+            if (account.first==0 || account.second==0 || PegsGetTokenPrice(tokenid)<=0) ratio=0;
+            else ratio=PegsGetRatio(tokenid,account);
+            if (ratio>PEGS_ACCOUNT_RED_ZONE)
+            {
+                UniValue obj(UniValue::VOBJ);
+                obj.push_back(Pair("accounttxid",txid.GetHex()));
+                obj.push_back(Pair("deposit",account.first));
+                obj.push_back(Pair("debt",account.second));
+                obj.push_back(Pair("ratio",strprintf("%.2f%%",ratio)));                
+                map.insert(std::pair<uint256,UniValue>(tokenid,obj));
+            }
+        }
+    }
+    std::multimap<uint256,UniValue>::iterator it = map.begin();
+    for (prev=it->first; it != map.end(); ++it)
+    {
+        if (it->first!=prev)
+        {
+            result.push_back(Pair(PegsGetTokenName(prev),acc));
+            acc.clear();
+            prev=it->first;
+        }
+        acc.push_back(it->second);
+    }
+    result.push_back(Pair(PegsGetTokenName(prev),acc));
     return(result);
 }
 
+UniValue PegsInfo(uint256 pegstxid)
+{
+    char coinaddr[64]; int64_t nValue,amount; uint256 txid,accounttxid,hashBlock,tmppegstxid,tokenid;
+    CTransaction tx; int32_t numvouts,vout; char funcid; CPubKey pegspk,pk; std::vector<uint256> bindtxids;
+    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs; std::pair<int64_t,int64_t> account;
+    std::map<uint256,std::pair<int64_t,int64_t>> globalaccounts; double globaldeposit=0;
+    UniValue result(UniValue::VOBJ),acc(UniValue::VARR); struct CCcontract_info *cp,C;
+
+    if (myGetTransaction(pegstxid,tx,hashBlock)==0 || (numvouts=tx.vout.size())<=0)
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "cant find pegstxid " << pegstxid.GetHex());
+    if (DecodePegsCreateOpRet(tx.vout[numvouts-1].scriptPubKey,bindtxids)!='C')
+        CCERR_RESULT("pegscc",CCLOG_INFO, stream << "invalid pegstxid " << pegstxid.GetHex());
+    result.push_back(Pair("result","success"));
+    result.push_back(Pair("name","pegsinfo"));
+    cp = CCinit(&C,EVAL_PEGS);
+    pegspk = GetUnspendable(cp,0);
+    GetCCaddress1of2(cp,coinaddr,pegspk,pegspk);
+    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 = (int64_t)it->second.satoshis;
+        if (vout == 0 && nValue == CC_MARKER_VALUE && myGetTransaction(txid,tx,hashBlock) != 0 && (numvouts=tx.vout.size())>0 &&
+            (funcid=DecodePegsOpRet(tx,tmppegstxid,tokenid))!=0 && pegstxid==tmppegstxid)
+        {               
+            PegsDecodeAccountTx(tx,pk,amount,account);
+            globalaccounts[tokenid].first+=account.first;
+            globalaccounts[tokenid].second+=account.second;
+        }
+    }
+    unspentOutputs.clear();
+    GetTokensCCaddress(cp,coinaddr,pegspk);
+    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 = (int64_t)it->second.satoshis;
+        if (myGetTransaction(txid,tx,hashBlock) != 0 && (numvouts=tx.vout.size())>0 && DecodePegsOpRet(tx,tmppegstxid,tokenid)!=0 && pegstxid==tmppegstxid)
+        {
+            globalaccounts[tokenid].first+=nValue;
+        }
+    }
+    for (std::map<uint256,std::pair<int64_t,int64_t>>::iterator it = globalaccounts.begin(); it != globalaccounts.end(); ++it)
+    {
+        UniValue obj(UniValue::VOBJ);
+        obj.push_back(Pair("token",PegsGetTokenName(it->first)));
+        obj.push_back(Pair("total deposit",globalaccounts[it->first].first));
+        obj.push_back(Pair("total debt",globalaccounts[it->first].second));
+        if (globalaccounts[it->first].first==0 || globalaccounts[it->first].second==0 || PegsGetTokenPrice(it->first)<=0) obj.push_back(Pair("total ratio",0));
+        else obj.push_back(Pair("total ratio",strprintf("%.2f%%",PegsGetRatio(it->first,globalaccounts[it->first]))));                
+        acc.push_back(obj);
+    }
+    result.push_back(Pair("info",acc));
+    result.push_back(Pair("global ratio",strprintf("%.2f%%",PegsGetGlobalRatio(pegstxid))));
+    return(result);
+}
diff --git a/src/cc/prices.cpp b/src/cc/prices.cpp
index 97c6ba30..9b0e7873 100644
--- a/src/cc/prices.cpp
+++ b/src/cc/prices.cpp
@@ -590,7 +590,7 @@ int64_t AddPricesInputs(struct CCcontract_info *cp, CMutableTransaction &mtx, ch
         vout = (int32_t)it->first.index;
         //if (vout == exclvout && txid == excltxid)  // exclude vout which is added directly to vins outside this function
         //    continue;
-        if (GetTransaction(txid, vintx, hashBlock, false) != 0 && vout < vintx.vout.size())
+        if (myGetTransaction(txid, vintx, hashBlock) != 0 && vout < vintx.vout.size())
         {
             vscript_t vopret;
             uint8_t funcId = PricesCheckOpret(vintx, vopret);
@@ -2161,7 +2161,7 @@ UniValue PricesList(uint32_t filter, CPubKey mypk)
         std::vector<uint16_t> vec;
         CTransaction vintx;
 
-        if (GetTransaction(txid, vintx, hashBlock, false) != 0)
+        if (myGetTransaction(txid, vintx, hashBlock) != 0)
         {
 
             // TODO: forget old tx
diff --git a/src/cc/rewards.cpp b/src/cc/rewards.cpp
index 6b893da4..44f68a3f 100644
--- a/src/cc/rewards.cpp
+++ b/src/cc/rewards.cpp
@@ -65,11 +65,19 @@
  vout.n-1: opreturn 'U' sbits fundingtxid
  
  */
-
-int64_t RewardsCalc(int64_t amount,uint256 txid,uint64_t APR,uint64_t minseconds,uint64_t maxseconds,uint64_t mindeposit)
+ 
+/// the following are compatible with windows
+/// mpz_set_lli sets a long long singed int to a big num mpz_t for very large integer math
+extern void mpz_set_lli( mpz_t rop, long long op );
+// mpz_get_si2 gets a mpz_t and returns a signed long long int
+extern int64_t mpz_get_si2( mpz_t op );
+// mpz_get_ui2 gets a mpz_t and returns a unsigned long long int
+extern uint64_t mpz_get_ui2( mpz_t op );
+ 
+uint64_t RewardsCalc(int64_t amount, uint256 txid, int64_t APR, int64_t minseconds, int64_t maxseconds, uint32_t timestamp)
 {
-    int32_t numblocks; uint64_t duration,reward = 0;
-    //LogPrintf("minseconds %llu maxseconds %llu\n",(long long)minseconds,(long long)maxseconds);
+    int32_t numblocks; int64_t duration; uint64_t reward = 0;
+    //fprintf(stderr,"minseconds %llu maxseconds %llu\n",(long long)minseconds,(long long)maxseconds);
     if ( (duration= CCduration(numblocks,txid)) < minseconds )
     {
         LogPrintf("duration %llu < minseconds %llu\n",(long long)duration,(long long)minseconds);
@@ -77,12 +85,42 @@ int64_t RewardsCalc(int64_t amount,uint256 txid,uint64_t APR,uint64_t minseconds
         //duration = (uint32_t)time(NULL) - (1532713903 - 3600 * 24);
     } else if ( duration > maxseconds )
         duration = maxseconds;
-    if ( 0 ) // amount * APR * duration / COIN * 100 * 365*24*3600
+    /* if ( 0 ) // amount * APR * duration / COIN * 100 * 365*24*3600
         reward = (((amount * APR) / COIN) * duration) / (365*24*3600LL * 100);
     else reward = (((amount * duration) / (365 * 24 * 3600LL)) * (APR / 1000000)) / 10000;
+    */
+    if ( !komodo_hardfork_active(timestamp) )
+        reward = (((amount * duration) / (365 * 24 * 3600LL)) * (APR / 1000000)) / 10000;
+    else 
+    {
+        // declare and init the mpz_t big num variables 
+        mpz_t mpzAmount, mpzDuration, mpzReward, mpzAPR, mpzModifier;
+        mpz_init(mpzAmount);
+        mpz_init(mpzDuration);
+        mpz_init(mpzAPR);
+        mpz_init(mpzReward);
+        mpz_init(mpzModifier);
+
+        // set the inputs to big num variables
+        mpz_set_lli(mpzAmount, amount);
+        mpz_set_lli(mpzDuration, duration);
+        mpz_set_lli(mpzAPR, APR);
+        mpz_set_lli(mpzModifier, COIN*100*365*24*3600LL);
+
+        // (amount * APR * duration)
+        mpz_mul(mpzReward, mpzAmount, mpzDuration);
+        mpz_mul(mpzReward, mpzReward, mpzAPR);
+
+        // total_of_above / (COIN * 100 * 365*24*3600LL)
+        mpz_tdiv_q(mpzReward, mpzReward, mpzModifier);
+
+        // set result to variable we can use and return it.
+        reward = mpz_get_ui2(mpzReward);
+    }
     if ( reward > amount )
         reward = amount;
-    LogPrintf("amount %.8f %.8f %llu -> duration.%llu reward %.8f vals %.8f %.8f\n",(double)amount/COIN,((double)amount * APR)/COIN,(long long)((amount * APR) / (COIN * 365*24*3600)),(long long)duration,(double)reward/COIN,(double)((amount * duration) / (365 * 24 * 3600LL))/COIN,(double)(((amount * duration) / (365 * 24 * 3600LL)) * (APR / 1000000))/COIN);
+    LogPrintf("amount.%lli duration.%lli APR.%lli reward.%llu\n", (long long)amount, (long long)duration, (long long)APR, (long long)reward);
+    //fprintf(stderr,"amount %.8f %.8f %llu -> duration.%llu reward %.8f vals %.8f %.8f\n",(double)amount/COIN,((double)amount * APR)/COIN,(long long)((amount * APR) / (COIN * 365*24*3600)),(long long)duration,(double)reward/COIN,(double)((amount * duration) / (365 * 24 * 3600LL))/COIN,(double)(((amount * duration) / (365 * 24 * 3600LL)) * (APR / 1000000))/COIN);
     return(reward);
 }
 
@@ -259,7 +297,7 @@ bool RewardsValidate(struct CCcontract_info *cp,Eval* eval,const CTransaction &t
                     if ( !CheckTxFee(tx, txfee, chainActive.LastTip()->GetHeight(), chainActive.LastTip()->nTime, dummy) )
                         return eval->Invalid("txfee is too high");
                     amount = vinTx.vout[0].nValue;
-                    reward = RewardsCalc(amount,tx.vin[0].prevout.hash,APR,minseconds,maxseconds,mindeposit);
+                    reward = RewardsCalc((int64_t)amount,tx.vin[0].prevout.hash,(int64_t)APR,(int64_t)minseconds,(int64_t)maxseconds,GetLatestTimestamp(eval->GetCurrentHeight()));
                     if ( reward == 0 )
                         return eval->Invalid("no eligible rewards");
                     if ( numvins == 1 && tx.vout[0].scriptPubKey.IsPayToCryptoCondition() == 0 )
@@ -357,7 +395,7 @@ int64_t AddRewardsInputs(CScript &scriptPubKey,uint64_t maxseconds,struct CCcont
                 break;
         if ( j != mtx.vin.size() )
             continue;
-        if ( GetTransaction(txid,tx,hashBlock,false) != 0 && tx.vout.size() > 0 && tx.vout[vout].scriptPubKey.IsPayToCryptoCondition() != 0 && myIsutxo_spentinmempool(ignoretxid,ignorevin,txid,vout) == 0 )
+        if ( myGetTransaction(txid,tx,hashBlock) != 0 && tx.vout.size() > 0 && tx.vout[vout].scriptPubKey.IsPayToCryptoCondition() != 0 && myIsutxo_spentinmempool(ignoretxid,ignorevin,txid,vout) == 0 )
         {
             if ( (funcid= DecodeRewardsOpRet(txid,tx.vout[tx.vout.size()-1].scriptPubKey,sbits,fundingtxid)) != 0 )
             {
@@ -409,7 +447,7 @@ int64_t RewardsPlanFunds(uint64_t &lockedfunds,uint64_t refsbits,struct CCcontra
     {
         txid = it->first.txhash;
         vout = (int32_t)it->first.index;
-        if ( GetTransaction(txid,tx,hashBlock,false) != 0 && tx.vout[vout].scriptPubKey.IsPayToCryptoCondition() != 0 )
+        if ( myGetTransaction(txid,tx,hashBlock) != 0 && tx.vout[vout].scriptPubKey.IsPayToCryptoCondition() != 0 )
         {
             if ( (funcid= DecodeRewardsOpRet(txid,tx.vout[tx.vout.size()-1].scriptPubKey,sbits,fundingtxid)) == 'F' || funcid == 'A' || funcid == 'U' || funcid == 'L' )
             {
@@ -432,14 +470,14 @@ int64_t RewardsPlanFunds(uint64_t &lockedfunds,uint64_t refsbits,struct CCcontra
 bool RewardsPlanExists(struct CCcontract_info *cp,uint64_t refsbits,CPubKey rewardspk,uint64_t &APR,uint64_t &minseconds,uint64_t &maxseconds,uint64_t &mindeposit)
 {
     char CCaddr[64]; uint64_t sbits; uint256 txid,hashBlock; CTransaction tx;
-    std::vector<std::pair<CAddressIndexKey, CAmount> > txids;
+    std::vector<uint256> txids;
     GetCCaddress(cp,CCaddr,rewardspk);
-    SetCCtxids(txids,CCaddr,true);
-    for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=txids.begin(); it!=txids.end(); it++)
+    SetCCtxids(txids,CCaddr,true,cp->evalcode,zeroid,'F');
+    for (std::vector<uint256>::const_iterator it=txids.begin(); it!=txids.end(); it++)
     {
         //int height = it->first.blockHeight;
-        txid = it->first.txhash;
-        if ( GetTransaction(txid,tx,hashBlock,false) != 0 && tx.vout.size() > 0 && ConstrainVout(tx.vout[0],1,CCaddr,0) != 0 )
+        txid = *it;
+        if ( myGetTransaction(txid,tx,hashBlock) != 0 && tx.vout.size() > 0 && ConstrainVout(tx.vout[0],1,CCaddr,0) != 0 )
         {
             //char str[65]; LogPrintf("rewards plan %s\n",uint256_str(str,txid));
             if ( DecodeRewardsFundingOpRet(tx.vout[tx.vout.size()-1].scriptPubKey,sbits,APR,minseconds,maxseconds,mindeposit) == 'F' )
@@ -455,7 +493,7 @@ bool RewardsPlanExists(struct CCcontract_info *cp,uint64_t refsbits,CPubKey rewa
 UniValue RewardsInfo(uint256 rewardsid)
 {
     UniValue result(UniValue::VOBJ); uint256 hashBlock; CTransaction vintx; uint64_t lockedfunds,APR,minseconds,maxseconds,mindeposit,sbits,funding; CPubKey rewardspk; struct CCcontract_info *cp,C; char str[67],numstr[65];
-    if ( GetTransaction(rewardsid,vintx,hashBlock,false) == 0 )
+    if ( myGetTransaction(rewardsid,vintx,hashBlock) == 0 )
     {
         LogPrintf("cant find fundingtxid\n");
         result.push_back(Pair("result","error"));
@@ -492,13 +530,13 @@ UniValue RewardsInfo(uint256 rewardsid)
 
 UniValue RewardsList()
 {
-    UniValue result(UniValue::VARR); std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex; struct CCcontract_info *cp,C; uint256 txid,hashBlock; CTransaction vintx; uint64_t sbits,APR,minseconds,maxseconds,mindeposit; char str[65];
+    UniValue result(UniValue::VARR); std::vector<uint256> txids; struct CCcontract_info *cp,C; uint256 txid,hashBlock; CTransaction vintx; uint64_t sbits,APR,minseconds,maxseconds,mindeposit; char str[65];
     cp = CCinit(&C,EVAL_REWARDS);
-    SetCCtxids(addressIndex,cp->normaladdr,false);
-    for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=addressIndex.begin(); it!=addressIndex.end(); it++)
+    SetCCtxids(txids,cp->normaladdr,false,cp->evalcode,zeroid,'F');
+    for (std::vector<uint256>::const_iterator it=txids.begin(); it!=txids.end(); it++)
     {
-        txid = it->first.txhash;
-        if ( GetTransaction(txid,vintx,hashBlock,false) != 0 )
+        txid = *it;
+        if ( myGetTransaction(txid,vintx,hashBlock) != 0 )
         {
             if ( vintx.vout.size() > 0 && DecodeRewardsFundingOpRet(vintx.vout[vintx.vout.size()-1].scriptPubKey,sbits,APR,minseconds,maxseconds,mindeposit) != 0 )
             {
@@ -657,7 +695,7 @@ std::string RewardsUnlock(uint64_t txfee,char *planstr,uint256 fundingtxid,uint2
             CCerror = "locktxid/v0 is spent";
             return("");
         }
-        if ( GetTransaction(locktxid,tx,hashBlock,false) != 0 && tx.vout.size() > 0 && tx.vout[1].scriptPubKey.IsPayToCryptoCondition() == 0 )
+        if ( myGetTransaction(locktxid,tx,hashBlock) != 0 && tx.vout.size() > 0 && tx.vout[1].scriptPubKey.IsPayToCryptoCondition() == 0 )
         {
             scriptPubKey = tx.vout[1].scriptPubKey;
             mtx.vin.push_back(CTxIn(locktxid,0,CScript()));
@@ -671,7 +709,7 @@ std::string RewardsUnlock(uint64_t txfee,char *planstr,uint256 fundingtxid,uint2
     }
     if ( amount > txfee )
     {
-        reward = RewardsCalc(amount,mtx.vin[0].prevout.hash,APR,minseconds,maxseconds,mindeposit);
+        reward = RewardsCalc((int64_t)amount,mtx.vin[0].prevout.hash,(int64_t)APR,(int64_t)minseconds,(int64_t)maxseconds,komodo_chainactive_timestamp());
         if ( scriptPubKey.size() > 0 )
         {
             if ( reward > txfee )
diff --git a/src/cc/rogue_rpc.cpp b/src/cc/rogue_rpc.cpp
index aa622ef0..f0ae9d1a 100644
--- a/src/cc/rogue_rpc.cpp
+++ b/src/cc/rogue_rpc.cpp
@@ -962,7 +962,8 @@ UniValue rogue_keystrokes(uint64_t txfee,struct CCcontract_info *cp,cJSON *param
                     Myprivkey(mypriv);
                     CCaddr1of2set(cp,roguepk,mypk,mypriv,destaddr);
                     rawtx = FinalizeCCTx(0,cp,mtx,mypk,txfee,rogue_keystrokesopret(gametxid,batontxid,mypk,keystrokes));
-                    //LogPrintf("KEYSTROKES.(%s)\n",rawtx.c_str());
+                    //fprintf(stderr,"KEYSTROKES.(%s)\n",rawtx.c_str());
+                    memset(mypriv,0,32);
                     return(rogue_rawtxresult(result,rawtx,1));
                 } else return(cclib_error(result,"keystrokes tx was too late"));
             } else return(cclib_error(result,"couldnt find batontxid"));
@@ -1330,6 +1331,7 @@ UniValue rogue_finishgame(uint64_t txfee,struct CCcontract_info *cp,cJSON *param
                         GetOpReturnData(opret, vopretNonfungible);
                         rawtx = FinalizeCCTx(0, cp, mtx, mypk, txfee, EncodeTokenCreateOpRet('c', Mypubkey(), std::string(seedstr), gametxid.GetHex(), vopretNonfungible));
                     }
+                    memset(mypriv,0,32);
                     return(rogue_rawtxresult(result,rawtx,1));
                 }
                 result.push_back(Pair("result","success"));
@@ -1450,15 +1452,15 @@ UniValue rogue_players(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
 UniValue rogue_games(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
 {
     UniValue result(UniValue::VOBJ),a(UniValue::VARR),b(UniValue::VARR); uint256 txid,hashBlock,gametxid,tokenid,playertxid; int32_t vout,maxplayers,gameheight,numvouts; CPubKey roguepk,mypk; char coinaddr[64]; CTransaction tx,gametx; int64_t buyin;
-    std::vector<std::pair<CAddressIndexKey, CAmount> > addressIndex;
+    std::vector<uint256> txids;
     //std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
     roguepk = GetUnspendable(cp,0);
     mypk = pubkey2pk(Mypubkey());
     GetCCaddress1of2(cp,coinaddr,roguepk,mypk);
     //SetCCunspents(unspentOutputs,coinaddr);
-    SetCCtxids(addressIndex,coinaddr,true);
+    SetCCtxids(txids,coinaddr,true,cp->evalcode,zeroid,'R');
     rogue_univalue(result,"games",-1,-1);
-    for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=addressIndex.begin(); it!=addressIndex.end(); it++)
+    for (std::vector<uint256>::const_iterator it=txids.begin(); it!=txids.end(); it++)
     //for (std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> >::const_iterator it=unspentOutputs.begin(); it!=unspentOutputs.end(); it++)
     {
         txid = it->first.txhash;
diff --git a/src/cc/sudoku.cpp b/src/cc/sudoku.cpp
index 4fffd2df..7be7a923 100644
--- a/src/cc/sudoku.cpp
+++ b/src/cc/sudoku.cpp
@@ -2730,7 +2730,7 @@ UniValue sudoku_txidinfo(uint64_t txfee,struct CCcontract_info *cp,cJSON *params
             decode_hex((uint8_t *)&txid,32,txidstr);
             txid = revuint256(txid);
             result.push_back(Pair("txid",txid.GetHex()));
-            if ( GetTransaction(txid,tx,hashBlock,false) != 0 && (numvouts= tx.vout.size()) > 1 )
+            if ( myGetTransaction(txid,tx,hashBlock) != 0 && (numvouts= tx.vout.size()) > 1 )
             {
                 if ( sudoku_genopreturndecode(unsolved,tx.vout[numvouts-1].scriptPubKey) == 'G' )
                 {
@@ -2780,7 +2780,7 @@ UniValue sudoku_pending(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
         //char str[65]; LogPrintf("%s check %s/v%d %.8f\n",coinaddr,uint256_str(str,txid),vout,(double)it->second.satoshis/COIN);
         if ( it->second.satoshis != txfee || vout != 0 )
             continue;
-        if ( GetTransaction(txid,tx,hashBlock,false) != 0 && (numvouts= tx.vout.size()) > 1 )
+        if ( myGetTransaction(txid,tx,hashBlock) != 0 && (numvouts= tx.vout.size()) > 1 )
         {
             if ( (nValue= IsCClibvout(cp,tx,vout,coinaddr)) == txfee && myIsutxo_spentinmempool(ignoretxid,ignorevin,txid,vout) == 0 )
             {
@@ -2861,7 +2861,7 @@ UniValue sudoku_solution(uint64_t txfee,struct CCcontract_info *cp,cJSON *params
                             result.push_back(Pair("txid",txid.GetHex()));
                             if ( CCgettxout(txid,0,1,0) < 0 )
                                 result.push_back(Pair("error","already solved"));
-                            else if ( GetTransaction(txid,tx,hashBlock,false) != 0 && (numvouts= tx.vout.size()) > 1 )
+                            else if ( myGetTransaction(txid,tx,hashBlock) != 0 && (numvouts= tx.vout.size()) > 1 )
                             {
                                 Getscriptaddress(checkaddr,tx.vout[1].scriptPubKey);
                                 if ( strcmp(checkaddr,CCaddr) != 0 )
diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index 12a667fe..72734093 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -89,7 +89,7 @@ static CBlock CreateGenesisBlock(uint32_t nTime, const uint256& nNonce, const st
  *    timestamp before)
  * + Contains no strange transactions
  */
-void *chainparams_commandline(void *ptr);
+void *chainparams_commandline();
 #include "komodo_defs.h"
 int32_t ASSETCHAINS_BLOCKTIME = 60;
 uint64_t ASSETCHAINS_NK[2];
@@ -182,10 +182,7 @@ class CMainParams : public CChainParams {
         assert(genesis.hashMerkleRoot == uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
         vFixedSeeds.clear();
         vSeeds.clear();
-        vSeeds.push_back(CDNSSeedData("veruscoin.io", "seeds.veruscoin.io")); // @kolo - old static dns seeds
-        vSeeds.push_back(CDNSSeedData("komodoplatform.com", "seeds.komodoplatform.com")); // @kolo - old static dns seeds
-        vSeeds.push_back(CDNSSeedData("kolo.supernet.org", "static.kolo.supernet.org")); // @kolo - new static dns seeds ToDo
-        vSeeds.push_back(CDNSSeedData("kolo.supernet.org", "dynamic.kolo.supernet.org")); // @kolo - crawler seeds ToDo
+        vSeeds.push_back(CDNSSeedData("komodoseeds.com", "kmd.komodoseeds.com")); // @kolo, static dns seeds revised
         // TODO: set up bootstrapping for mainnet
         base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,60);
         base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,85);
@@ -211,11 +208,6 @@ class CMainParams : public CChainParams {
         fRequireStandard = true;
         fMineBlocksOnDemand = false;
         fTestnetToBeDeprecatedFieldRPC = false;
-
-        if ( pthread_create((pthread_t *)malloc(sizeof(pthread_t)),NULL,chainparams_commandline,(void *)&consensus) != 0 )
-        {
-
-        }
     }
 };
 
@@ -244,337 +236,6 @@ void CChainParams::SetCheckpointData(CChainParams::CCheckpointData checkpointDat
 
 */
 
-int32_t MAX_BLOCK_SIZE(int32_t height)
-{
-    int32_t saplinght = mainParams.consensus.vUpgrades[Consensus::UPGRADE_SAPLING].nActivationHeight;
-    //LogPrintf("MAX_BLOCK_SIZE %d vs. %d\n",height,mainParams.consensus.vUpgrades[Consensus::UPGRADE_SAPLING].nActivationHeight);
-    if ( height <= 0 || (saplinght > 0 && height >= saplinght) )
-    {
-        return(_MAX_BLOCK_SIZE);
-    }
-    else return(2000000);
-}
-
-void komodo_setactivation(int32_t height)
-{
-    mainParams.consensus.vUpgrades[Consensus::UPGRADE_SAPLING].nActivationHeight = height;
-    mainParams.consensus.vUpgrades[Consensus::UPGRADE_OVERWINTER].nActivationHeight = height;
-    ASSETCHAINS_SAPLING = height;
-    LogPrintf("SET SAPLING ACTIVATION height.%d\n",height);
-}
-
-void *chainparams_commandline(void *ptr)
-{
-    CChainParams::CCheckpointData checkpointData;
-    while ( ASSETCHAINS_P2PPORT == 0 )
-    {
-        #ifdef _WIN32
-        boost::this_thread::sleep(boost::posix_time::milliseconds(1000));
-        #else
-        sleep(1);
-        #endif
-    }
-    //LogPrintf(">>>>>>>> port.%u\n",ASSETCHAINS_P2PPORT);
-    if ( ASSETCHAINS_SYMBOL[0] != 0 )
-    {
-        if ( ASSETCHAINS_BLOCKTIME != 60 )
-        {
-            mainParams.consensus.nMaxFutureBlockTime = 7 * ASSETCHAINS_BLOCKTIME; // 7 blocks
-            mainParams.consensus.nPowTargetSpacing = ASSETCHAINS_BLOCKTIME;
-        }
-        mainParams.SetDefaultPort(ASSETCHAINS_P2PPORT);
-        if ( ASSETCHAINS_NK[0] != 0 && ASSETCHAINS_NK[1] != 0 )
-        {
-            //BOOST_STATIC_ASSERT(equihash_parameters_acceptable(ASSETCHAINS_NK[0], ASSETCHAINS_NK[1]));
-            mainParams.SetNValue(ASSETCHAINS_NK[0]);
-            mainParams.SetKValue(ASSETCHAINS_NK[1]);
-        }
-        if ( KOMODO_TESTNODE != 0 )
-            mainParams.SetMiningRequiresPeers(false);
-        if ( ASSETCHAINS_RPCPORT == 0 )
-            ASSETCHAINS_RPCPORT = ASSETCHAINS_P2PPORT + 1;
-        mainParams.pchMessageStart[0] = ASSETCHAINS_MAGIC & 0xff;
-        mainParams.pchMessageStart[1] = (ASSETCHAINS_MAGIC >> 8) & 0xff;
-        mainParams.pchMessageStart[2] = (ASSETCHAINS_MAGIC >> 16) & 0xff;
-        mainParams.pchMessageStart[3] = (ASSETCHAINS_MAGIC >> 24) & 0xff;
-        LogPrintf(">>>>>>>>>> %s: p2p.%u rpc.%u magic.%08x %u %u coins\n",ASSETCHAINS_SYMBOL,ASSETCHAINS_P2PPORT,ASSETCHAINS_RPCPORT,ASSETCHAINS_MAGIC,ASSETCHAINS_MAGIC,(uint32_t)ASSETCHAINS_SUPPLY);
-        if (ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASH) 
-        {
-            // this is only good for 60 second blocks with an averaging window of 45. for other parameters, use:
-            // nLwmaAjustedWeight = (N+1)/2 * (0.9989^(500/nPowAveragingWindow)) * nPowTargetSpacing
-            mainParams.consensus.nLwmaAjustedWeight = 1350;
-            mainParams.consensus.nPowAveragingWindow = 45;
-            mainParams.consensus.powAlternate = uint256S("00000f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f");
-        }
-        else if (ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASHV1_1)
-        {
-            // this is only good for 60 second blocks with an averaging window of 45. for other parameters, use:
-            // nLwmaAjustedWeight = (N+1)/2 * (0.9989^(500/nPowAveragingWindow)) * nPowTargetSpacing
-            mainParams.consensus.nLwmaAjustedWeight = 1350;
-            mainParams.consensus.nPowAveragingWindow = 45;
-            mainParams.consensus.powAlternate = uint256S("0000000f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f");
-        }
-
-        if (ASSETCHAINS_LWMAPOS != 0)
-        {
-            mainParams.consensus.posLimit = uint256S("000000000f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f");
-            mainParams.consensus.nPOSAveragingWindow = 45;
-            // spacing is 1000 units per block to get better resolution, POS is 50% hard coded for now, we can vary it later
-            // when we get reliable integer math on nLwmaPOSAjustedWeight
-            mainParams.consensus.nPOSTargetSpacing = VERUS_BLOCK_POSUNITS * 2;
-            // nLwmaPOSAjustedWeight = (N+1)/2 * (0.9989^(500/nPOSAveragingWindow)) * nPOSTargetSpacing
-            // this needs to be recalculated if VERUS_BLOCK_POSUNITS is changed
-            mainParams.consensus.nLwmaPOSAjustedWeight = 46531;
-        }
-
-        // only require coinbase protection on Verus from the Komodo family of coins
-        if (strcmp(ASSETCHAINS_SYMBOL,"VRSC") == 0)
-        {
-            mainParams.consensus.vUpgrades[Consensus::UPGRADE_SAPLING].nActivationHeight = 227520;
-            mainParams.consensus.vUpgrades[Consensus::UPGRADE_OVERWINTER].nActivationHeight = 227520;
-            mainParams.consensus.fCoinbaseMustBeProtected = true;
-            checkpointData = //(Checkpoints::CCheckpointData)
-                {
-                    boost::assign::map_list_of
-                    (0, mainParams.consensus.hashGenesisBlock)
-                    (10000, uint256S("0xac2cd7d37177140ea4991cf630c0b9c7f94d707b84fb0351bf3a44856d2ae5dc"))
-                    (20000, uint256S("0xb0e8cb9f77aaa7ff5bd90d6c08d06f4c4bf03e00c2b8a35a042e760845590c8a"))
-                    (30000, uint256S("0xf2112ca577338ad7104bf905fa6a63d36b17a86f914c97b73cd31d43fcd7557c"))
-                    (40000, uint256S("0x00000000008f83378dab727864b763ce91a4ea5f75d55939c0c1390cfb8c38f1"))
-                    (49170, uint256S("0x2add646c0089871ec2379f02f7cd60b3af6efd9c152a6f16fc10925458c270cc")),
-                    (int64_t)1529910234,    // * UNIX timestamp of last checkpoint block
-                    (int64_t)63661,         // * total number of transactions between genesis and last checkpoint
-                                            //   (the tx=... number in the SetBestChain debug.log lines)
-                    (double)2777            // * estimated number of transactions per day after checkpoint
-                                            //   total number of tx / (checkpoint block height / (24 * 24))
-                };
-
-            mainParams.consensus.nMinimumChainWork = uint256S("0x000000000000000000000000000000000000000000000001a8f4f23f8b2d1f7e");
-        }
-        else
-        {
-            if (strcmp(ASSETCHAINS_SYMBOL,"VRSCTEST") == 0 || strcmp(ASSETCHAINS_SYMBOL,"VERUSTEST") == 0)
-            {
-                mainParams.consensus.nMinimumChainWork = uint256S("0x0000000000000000000000000000000000000000000000000000000000001f7e");
-            }
-            mainParams.consensus.vUpgrades[Consensus::UPGRADE_SAPLING].nActivationHeight = ASSETCHAINS_SAPLING;
-            mainParams.consensus.vUpgrades[Consensus::UPGRADE_OVERWINTER].nActivationHeight = ASSETCHAINS_OVERWINTER;
-            checkpointData = //(Checkpoints::CCheckpointData)
-                {
-                    boost::assign::map_list_of
-                    (0, mainParams.consensus.hashGenesisBlock),
-                    (int64_t)1231006505,
-                    (int64_t)1,
-                    (double)2777            // * estimated number of transactions per day after checkpoint
-                                            //   total number of tx / (checkpoint block height / (24 * 24))
-                };
-        }
-    }
-    else
-    {
-            /*
-            checkpointData = //(Checkpoints::CCheckpointData)
-            {
-                boost::assign::map_list_of
-
-                (0, mainParams.consensus.hashGenesisBlock)
-                (	5000,	uint256S("0x049cfc91eef411e96603a42c9a77c5e30e9fe96f783ab818f4c00fb56fb29b6c"))
-                (	10000,	uint256S("0x0a0169db3614311cd4181deb73cfcf7f640e7dc956cda34e0121a0351925e9ae"))
-                (	15000,	uint256S("0x00f0bd236790e903321a2d22f85bd6bf8a505f6ef4eddb20458a65d37e14d142"))
-                (	20000,	uint256S("0x01bbf0c38892bdcced62b538329cf63bc7badca3e7e1bff8eb10345436871c6e"))
-                (	25000,	uint256S("0x04ca27808268dda8f942b647a6df844be1b263a661a13740293db962022d1f9e"))
-                (	30000,	uint256S("0x04c9e8cfbcd37399085e529b50147de8afb80c76c48752c122d56f23316a7acb"))
-                (	35000,	uint256S("0x00815f1240354cff7487c67f7dff78e248cb9053ed2c92751d1a9ad42d3eaedf"))
-                (	40000,	uint256S("0x00eafd9dfb1e5f1bf1cca0c49be628538900daf69b665464443d29c2c3b6a2fe"))
-                (	45000,	uint256S("0x0377730632caf694b92f40d03ae0fbe5bd86a1205014b71d975453ac793b0af9"))
-                (	50000,	uint256S("0x00076e16d3fa5194da559c17cf9cf285e21d1f13154ae4f7c7b87919549345aa"))
-                (	55000,	uint256S("0x0005a0701a83e05b639418ea4c87018544a4d22b2b49e5f111161e8ffc455108"))
-                (	60000,	uint256S("0x0000296fc15f8599b7c6561d0e0a96f24766135ed79107b603d6dd6e55142c0d"))
-                (	65000,	uint256S("0x000861f5d7970d5399733b4605074d47f877d6536f74ffae6f08e871ee29e6f2"))
-                (	70000,	uint256S("0x0002af1d487c567526c517b52996944dca344e139cddca77c2e72f746e73b263"))
-                (	75000,	uint256S("0x0d08129659be5f105e70c047769359eaf3475d61a726750859fdca3e1a2bf5cc"))
-                (	80000,	uint256S("0x0af5f3f1caae4f08c74a82689731d1ef8e55107c06f9a996e251b8ecb96989ad"))
-                (	85000,	uint256S("0x00000c8ee29086c5fb39eddad0619773b9ce936c77c13e5e5118a4998e939544"))
-                (	90000,	uint256S("0x06d3bb7f9ee5b55f67b2dc13c680699a2f736f43a44b4e4cfd41a58aa00f063f"))
-                (	95000,	uint256S("0x0670981b269879aae83a88f6f0c4db34763c93fd410d96435f2acb4e6580b976"))
-                (	100000,	uint256S("0x0f02eb1f3a4b89df9909fec81a4bd7d023e32e24e1f5262d9fc2cc36a715be6f"))
-                (	105000,	uint256S("0x018b97d7e6d259add24afe0e08fc125dc21d734e8831b68b430f5c3896deb4af"))
-                (	110000,	uint256S("0x09644ff52734e0e911a9ba7ecd03cf7995b25301840a9637891ef9af69f59c32"))
-                (	115000,	uint256S("0x0ee382b4729b8ceb918a92913f9c144a6a4f8a50bfc0f8b4aac5b12592caed7f"))
-                (	120000,	uint256S("0x082a7918a0dd9cb2df65f55acb8d0a4a535b3fa684d92c3ebcb24ed7019d975b"))
-                (	125000,	uint256S("0x00008f76c4484fd539c9d02fc69c40a50b6f9e00984d33890b85cc0324159e9e"))
-                (	130000,	uint256S("0x011b09e53acfe46f310e8c960a9c4f4f490cc7b2cd3791d7a6a80d6e8ac96b36"))
-                (	135000,	uint256S("0x01e0cd48358fa05646baa6f00e26717474d6049a537c8861b324d1f497dc3d4a"))
-                (	140000,	uint256S("0x0e6db36fd8a9d1b7baf359c8bd5c76635d0bcada973a75b5d2028ca3baea4961"))
-                (	145000,	uint256S("0x00010c40b57316ce6cde076807c9db956452a3c82cb09fe7d56c6bb1a7e24726"))
-                (	150000,	uint256S("0x0a817f15b9da636f453a7a01835cfc534ed1a55ce7f08c566471d167678bedce"))
-                (	155000,	uint256S("0x0528084fd00223bd9747635d7a4d8cc79f158795cad654efb78e4e4cc5f23d6a"))
-                (	160000,	uint256S("0x00003a09f26ae9fb7ebbfa3ef589b81ccd8909a82430f7414bc68d5a5a3316ab"))
-                (	165000,	uint256S("0x00004a0c6a29e7d1f22ea4e44d05e861fec5fcd8eebc5a61574c4ecf29dbb9be"))
-                (	170000,	uint256S("0x0cf9eac27badc0ae9a2b370dd7cc3fcb550f139349551e60978f394a2e1b262b"))
-                (	175000,	uint256S("0x0000137856b825d431da27ff4c3cf22f5482fa21952d45b0db0ec6774fb9b510"))
-                (	180000,	uint256S("0x000000b0afcccf98aa0afb6ac61050892bd9415857d66313d1f67fd1bbac312f"))
-                (	185000,	uint256S("0x00c2af8f88d84de080067f8ae1c25754e32e5516d20c11f85b9adae2d683687b"))
-                (	190000,	uint256S("0x00000033d85b3e7d19e02278ef300b8ab957d3dd3e58b4c81166ba0a58af5c3f"))
-                (	195000,	uint256S("0x000000964b6068be1dd4ee6893d183e86cba82a2744fb5439c463d0ba7e053b6"))
-                (	200000,	uint256S("0x000001763a9337328651ca57ac487cc0507087be5838fb74ca4165ff19f0e84f"))
-                (	205000,	uint256S("0x049fc6832e64a75ae898b32804e151e7561ea49082858c3d4af89a7de4b82f06"))
-                (	210000,	uint256S("0x0000000d9078b9c9604cc663eafafba8f3643bb3f3ddbb78fed4993236e1edb5"))
-                (	215000,	uint256S("0x00060089ecc21bcc62094e2f7f0448fe163415f6ef2f2aafe047757889ca82fe"))
-                (	220000,	uint256S("0x000082c78e6c2a13a9c23dd7a6faaf962fc133142b4a2d07725561f59c03bfa2"))
-                (	225000,	uint256S("0x00030026483167fe13505cf27049307ce42e0d9c5aa093aed10baa4f49edf4ca"))
-                (	230000,	uint256S("0x000183a3e17988060a35776b99c1f0b43393bbe7153b2718dfc57f428191de4e"))
-                (	235000,	uint256S("0x000184995f0ec024ed3783e322c8cfa5e68d9f0c77c3aaea301b22d311619156"))
-                (	240000,	uint256S("0x0000002cc7cf6d0a44ab57f9bd3bfa11a865bbf1cd87a2081095bc90981633a3"))
-                (	245000,	uint256S("0x004c5f19a88c8fe8a604006dbd2d44c94baef2a00876a17d8e2be2124003f979"))
-                (	250000,	uint256S("0x0dd54ef5f816c7fde9d2b1c8c1a26412b3c761cc5dd3901fa5c4cd1900892fba"))
-                (	255000,	uint256S("0x0b6da9e4f50c8bc7a92c539bc7474ffd6c29e0a8531f0dbbbc261fff1f990827"))
-                (	260000,	uint256S("0x0cac8b12bf7233ee5a68fcde9e251852b177833fefa2a9f39ec28474b0851cb9"))
-                (	265000,	uint256S("0x04feb5b4029f3b8b8eb3e6661a78eadd1a26b4af00ac59b5f05b261afcfd2818"))
-                (	270000,	uint256S("0x01bc5897bd20b8b61acf4989987ba85fbc37d9ebe848924aa8effcb08bf48fe0"))
-                (	275000,	uint256S("0x0416bc29eb5a12231826e546ba90fcd38aeef387ff77b45849cd418a9c1a6f12"))
-                (	280000,	uint256S("0x000007593e9880b171d46bce59aa0cec2a1b1f53d1fd7e8f71ccb2b9182374a4"))
-                (	285000,	uint256S("0x05a338b2d90cd79740221fe8635b7a834f2e486fcbb2464a4294f5a21231a5f5"))
-                (	290000,	uint256S("0x064ca3912cdcd833702d07a530e98bc5c6c1cd738a8825c7240b17cd68ca0cc4"))
-                (	295000,	uint256S("0x036b3bb318d743fd78db983a9aadd52869991d48913c4eebe2a074387d67cc5a"))
-                (	300000,	uint256S("0x000000fa5efd1998959926047727519ed7de06dcf9f2cd92a4f71e907e1312dc"))
-                (	305000,	uint256S("0x00003656231e83de2348755153ed175794696a113d7e8a15c01f90fdb7c2f287"))
-                (	310000,	uint256S("0x0cf6baf727eb931da0813ed8b032648c4766be79e146b0d40c643f9d8edf40f7"))
-                (	315000,	uint256S("0x082469974c152ebe69f1787f0d06aa5d9dd1dc69c880febde7eac2bc800146dd"))
-                (	320000,	uint256S("0x0000063df36b99bfb2516f55cb548a5baed1f2d8ae69c3559dc478c5c2eb32df"))
-                (	325000,	uint256S("0x0cb926b303a1514ba0a2f729af88ccb143517f396e9e0bde09b0736900698e0f"))
-                (	330000,	uint256S("0x000000be3d8bb6e31c3b534819aae7014cbbe9a44ab3e799dc1bfc724c6ab184"))
-                (	335000,	uint256S("0x0d0756608189fd5bbd8ec50e76180074e69e973439cc09df49134e4cb970ed4d"))
-                (	340000,	uint256S("0x0d814eacdb9c97003d703c0ff79b1b97b9ed8615fe12b1afaede946e5fdfe0a7"))
-                (	345000,	uint256S("0x000000c2910f510f1de325d300202da1a391f2719dd378173299151c3da94e85"))
-                (	350000,	uint256S("0x0000000228ef321323f81dae00c98d7960fc7486fb2d881007fee60d1e34653f"))
-                (	355000,	uint256S("0x03e6a55e382b478e0fab9c3584da3629fd9b977986a333a406b24b0d3559bf44"))
-                (	360000,	uint256S("0x0859c86dd718bcb5b58af06389197794e2beea6239653f2e6fa7b8a7433d29ea"))
-                (	365000,	uint256S("0x07896332665c707a8f55398a998e7878e8d2681ba79dd95c2859b1dafc9343d0"))
-                (	370000,	uint256S("0x040efd8c64cf5cf96ecf75468741a8880d1386eb5e349bef0a55116d4023944c"))
-                (	375000,	uint256S("0x053029e7599a09fe6c01203997d7ca738dd4c6d216a433695a0d514def1eccc0"))
-                (	380000,	uint256S("0x0cae44e7a421c389b88a5a204d3e39779e93aeacaab1b693741bf279fd0c8acd"))
-                (	385000,	uint256S("0x0b4032d2c799ba93644231ce57134dd24e13ec0dc267c1ed5912389691d2bd72"))
-                (	390000,	uint256S("0x0afd0f166f33a881ef289af7ea7010d58c4bbd560dee10b561c79e1b8dfd0593"))
-                (	395000,	uint256S("0x083774b88cf1b138d67c242d9b33c54f69d7e901b5e8144dc4a2303ab9927102"))
-                (	400000,	uint256S("0x036d294c5be96f4c0efb28e652eb3968231e87204a823991a85c5fdab3c43ae6"))
-                (	405000,	uint256S("0x0522e33bb2161fb1b33acef9a4a438fcf420dcae8a0b472e234d223d731c42b2"))
-                (	410000,	uint256S("0x0361d06aa807c66b87befea8119a485341d1118b694c3dbb4c3cf0b85ac69e9b"))
-                (	415000,	uint256S("0x072d5653d8673f64ef8b9c655f7b8021072070a072b799013ff6e96de99a59e6"))
-                (	420000,	uint256S("0x013b693d66955be69d4501cb1d307ca323a5c8473e25866ae7e700cdce0c654f"))
-                (	425000,	uint256S("0x0ef0c55af27c6971289a790dee2b2ec728fb9c6555ff9306c07f1083cf0fb4b5"))
-                (	430000,	uint256S("0x0ccbeeaba28291e0316a9cf54c005097c61dc67ba6f32283406d6c83b828da00"))
-                (	435000,	uint256S("0x020ed6b7fe1124400baba7feed463ba0c90e7e6903493fdc1a1a18c4a506055a"))
-                (	440000,	uint256S("0x055aaadca1908abeedc831a3f9115aa31284fc223d010590caf7b612960b61a4"))
-                (	445000,	uint256S("0x06d2327fa25ea7e2be742fc0e45fc4f9adb41811f21be0357f8543c5434df715"))
-                (	450000,	uint256S("0x0906ef1e8dc194f1f03bd4ce1ac8c6992fd721ef2c5ccbf4871ec8cdbb456c18"))
-                (	455000,	uint256S("0x0b8b92eec29eb20262dcf9916f0ca36d6abf0c39d321d3f480a5535cb978db71"))
-                (	460000,	uint256S("0x0cb04591f69a255b1127aaff3bbd59eaa21a5d9cca999de197516c251895c536"))
-                (	465000,	uint256S("0x029985ae78d8bb8fd170aeb3ab02ea76134ed0c19ae00211cc28a61fe5755b88"))
-                (	470000,	uint256S("0x01a2f4b56f37b223e75572862ad1ba956ec179332f8cd40590d7253563c86ba8"))
-                (	475000,	uint256S("0x0a34c6f9d4d9cb8c78c14b8041a7cc1874cfcbb22a34a5c068d1d6ff3ed9fdf0"))
-                (	480000,	uint256S("0x0ebab25030179996ae25969f34f6a297c7ffce1994f9b4186082a47032a9a7dc"))
-                (	485000,	uint256S("0x06a096e6bccf3b85537a30f95db6a414deacc0509bc84da264c2830df1a1d9b0"))
-                (	490000,	uint256S("0x0af828930ef13405cb536b88a3d1d4e0d84dc79ee260402c56bfa86e261c74ff"))
-                (	495000,	uint256S("0x09d44905bfd12849d3c2178b2ba882f8e9d6565b6e4d7a97c70a92bd6de7c5e6"))
-                (	500000,	uint256S("0x0bebdb417f7a51fe0c36fcf94e2ed29895a9a862eaa61601272866a7ecd6391b"))
-                (	505000,	uint256S("0x0c1609f4f3561baa1fc975877948af94d2107c88686a9821bc240016cc87d953"))
-                (	510000,	uint256S("0x0cf9a5a4997b871e615e5e398627e45fa15b3e6970ae22b47bdd11b0f5fa0fa7"))
-                (	515000,	uint256S("0x034171d4819e9961de13309743a32a179abede97d60ea64101dc04c97a1a0807"))
-                (	520000,	uint256S("0x0648fa44d5bbc2cc04a782e083c11df64ac06185f0f8e11a7416625ebb6409a6"))
-                (	525000,	uint256S("0x0000000ef17d63af3159e52cd351b6f000536ad88adc3a937bb747955fed58a2"))
-                (	530000,	uint256S("0x08e3af153995ba09e50086b64145cf4cd57db6b29f16f06f28d80d7f6121cfad"))
-                (	535000,	uint256S("0x02a0ffd00b51e2061b85de50a9223d9c84f4e357dc1046397bb9d7d4a827a3fb"))
-                (	540000,	uint256S("0x04bf07d026af29025c1ac2815e067f4a41d2872701ac9780eb3015d51cdcd854"))
-                (	545000,	uint256S("0x0a0d6d86635946792ad0dca57ed227a5360fc8b6d79e47132aac11e90a4963ce"))
-                (	550000,	uint256S("0x06df52fc5f9ba03ccc3a7673b01ab47990bd5c4947f6e1bc0ba14d21cd5bcccd"))
-                (	555000,	uint256S("0x0baf38eea8e08fcad3a9d760f27377e79c291b08e7fb4920cadd5cb7bab547f3"))
-                (	560000,	uint256S("0x00000004c34abbf1366adbae965b644c01debf15409acc715ff51cb221d92dd7"))
-                (	565000,	uint256S("0x067bae7119f083e0fa1820bc8e25dcfa7717e42aabaef18beefd87d974953dfb"))
-                (	570000,	uint256S("0x00000011a7ce7b628b7be17777d8dea2574d83f165e23c9e44aa705975820fd3"))
-                (	575000,	uint256S("0x0e1110a193a30d3f8d369017233a2486b11c748b3d033859a2eb7b37062d303e"))
-                (	580000,	uint256S("0x083cb58484aff80f48e3537e0451d49e544b3efa3da97274800c91e567d33a92"))
-                (	585000,	uint256S("0x0224cf835428d03472edf4f7b6fcc63b9d8d6f1d5a90ad8186bf123d541b4ea8"))
-                (	590000,	uint256S("0x0cfcf3b9517894e4df49db5faf8b74f3a9e01eb83c0cc5051c115d4424615dae"))
-                (	595000,	uint256S("0x0000000a45266983dd81e0df381a3b0455699b2f76d5b4d3f17b87d657a1b56d"))
-                (	600000,	uint256S("0x00000005080d5689c3b4466e551cd1986e5d2024a62a79b1335afe12c42779e4"))
-                (	605000,	uint256S("0x0000001c691da36848542299af859d4eb3fa408a0f425b1fbe6d622d2100623a"))
-                (	610000,	uint256S("0x040d8c7a0ac89e3ed8605a198583a795986aacbf18722a9897d7b925bcf757f6"))
-                (	615000,	uint256S("0x0449cf00fc36206389c14cbf1d762f8b96bb0440ccea5b46703e7c69b0e2bc42"))
-                (	620000,	uint256S("0x07227a41340c25ee1a7e9b60414259780202ffa990079fc91d8faeac9af03e60"))
-                (	625000,	uint256S("0x047c2472fe2afabb3d38decf24bba4ba712b60e7a1782f4afae3ede3f912f493"))
-                (	630000,	uint256S("0x0a7f1f04e66260cf972ab1374a9126b8abc1adaa3ab4669db5d4d4ddb9ad493d"))
-                (	635000,	uint256S("0x048df95165eb821dabf37ef28cf7f3be72e216e95377684253dab806985b50a4"))
-                (	640000,	uint256S("0x066b3c6a6a3c8dc58bef509a972c3e3ade14493b40e1b361ecbc928134e302be"))
-                (	645000,	uint256S("0x07d059888c9ade3bbe16d6b4d70ee9b8302d104b37a3c6cd61f81012aabd0e1e"))
-                (	650000,	uint256S("0x039a3cb760cc6e564974caf69e8ae621c14567f3a36e4991f77fd869294b1d52"))
-                (	655000,	uint256S("0x089350ee8d28b44837eb4b1fe77704953d5de2077f10c74a888d9d3ea1e13c2a"))
-                (	660000,	uint256S("0x000000023f8a582a61ae2f6fab6fe8197e79b7a68aaac67432421b09f1bdd4ba"))
-                (	665000,	uint256S("0x0b16edce865e7a0d662115774e0c0d3abbf9c69004155b693ddc933f051bfb26"))
-                (	670000,	uint256S("0x09070b109b089490bc372fd8358abae352d6db0e46ade6ed2200e4d4ff7aa6af"))
-                (	675000,	uint256S("0x08d9edeed3b6ac55991e9f32af0218ff8fa9dc808078623f4c831eb09d4f186b"))
-                (	680000,	uint256S("0x00000003eb2b30bfac929d3496acecab19625ac9f854a86aaf9678bea99e1cc1"))
-                (	681777,	uint256S("0x0000243296b9b26c040f471fdd9398ef72e57062cf05c19b9ba2fefac8165306")),
-                (int64_t)1516924927,     // * UNIX timestamp of last checkpoint block
-                (int64_t)1253783,         // * total number of transactions between genesis and last checkpoint
-                                //   (the tx=... number in the SetBestChain debug.log lines)
-                (double)2777            // * estimated number of transactions per day after checkpoint
-                                //   total number of tx / (checkpoint block height / (24 * 24))
-            };
-            */
-
-            checkpointData = // (Checkpoints::CCheckpointData)
-            {
-                boost::assign::map_list_of
-
-                (0, mainParams.consensus.hashGenesisBlock)
-                (	50000,	uint256S("0x00076e16d3fa5194da559c17cf9cf285e21d1f13154ae4f7c7b87919549345aa"))
-                (	100000,	uint256S("0x0f02eb1f3a4b89df9909fec81a4bd7d023e32e24e1f5262d9fc2cc36a715be6f"))
-                (	150000,	uint256S("0x0a817f15b9da636f453a7a01835cfc534ed1a55ce7f08c566471d167678bedce"))
-                (	200000,	uint256S("0x000001763a9337328651ca57ac487cc0507087be5838fb74ca4165ff19f0e84f"))
-                (	250000,	uint256S("0x0dd54ef5f816c7fde9d2b1c8c1a26412b3c761cc5dd3901fa5c4cd1900892fba"))
-                (	300000,	uint256S("0x000000fa5efd1998959926047727519ed7de06dcf9f2cd92a4f71e907e1312dc"))
-                (	350000,	uint256S("0x0000000228ef321323f81dae00c98d7960fc7486fb2d881007fee60d1e34653f"))
-                (	400000,	uint256S("0x036d294c5be96f4c0efb28e652eb3968231e87204a823991a85c5fdab3c43ae6"))
-                (	450000,	uint256S("0x0906ef1e8dc194f1f03bd4ce1ac8c6992fd721ef2c5ccbf4871ec8cdbb456c18"))
-                (	500000,	uint256S("0x0bebdb417f7a51fe0c36fcf94e2ed29895a9a862eaa61601272866a7ecd6391b"))
-                (	550000,	uint256S("0x06df52fc5f9ba03ccc3a7673b01ab47990bd5c4947f6e1bc0ba14d21cd5bcccd"))
-                (	600000,	uint256S("0x00000005080d5689c3b4466e551cd1986e5d2024a62a79b1335afe12c42779e4"))
-                (	650000,	uint256S("0x039a3cb760cc6e564974caf69e8ae621c14567f3a36e4991f77fd869294b1d52"))
-                (	700000,	uint256S("0x00002285be912b2b887a5bb42d2f1aa011428c565b0ffc908129c47b5ce87585"))
-                (	750000,	uint256S("0x04cff4c26d185d591bed3613ce15e1d15d9c91dd8b98a6729f89c58ce4bd1fd6"))
-                (	800000,	uint256S("0x0000000617574d402fca8e6570f0845bd5fe449398b318b4e1f65bc69cdd6606"))
-                (	850000,	uint256S("0x044199301f37194f20ba7b498fc72ed742f6c0ba6e476f28d6c81d225e58d5ce"))
-                (	900000,	uint256S("0x08bdbe4de2a65ac89fd2913192d05362c900e3af476a0c99d9f311875067451e"))
-                (	950000,	uint256S("0x0000000aa9a44b593e6138f247bfae75bd43b9396ef9ff0a6a3ebd852f131806"))
-                (	1000000,	uint256S("0x0cb1d2457eaa58af5028e86e27ac54578fa09558206e7b868ebd35e7005ed8bb"))
-                (	1050000,	uint256S("0x044d49bbc3bd9d32b6288b768d4f7e0afe3cbeda606f3ac3579a076e4bddf6ae"))
-                (	1100000,	uint256S("0x000000050cad04887e170059dd2556d85bbd20390b04afb9b07fb62cafd647b4"))
-                (	1150000,	uint256S("0x0c85501c759d957dd1ccc5f7fdfcc415c89c7f2a26471fffc75b75f79e63c16a"))
-                (	1200000,	uint256S("0x0763cbf43ed7227988081c29d9e9fc7ab2450216e6d0354cc4596c86689702d4"))
-                (	1250000,	uint256S("0x0489640207f8c343a56a10e45d987516059ea82a3c6859a771b3a9cf94f5c3bb"))
-                (	1300000,	uint256S("0x000000012a01709b254b4f75e2b9ed772d8fe558655c8c859892ca8c9d625e87"))
-                (	1350000,	uint256S("0x075a1a5c66a68b47d9848ca6986687ed2665b1852457051bf142208e62f98a60"))
-                (	1400000,	uint256S("0x055f73dd9b20650c3d6e6dbb606af8d9479e4c81d89430867abff5329f167bb2"))
-                (	1450000,	uint256S("0x014c2926e07e9712211c5e82f05df1b802c59cc8bc24e3cc9b09942017080f2d"))
-                (	1500000,	uint256S("0x0791f892210ce3c513ab607d689cd1e8907a27f3dfeb58dec21ae299b7981cb7"))
-                (	1550000,	uint256S("0x08fcbaffb7164b161a25efc6dd5c70b679498ee637d663fe201a55c7decc37a3"))
-                (	1600000,	uint256S("0x0e577dcd49319a67fe2acbb39ae6d46afccd3009d3ba9d1bcf6c624708e12bac"))
-                (	1615921,	uint256S("0x049140623cc54a4a3d5868f720611e180ba0cafa21eab1edd0bc9ec2e6b7c374")),
-                1573604104,     // * UNIX timestamp of last checkpoint block
-                7371665,         // * total number of transactions between genesis and last checkpoint
-                                //   (the tx=... number in the SetBestChain debug.log lines)
-                2777            // * estimated number of transactions per day after checkpoint
-                                //   total number of tx / (checkpoint block height / (24 * 24))
-            };
-    }
-
-    mainParams.SetCheckpointData(checkpointData);
-
-    ASSETCHAIN_INIT = 1;
-    return(0);
-}
-
 /**
  * Testnet (v3)
  */
@@ -872,3 +533,176 @@ void UpdateNetworkUpgradeParameters(Consensus::UpgradeIndex idx, int nActivation
 {
     regTestParams.UpdateNetworkUpgradeParameters(idx, nActivationHeight);
 }
+
+int32_t MAX_BLOCK_SIZE(int32_t height)
+{
+    int32_t saplinght = pCurrentParams->consensus.vUpgrades[Consensus::UPGRADE_SAPLING].nActivationHeight;
+    //fprintf(stderr,"MAX_BLOCK_SIZE %d vs. %d\n",height,mainParams.consensus.vUpgrades[Consensus::UPGRADE_SAPLING].nActivationHeight);
+    if ( height <= 0 || (saplinght > 0 && height >= saplinght) )
+    {
+        return(_MAX_BLOCK_SIZE);
+    }
+    else return(2000000);
+}
+
+void komodo_setactivation(int32_t height)
+{
+    pCurrentParams->consensus.vUpgrades[Consensus::UPGRADE_SAPLING].nActivationHeight = height;
+    pCurrentParams->consensus.vUpgrades[Consensus::UPGRADE_OVERWINTER].nActivationHeight = height;
+    ASSETCHAINS_SAPLING = height;
+    fprintf(stderr,"SET SAPLING ACTIVATION height.%d\n",height);
+}
+
+void *chainparams_commandline()
+{
+    fprintf(stderr,"chainparams_commandline called\n");
+    CChainParams::CCheckpointData checkpointData;
+    //fprintf(stderr,">>>>>>>> port.%u\n",ASSETCHAINS_P2PPORT);
+    if ( ASSETCHAINS_SYMBOL[0] != 0 )
+    {
+        if ( ASSETCHAINS_BLOCKTIME != 60 )
+        {
+            pCurrentParams->consensus.nMaxFutureBlockTime = 7 * ASSETCHAINS_BLOCKTIME; // 7 blocks
+            pCurrentParams->consensus.nPowTargetSpacing = ASSETCHAINS_BLOCKTIME;
+        }
+        pCurrentParams->SetDefaultPort(ASSETCHAINS_P2PPORT);
+        if ( ASSETCHAINS_NK[0] != 0 && ASSETCHAINS_NK[1] != 0 )
+        {
+            //BOOST_STATIC_ASSERT(equihash_parameters_acceptable(ASSETCHAINS_NK[0], ASSETCHAINS_NK[1]));
+            pCurrentParams->SetNValue(ASSETCHAINS_NK[0]);
+            pCurrentParams->SetKValue(ASSETCHAINS_NK[1]);
+        }
+        if ( KOMODO_TESTNODE != 0 )
+            pCurrentParams->SetMiningRequiresPeers(false);
+        if ( ASSETCHAINS_RPCPORT == 0 )
+            ASSETCHAINS_RPCPORT = ASSETCHAINS_P2PPORT + 1;
+        pCurrentParams->pchMessageStart[0] = ASSETCHAINS_MAGIC & 0xff;
+        pCurrentParams->pchMessageStart[1] = (ASSETCHAINS_MAGIC >> 8) & 0xff;
+        pCurrentParams->pchMessageStart[2] = (ASSETCHAINS_MAGIC >> 16) & 0xff;
+        pCurrentParams->pchMessageStart[3] = (ASSETCHAINS_MAGIC >> 24) & 0xff;
+        fprintf(stderr,">>>>>>>>>> %s: p2p.%u rpc.%u magic.%08x %u %u coins\n",ASSETCHAINS_SYMBOL,ASSETCHAINS_P2PPORT,ASSETCHAINS_RPCPORT,ASSETCHAINS_MAGIC,ASSETCHAINS_MAGIC,(uint32_t)ASSETCHAINS_SUPPLY);
+        if (ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASH)
+        {
+            // this is only good for 60 second blocks with an averaging window of 45. for other parameters, use:
+            // nLwmaAjustedWeight = (N+1)/2 * (0.9989^(500/nPowAveragingWindow)) * nPowTargetSpacing
+            pCurrentParams->consensus.nLwmaAjustedWeight = 1350;
+            pCurrentParams->consensus.nPowAveragingWindow = 45;
+            pCurrentParams->consensus.powAlternate = uint256S("00000f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f");
+        }
+        else if (ASSETCHAINS_ALGO == ASSETCHAINS_VERUSHASHV1_1)
+        {
+            // this is only good for 60 second blocks with an averaging window of 45. for other parameters, use:
+            // nLwmaAjustedWeight = (N+1)/2 * (0.9989^(500/nPowAveragingWindow)) * nPowTargetSpacing
+            pCurrentParams->consensus.nLwmaAjustedWeight = 1350;
+            pCurrentParams->consensus.nPowAveragingWindow = 45;
+            pCurrentParams->consensus.powAlternate = uint256S("0000000f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f");
+        }
+
+        if (ASSETCHAINS_LWMAPOS != 0)
+        {
+            pCurrentParams->consensus.posLimit = uint256S("000000000f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f");
+            pCurrentParams->consensus.nPOSAveragingWindow = 45;
+            // spacing is 1000 units per block to get better resolution, POS is 50% hard coded for now, we can vary it later
+            // when we get reliable integer math on nLwmaPOSAjustedWeight
+            pCurrentParams->consensus.nPOSTargetSpacing = VERUS_BLOCK_POSUNITS * 2;
+            // nLwmaPOSAjustedWeight = (N+1)/2 * (0.9989^(500/nPOSAveragingWindow)) * nPOSTargetSpacing
+            // this needs to be recalculated if VERUS_BLOCK_POSUNITS is changed
+            pCurrentParams->consensus.nLwmaPOSAjustedWeight = 46531;
+        }
+
+        // only require coinbase protection on Verus from the Komodo family of coins
+        if (strcmp(ASSETCHAINS_SYMBOL,"VRSC") == 0)
+        {
+            pCurrentParams->consensus.vUpgrades[Consensus::UPGRADE_SAPLING].nActivationHeight = 227520;
+            pCurrentParams->consensus.vUpgrades[Consensus::UPGRADE_OVERWINTER].nActivationHeight = 227520;
+            pCurrentParams->consensus.fCoinbaseMustBeProtected = true;
+            checkpointData = //(Checkpoints::CCheckpointData)
+                    {
+                            boost::assign::map_list_of
+                                    (0, pCurrentParams->consensus.hashGenesisBlock)
+                                    (10000, uint256S("0xac2cd7d37177140ea4991cf630c0b9c7f94d707b84fb0351bf3a44856d2ae5dc"))
+                                    (20000, uint256S("0xb0e8cb9f77aaa7ff5bd90d6c08d06f4c4bf03e00c2b8a35a042e760845590c8a"))
+                                    (30000, uint256S("0xf2112ca577338ad7104bf905fa6a63d36b17a86f914c97b73cd31d43fcd7557c"))
+                                    (40000, uint256S("0x00000000008f83378dab727864b763ce91a4ea5f75d55939c0c1390cfb8c38f1"))
+                                    (49170, uint256S("0x2add646c0089871ec2379f02f7cd60b3af6efd9c152a6f16fc10925458c270cc")),
+                            (int64_t)1529910234,    // * UNIX timestamp of last checkpoint block
+                            (int64_t)63661,         // * total number of transactions between genesis and last checkpoint
+                            //   (the tx=... number in the SetBestChain debug.log lines)
+                            (double)2777            // * estimated number of transactions per day after checkpoint
+                            //   total number of tx / (checkpoint block height / (24 * 24))
+                    };
+
+            pCurrentParams->consensus.nMinimumChainWork = uint256S("0x000000000000000000000000000000000000000000000001a8f4f23f8b2d1f7e");
+        }
+        else
+        {
+            if (strcmp(ASSETCHAINS_SYMBOL,"VRSCTEST") == 0 || strcmp(ASSETCHAINS_SYMBOL,"VERUSTEST") == 0)
+            {
+                pCurrentParams->consensus.nMinimumChainWork = uint256S("0x0000000000000000000000000000000000000000000000000000000000001f7e");
+            }
+            pCurrentParams->consensus.vUpgrades[Consensus::UPGRADE_SAPLING].nActivationHeight = ASSETCHAINS_SAPLING;
+            pCurrentParams->consensus.vUpgrades[Consensus::UPGRADE_OVERWINTER].nActivationHeight = ASSETCHAINS_OVERWINTER;
+            checkpointData = //(Checkpoints::CCheckpointData)
+                    {
+                            boost::assign::map_list_of
+                                    (0, pCurrentParams->consensus.hashGenesisBlock),
+                            (int64_t)1231006505,
+                            (int64_t)1,
+                            (double)2777            // * estimated number of transactions per day after checkpoint
+                            //   total number of tx / (checkpoint block height / (24 * 24))
+                    };
+        }
+    }
+    else
+    {
+        checkpointData = // (Checkpoints::CCheckpointData)
+            {
+                boost::assign::map_list_of
+
+                (0, pCurrentParams->consensus.hashGenesisBlock)
+                (	50000,	uint256S("0x00076e16d3fa5194da559c17cf9cf285e21d1f13154ae4f7c7b87919549345aa"))
+                (	100000,	uint256S("0x0f02eb1f3a4b89df9909fec81a4bd7d023e32e24e1f5262d9fc2cc36a715be6f"))
+                (	150000,	uint256S("0x0a817f15b9da636f453a7a01835cfc534ed1a55ce7f08c566471d167678bedce"))
+                (	200000,	uint256S("0x000001763a9337328651ca57ac487cc0507087be5838fb74ca4165ff19f0e84f"))
+                (	250000,	uint256S("0x0dd54ef5f816c7fde9d2b1c8c1a26412b3c761cc5dd3901fa5c4cd1900892fba"))
+                (	300000,	uint256S("0x000000fa5efd1998959926047727519ed7de06dcf9f2cd92a4f71e907e1312dc"))
+                (	350000,	uint256S("0x0000000228ef321323f81dae00c98d7960fc7486fb2d881007fee60d1e34653f"))
+                (	400000,	uint256S("0x036d294c5be96f4c0efb28e652eb3968231e87204a823991a85c5fdab3c43ae6"))
+                (	450000,	uint256S("0x0906ef1e8dc194f1f03bd4ce1ac8c6992fd721ef2c5ccbf4871ec8cdbb456c18"))
+                (	500000,	uint256S("0x0bebdb417f7a51fe0c36fcf94e2ed29895a9a862eaa61601272866a7ecd6391b"))
+                (	550000,	uint256S("0x06df52fc5f9ba03ccc3a7673b01ab47990bd5c4947f6e1bc0ba14d21cd5bcccd"))
+                (	600000,	uint256S("0x00000005080d5689c3b4466e551cd1986e5d2024a62a79b1335afe12c42779e4"))
+                (	650000,	uint256S("0x039a3cb760cc6e564974caf69e8ae621c14567f3a36e4991f77fd869294b1d52"))
+                (	700000,	uint256S("0x00002285be912b2b887a5bb42d2f1aa011428c565b0ffc908129c47b5ce87585"))
+                (	750000,	uint256S("0x04cff4c26d185d591bed3613ce15e1d15d9c91dd8b98a6729f89c58ce4bd1fd6"))
+                (	800000,	uint256S("0x0000000617574d402fca8e6570f0845bd5fe449398b318b4e1f65bc69cdd6606"))
+                (	850000,	uint256S("0x044199301f37194f20ba7b498fc72ed742f6c0ba6e476f28d6c81d225e58d5ce"))
+                (	900000,	uint256S("0x08bdbe4de2a65ac89fd2913192d05362c900e3af476a0c99d9f311875067451e"))
+                (	950000,	uint256S("0x0000000aa9a44b593e6138f247bfae75bd43b9396ef9ff0a6a3ebd852f131806"))
+                (	1000000,	uint256S("0x0cb1d2457eaa58af5028e86e27ac54578fa09558206e7b868ebd35e7005ed8bb"))
+                (	1050000,	uint256S("0x044d49bbc3bd9d32b6288b768d4f7e0afe3cbeda606f3ac3579a076e4bddf6ae"))
+                (	1100000,	uint256S("0x000000050cad04887e170059dd2556d85bbd20390b04afb9b07fb62cafd647b4"))
+                (	1150000,	uint256S("0x0c85501c759d957dd1ccc5f7fdfcc415c89c7f2a26471fffc75b75f79e63c16a"))
+                (	1200000,	uint256S("0x0763cbf43ed7227988081c29d9e9fc7ab2450216e6d0354cc4596c86689702d4"))
+                (	1250000,	uint256S("0x0489640207f8c343a56a10e45d987516059ea82a3c6859a771b3a9cf94f5c3bb"))
+                (	1300000,	uint256S("0x000000012a01709b254b4f75e2b9ed772d8fe558655c8c859892ca8c9d625e87"))
+                (	1350000,	uint256S("0x075a1a5c66a68b47d9848ca6986687ed2665b1852457051bf142208e62f98a60"))
+                (	1400000,	uint256S("0x055f73dd9b20650c3d6e6dbb606af8d9479e4c81d89430867abff5329f167bb2"))
+                (	1450000,	uint256S("0x014c2926e07e9712211c5e82f05df1b802c59cc8bc24e3cc9b09942017080f2d"))
+                (	1500000,	uint256S("0x0791f892210ce3c513ab607d689cd1e8907a27f3dfeb58dec21ae299b7981cb7"))
+                (	1550000,	uint256S("0x08fcbaffb7164b161a25efc6dd5c70b679498ee637d663fe201a55c7decc37a3"))
+                (	1600000,	uint256S("0x0e577dcd49319a67fe2acbb39ae6d46afccd3009d3ba9d1bcf6c624708e12bac"))
+                (	1615921,	uint256S("0x049140623cc54a4a3d5868f720611e180ba0cafa21eab1edd0bc9ec2e6b7c374")),
+                1573604104,     // * UNIX timestamp of last checkpoint block
+                7371665,         // * total number of transactions between genesis and last checkpoint
+                                //   (the tx=... number in the SetBestChain debug.log lines)
+                2777            // * estimated number of transactions per day after checkpoint
+                                //   total number of tx / (checkpoint block height / (24 * 24))
+            };
+    }
+
+    pCurrentParams->SetCheckpointData(checkpointData);
+
+    ASSETCHAIN_INIT = 1;
+    return(0);
+}
diff --git a/src/clientversion.cpp b/src/clientversion.cpp
index 271fffd8..beac4736 100644
--- a/src/clientversion.cpp
+++ b/src/clientversion.cpp
@@ -67,8 +67,8 @@ const std::string CLIENT_NAME = GetArg("-clientname", "MagicBean");
 //! git will put "#define GIT_ARCHIVE 1" on the next line inside archives. 
 #define GIT_ARCHIVE 1
 #ifdef GIT_ARCHIVE
-#define GIT_COMMIT_ID "28"
-#define GIT_COMMIT_DATE "Sun, 16 Jun 2019 00:00:00 +0500"
+#define GIT_COMMIT_ID "29"
+#define GIT_COMMIT_DATE "Tue, 17 Dec 2019 00:00:00 +0500"
 #endif
 
 #define RENDER_BETA_STRING(num) "-beta" DO_STRINGIZE(num)
diff --git a/src/clientversion.h b/src/clientversion.h
index e27b932d..79e2404b 100644
--- a/src/clientversion.h
+++ b/src/clientversion.h
@@ -32,8 +32,8 @@
 //! These need to be macros, as clientversion.cpp's and bitcoin*-res.rc's voodoo requires it
 #define CLIENT_VERSION_MAJOR 3
 #define CLIENT_VERSION_MINOR 0
-#define CLIENT_VERSION_REVISION 0
-#define CLIENT_VERSION_BUILD 0
+#define CLIENT_VERSION_REVISION 1
+#define CLIENT_VERSION_BUILD 1
 
 //! Set to true for release, false for prerelease or test build
 #define CLIENT_VERSION_IS_RELEASE true
diff --git a/src/coins.cpp b/src/coins.cpp
index 51af9651..7f4266f2 100644
--- a/src/coins.cpp
+++ b/src/coins.cpp
@@ -604,6 +604,11 @@ CAmount CCoinsViewCache::GetValueIn(int32_t nHeight,int64_t *interestp,const CTr
         return 0;
     for (unsigned int i = 0; i < tx.vin.size(); i++)
     {
+        if (tx.IsPegsImport() && i==0)
+        {
+            nResult = GetCoinImportValue(tx);
+            continue;
+        } 
         value = GetOutputFor(tx.vin[i]).nValue;
         nResult += value;
 #ifdef KOMODO_ENABLE_INTEREST
@@ -675,6 +680,7 @@ bool CCoinsViewCache::HaveInputs(const CTransaction& tx) const
 {
     if (!tx.IsMint()) {
         for (unsigned int i = 0; i < tx.vin.size(); i++) {
+            if (tx.IsPegsImport() && i==0) continue;
             const COutPoint &prevout = tx.vin[i].prevout;
             const CCoins* coins = AccessCoins(prevout.hash);
             if (!coins || !coins->IsAvailable(prevout.n)) {
@@ -696,7 +702,7 @@ double CCoinsViewCache::GetPriority(const CTransaction &tx, int nHeight) const
     // use the maximum priority for all (partially or fully) shielded transactions.
     // (Note that coinbase transactions cannot contain JoinSplits, or Sapling shielded Spends or Outputs.)
 
-    if (tx.vjoinsplit.size() > 0 || tx.vShieldedSpend.size() > 0 || tx.vShieldedOutput.size() > 0 || tx.IsCoinImport()) {
+    if (tx.vjoinsplit.size() > 0 || tx.vShieldedSpend.size() > 0 || tx.vShieldedOutput.size() > 0 || tx.IsCoinImport() || tx.IsPegsImport()) {
         return MAX_PRIORITY;
     }
 
diff --git a/src/consensus/upgrades.cpp b/src/consensus/upgrades.cpp
index b8fbb2c8..2dff08b7 100644
--- a/src/consensus/upgrades.cpp
+++ b/src/consensus/upgrades.cpp
@@ -2,8 +2,33 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+/******************************************************************************
+ * Copyright © 2014-2019 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+
 #include "consensus/upgrades.h"
 #include "util.h"
+extern int32_t KOMODO_NSPV;
+#define NSPV_BRANCHID 0x76b809bb
+
+#ifndef KOMODO_NSPV_FULLNODE
+#define KOMODO_NSPV_FULLNODE (KOMODO_NSPV <= 0)
+#endif // !KOMODO_NSPV_FULLNODE
+
+#ifndef KOMODO_NSPV_SUPERLITE
+#define KOMODO_NSPV_SUPERLITE (KOMODO_NSPV > 0)
+#endif // !KOMODO_NSPV_SUPERLITE
 
 /**
  * General information about each network upgrade.
@@ -83,7 +108,10 @@ int CurrentEpoch(int nHeight, const Consensus::Params& params) {
     return Consensus::BASE_SPROUT;
 }
 
-uint32_t CurrentEpochBranchId(int nHeight, const Consensus::Params& params) {
+uint32_t CurrentEpochBranchId(int nHeight, const Consensus::Params& params)
+{
+    if ( KOMODO_NSPV_SUPERLITE )
+        return(NSPV_BRANCHID);
     return NetworkUpgradeInfo[CurrentEpoch(nHeight, params)].nBranchId;
 }
 
diff --git a/src/consensus/upgrades.h b/src/consensus/upgrades.h
index 920ec1ea..097f8962 100644
--- a/src/consensus/upgrades.h
+++ b/src/consensus/upgrades.h
@@ -2,6 +2,21 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+/******************************************************************************
+ * Copyright © 2014-2019 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+
 #ifndef ZCASH_CONSENSUS_UPGRADES_H
 #define ZCASH_CONSENSUS_UPGRADES_H
 
diff --git a/src/consensus/validation.h b/src/consensus/validation.h
index a5501592..d2606ecd 100644
--- a/src/consensus/validation.h
+++ b/src/consensus/validation.h
@@ -3,8 +3,23 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#ifndef KOMODO_CONSENSUS_VALIDATION_H
-#define KOMODO_CONSENSUS_VALIDATION_H
+/******************************************************************************
+ * Copyright © 2014-2019 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+
+#ifndef BITCOIN_CONSENSUS_VALIDATION_H
+#define BITCOIN_CONSENSUS_VALIDATION_H
 
 #include <string>
 #include "primitives/transaction.h"
@@ -88,4 +103,4 @@ static inline int64_t GetTransactionWeight(const CTransaction& tx)
     return ::GetSerializeSize(tx, SER_NETWORK, PROTOCOL_VERSION | SERIALIZE_TRANSACTION_NO_WITNESS) * (WITNESS_SCALE_FACTOR - 1) + ::GetSerializeSize(tx, SER_NETWORK, PROTOCOL_VERSION);
 }
 
-#endif // KOMODO_CONSENSUS_VALIDATION_H
+#endif // BITCOIN_CONSENSUS_VALIDATION_H
diff --git a/src/crypto/common.h b/src/crypto/common.h
index d20a0ef4..b05fa5fc 100644
--- a/src/crypto/common.h
+++ b/src/crypto/common.h
@@ -2,8 +2,8 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#ifndef KOMODO_CRYPTO_COMMON_H
-#define KOMODO_CRYPTO_COMMON_H
+#ifndef BITCOIN_CRYPTO_COMMON_H
+#define BITCOIN_CRYPTO_COMMON_H
 
 #if defined(HAVE_CONFIG_H)
 #include "config/bitcoin-config.h"
@@ -123,4 +123,4 @@ int inline init_and_check_sodium()
     return 0;
 }
 
-#endif // KOMODO_CRYPTO_COMMON_H
+#endif // BITCOIN_CRYPTO_COMMON_H
diff --git a/src/crypto/sha256.cpp b/src/crypto/sha256.cpp
index 9ff8767f..0718d2d2 100644
--- a/src/crypto/sha256.cpp
+++ b/src/crypto/sha256.cpp
@@ -149,8 +149,8 @@ bool SelfTest(TransformType tr) {
     static const unsigned char in1[65] = {0, 0x80};
     static const unsigned char in2[129] = {
         0,
-        32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 
-        32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 
+        32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
+        32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
         0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0
     };
diff --git a/src/cryptoconditions/src/cryptoconditions.c b/src/cryptoconditions/src/cryptoconditions.c
index 9bbdfbd9..8e30e206 100644
--- a/src/cryptoconditions/src/cryptoconditions.c
+++ b/src/cryptoconditions/src/cryptoconditions.c
@@ -86,6 +86,7 @@ char *cc_conditionUri(const CC *cond) {
 
 ConditionTypes_t asnSubtypes(uint32_t mask) {
     ConditionTypes_t types;
+    memset(&types,0,sizeof(types));
     uint8_t buf[4] = {0,0,0,0};
     int maxId = 0;
 
diff --git a/src/cryptoconditions/src/secp256k1.c b/src/cryptoconditions/src/secp256k1.c
index 294750b2..8a6aa478 100644
--- a/src/cryptoconditions/src/secp256k1.c
+++ b/src/cryptoconditions/src/secp256k1.c
@@ -188,7 +188,8 @@ int cc_signTreeSecp256k1Msg32(CC *cond, const unsigned char *privateKey, const u
     }
 
     // serialize pubkey
-    unsigned char *publicKey = calloc(1, SECP256K1_PK_SIZE);
+    //unsigned char *publicKey = calloc(1, SECP256K1_PK_SIZE);
+    unsigned char publicKey[SECP256K1_PK_SIZE];
     size_t ol = SECP256K1_PK_SIZE;
     secp256k1_ec_pubkey_serialize(ec_ctx_verify, publicKey, &ol, &spk, SECP256K1_EC_COMPRESSED);
 
@@ -197,7 +198,7 @@ int cc_signTreeSecp256k1Msg32(CC *cond, const unsigned char *privateKey, const u
     CCVisitor visitor = {&secp256k1Sign, msg32, 32, &signing};
     cc_visit(cond, visitor);
 
-    free(publicKey);
+    //free(publicKey);
     return signing.nSigned;
 }
 
diff --git a/src/cryptoconditions/src/utils.c b/src/cryptoconditions/src/utils.c
index 1e5ad703..b5f78b52 100644
--- a/src/cryptoconditions/src/utils.c
+++ b/src/cryptoconditions/src/utils.c
@@ -212,7 +212,6 @@ void jsonAddBase64(cJSON *params, char *key, unsigned char *bin, size_t size) {
 
 unsigned char *hashFingerprintContents(asn_TYPE_descriptor_t *asnType, void *fp) {
     unsigned char buf[BUF_SIZE];
-    memset(buf,0,sizeof(buf));
     asn_enc_rval_t rc = der_encode_to_buffer(asnType, fp, buf, BUF_SIZE);
     ASN_STRUCT_FREE(*asnType, fp);
 
diff --git a/src/gtest/test_checktransaction.cpp b/src/gtest/test_checktransaction.cpp
index c6f66cc6..0efac93d 100644
--- a/src/gtest/test_checktransaction.cpp
+++ b/src/gtest/test_checktransaction.cpp
@@ -166,7 +166,7 @@ TEST(checktransaction_tests, BadTxnsOversize) {
 
         // ... but fails contextual ones!
         EXPECT_CALL(state, DoS(100, false, REJECT_INVALID, "bad-txns-oversize", false)).Times(1);
-        EXPECT_FALSE(ContextualCheckTransaction(tx, state, 1, 100));
+        EXPECT_FALSE(ContextualCheckTransaction(0,tx, state, 1, 100));
     }
 
     {
@@ -188,7 +188,7 @@ TEST(checktransaction_tests, BadTxnsOversize) {
 
         MockCValidationState state;
         EXPECT_TRUE(CheckTransactionWithoutProofVerification(tx, state));
-        EXPECT_TRUE(ContextualCheckTransaction(tx, state, 1, 100));
+        EXPECT_TRUE(ContextualCheckTransaction(0,tx, state, 1, 100));
 
         // Revert to default
         UpdateNetworkUpgradeParameters(Consensus::UPGRADE_SAPLING, Consensus::NetworkUpgrade::NO_ACTIVATION_HEIGHT);
@@ -508,9 +508,9 @@ TEST(checktransaction_tests, bad_txns_invalid_joinsplit_signature) {
     MockCValidationState state;
     // during initial block download, DoS ban score should be zero, else 100
     EXPECT_CALL(state, DoS(0, false, REJECT_INVALID, "bad-txns-invalid-joinsplit-signature", false)).Times(1);
-    ContextualCheckTransaction(tx, state, 0, 100, []() { return true; });
+    ContextualCheckTransaction(0,tx, state, 0, 100, []() { return true; });
     EXPECT_CALL(state, DoS(100, false, REJECT_INVALID, "bad-txns-invalid-joinsplit-signature", false)).Times(1);
-    ContextualCheckTransaction(tx, state, 0, 100, []() { return false; });
+    ContextualCheckTransaction(0,tx, state, 0, 100, []() { return false; });
 }
 
 TEST(checktransaction_tests, non_canonical_ed25519_signature) {
@@ -522,7 +522,7 @@ TEST(checktransaction_tests, non_canonical_ed25519_signature) {
     {
         CTransaction tx(mtx);
         MockCValidationState state;
-        EXPECT_TRUE(ContextualCheckTransaction(tx, state, 0, 100));
+        EXPECT_TRUE(ContextualCheckTransaction(0,tx, state, 0, 100));
     }
 
     // Copied from libsodium/crypto_sign/ed25519/ref10/open.c
@@ -544,9 +544,9 @@ TEST(checktransaction_tests, non_canonical_ed25519_signature) {
     MockCValidationState state;
     // during initial block download, DoS ban score should be zero, else 100
     EXPECT_CALL(state, DoS(0, false, REJECT_INVALID, "bad-txns-invalid-joinsplit-signature", false)).Times(1);
-    ContextualCheckTransaction(tx, state, 0, 100, []() { return true; });
+    ContextualCheckTransaction(0,tx, state, 0, 100, []() { return true; });
     EXPECT_CALL(state, DoS(100, false, REJECT_INVALID, "bad-txns-invalid-joinsplit-signature", false)).Times(1);
-    ContextualCheckTransaction(tx, state, 0, 100, []() { return false; });
+    ContextualCheckTransaction(0,tx, state, 0, 100, []() { return false; });
 }
 
 TEST(checktransaction_tests, OverwinterConstructors) {
@@ -801,7 +801,7 @@ TEST(checktransaction_tests, OverwinterVersionNumberHigh) {
     UNSAFE_CTransaction tx(mtx);
     MockCValidationState state;
     EXPECT_CALL(state, DoS(100, false, REJECT_INVALID, "bad-tx-overwinter-version-too-high", false)).Times(1);
-    ContextualCheckTransaction(tx, state, 1, 100);
+    ContextualCheckTransaction(0,tx, state, 1, 100);
 
     // Revert to default
     UpdateNetworkUpgradeParameters(Consensus::UPGRADE_OVERWINTER, Consensus::NetworkUpgrade::NO_ACTIVATION_HEIGHT);
@@ -837,9 +837,9 @@ TEST(checktransaction_tests, OverwinterNotActive) {
     MockCValidationState state;
     // during initial block download, DoS ban score should be zero, else 100
     EXPECT_CALL(state, DoS(0, false, REJECT_INVALID, "tx-overwinter-not-active", false)).Times(1);
-    ContextualCheckTransaction(tx, state, 1, 100, []() { return true; });
+    ContextualCheckTransaction(0,tx, state, 1, 100, []() { return true; });
     EXPECT_CALL(state, DoS(100, false, REJECT_INVALID, "tx-overwinter-not-active", false)).Times(1);
-    ContextualCheckTransaction(tx, state, 1, 100, []() { return false; });
+    ContextualCheckTransaction(0,tx, state, 1, 100, []() { return false; });
 }
 
 // This tests a transaction without the fOverwintered flag set, against the Overwinter consensus rule set.
@@ -856,7 +856,7 @@ TEST(checktransaction_tests, OverwinterFlagNotSet) {
     CTransaction tx(mtx);
     MockCValidationState state;
     EXPECT_CALL(state, DoS(100, false, REJECT_INVALID, "tx-overwinter-flag-not-set", false)).Times(1);
-    ContextualCheckTransaction(tx, state, 1, 100);
+    ContextualCheckTransaction(0,tx, state, 1, 100);
 
     // Revert to default
     UpdateNetworkUpgradeParameters(Consensus::UPGRADE_OVERWINTER, Consensus::NetworkUpgrade::NO_ACTIVATION_HEIGHT);
diff --git a/src/gtest/test_transaction_builder.cpp b/src/gtest/test_transaction_builder.cpp
index 05a8cb60..a04e30b0 100644
--- a/src/gtest/test_transaction_builder.cpp
+++ b/src/gtest/test_transaction_builder.cpp
@@ -51,7 +51,7 @@ TEST(TransactionBuilder, Invoke)
     EXPECT_EQ(tx1.valueBalance, -40000);
 
     CValidationState state;
-    EXPECT_TRUE(ContextualCheckTransaction(tx1, state, 2, 0));
+    EXPECT_TRUE(ContextualCheckTransaction(0,tx1, state, 2, 0));
     EXPECT_EQ(state.GetRejectReason(), "");
 
     // Prepare to spend the note that was just created
@@ -85,7 +85,7 @@ TEST(TransactionBuilder, Invoke)
     EXPECT_EQ(tx2.vShieldedOutput.size(), 2);
     EXPECT_EQ(tx2.valueBalance, 10000);
 
-    EXPECT_TRUE(ContextualCheckTransaction(tx2, state, 3, 0));
+    EXPECT_TRUE(ContextualCheckTransaction(0,tx2, state, 3, 0));
     EXPECT_EQ(state.GetRejectReason(), "");
 
     // Revert to default
diff --git a/src/importcoin.cpp b/src/importcoin.cpp
index 47bb2bb0..ee8d1a45 100644
--- a/src/importcoin.cpp
+++ b/src/importcoin.cpp
@@ -75,6 +75,18 @@ CTransaction MakeImportCoinTransaction(const ImportProof proof, const CTransacti
     return CTransaction(mtx);
 }
 
+CTransaction MakePegsImportCoinTransaction(const ImportProof proof, const CTransaction burnTx, const std::vector<CTxOut> payouts, uint32_t nExpiryHeightOverride)
+{
+    CMutableTransaction mtx; uint256 accounttxid,pegstxid,tokenid; CScript opret; CScript scriptSig;
+
+    mtx=MakeImportCoinTransaction(proof,burnTx,payouts);
+    // for spending markers in import tx - to track account state
+    accounttxid=burnTx.vin[0].prevout.hash;    
+    mtx.vin.push_back(CTxIn(accounttxid,0,CScript()));
+    mtx.vin.push_back(CTxIn(accounttxid,1,CScript()));
+    return (mtx);
+}
+
 
 CTxOut MakeBurnOutput(CAmount value, uint32_t targetCCid, const std::string targetSymbol, const std::vector<CTxOut> payouts, const std::vector<uint8_t> rawproof)
 {
@@ -123,13 +135,30 @@ CTxOut MakeBurnOutput(CAmount value, uint32_t targetCCid, std::string targetSymb
     return CTxOut(value, CScript() << OP_RETURN << opret);
 }
 
+CTxOut MakeBurnOutput(CAmount value,uint32_t targetCCid,std::string targetSymbol,const std::vector<CTxOut> payouts,std::vector<uint8_t> rawproof,uint256 pegstxid,
+                        uint256 tokenid,CPubKey srcpub,int64_t amount,std::pair<int64_t,int64_t> account)
+{
+    std::vector<uint8_t> opret;
+    opret = E_MARSHAL(ss << (uint8_t)EVAL_IMPORTCOIN;
+                      ss << VARINT(targetCCid);
+                      ss << targetSymbol;
+                      ss << SerializeHash(payouts);
+                      ss << rawproof;
+                      ss << pegstxid;
+                      ss << tokenid;
+                      ss << srcpub;
+                      ss << amount;
+                      ss << account);
+    return CTxOut(value, CScript() << OP_RETURN << opret);
+}
+
 
 bool UnmarshalImportTx(const CTransaction importTx, ImportProof &proof, CTransaction &burnTx, std::vector<CTxOut> &payouts)
 {
     if (importTx.vout.size() < 1) 
         return false;
     
-    if (importTx.vin.size() != 1 || importTx.vin[0].scriptSig != (CScript() << E_MARSHAL(ss << EVAL_IMPORTCOIN))) {
+    if ((!importTx.IsPegsImport() && importTx.vin.size() != 1) || importTx.vin[0].scriptSig != (CScript() << E_MARSHAL(ss << EVAL_IMPORTCOIN))) {
         LOGSTREAM("importcoin", CCLOG_INFO, stream << "UnmarshalImportTx() incorrect import tx vin" << std::endl);
         return false;
     }
@@ -263,17 +292,35 @@ bool UnmarshalBurnTx(const CTransaction burnTx,uint256 &bindtxid,std::vector<CPu
                     ss >> amount));
 }
 
+bool UnmarshalBurnTx(const CTransaction burnTx,uint256 &pegstxid,uint256 &tokenid,CPubKey &srcpub, int64_t &amount,std::pair<int64_t,int64_t> &account)
+{
+    std::vector<uint8_t> burnOpret,rawproof; bool isEof=true;
+    uint32_t targetCCid; uint256 payoutsHash; std::string targetSymbol;
+    uint8_t evalCode;
+
+
+    if (burnTx.vout.size() == 0) return false;
+    GetOpReturnData(burnTx.vout.back().scriptPubKey, burnOpret);
+    return (E_UNMARSHAL(burnOpret, ss >> evalCode;
+                    ss >> VARINT(targetCCid);
+                    ss >> targetSymbol;
+                    ss >> payoutsHash;
+                    ss >> rawproof;
+                    ss >> pegstxid;
+                    ss >> tokenid;
+                    ss >> srcpub;
+                    ss >> amount;
+                    ss >> account));
+}
 
 /*
  * Required by main
  */
 CAmount GetCoinImportValue(const CTransaction &tx)
 {
-    ImportProof proof;
-    CTransaction burnTx;
-    std::vector<CTxOut> payouts;
-
+    ImportProof proof; CTransaction burnTx; std::vector<CTxOut> payouts;
     bool isNewImportTx = false;
+    
     if ((isNewImportTx = UnmarshalImportTx(tx, proof, burnTx, payouts))) {
         if (burnTx.vout.size() > 0) {
             vscript_t vburnOpret;
diff --git a/src/importcoin.h b/src/importcoin.h
index 951ffab0..94f00bb8 100644
--- a/src/importcoin.h
+++ b/src/importcoin.h
@@ -94,16 +94,20 @@ class ImportProof {
 CAmount GetCoinImportValue(const CTransaction &tx);
 
 CTransaction MakeImportCoinTransaction(const ImportProof proof, const CTransaction burnTx, const std::vector<CTxOut> payouts, uint32_t nExpiryHeightOverride = 0);
+CTransaction MakePegsImportCoinTransaction(const ImportProof proof, const CTransaction burnTx, const std::vector<CTxOut> payouts, uint32_t nExpiryHeightOverride = 0);
 
 CTxOut MakeBurnOutput(CAmount value, uint32_t targetCCid, const std::string targetSymbol, const std::vector<CTxOut> payouts, const std::vector<uint8_t> rawproof);
 CTxOut MakeBurnOutput(CAmount value, uint32_t targetCCid, std::string targetSymbol, const std::vector<CTxOut> payouts,std::vector<uint8_t> rawproof,
                         uint256 bindtxid,std::vector<CPubKey> publishers,std::vector<uint256>txids,uint256 burntxid,int32_t height,int32_t burnvout,std::string rawburntx,CPubKey destpub, int64_t amount);
 CTxOut MakeBurnOutput(CAmount value, uint32_t targetCCid, std::string targetSymbol, const std::vector<CTxOut> payouts,std::vector<uint8_t> rawproof,std::string srcaddr,
                         std::string receipt);
+CTxOut MakeBurnOutput(CAmount value,uint32_t targetCCid,std::string targetSymbol,const std::vector<CTxOut> payouts,std::vector<uint8_t> rawproof,uint256 pegstxid,
+                        uint256 tokenid,CPubKey srcpub,int64_t amount,std::pair<int64_t,int64_t> account);
 
 bool UnmarshalBurnTx(const CTransaction burnTx, std::string &targetSymbol, uint32_t *targetCCid, uint256 &payoutsHash,std::vector<uint8_t> &rawproof);
 bool UnmarshalBurnTx(const CTransaction burnTx, std::string &srcaddr, std::string &receipt);
 bool UnmarshalBurnTx(const CTransaction burnTx,uint256 &bindtxid,std::vector<CPubKey> &publishers,std::vector<uint256> &txids,uint256& burntxid,int32_t &height,int32_t &burnvout,std::string &rawburntx,CPubKey &destpub, int64_t &amount);
+bool UnmarshalBurnTx(const CTransaction burnTx,uint256 &pegstxid,uint256 &tokenid,CPubKey &srcpub,int64_t &amount,std::pair<int64_t,int64_t> &account);
 bool UnmarshalImportTx(const CTransaction importTx, ImportProof &proof, CTransaction &burnTx,std::vector<CTxOut> &payouts);
 
 bool VerifyCoinImport(const CScript& scriptSig, TransactionSignatureChecker& checker, CValidationState &state);
diff --git a/src/init.cpp b/src/init.cpp
index da4720a1..d9378f84 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -92,6 +92,7 @@
 
 using namespace std;
 
+#include "komodo_defs.h"
 extern void ThreadSendAlert();
 extern bool komodo_dailysnapshot(int32_t height);
 extern int32_t KOMODO_LOADINGBLOCKS;
@@ -1009,7 +1010,7 @@ bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
         return InitError(_("Not enough file descriptors available."));
     if (nFD - MIN_CORE_FILEDESCRIPTORS < nMaxConnections)
         nMaxConnections = nFD - MIN_CORE_FILEDESCRIPTORS;
-
+    LogPrintf("nMaxConnections %d\n",nMaxConnections);
     // if using block pruning, then disable txindex
     // also disable the wallet (for now, until SPV support is implemented in wallet)
     if (GetArg("-prune", 0)) {
@@ -1091,6 +1092,11 @@ bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
     RegisterAllCoreRPCCommands(tableRPC);
 #ifdef ENABLE_WALLET
     bool fDisableWallet = GetBoolArg("-disablewallet", false);
+    if ( KOMODO_NSPV_SUPERLITE )
+    {
+        fDisableWallet = true;
+        nLocalServices = 0;
+    }
     if (!fDisableWallet)
         RegisterWalletRPCCommands(tableRPC);
 #endif
@@ -1167,9 +1173,11 @@ bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
     // Option to startup with mocktime set (used for regression testing):
     SetMockTime(GetArg("-mocktime", 0)); // SetMockTime(0) is a no-op
 
-    if (GetBoolArg("-peerbloomfilters", true))
-        nLocalServices |= NODE_BLOOM;
-
+    if ( KOMODO_NSPV_FULLNODE )
+    {
+        if (GetBoolArg("-peerbloomfilters", true))
+            nLocalServices |= NODE_BLOOM;
+    }
     nMaxTipAge = GetArg("-maxtipage", DEFAULT_MAX_TIP_AGE);
 
 #ifdef ENABLE_MINING
@@ -1333,11 +1341,12 @@ bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
     libsnark::inhibit_profiling_info = true;
     libsnark::inhibit_profiling_counters = true;
 
-    uiInterface.InitMessage(_("Loading Sapling parameters..."));
-
-    // Initialize Zcash circuit parameters
-    ZC_LoadParams(chainparams);
-
+    if ( KOMODO_NSPV_FULLNODE )
+    {
+		uiInterface.InitMessage(_("Loading Sapling parameters..."));
+        // Initialize Zcash circuit parameters
+        ZC_LoadParams(chainparams);
+    }
     /* Start the RPC server already.  It will be started in "warmup" mode
      * and not really process calls already (but it will signify connections
      * that the server is there and will be ready later).  Warmup mode will
@@ -1514,6 +1523,18 @@ bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
     }
 #endif
 
+    if ( KOMODO_NSPV_SUPERLITE )
+    {
+        std::vector<boost::filesystem::path> vImportFiles;
+        threadGroup.create_thread(boost::bind(&ThreadImport, vImportFiles));
+        StartNode(threadGroup, scheduler);
+        pcoinsTip = new CCoinsViewCache(pcoinscatcher);
+        InitBlockIndex();
+        SetRPCWarmupFinished();
+        uiInterface.InitMessage(_("Done loading"));
+        pwalletMain = new CWallet("tmptmp.wallet");
+        return !fRequestShutdown;
+    }
     // ********************************************************* Step 7: load block chain
 
     fReindex = GetBoolArg("-reindex", false);
@@ -1933,7 +1954,14 @@ bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
             PruneAndFlush();
         }
     }
-
+    if ( KOMODO_NSPV == 0 )
+    {
+        if ( GetBoolArg("-addressindex", DEFAULT_ADDRESSINDEX) != 0 )
+            nLocalServices |= NODE_ADDRINDEX;
+        if ( GetBoolArg("-spentindex", DEFAULT_SPENTINDEX) != 0 )
+            nLocalServices |= NODE_SPENTINDEX;
+        fprintf(stderr,"nLocalServices %llx %d, %d\n",(long long)nLocalServices,GetBoolArg("-addressindex", DEFAULT_ADDRESSINDEX),GetBoolArg("-spentindex", DEFAULT_SPENTINDEX));
+    }
     // ********************************************************* Step 10: import blocks
 
     if (mapArgs.count("-blocknotify"))
diff --git a/src/key_io.cpp b/src/key_io.cpp
index 014159d6..dd4176fe 100644
--- a/src/key_io.cpp
+++ b/src/key_io.cpp
@@ -207,6 +207,22 @@ CKey DecodeSecret(const std::string& str)
     return key;
 }
 
+CKey DecodeCustomSecret(const std::string& str, uint8_t secret_key)
+{
+    CKey key;
+    std::vector<unsigned char> data;
+    if (DecodeBase58Check(str, data)) {
+        const std::vector<unsigned char>& privkey_prefix = std::vector<unsigned char>(1, secret_key);
+        if ((data.size() == 32 + privkey_prefix.size() || (data.size() == 33 + privkey_prefix.size() && data.back() == 1)) &&
+            std::equal(privkey_prefix.begin(), privkey_prefix.end(), data.begin())) {
+            bool compressed = data.size() == 33 + privkey_prefix.size();
+            key.Set(data.begin() + privkey_prefix.size(), data.begin() + privkey_prefix.size() + 32, compressed);
+        }
+    }
+    memory_cleanse(data.data(), data.size());
+    return key;
+}
+
 std::string EncodeSecret(const CKey& key)
 {
     assert(key.IsValid());
diff --git a/src/key_io.h b/src/key_io.h
index 72823d57..013469ab 100644
--- a/src/key_io.h
+++ b/src/key_io.h
@@ -17,6 +17,7 @@
 #include <string>
 
 CKey DecodeSecret(const std::string& str);
+CKey DecodeCustomSecret(const std::string& str, uint8_t secret_key);
 std::string EncodeSecret(const CKey& key);
 std::string EncodeCustomSecret(const CKey& key,uint8_t secret_key);
 
diff --git a/src/komodo.h b/src/komodo.h
index 0ed449a8..d8876579 100644
--- a/src/komodo.h
+++ b/src/komodo.h
@@ -63,9 +63,14 @@ void komodo_currentheight_set(int32_t height)
         sp->CURRENT_HEIGHT = height;
 }
 
+extern struct NSPV_inforesp NSPV_inforesult;
 int32_t komodo_currentheight()
 {
     char symbol[KOMODO_ASSETCHAIN_MAXLEN],dest[KOMODO_ASSETCHAIN_MAXLEN]; struct komodo_state *sp;
+    if ( KOMODO_NSPV_SUPERLITE )
+    {
+        return (NSPV_inforesult.height);
+    }
     if ( (sp= komodo_stateptr(symbol,dest)) != 0 )
         return(sp->CURRENT_HEIGHT);
     else return(0);
diff --git a/src/komodo_bitcoind.h b/src/komodo_bitcoind.h
index 2d9b1bbe..cae0acc0 100644
--- a/src/komodo_bitcoind.h
+++ b/src/komodo_bitcoind.h
@@ -1499,6 +1499,32 @@ uint32_t komodo_stakehash(uint256 *hashp,char *address,uint8_t *hashbuf,uint256
     return(addrhash.uints[0]);
 }
 
+arith_uint256 komodo_adaptivepow_target(int32_t height,arith_uint256 bnTarget,uint32_t nTime)
+{
+    arith_uint256 origtarget,easy; int32_t diff,tipdiff; int64_t mult; bool fNegative,fOverflow; CBlockIndex *tipindex;
+    if ( height > 10 && (tipindex= komodo_chainactive(height - 1)) != 0 ) // disable offchain diffchange
+    {
+        diff = (nTime - tipindex->GetMedianTimePast());
+        tipdiff = (nTime - tipindex->nTime);
+        if ( tipdiff > 13*ASSETCHAINS_BLOCKTIME )
+            diff = tipdiff;
+        if ( diff >= 13 * ASSETCHAINS_BLOCKTIME && (height < 30 || tipdiff > 2*ASSETCHAINS_BLOCKTIME) )
+        {
+            mult = diff - 12 * ASSETCHAINS_BLOCKTIME;
+            mult = (mult / ASSETCHAINS_BLOCKTIME) * ASSETCHAINS_BLOCKTIME + ASSETCHAINS_BLOCKTIME / 2;
+            origtarget = bnTarget;
+            bnTarget = bnTarget * arith_uint256(mult * mult);
+            easy.SetCompact(KOMODO_MINDIFF_NBITS,&fNegative,&fOverflow);
+            if ( bnTarget < origtarget || bnTarget > easy ) // deal with overflow
+            {
+                bnTarget = easy;
+                LogPrintf("tipdiff.%d diff.%d height.%d miner overflowed mult.%lld, set to mindiff\n",tipdiff,diff,height,(long long)mult);
+            } else LogPrintf("tipdiff.%d diff.%d height.%d miner elapsed %d, adjust by factor of %lld\n",tipdiff,diff,height,diff,(long long)mult);
+        } //else fprintf(stderr,"height.%d tipdiff.%d diff %d, vs %d\n",height,tipdiff,diff,13*ASSETCHAINS_BLOCKTIME);
+    } else LogPrintf("adaptive cant find height.%d\n",height);
+    return(bnTarget);
+}
+
 arith_uint256 komodo_PoWtarget(int32_t *percPoSp,arith_uint256 target,int32_t height,int32_t goalperc,int32_t newStakerActive)
 {
     int32_t oldflag = 0,dispflag = 0;
@@ -2177,7 +2203,7 @@ bool komodo_appendACscriptpub()
     {
         CTransaction tx; uint256 blockhash; 
         // get transaction and check that it occured before height 100. 
-        if ( myGetTransaction(KOMODO_EARLYTXID,tx,blockhash) && mapBlockIndex[blockhash]->GetHeight() < 100 )
+        if ( myGetTransaction(KOMODO_EARLYTXID,tx,blockhash) && mapBlockIndex[blockhash]->GetHeight() < KOMODO_EARLYTXID_HEIGHT )
         {
              for (int i = 0; i < tx.vout.size(); i++) 
              {
@@ -2212,15 +2238,15 @@ void GetKomodoEarlytxidScriptPub()
         StartShutdown();
         return;
     }
-    if ( chainActive.Height() < 100 )
+    if ( chainActive.Height() < KOMODO_EARLYTXID_HEIGHT )
     {
-        LogPrintf( "Cannot fetch -earlytxid before block 100.\n");
+        LogPrintf("Cannot fetch -earlytxid before block %d.\n",KOMODO_EARLYTXID_HEIGHT);
         StartShutdown();
         return;
     }
     CTransaction tx; uint256 blockhash; int32_t i;
     // get transaction and check that it occured before height 100. 
-    if ( myGetTransaction(KOMODO_EARLYTXID,tx,blockhash) && mapBlockIndex[blockhash]->GetHeight() < 100 )
+    if ( myGetTransaction(KOMODO_EARLYTXID,tx,blockhash) && mapBlockIndex[blockhash]->GetHeight() < KOMODO_EARLYTXID_HEIGHT )
     {
         for (i = 0; i < tx.vout.size(); i++) 
             if ( tx.vout[i].scriptPubKey[0] == OP_RETURN )
@@ -2261,7 +2287,7 @@ int64_t komodo_checkcommission(CBlock *pblock,int32_t height)
             if ( ASSETCHAINS_SCRIPTPUB.size() > 1 )
             {
                 static bool didinit = false;
-                if ( !didinit && height > 100 && KOMODO_EARLYTXID != zeroid && komodo_appendACscriptpub() )
+                if ( !didinit && height > KOMODO_EARLYTXID_HEIGHT && KOMODO_EARLYTXID != zeroid && komodo_appendACscriptpub() )
                 {
                     LogPrintf( "appended CC_op_return to ASSETCHAINS_SCRIPTPUB.%s\n", ASSETCHAINS_SCRIPTPUB.c_str());
                     didinit = true;
@@ -2328,6 +2354,8 @@ int32_t komodo_checkPOW(int64_t stakeTxValue, int32_t slowflag,CBlock *pblock,in
         if ( height == 0 )
             return(0);
     }
+    //if ( ASSETCHAINS_ADAPTIVEPOW > 0 )
+    //    bnTarget = komodo_adaptivepow_target(height,bnTarget,pblock->nTime);
     if ( ASSETCHAINS_LWMAPOS != 0 && bhash > bnTarget )
     {
         // if proof of stake is active, check if this is a valid PoS block before we fail
diff --git a/src/komodo_cJSON.h b/src/komodo_cJSON.h
index 94707859..bdf50d08 100644
--- a/src/komodo_cJSON.h
+++ b/src/komodo_cJSON.h
@@ -57,6 +57,12 @@ extern "C"
 {
 #endif
 
+#ifndef _BITS256
+#define _BITS256
+    union _bits256 { uint8_t bytes[32]; uint16_t ushorts[16]; uint32_t uints[8]; uint64_t ulongs[4]; uint64_t txid; };
+    typedef union _bits256 bits256;
+#endif
+
     /* Macros for creating things quickly. */
 #define cJSON_AddNullToObject(object,name)		cJSON_AddItemToObject(object, name, cJSON_CreateNull())
 #define cJSON_AddTrueToObject(object,name)		cJSON_AddItemToObject(object, name, cJSON_CreateTrue())
diff --git a/src/komodo_defs.h b/src/komodo_defs.h
index 5624194f..0bb4b98d 100644
--- a/src/komodo_defs.h
+++ b/src/komodo_defs.h
@@ -1,5 +1,5 @@
 /******************************************************************************
- * Copyright 
+ * Copyright © 2014-2019 The SuperNET Developers.                             *
  *                                                                            *
  * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
  * the top-level directory of this distribution for the individual copyright  *
@@ -15,9 +15,12 @@
 
 #ifndef KOMODO_DEFS_H
 #define KOMODO_DEFS_H
-#include "komodo_nk.h"
 #include "arith_uint256.h"
+#include "chain.h"
+#include "komodo_nk.h"
 
+#define KOMODO_EARLYTXID_HEIGHT 100
+//#define ADAPTIVEPOW_CHANGETO_DEFAULTON 1572480000
 #define ASSETCHAINS_MINHEIGHT 128
 #define ASSETCHAINS_MAX_ERAS 7
 #define KOMODO_ELECTION_GAP 2000
@@ -337,6 +340,7 @@ static const char *notaries_elected[NUM_KMD_SEASONS][NUM_KMD_NOTARIES][2] =
 //#endif
 
 extern uint8_t ASSETCHAINS_TXPOW,ASSETCHAINS_PUBLIC;
+extern int8_t ASSETCHAINS_ADAPTIVEPOW;
 int32_t MAX_BLOCK_SIZE(int32_t height);
 extern char ASSETCHAINS_SYMBOL[KOMODO_ASSETCHAIN_MAXLEN];
 extern uint16_t ASSETCHAINS_P2PPORT,ASSETCHAINS_RPCPORT;
@@ -347,10 +351,10 @@ extern uint64_t ASSETCHAINS_SUPPLY, ASSETCHAINS_FOUNDERS_REWARD;
 extern uint64_t ASSETCHAINS_TIMELOCKGTE;
 extern uint32_t ASSETCHAINS_ALGO, ASSETCHAINS_VERUSHASH,ASSETCHAINS_EQUIHASH,KOMODO_INITDONE;
 
-extern int32_t KOMODO_MININGTHREADS,KOMODO_LONGESTCHAIN,ASSETCHAINS_SEED,IS_KOMODO_NOTARY,USE_EXTERNAL_PUBKEY,KOMODO_CHOSEN_ONE,KOMODO_ON_DEMAND,KOMODO_PASSPORT_INITDONE,ASSETCHAINS_STAKED;
+extern int32_t KOMODO_MININGTHREADS,KOMODO_LONGESTCHAIN,ASSETCHAINS_SEED,IS_KOMODO_NOTARY,USE_EXTERNAL_PUBKEY,KOMODO_CHOSEN_ONE,KOMODO_ON_DEMAND,KOMODO_PASSPORT_INITDONE,ASSETCHAINS_STAKED,KOMODO_NSPV;
 extern uint64_t ASSETCHAINS_COMMISSION, ASSETCHAINS_LASTERA,ASSETCHAINS_CBOPRET;
 extern bool VERUS_MINTBLOCKS;
-extern uint64_t ASSETCHAINS_REWARD[ASSETCHAINS_MAX_ERAS], ASSETCHAINS_NOTARY_PAY[ASSETCHAINS_MAX_ERAS], ASSETCHAINS_TIMELOCKGTE, ASSETCHAINS_NONCEMASK[],ASSETCHAINS_NK[2];
+extern uint64_t ASSETCHAINS_REWARD[ASSETCHAINS_MAX_ERAS+1], ASSETCHAINS_NOTARY_PAY[ASSETCHAINS_MAX_ERAS+1], ASSETCHAINS_TIMELOCKGTE, ASSETCHAINS_NONCEMASK[],ASSETCHAINS_NK[2];
 extern const char *ASSETCHAINS_ALGORITHMS[];
 extern int32_t VERUS_MIN_STAKEAGE;
 extern uint32_t ASSETCHAINS_VERUSHASH, ASSETCHAINS_VERUSHASHV1_1, ASSETCHAINS_NONCESHIFT[], ASSETCHAINS_HASHESPERROUND[];
@@ -413,7 +417,28 @@ int64_t komodo_pricemult(int32_t ind);
 int32_t komodo_priceget(int64_t *buf64,int32_t ind,int32_t height,int32_t numblocks);
 uint64_t komodo_accrued_interest(int32_t *txheightp,uint32_t *locktimep,uint256 hash,int32_t n,int32_t checkheight,uint64_t checkvalue,int32_t tipheight);
 int32_t komodo_currentheight();
+int32_t komodo_notarized_bracket(struct notarized_checkpoint *nps[2],int32_t height);
+arith_uint256 komodo_adaptivepow_target(int32_t height,arith_uint256 bnTarget,uint32_t nTime);
 bool komodo_hardfork_active(uint32_t time);
 int32_t komodo_newStakerActive(int32_t height, uint32_t timestamp);
+
+uint256 Parseuint256(const char *hexstr);
+void komodo_sendmessage(int32_t minpeers, int32_t maxpeers, const char *message, std::vector<uint8_t> payload);
+CBlockIndex *komodo_getblockindex(uint256 hash);
+int32_t komodo_nextheight();
+CBlockIndex *komodo_blockindex(uint256 hash);
+CBlockIndex *komodo_chainactive(int32_t height);
+int32_t komodo_blockheight(uint256 hash);
+bool komodo_txnotarizedconfirmed(uint256 txid);
+int32_t komodo_blockload(CBlock& block, CBlockIndex *pindex);
 uint32_t komodo_chainactive_timestamp();
+uint32_t GetLatestTimestamp(int32_t height);
+
+#ifndef KOMODO_NSPV_FULLNODE
+#define KOMODO_NSPV_FULLNODE (KOMODO_NSPV <= 0)
+#endif // !KOMODO_NSPV_FULLNODE
+#ifndef KOMODO_NSPV_SUPERLITE
+#define KOMODO_NSPV_SUPERLITE (KOMODO_NSPV > 0)
+#endif // !KOMODO_NSPV_SUPERLITE
+
 #endif
diff --git a/src/komodo_gateway.h b/src/komodo_gateway.h
index 5ecbd54b..8c4437e5 100644
--- a/src/komodo_gateway.h
+++ b/src/komodo_gateway.h
@@ -656,6 +656,9 @@ const char *banned_txids[] =
     //"01d8c839463bda2f2f6400ede4611357913684927a767422a8560ead1b22557c",
     //"6e4980a9e1bd669f4df04732dc6f11b7773b6de88d1abcf89a6b9007d72ef9ac",
     //"6cc1d0495170bc0e11fd3925297623562e529ea1336b66ea61f8a1159041aed2",
+    //"250875424cece9bcd98cb226b09da7671625633d6958589e3a462bad89ad87cc", // missed
+    //"ea8659011de52f4dac42cda12326064b7b5013b8492f88e33159884ca299aa05", // missed
+    //"ce567928b5490a17244167af161b1d8dd6ff753fef222fe6855d95b2278a35b3", // missed
 };
 
 int32_t komodo_checkvout(int32_t vout,int32_t k,int32_t indallvouts)
@@ -727,8 +730,7 @@ int32_t komodo_check_deposit(int32_t height,const CBlock& block,uint32_t prevtim
                         {
                             notmatched = 1;
                         }
-                }
-
+                }  
             }
             n = block.vtx[i].vin.size();
             for (j=0; j<n; j++)
diff --git a/src/komodo_globals.h b/src/komodo_globals.h
index 2c4d241a..bf9d42ad 100644
--- a/src/komodo_globals.h
+++ b/src/komodo_globals.h
@@ -48,10 +48,12 @@ const int32_t nDecemberHardforkHeight = 1670000;   //December 2019 hardfork
 int COINBASE_MATURITY = _COINBASE_MATURITY;//100;
 unsigned int WITNESS_CACHE_SIZE = _COINBASE_MATURITY+10;
 uint256 KOMODO_EARLYTXID;
-int32_t KOMODO_MININGTHREADS = -1,IS_KOMODO_NOTARY,IS_STAKED_NOTARY,USE_EXTERNAL_PUBKEY,KOMODO_CHOSEN_ONE,ASSETCHAINS_SEED,KOMODO_ON_DEMAND,KOMODO_EXTERNAL_NOTARIES,KOMODO_PASSPORT_INITDONE,KOMODO_PAX,KOMODO_EXCHANGEWALLET,KOMODO_REWIND,STAKED_ERA,KOMODO_CONNECTING = -1,KOMODO_DEALERNODE,KOMODO_EXTRASATOSHI,ASSETCHAINS_FOUNDERS;
+
+int32_t KOMODO_MININGTHREADS = -1,IS_KOMODO_NOTARY,IS_STAKED_NOTARY,USE_EXTERNAL_PUBKEY,KOMODO_CHOSEN_ONE,ASSETCHAINS_SEED,KOMODO_ON_DEMAND,KOMODO_EXTERNAL_NOTARIES,KOMODO_PASSPORT_INITDONE,KOMODO_PAX,KOMODO_EXCHANGEWALLET,KOMODO_REWIND,STAKED_ERA,KOMODO_CONNECTING = -1,KOMODO_DEALERNODE,KOMODO_EXTRASATOSHI,ASSETCHAINS_FOUNDERS,ASSETCHAINS_CBMATURITY,KOMODO_NSPV;
 int32_t KOMODO_INSYNC,KOMODO_LASTMINED,prevKOMODO_LASTMINED,KOMODO_CCACTIVATE,JUMBLR_PAUSE = 1;
 std::string NOTARY_PUBKEY,ASSETCHAINS_NOTARIES,ASSETCHAINS_OVERRIDE_PUBKEY,DONATION_PUBKEY,ASSETCHAINS_SCRIPTPUB,NOTARY_ADDRESS,ASSETCHAINS_SELFIMPORT,ASSETCHAINS_CCLIB;
 uint8_t NOTARY_PUBKEY33[33],ASSETCHAINS_OVERRIDE_PUBKEY33[33],ASSETCHAINS_OVERRIDE_PUBKEYHASH[20],ASSETCHAINS_PUBLIC,ASSETCHAINS_PRIVATE,ASSETCHAINS_TXPOW,ASSETCHAINS_MARMARA;
+int8_t ASSETCHAINS_ADAPTIVEPOW;
 bool VERUS_MINTBLOCKS;
 std::vector<uint8_t> Mineropret;
 std::vector<std::string> vWhiteListAddress;
@@ -76,7 +78,7 @@ uint64_t ASSETCHAINS_TIMELOCKGTE = _ASSETCHAINS_TIMELOCKOFF;
 uint64_t ASSETCHAINS_TIMEUNLOCKFROM = 0, ASSETCHAINS_TIMEUNLOCKTO = 0,ASSETCHAINS_CBOPRET=0;
 
 uint64_t ASSETCHAINS_LASTERA = 1;
-uint64_t ASSETCHAINS_ENDSUBSIDY[ASSETCHAINS_MAX_ERAS],ASSETCHAINS_REWARD[ASSETCHAINS_MAX_ERAS],ASSETCHAINS_HALVING[ASSETCHAINS_MAX_ERAS],ASSETCHAINS_DECAY[ASSETCHAINS_MAX_ERAS],ASSETCHAINS_NOTARY_PAY[ASSETCHAINS_MAX_ERAS];
+uint64_t ASSETCHAINS_ENDSUBSIDY[ASSETCHAINS_MAX_ERAS+1],ASSETCHAINS_REWARD[ASSETCHAINS_MAX_ERAS+1],ASSETCHAINS_HALVING[ASSETCHAINS_MAX_ERAS+1],ASSETCHAINS_DECAY[ASSETCHAINS_MAX_ERAS+1],ASSETCHAINS_NOTARY_PAY[ASSETCHAINS_MAX_ERAS+1],ASSETCHAINS_PEGSCCPARAMS[3];
 uint8_t ASSETCHAINS_CCDISABLES[256];
 std::vector<std::string> ASSETCHAINS_PRICES,ASSETCHAINS_STOCKS;
 
diff --git a/src/komodo_nSPV.h b/src/komodo_nSPV.h
new file mode 100644
index 00000000..9aaa18ce
--- /dev/null
+++ b/src/komodo_nSPV.h
@@ -0,0 +1,602 @@
+
+/******************************************************************************
+ * Copyright © 2014-2019 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+
+// todo:
+// spentinfo via CC
+
+// headers "sync" make sure it connects to prior blocks to notarization. use getinfo hdrht to get missing hdrs
+
+// make sure to sanity check all vector lengths on receipt
+// make sure no files are updated (this is to allow nSPV=1 and later nSPV=0 without affecting database)
+// bug: under load, fullnode was returning all 0 nServices
+
+#ifndef KOMODO_NSPV_H
+#define KOMODO_NSPV_H
+
+int32_t iguana_rwbuf(int32_t rwflag,uint8_t *serialized,int32_t len,uint8_t *buf)
+{
+    if ( rwflag != 0 )
+        memcpy(serialized,buf,len);
+    else memcpy(buf,serialized,len);
+    return(len);
+}
+
+int32_t NSPV_rwequihdr(int32_t rwflag,uint8_t *serialized,struct NSPV_equihdr *ptr)
+{
+    int32_t len = 0;
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->nVersion),&ptr->nVersion);
+    len += iguana_rwbignum(rwflag,&serialized[len],sizeof(ptr->hashPrevBlock),(uint8_t *)&ptr->hashPrevBlock);
+    len += iguana_rwbignum(rwflag,&serialized[len],sizeof(ptr->hashMerkleRoot),(uint8_t *)&ptr->hashMerkleRoot);
+    len += iguana_rwbignum(rwflag,&serialized[len],sizeof(ptr->hashFinalSaplingRoot),(uint8_t *)&ptr->hashFinalSaplingRoot);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->nTime),&ptr->nTime);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->nBits),&ptr->nBits);
+    len += iguana_rwbignum(rwflag,&serialized[len],sizeof(ptr->nNonce),(uint8_t *)&ptr->nNonce);
+    len += iguana_rwbuf(rwflag,&serialized[len],sizeof(ptr->nSolution),ptr->nSolution);
+    return(len);
+}
+
+int32_t iguana_rwequihdrvec(int32_t rwflag,uint8_t *serialized,uint16_t *vecsizep,struct NSPV_equihdr **ptrp)
+{
+    int32_t i,vsize,len = 0;
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(*vecsizep),vecsizep);
+    if ( (vsize= *vecsizep) != 0 )
+    {
+        //LogPrintf("vsize.%d ptrp.%p alloc %ld\n",vsize,*ptrp,sizeof(struct NSPV_equihdr)*vsize);
+        if ( *ptrp == 0 )
+            *ptrp = (struct NSPV_equihdr *)calloc(sizeof(struct NSPV_equihdr),vsize); // relies on uint16_t being "small" to prevent mem exhaustion
+        for (i=0; i<vsize; i++)
+            len += NSPV_rwequihdr(rwflag,&serialized[len],&(*ptrp)[i]);
+    }
+    return(len);
+}
+
+int32_t iguana_rwuint8vec(int32_t rwflag,uint8_t *serialized,int32_t *biglenp,uint8_t **ptrp)
+{
+    int32_t vsize,len = 0;
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(*biglenp),biglenp);
+    if ( (vsize= *biglenp) > 0 && vsize < MAX_TX_SIZE_AFTER_SAPLING )
+    {
+        if ( *ptrp == 0 )
+            *ptrp = (uint8_t *)calloc(1,vsize);
+        len += iguana_rwbuf(rwflag,&serialized[len],vsize,*ptrp);
+    }
+    return(len);
+}
+
+int32_t NSPV_rwutxoresp(int32_t rwflag,uint8_t *serialized,struct NSPV_utxoresp *ptr)
+{
+    int32_t len = 0;
+    len += iguana_rwbignum(rwflag,&serialized[len],sizeof(ptr->txid),(uint8_t *)&ptr->txid);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->satoshis),&ptr->satoshis);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->extradata),&ptr->extradata);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->vout),&ptr->vout);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->height),&ptr->height);
+    return(len);
+}
+
+int32_t NSPV_rwutxosresp(int32_t rwflag,uint8_t *serialized,struct NSPV_utxosresp *ptr) // check mempool
+{
+    int32_t i,len = 0;
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->numutxos),&ptr->numutxos);
+    if ( ptr->numutxos != 0 )
+    {
+        if ( ptr->utxos == 0 )
+            ptr->utxos = (struct NSPV_utxoresp *)calloc(sizeof(*ptr->utxos),ptr->numutxos); // relies on uint16_t being "small" to prevent mem exhaustion
+        for (i=0; i<ptr->numutxos; i++)
+            len += NSPV_rwutxoresp(rwflag,&serialized[len],&ptr->utxos[i]);
+    }
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->total),&ptr->total);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->interest),&ptr->interest);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->nodeheight),&ptr->nodeheight);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->filter),&ptr->filter);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->CCflag),&ptr->CCflag);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->skipcount),&ptr->skipcount);
+    if ( rwflag != 0 )
+    {
+        memcpy(&serialized[len],ptr->coinaddr,sizeof(ptr->coinaddr));
+        len += sizeof(ptr->coinaddr);
+    }
+    else
+    {
+        memcpy(ptr->coinaddr,&serialized[len],sizeof(ptr->coinaddr));
+        len += sizeof(ptr->coinaddr);
+    }
+    return(len);
+}
+
+void NSPV_utxosresp_purge(struct NSPV_utxosresp *ptr)
+{
+    if ( ptr != 0 )
+    {
+        if ( ptr->utxos != 0 )
+            free(ptr->utxos);
+        memset(ptr,0,sizeof(*ptr));
+    }
+}
+
+void NSPV_utxosresp_copy(struct NSPV_utxosresp *dest,struct NSPV_utxosresp *ptr)
+{
+    *dest = *ptr;
+    if ( ptr->utxos != 0 )
+    {
+        dest->utxos = (struct NSPV_utxoresp *)malloc(ptr->numutxos * sizeof(*ptr->utxos));
+        memcpy(dest->utxos,ptr->utxos,ptr->numutxos * sizeof(*ptr->utxos));
+    }
+}
+
+int32_t NSPV_rwtxidresp(int32_t rwflag,uint8_t *serialized,struct NSPV_txidresp *ptr)
+{
+    int32_t len = 0;
+    len += iguana_rwbignum(rwflag,&serialized[len],sizeof(ptr->txid),(uint8_t *)&ptr->txid);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->satoshis),&ptr->satoshis);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->vout),&ptr->vout);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->height),&ptr->height);
+    return(len);
+}
+
+int32_t NSPV_rwtxidsresp(int32_t rwflag,uint8_t *serialized,struct NSPV_txidsresp *ptr)
+{
+    int32_t i,len = 0;
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->numtxids),&ptr->numtxids);
+    if ( ptr->numtxids != 0 )
+    {
+        if ( ptr->txids == 0 )
+            ptr->txids = (struct NSPV_txidresp *)calloc(sizeof(*ptr->txids),ptr->numtxids);
+        for (i=0; i<ptr->numtxids; i++)
+            len += NSPV_rwtxidresp(rwflag,&serialized[len],&ptr->txids[i]);
+    }
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->nodeheight),&ptr->nodeheight);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->filter),&ptr->filter);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->CCflag),&ptr->CCflag);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->skipcount),&ptr->skipcount);
+    if ( rwflag != 0 )
+    {
+        memcpy(&serialized[len],ptr->coinaddr,sizeof(ptr->coinaddr));
+        len += sizeof(ptr->coinaddr);
+    }
+    else
+    {
+        memcpy(ptr->coinaddr,&serialized[len],sizeof(ptr->coinaddr));
+        len += sizeof(ptr->coinaddr);
+    }
+//LogPrintf("rwlen.%d\n",len);
+    return(len);
+}
+
+void NSPV_txidsresp_purge(struct NSPV_txidsresp *ptr)
+{
+    if ( ptr != 0 )
+    {
+        if ( ptr->txids != 0 )
+            free(ptr->txids);
+        memset(ptr,0,sizeof(*ptr));
+    }
+}
+
+void NSPV_txidsresp_copy(struct NSPV_txidsresp *dest,struct NSPV_txidsresp *ptr)
+{
+    *dest = *ptr;
+    if ( ptr->txids != 0 )
+    {
+        dest->txids = (struct NSPV_txidresp *)malloc(ptr->numtxids * sizeof(*ptr->txids));
+        memcpy(dest->txids,ptr->txids,ptr->numtxids * sizeof(*ptr->txids));
+    }
+}
+
+int32_t NSPV_rwmempoolresp(int32_t rwflag,uint8_t *serialized,struct NSPV_mempoolresp *ptr)
+{
+    int32_t i,len = 0;
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->numtxids),&ptr->numtxids);
+    if ( ptr->numtxids != 0 )
+    {
+        if ( ptr->txids == 0 )
+            ptr->txids = (uint256 *)calloc(sizeof(*ptr->txids),ptr->numtxids);
+        for (i=0; i<ptr->numtxids; i++)
+            len += iguana_rwbignum(rwflag,&serialized[len],sizeof(ptr->txids[i]),(uint8_t *)&ptr->txids[i]);
+    }
+    len += iguana_rwbignum(rwflag,&serialized[len],sizeof(ptr->txid),(uint8_t *)&ptr->txid);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->nodeheight),&ptr->nodeheight);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->vout),&ptr->vout);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->vindex),&ptr->vindex);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->CCflag),&ptr->CCflag);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->funcid),&ptr->funcid);
+    if ( rwflag != 0 )
+    {
+        memcpy(&serialized[len],ptr->coinaddr,sizeof(ptr->coinaddr));
+        len += sizeof(ptr->coinaddr);
+    }
+    else
+    {
+        memcpy(ptr->coinaddr,&serialized[len],sizeof(ptr->coinaddr));
+        len += sizeof(ptr->coinaddr);
+    }
+    //LogPrintf("NSPV_rwmempoolresp rwlen.%d\n",len);
+    return(len);
+}
+
+void NSPV_mempoolresp_purge(struct NSPV_mempoolresp *ptr)
+{
+    if ( ptr != 0 )
+    {
+        if ( ptr->txids != 0 )
+            free(ptr->txids);
+        memset(ptr,0,sizeof(*ptr));
+    }
+}
+
+void NSPV_mempoolresp_copy(struct NSPV_mempoolresp *dest,struct NSPV_mempoolresp *ptr)
+{
+    *dest = *ptr;
+    if ( ptr->txids != 0 )
+    {
+        dest->txids = (uint256 *)malloc(ptr->numtxids * sizeof(*ptr->txids));
+        memcpy(dest->txids,ptr->txids,ptr->numtxids * sizeof(*ptr->txids));
+    }
+}
+
+int32_t NSPV_rwntz(int32_t rwflag,uint8_t *serialized,struct NSPV_ntz *ptr)
+{
+    int32_t len = 0;
+    len += iguana_rwbignum(rwflag,&serialized[len],sizeof(ptr->blockhash),(uint8_t *)&ptr->blockhash);
+    len += iguana_rwbignum(rwflag,&serialized[len],sizeof(ptr->txid),(uint8_t *)&ptr->txid);
+    len += iguana_rwbignum(rwflag,&serialized[len],sizeof(ptr->othertxid),(uint8_t *)&ptr->othertxid);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->height),&ptr->height);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->txidheight),&ptr->txidheight);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->timestamp),&ptr->timestamp);
+    return(len);
+}
+
+int32_t NSPV_rwntzsresp(int32_t rwflag,uint8_t *serialized,struct NSPV_ntzsresp *ptr)
+{
+    int32_t len = 0;
+    len += NSPV_rwntz(rwflag,&serialized[len],&ptr->prevntz);
+    len += NSPV_rwntz(rwflag,&serialized[len],&ptr->nextntz);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->reqheight),&ptr->reqheight);
+    return(len);
+}
+
+void NSPV_ntzsresp_copy(struct NSPV_ntzsresp *dest,struct NSPV_ntzsresp *ptr)
+{
+    *dest = *ptr;
+}
+
+void NSPV_ntzsresp_purge(struct NSPV_ntzsresp *ptr)
+{
+    if ( ptr != 0 )
+        memset(ptr,0,sizeof(*ptr));
+}
+
+int32_t NSPV_rwinforesp(int32_t rwflag,uint8_t *serialized,struct NSPV_inforesp *ptr)
+{
+    int32_t len = 0;
+    len += NSPV_rwntz(rwflag,&serialized[len],&ptr->notarization);
+    len += iguana_rwbignum(rwflag,&serialized[len],sizeof(ptr->blockhash),(uint8_t *)&ptr->blockhash);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->height),&ptr->height);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->hdrheight),&ptr->hdrheight);
+    len += NSPV_rwequihdr(rwflag,&serialized[len],&ptr->H);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->version),&ptr->version);
+//LogPrintf("getinfo rwlen.%d\n",len);
+    return(len);
+}
+
+void NSPV_inforesp_purge(struct NSPV_inforesp *ptr)
+{
+    if ( ptr != 0 )
+        memset(ptr,0,sizeof(*ptr));
+}
+
+int32_t NSPV_rwtxproof(int32_t rwflag,uint8_t *serialized,struct NSPV_txproof *ptr)
+{
+    int32_t len = 0;
+    len += iguana_rwbignum(rwflag,&serialized[len],sizeof(ptr->txid),(uint8_t *)&ptr->txid);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->unspentvalue),&ptr->unspentvalue);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->height),&ptr->height);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->vout),&ptr->vout);
+    len += iguana_rwuint8vec(rwflag,&serialized[len],&ptr->txlen,&ptr->tx);
+    len += iguana_rwuint8vec(rwflag,&serialized[len],&ptr->txprooflen,&ptr->txproof);
+    len += iguana_rwbignum(rwflag,&serialized[len],sizeof(ptr->hashblock),(uint8_t *)&ptr->hashblock);
+    return(len);
+}
+
+void NSPV_txproof_copy(struct NSPV_txproof *dest,struct NSPV_txproof *ptr)
+{
+    *dest = *ptr;
+    if ( ptr->tx != 0 && ptr->txlen < MAX_TX_SIZE_AFTER_SAPLING )
+    {
+        dest->tx = (uint8_t *)malloc(ptr->txlen);
+        memcpy(dest->tx,ptr->tx,ptr->txlen);
+    }
+    if ( ptr->txproof != 0 )
+    {
+        dest->txproof = (uint8_t *)malloc(ptr->txprooflen);
+        memcpy(dest->txproof,ptr->txproof,ptr->txprooflen);
+    }
+}
+
+void NSPV_txproof_purge(struct NSPV_txproof *ptr)
+{
+    if ( ptr != 0 )
+    {
+        if ( ptr->tx != 0 )
+            free(ptr->tx);
+        if ( ptr->txproof != 0 )
+            free(ptr->txproof);
+        memset(ptr,0,sizeof(*ptr));
+    }
+}
+
+int32_t NSPV_rwntzproofshared(int32_t rwflag,uint8_t *serialized,struct NSPV_ntzproofshared *ptr)
+{
+    int32_t len = 0;
+    len += iguana_rwequihdrvec(rwflag,&serialized[len],&ptr->numhdrs,&ptr->hdrs);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->prevht),&ptr->prevht);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->nextht),&ptr->nextht);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->pad32),&ptr->pad32);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->pad16),&ptr->pad16);
+    //LogPrintf("rwcommon prev.%d next.%d\n",ptr->prevht,ptr->nextht);
+    return(len);
+}
+
+int32_t NSPV_rwntzsproofresp(int32_t rwflag,uint8_t *serialized,struct NSPV_ntzsproofresp *ptr)
+{
+    int32_t len = 0;
+    len += NSPV_rwntzproofshared(rwflag,&serialized[len],&ptr->common);
+    len += iguana_rwbignum(rwflag,&serialized[len],sizeof(ptr->prevtxid),(uint8_t *)&ptr->prevtxid);
+    len += iguana_rwbignum(rwflag,&serialized[len],sizeof(ptr->nexttxid),(uint8_t *)&ptr->nexttxid);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->prevtxidht),&ptr->prevtxidht);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->nexttxidht),&ptr->nexttxidht);
+    len += iguana_rwuint8vec(rwflag,&serialized[len],&ptr->prevtxlen,&ptr->prevntz);
+    len += iguana_rwuint8vec(rwflag,&serialized[len],&ptr->nexttxlen,&ptr->nextntz);
+    //LogPrintf("retlen.%d\n",len);
+    return(len);
+}
+
+void NSPV_ntzsproofresp_copy(struct NSPV_ntzsproofresp *dest,struct NSPV_ntzsproofresp *ptr)
+{
+    *dest = *ptr;
+    if ( ptr->common.hdrs != 0 )
+    {
+        dest->common.hdrs = (struct NSPV_equihdr *)malloc(ptr->common.numhdrs * sizeof(*ptr->common.hdrs));
+        memcpy(dest->common.hdrs,ptr->common.hdrs,ptr->common.numhdrs * sizeof(*ptr->common.hdrs));
+    }
+    if ( ptr->prevntz != 0 )
+    {
+        dest->prevntz = (uint8_t *)malloc(ptr->prevtxlen);
+        memcpy(dest->prevntz,ptr->prevntz,ptr->prevtxlen);
+    }
+    if ( ptr->nextntz != 0 )
+    {
+        dest->nextntz = (uint8_t *)malloc(ptr->nexttxlen);
+        memcpy(dest->nextntz,ptr->nextntz,ptr->nexttxlen);
+    }
+}
+
+void NSPV_ntzsproofresp_purge(struct NSPV_ntzsproofresp *ptr)
+{
+    if ( ptr != 0 )
+    {
+        if ( ptr->common.hdrs != 0 )
+            free(ptr->common.hdrs);
+        if ( ptr->prevntz != 0 )
+            free(ptr->prevntz);
+        if ( ptr->nextntz != 0 )
+            free(ptr->nextntz);
+        memset(ptr,0,sizeof(*ptr));
+    }
+}
+
+int32_t NSPV_rwspentinfo(int32_t rwflag,uint8_t *serialized,struct NSPV_spentinfo *ptr) // check mempool
+{
+    int32_t len = 0;
+    len += NSPV_rwtxproof(rwflag,&serialized[len],&ptr->spent);
+    len += iguana_rwbignum(rwflag,&serialized[len],sizeof(ptr->txid),(uint8_t *)&ptr->txid);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->vout),&ptr->vout);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->spentvini),&ptr->spentvini);
+    return(len);
+}
+
+void NSPV_spentinfo_purge(struct NSPV_spentinfo *ptr)
+{
+    if ( ptr != 0 )
+    {
+        NSPV_txproof_purge(&ptr->spent);
+        memset(ptr,0,sizeof(*ptr));
+    }
+}
+
+int32_t NSPV_rwbroadcastresp(int32_t rwflag,uint8_t *serialized,struct NSPV_broadcastresp *ptr)
+{
+    int32_t len = 0;
+    len += iguana_rwbignum(rwflag,&serialized[len],sizeof(ptr->txid),(uint8_t *)&ptr->txid);
+    len += iguana_rwnum(rwflag,&serialized[len],sizeof(ptr->retcode),&ptr->retcode);
+    return(len);
+}
+
+void NSPV_broadcast_purge(struct NSPV_broadcastresp *ptr)
+{
+    if ( ptr != 0 )
+        memset(ptr,0,sizeof(*ptr));
+}
+
+int32_t NSPV_rwremoterpcresp(int32_t rwflag,uint8_t *serialized,struct NSPV_remoterpcresp *ptr, int32_t slen)
+{
+    int32_t len = 0;
+    len+=iguana_rwbuf(rwflag,&serialized[len],sizeof(ptr->method),(uint8_t*)ptr->method);
+    len+=iguana_rwbuf(rwflag,&serialized[len],slen-len,(uint8_t*)ptr->json);
+    return(len);
+}
+
+void NSPV_remoterpc_purge(struct NSPV_remoterpcresp *ptr)
+{
+    if ( ptr != 0 )
+        memset(ptr,0,sizeof(*ptr));
+}
+
+// useful utility functions
+
+uint256 NSPV_doublesha256(uint8_t *data,int32_t datalen)
+{
+    bits256 _hash; uint256 hash; int32_t i;
+    _hash = bits256_doublesha256(0,data,datalen);
+    for (i=0; i<32; i++)
+        ((uint8_t *)&hash)[i] = _hash.bytes[31 - i];
+    return(hash);
+}
+
+uint256 NSPV_hdrhash(struct NSPV_equihdr *hdr)
+{
+    CBlockHeader block;
+    block.nVersion = hdr->nVersion;
+    block.hashPrevBlock = hdr->hashPrevBlock;
+    block.hashMerkleRoot = hdr->hashMerkleRoot;
+    block.hashFinalSaplingRoot = hdr->hashFinalSaplingRoot;
+    block.nTime = hdr->nTime;
+    block.nBits = hdr->nBits;
+    block.nNonce = hdr->nNonce;
+    block.nSolution.resize(sizeof(hdr->nSolution));
+    memcpy(&block.nSolution[0],hdr->nSolution,sizeof(hdr->nSolution));
+    return(block.GetHash());
+}
+
+int32_t NSPV_txextract(CTransaction &tx,uint8_t *data,int32_t datalen)
+{
+    std::vector<uint8_t> rawdata;
+    if ( datalen < MAX_TX_SIZE_AFTER_SAPLING )
+    {
+        rawdata.resize(datalen);
+        memcpy(&rawdata[0],data,datalen);
+        if ( DecodeHexTx(tx,HexStr(rawdata)) != 0 )
+            return(0);
+    }
+    return(-1);
+}
+
+bool NSPV_SignTx(CMutableTransaction &mtx,int32_t vini,int64_t utxovalue,const CScript scriptPubKey,uint32_t nTime);
+
+int32_t NSPV_fastnotariescount(CTransaction tx,uint8_t elected[64][33],uint32_t nTime)
+{
+    CPubKey pubkeys[64]; uint8_t sig[512]; CScript scriptPubKeys[64]; CMutableTransaction mtx(tx); int32_t vini,j,siglen,retval; uint64_t mask = 0; char *str; std::vector<std::vector<unsigned char>> vData;
+    for (j=0; j<64; j++)
+    {
+        pubkeys[j] = buf2pk(elected[j]);
+        scriptPubKeys[j] = (CScript() << ParseHex(HexStr(pubkeys[j])) << OP_CHECKSIG);
+        //LogPrintf("%d %s\n",j,HexStr(pubkeys[j]).c_str());
+    }
+    LogPrintf("txid %s\n",tx.GetHash().GetHex().c_str());
+    //for (vini=0; vini<tx.vin.size(); vini++)
+    //    mtx.vin[vini].scriptSig.resize(0);
+    for (vini=0; vini<tx.vin.size(); vini++)
+    {
+        CScript::const_iterator pc = tx.vin[vini].scriptSig.begin();
+        if ( tx.vin[vini].scriptSig.GetPushedData(pc,vData) != 0 )
+        {
+            vData[0].pop_back();
+            for (j=0; j<64; j++)
+            {
+                if ( ((1LL << j) & mask) != 0 )
+                    continue;
+                char coinaddr[64]; Getscriptaddress(coinaddr,scriptPubKeys[j]);
+                NSPV_SignTx(mtx,vini,10000,scriptPubKeys[j],nTime); // sets SIG_TXHASH
+                //LogPrintf("%s ",SIG_TXHASH.GetHex().c_str());
+                if ( (retval= pubkeys[j].Verify(SIG_TXHASH,vData[0])) != 0 )
+                {
+                    //LogPrintf("(vini.%d %s.%d) ",vini,coinaddr,retval);
+                    mask |= (1LL << j);
+                    break;
+                }
+            }
+            //LogPrintf(" vini.%d verified %llx\n",vini,(long long)mask);
+        }
+    }
+    return(bitweight(mask));
+}
+
+/*
+ NSPV_notariescount is the slowest process during full validation as it requires looking up 13 transactions.
+ one way that would be 10000x faster would be to bruteforce validate the signatures in each vin, against all 64 pubkeys! for a valid tx, that is on average 13*32 secp256k1/sapling verify operations, which is much faster than even a single network request.
+ Unfortunately, due to the complexity of calculating the hash to sign for a tx, this bruteforcing would require determining what type of signature method and having sapling vs legacy methods of calculating the txhash.
+ It could be that the fullnode side could calculate this and send it back to the superlite side as any hash that would validate 13 different ways has to be the valid txhash.
+ However, since the vouts being spent by the notaries are highly constrained p2pk vouts, the txhash can be deduced if a specific notary pubkey is indeed the signer
+ */
+int32_t NSPV_notariescount(CTransaction tx,uint8_t elected[64][33])
+{
+    uint8_t *script; CTransaction vintx; int64_t rewardsum = 0; int32_t i,j,utxovout,scriptlen,numsigs = 0,txheight,currentheight; uint256 hashBlock;
+    for (i=0; i<tx.vin.size(); i++)
+    {
+        utxovout = tx.vin[i].prevout.n;
+        if ( NSPV_gettransaction(1,utxovout,tx.vin[i].prevout.hash,0,vintx,hashBlock,txheight,currentheight,-1,0,rewardsum) != 0 )
+        {
+            LogPrintf("error getting %s/v%d\n",tx.vin[i].prevout.hash.GetHex().c_str(),utxovout);
+            return(numsigs);
+        }
+        if ( utxovout < vintx.vout.size() )
+        {
+            script = (uint8_t *)&vintx.vout[utxovout].scriptPubKey[0];
+            if ( (scriptlen= vintx.vout[utxovout].scriptPubKey.size()) == 35 )
+            {
+                for (j=0; j<64; j++)
+                    if ( memcmp(&script[1],elected[j],33) == 0 )
+                    {
+                        numsigs++;
+                        break;
+                    }
+            } else LogPrintf("invalid scriptlen.%d\n",scriptlen);
+        } else LogPrintf("invalid utxovout.%d vs %d\n",utxovout,(int32_t)vintx.vout.size());
+    }
+    return(numsigs);
+}
+
+uint256 NSPV_opretextract(int32_t *heightp,uint256 *blockhashp,char *symbol,std::vector<uint8_t> opret,uint256 txid)
+{
+    uint256 desttxid; int32_t i;
+    iguana_rwnum(0,&opret[32],sizeof(*heightp),heightp);
+    for (i=0; i<32; i++)
+        ((uint8_t *)blockhashp)[i] = opret[i];
+    for (i=0; i<32; i++)
+        ((uint8_t *)&desttxid)[i] = opret[4 + 32 + i];
+    if ( 0 && *heightp != 2690 )
+        LogPrintf(" ntzht.%d %s <- txid.%s size.%d\n",*heightp,(*blockhashp).GetHex().c_str(),(txid).GetHex().c_str(),(int32_t)opret.size());
+    return(desttxid);
+}
+
+int32_t NSPV_notarizationextract(int32_t verifyntz,int32_t *ntzheightp,uint256 *blockhashp,uint256 *desttxidp,CTransaction tx)
+{
+    int32_t numsigs=0; uint8_t elected[64][33]; char *symbol; std::vector<uint8_t> opret; uint32_t nTime;
+    if ( tx.vout.size() >= 2 )
+    {
+        symbol = (ASSETCHAINS_SYMBOL[0] == 0) ? (char *)"KMD" : ASSETCHAINS_SYMBOL;
+        GetOpReturnData(tx.vout[1].scriptPubKey,opret);
+        if ( opret.size() >= 32*2+4 )
+        {
+            //sleep(1); // needed to avoid no pnodes error
+            *desttxidp = NSPV_opretextract(ntzheightp,blockhashp,symbol,opret,tx.GetHash());
+            nTime = NSPV_blocktime(*ntzheightp);
+            komodo_notaries(elected,*ntzheightp,nTime);
+            if ( verifyntz != 0 && (numsigs= NSPV_fastnotariescount(tx,elected,nTime)) < 12 )
+            {
+                LogPrintf("numsigs.%d error\n",numsigs);
+                return(-3);
+            } 
+            return(0);
+        }
+        else
+        {
+            LogPrintf("opretsize.%d error\n",(int32_t)opret.size());
+            return(-2);
+        }
+    } else return(-1);
+}
+#endif // KOMODO_NSPV_H
diff --git a/src/komodo_nSPV_defs.h b/src/komodo_nSPV_defs.h
new file mode 100644
index 00000000..40d9dc02
--- /dev/null
+++ b/src/komodo_nSPV_defs.h
@@ -0,0 +1,192 @@
+
+/******************************************************************************
+ * Copyright © 2014-2019 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+
+#ifndef KOMODO_NSPV_DEFSH
+#define KOMODO_NSPV_DEFSH
+
+#define NSPV_PROTOCOL_VERSION 0x00000004
+#define NSPV_POLLITERS 200
+#define NSPV_POLLMICROS 50000
+#define NSPV_MAXVINS 64
+#define NSPV_AUTOLOGOUT 777
+#define NSPV_BRANCHID 0x76b809bb
+
+// nSPV defines and struct definitions with serialization and purge functions
+
+#define NSPV_INFO 0x00
+#define NSPV_INFORESP 0x01
+#define NSPV_UTXOS 0x02
+#define NSPV_UTXOSRESP 0x03
+#define NSPV_NTZS 0x04
+#define NSPV_NTZSRESP 0x05
+#define NSPV_NTZSPROOF 0x06
+#define NSPV_NTZSPROOFRESP 0x07
+#define NSPV_TXPROOF 0x08
+#define NSPV_TXPROOFRESP 0x09
+#define NSPV_SPENTINFO 0x0a
+#define NSPV_SPENTINFORESP 0x0b
+#define NSPV_BROADCAST 0x0c
+#define NSPV_BROADCASTRESP 0x0d
+#define NSPV_TXIDS 0x0e
+#define NSPV_TXIDSRESP 0x0f
+#define NSPV_MEMPOOL 0x10
+#define NSPV_MEMPOOLRESP 0x11
+#define NSPV_CCMODULEUTXOS 0x12
+#define NSPV_CCMODULEUTXOSRESP 0x13
+#define NSPV_MEMPOOL_ALL 0
+#define NSPV_MEMPOOL_ADDRESS 1
+#define NSPV_MEMPOOL_ISSPENT 2
+#define NSPV_MEMPOOL_INMEMPOOL 3
+#define NSPV_MEMPOOL_CCEVALCODE 4
+#define NSPV_CC_TXIDS 16
+#define NSPV_REMOTERPC 0x14
+#define NSPV_REMOTERPCRESP 0x15
+
+int32_t NSPV_gettransaction(int32_t skipvalidation,int32_t vout,uint256 txid,int32_t height,CTransaction &tx,uint256 &hashblock,int32_t &txheight,int32_t &currentheight,int64_t extradata,uint32_t tiptime,int64_t &rewardsum);
+UniValue NSPV_spend(char *srcaddr,char *destaddr,int64_t satoshis);
+extern uint256 SIG_TXHASH;
+uint32_t NSPV_blocktime(int32_t hdrheight);
+
+struct NSPV_equihdr
+{
+    int32_t nVersion;
+    uint256 hashPrevBlock;
+    uint256 hashMerkleRoot;
+    uint256 hashFinalSaplingRoot;
+    uint32_t nTime;
+    uint32_t nBits;
+    uint256 nNonce;
+    uint8_t nSolution[1344];
+};
+
+struct NSPV_utxoresp
+{
+    uint256 txid;
+    int64_t satoshis,extradata;
+    int32_t vout,height;
+};
+
+struct NSPV_utxosresp
+{
+    struct NSPV_utxoresp *utxos;
+    char coinaddr[64];
+    int64_t total,interest;
+    int32_t nodeheight,skipcount,filter;
+    uint16_t numutxos,CCflag;
+};
+
+struct NSPV_txidresp
+{
+    uint256 txid;
+    int64_t satoshis;
+    int32_t vout,height;
+};
+
+struct NSPV_txidsresp
+{
+    struct NSPV_txidresp *txids;
+    char coinaddr[64];
+    int32_t nodeheight,skipcount,filter;
+    uint16_t numtxids,CCflag;
+};
+
+struct NSPV_mempoolresp
+{
+    uint256 *txids;
+    char coinaddr[64];
+    uint256 txid;
+    int32_t nodeheight,vout,vindex;
+    uint16_t numtxids; uint8_t CCflag,funcid;
+};
+
+struct NSPV_ntz
+{
+    uint256 blockhash,txid,othertxid;
+    int32_t height,txidheight;
+    uint32_t timestamp;
+};
+
+struct NSPV_ntzsresp
+{
+    struct NSPV_ntz prevntz,nextntz;
+    int32_t reqheight;
+};
+
+struct NSPV_inforesp
+{
+    struct NSPV_ntz notarization;
+    uint256 blockhash;
+    int32_t height,hdrheight;
+    struct NSPV_equihdr H;
+    uint32_t version;
+};
+
+struct NSPV_txproof
+{
+    uint256 txid;
+    int64_t unspentvalue;
+    int32_t height,vout,txlen,txprooflen;
+    uint8_t *tx,*txproof;
+    uint256 hashblock;
+};
+
+struct NSPV_ntzproofshared
+{
+    struct NSPV_equihdr *hdrs;
+    int32_t prevht,nextht,pad32;
+    uint16_t numhdrs,pad16;
+};
+
+struct NSPV_ntzsproofresp
+{
+    struct NSPV_ntzproofshared common;
+    uint256 prevtxid,nexttxid;
+    int32_t prevtxidht,nexttxidht,prevtxlen,nexttxlen;
+    uint8_t *prevntz,*nextntz;
+};
+
+struct NSPV_MMRproof
+{
+    struct NSPV_ntzproofshared common;
+    // tbd
+};
+
+struct NSPV_spentinfo
+{
+    struct NSPV_txproof spent;
+    uint256 txid;
+    int32_t vout,spentvini;
+};
+
+struct NSPV_broadcastresp
+{
+    uint256 txid;
+    int32_t retcode;
+};
+
+struct NSPV_CCmtxinfo
+{
+    struct NSPV_utxosresp U;
+    struct NSPV_utxoresp used[NSPV_MAXVINS];
+};
+
+struct NSPV_remoterpcresp
+{
+    char method[64];
+    char json[11000];
+};
+
+#endif // KOMODO_NSPV_DEFSH
diff --git a/src/komodo_nSPV_fullnode.h b/src/komodo_nSPV_fullnode.h
new file mode 100644
index 00000000..d758f686
--- /dev/null
+++ b/src/komodo_nSPV_fullnode.h
@@ -0,0 +1,1230 @@
+
+/******************************************************************************
+ * Copyright © 2014-2019 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+
+#ifndef KOMODO_NSPVFULLNODE_H
+#define KOMODO_NSPVFULLNODE_H
+
+// NSPV_get... functions need to return the exact serialized length, which is the size of the structure minus size of pointers, plus size of allocated data
+
+#include "notarisationdb.h"
+#include "rpc/server.h"
+
+static std::map<std::string,bool> nspv_remote_commands =  {{"channelsopen", true},{"channelspayment", true},{"channelsclose", true},{"channelsrefund", true},
+{"channelslist", true},{"channelsinfo", true},{"oraclescreate", true},{"oraclesfund", true},{"oraclesregister", true},{"oraclessubscribe", true}, 
+{"oraclesdata", true},{"oraclesinfo", false},{"oracleslist", false},{"gatewaysbind", true},{"gatewaysdeposit", true},{"gatewaysclaim", true},{"gatewayswithdraw", true},
+{"gatewayspartialsign", true},{"gatewayscompletesigning", true},{"gatewaysmarkdone", true},{"gatewayspendingdeposits", true},{"gatewayspendingwithdraws", true},
+{"gatewaysprocessed", true},{"gatewaysinfo", false},{"gatewayslist", false},{"faucetfund", true},{"faucetget", true}};
+
+struct NSPV_ntzargs
+{
+    uint256 txid,desttxid,blockhash;
+    int32_t txidht,ntzheight;
+};
+
+int32_t NSPV_notarization_find(struct NSPV_ntzargs *args,int32_t height,int32_t dir)
+{
+    int32_t ntzheight = 0; uint256 hashBlock; CTransaction tx; Notarisation nota; char *symbol; std::vector<uint8_t> opret;
+    symbol = (ASSETCHAINS_SYMBOL[0] == 0) ? (char *)"KMD" : ASSETCHAINS_SYMBOL;
+    memset(args,0,sizeof(*args));
+    if ( dir > 0 )
+        height += 10;
+    if ( (args->txidht= ScanNotarisationsDB(height,symbol,1440,nota)) == 0 )
+        return(-1);
+    args->txid = nota.first;
+    if ( !GetTransaction(args->txid,tx,hashBlock,false) || tx.vout.size() < 2 )
+        return(-2);
+    GetOpReturnData(tx.vout[1].scriptPubKey,opret);
+    if ( opret.size() >= 32*2+4 )
+        args->desttxid = NSPV_opretextract(&args->ntzheight,&args->blockhash,symbol,opret,args->txid);
+    return(args->ntzheight);
+}
+
+int32_t NSPV_notarized_bracket(struct NSPV_ntzargs *prev,struct NSPV_ntzargs *next,int32_t height)
+{
+    uint256 bhash; int32_t txidht,ntzht,nextht,i=0;
+    memset(prev,0,sizeof(*prev));
+    memset(next,0,sizeof(*next));
+    if ( (ntzht= NSPV_notarization_find(prev,height,-1)) < 0 || ntzht > height || ntzht == 0 )
+        return(-1);
+    txidht = height+1;
+    while ( (ntzht=  NSPV_notarization_find(next,txidht,1)) < height )
+    {
+        nextht = next->txidht + 10*i;
+//LogPrintf("found forward ntz, but ntzht.%d vs height.%d, txidht.%d -> nextht.%d\n",next->ntzheight,height,txidht,nextht);
+        memset(next,0,sizeof(*next));
+        txidht = nextht;
+        if ( ntzht <= 0 )
+            break;
+        if ( i++ > 10 )
+            break;
+    }
+    return(0);
+}
+
+int32_t NSPV_ntzextract(struct NSPV_ntz *ptr,uint256 ntztxid,int32_t txidht,uint256 desttxid,int32_t ntzheight)
+{
+    CBlockIndex *pindex;
+    ptr->blockhash = *chainActive[ntzheight]->phashBlock;
+    ptr->height = ntzheight;
+    ptr->txidheight = txidht;
+    ptr->othertxid = desttxid;
+    ptr->txid = ntztxid;
+    if ( (pindex= komodo_chainactive(ptr->txidheight)) != 0 )
+        ptr->timestamp = pindex->nTime;
+    return(0);
+}
+
+int32_t NSPV_getntzsresp(struct NSPV_ntzsresp *ptr,int32_t origreqheight)
+{
+    struct NSPV_ntzargs prev,next; int32_t reqheight = origreqheight;
+    if ( reqheight < chainActive.LastTip()->GetHeight() )
+        reqheight++;
+    if ( NSPV_notarized_bracket(&prev,&next,reqheight) == 0 )
+    {
+        if ( prev.ntzheight != 0 )
+        {
+            ptr->reqheight = origreqheight;
+            if ( NSPV_ntzextract(&ptr->prevntz,prev.txid,prev.txidht,prev.desttxid,prev.ntzheight) < 0 )
+                return(-1);
+        }
+        if ( next.ntzheight != 0 )
+        {
+            if ( NSPV_ntzextract(&ptr->nextntz,next.txid,next.txidht,next.desttxid,next.ntzheight) < 0 )
+                return(-1);
+        }
+    }
+    return(sizeof(*ptr));
+}
+
+int32_t NSPV_setequihdr(struct NSPV_equihdr *hdr,int32_t height)
+{
+    CBlockIndex *pindex;
+    if ( (pindex= komodo_chainactive(height)) != 0 )
+    {
+        hdr->nVersion = pindex->nVersion;
+        if ( pindex->pprev == 0 )
+            return(-1);
+        hdr->hashPrevBlock = pindex->pprev->GetBlockHash();
+        hdr->hashMerkleRoot = pindex->hashMerkleRoot;
+        hdr->hashFinalSaplingRoot = pindex->hashFinalSaplingRoot;
+        hdr->nTime = pindex->nTime;
+        hdr->nBits = pindex->nBits;
+        hdr->nNonce = pindex->nNonce;
+        memcpy(hdr->nSolution,&pindex->nSolution[0],sizeof(hdr->nSolution));
+        return(sizeof(*hdr));
+    }
+    return(-1);
+}
+
+int32_t NSPV_getinfo(struct NSPV_inforesp *ptr,int32_t reqheight)
+{
+    int32_t prevMoMheight,len = 0; CBlockIndex *pindex, *pindex2; struct NSPV_ntzsresp pair;
+    if ( (pindex= chainActive.LastTip()) != 0 )
+    {
+        ptr->height = pindex->GetHeight();
+        ptr->blockhash = pindex->GetBlockHash();
+        memset(&pair,0,sizeof(pair));
+        if ( NSPV_getntzsresp(&pair,ptr->height-1) < 0 )
+            return(-1);
+        ptr->notarization = pair.prevntz;
+        if ( (pindex2= komodo_chainactive(ptr->notarization.txidheight)) != 0 )
+            ptr->notarization.timestamp = pindex->nTime;
+        //LogPrintf( "timestamp.%i\n", ptr->notarization.timestamp );
+        if ( reqheight == 0 )
+            reqheight = ptr->height;
+        ptr->hdrheight = reqheight;
+        ptr->version = NSPV_PROTOCOL_VERSION;
+        if ( NSPV_setequihdr(&ptr->H,reqheight) < 0 )
+            return(-1);
+        return(sizeof(*ptr));
+    } else return(-1);
+}
+
+int32_t NSPV_getaddressutxos(struct NSPV_utxosresp *ptr,char *coinaddr,bool isCC,int32_t skipcount,uint32_t filter)
+{
+    int64_t total = 0,interest=0; uint32_t locktime; int32_t ind=0,tipheight,maxlen,txheight,n = 0,len = 0;
+    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
+    SetCCunspents(unspentOutputs,coinaddr,isCC);
+    maxlen = MAX_BLOCK_SIZE(tipheight) - 512;
+    maxlen /= sizeof(*ptr->utxos);
+    strncpy(ptr->coinaddr,coinaddr,sizeof(ptr->coinaddr)-1);
+    ptr->CCflag = isCC;
+    ptr->filter = filter;
+    if ( skipcount < 0 )
+        skipcount = 0;
+    if ( (ptr->numutxos= (int32_t)unspentOutputs.size()) >= 0 && ptr->numutxos < maxlen )
+    {
+        tipheight = chainActive.LastTip()->GetHeight();
+        ptr->nodeheight = tipheight;
+        if ( skipcount >= ptr->numutxos )
+            skipcount = ptr->numutxos-1;
+        ptr->skipcount = skipcount;
+        if ( ptr->numutxos-skipcount > 0 )
+        {
+            ptr->utxos = (struct NSPV_utxoresp *)calloc(ptr->numutxos-skipcount,sizeof(*ptr->utxos));
+            for (std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> >::const_iterator it=unspentOutputs.begin(); it!=unspentOutputs.end(); it++)
+            {
+                // if gettxout is != null to handle mempool
+                {
+                    if ( n >= skipcount && myIsutxo_spentinmempool(ignoretxid,ignorevin,it->first.txhash,(int32_t)it->first.index) == 0  )
+                    {
+                        ptr->utxos[ind].txid = it->first.txhash;
+                        ptr->utxos[ind].vout = (int32_t)it->first.index;
+                        ptr->utxos[ind].satoshis = it->second.satoshis;
+                        ptr->utxos[ind].height = it->second.blockHeight;
+                        if ( ASSETCHAINS_SYMBOL[0] == 0 && it->second.satoshis >= 10*COIN )
+                        {
+                            ptr->utxos[n].extradata = komodo_accrued_interest(&txheight,&locktime,ptr->utxos[ind].txid,ptr->utxos[ind].vout,ptr->utxos[ind].height,ptr->utxos[ind].satoshis,tipheight);
+                            interest += ptr->utxos[ind].extradata;
+                        }
+                        ind++;
+                        total += it->second.satoshis;
+                    }
+                    n++;
+                }
+            }
+        }
+        ptr->numutxos = ind;
+        if ( len < maxlen )
+        {
+            len = (int32_t)(sizeof(*ptr) + sizeof(*ptr->utxos)*ptr->numutxos - sizeof(ptr->utxos));
+            //LogPrintf("getaddressutxos for %s -> n.%d:%d total %.8f interest %.8f len.%d\n",coinaddr,n,ptr->numutxos,dstr(total),dstr(interest),len);
+            ptr->total = total;
+            ptr->interest = interest;
+            return(len);
+        }
+    }
+    if ( ptr->utxos != 0 )
+        free(ptr->utxos);
+    memset(ptr,0,sizeof(*ptr));
+    return(0);
+}
+
+class BaseCCChecker {
+public:
+    /// base check function
+    /// @param vouts vouts where checked vout and opret are
+    /// @param nvout vout index to check
+    /// @param evalcode which must be in the opret
+    /// @param funcids allowed funcids in string
+    /// @param filtertxid txid that should be in the opret (after funcid)
+    virtual bool checkCC(uint256 txid, const std::vector<CTxOut> &vouts, int32_t nvout, uint8_t evalcode, std::string funcids, uint256 filtertxid) = 0;
+};
+
+/// default cc vout checker for use in NSPV_getccmoduleutxos
+/// checks if a vout is cc, has required evalcode, allowed funcids and txid
+/// check both cc opret and last vout opret
+/// maybe customized in via inheritance
+class DefaultCCChecker : public BaseCCChecker {
+
+private:
+
+public:
+    DefaultCCChecker() { }
+    virtual bool checkCC(uint256 txid, const std::vector<CTxOut> &vouts, int32_t nvout, uint8_t evalcode, std::string funcids, uint256 filtertxid)
+    {
+        CScript opret, dummy;
+        std::vector< vscript_t > vParams;
+        vscript_t vopret;
+
+        if (nvout < vouts.size())
+        {
+            // first check if it is cc vout
+            if (vouts[nvout].scriptPubKey.IsPayToCryptoCondition(&dummy, vParams))
+            {
+                // try to find cc opret
+                if (vParams.size() > 0)
+                {
+                    COptCCParams p(vParams[0]); // parse vout data
+                    if (p.vData.size() > 0)
+                    {
+                        vopret = p.vData[0]; // get opret data
+                    }
+                }
+                // if no cc opret check last vout opret
+                if (vopret.size() == 0)
+                {
+                    GetOpReturnData(vouts.back().scriptPubKey, vopret);
+                }
+                if (vopret.size() > 2)
+                {
+                    uint8_t opretEvalcode, opretFuncid;
+                    uint256 opretTxid;
+                    bool isEof = true;
+                    bool isCreateTx = false;
+
+                    // parse opret first 3 fields:
+                    bool parseOk = E_UNMARSHAL(vopret, 
+                        ss >> opretEvalcode; 
+                        ss >> opretFuncid; 
+                        if (funcids.size() > 0 && opretFuncid == funcids[0]) // this means that we check txid only for second+ funcid in array (considering that the first funcid is the creation txid itself like tokens) 
+                        {
+                            isCreateTx = true;
+                        }
+                        else
+                        {
+                            ss >> opretTxid;
+                            isCreateTx = false;
+                        }
+                        isEof = ss.eof(); );
+
+                    opretTxid = revuint256(opretTxid);
+                    std::cerr << __func__ << " " << "opretEvalcode=" << opretEvalcode << " opretFuncid=" << (char)opretFuncid << " isCreateTx=" << isCreateTx << " opretTxid=" << opretTxid.GetHex() << std::endl;
+                    if( parseOk /*parseOk=true if eof reached*/|| !isEof /*more data means okay*/)
+                    {
+                        if (evalcode == opretEvalcode && std::find(funcids.begin(), funcids.end(), (char)opretFuncid) != funcids.end() && 
+                            (isCreateTx && filtertxid == txid || !isCreateTx && filtertxid == opretTxid))
+                        {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+        return false;
+    }
+};
+
+static class DefaultCCChecker defaultCCChecker;
+
+// table of pluggable cc vout checkers for usage in NSPV_getccmoduleutxos
+// if the checker is not in the table for a evalcode then defaultCCChecker is used 
+static std::map<uint8_t, class BaseCCChecker*> ccCheckerTable = 
+{
+};
+
+// implements SPV server's part, gets cc module utxos, filtered by evalcode, funcid and txid on opret, for the specified amount
+// if the amount param is 0 returns total available filtere utxo amount and returns no utxos 
+// first char funcid in the string param is considered as the creation tx funcid so filtertxid is compared to the creation txid itself
+// for other funcids filtertxid is compared to the txid in opreturn
+int32_t NSPV_getccmoduleutxos(struct NSPV_utxosresp *ptr, char *coinaddr, int64_t amount, uint8_t evalcode,  std::string funcids, uint256 filtertxid)
+{
+    int64_t total = 0, totaladded = 0; 
+    uint32_t locktime; 
+    int32_t tipheight=0, len, maxlen;
+    int32_t maxinputs = CC_MAXVINS;
+
+    std::vector<struct CC_utxo> utxoSelected;
+    utxoSelected.reserve(CC_MAXVINS);
+
+    std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > unspentOutputs;
+    SetCCunspents(unspentOutputs, coinaddr, true);
+
+    maxlen = MAX_BLOCK_SIZE(tipheight) - 512;
+    //maxlen /= sizeof(*ptr->utxos);  // TODO why was this? we need maxlen in bytes, don't we? 
+    
+    //ptr->numutxos = (uint16_t)unspentOutputs.size();
+    //if (ptr->numutxos >= 0 && ptr->numutxos < maxlen)
+    //{
+    ptr->utxos = NULL;
+    ptr->numutxos = 0;
+    strncpy(ptr->coinaddr, coinaddr, sizeof(ptr->coinaddr) - 1);
+    ptr->CCflag = 1;
+    tipheight = chainActive.LastTip()->GetHeight();  
+    ptr->nodeheight = tipheight; // will be checked in libnspv
+    //}
+   
+    // select all appropriate utxos:
+    std::cerr << __func__ << " " << "searching addr=" << coinaddr << std::endl;
+    for (std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> >::const_iterator it = unspentOutputs.begin(); it != unspentOutputs.end(); it++)
+    {
+        if (myIsutxo_spentinmempool(ignoretxid, ignorevin, it->first.txhash, (int32_t)it->first.index) == 0)
+        {
+            //const CCoins *pcoins = pcoinsTip->AccessCoins(it->first.txhash); <-- no opret in coins
+            CTransaction tx;
+            uint256 hashBlock;
+            int32_t nvout = it->first.index;
+            if (myGetTransaction(it->first.txhash, tx, hashBlock))
+            {
+                class BaseCCChecker *baseChecker = ccCheckerTable[evalcode];
+
+                // if a checker is set for evalcode use it otherwise use the default checker:
+                if (baseChecker && baseChecker->checkCC(it->first.txhash, tx.vout, nvout, evalcode, funcids, filtertxid) || defaultCCChecker.checkCC(it->first.txhash, tx.vout, nvout, evalcode, funcids, filtertxid))
+                {
+                    std::cerr << __func__ << " " << "filtered utxo with amount=" << tx.vout[nvout].nValue << std::endl;
+
+                    struct CC_utxo utxo;
+                    utxo.txid = it->first.txhash;
+                    utxo.vout = (int32_t)it->first.index;
+                    utxo.nValue = it->second.satoshis;
+                    //utxo.height = it->second.blockHeight;
+                    utxoSelected.push_back(utxo);
+                    total += it->second.satoshis;
+                }
+            }
+            else
+                std::cerr << __func__ << " " << "ERROR: cant load tx for txid, please reindex" << std::endl;
+        }
+    }
+
+
+    if (amount == 0) {
+        // just return total value
+        ptr->total = total;
+        len = (int32_t)(sizeof(*ptr) - sizeof(ptr->utxos)/*subtract not serialized part of NSPV_utxoresp*/);
+        return len;
+    }
+
+    // pick optimal utxos for the requested amount
+    CAmount remains = amount;
+    std::vector<struct CC_utxo> utxoAdded;
+
+    while (utxoSelected.size() > 0)
+    {
+        int64_t below = 0, above = 0;
+        int32_t abovei = -1, belowi = -1, ind = -1;
+
+        if (CC_vinselect(&abovei, &above, &belowi, &below, utxoSelected.data(), utxoSelected.size(), remains) < 0)
+        {
+            std::cerr << "error CC_vinselect" << " remains=" << remains << " amount=" << amount << " abovei=" << abovei << " belowi=" << belowi << " ind=" << " utxoSelected.size()=" << utxoSelected.size() << ind << std::endl;
+            return 0;
+        }
+        if (abovei >= 0) // best is 'above'
+            ind = abovei;
+        else if (belowi >= 0)  // second try is 'below'
+            ind = belowi;
+        else
+        {
+            std::cerr << "error finding unspent" << " remains=" << remains << " amount=" << amount << " abovei=" << abovei << " belowi=" << belowi << " ind=" << " utxoSelected.size()=" << utxoSelected.size() << ind << std::endl;
+            return 0;
+        }
+
+        utxoAdded.push_back(utxoSelected[ind]);
+        total += utxoSelected[ind].nValue;
+        remains -= utxoSelected[ind].nValue;
+
+        // remove used utxo[ind]:
+        utxoSelected[ind] = utxoSelected.back();
+        utxoSelected.pop_back();
+
+        if (total >= amount) // found the requested amount
+            break;
+        if (utxoAdded.size() >= maxinputs)  // reached maxinputs
+            break;
+    }
+    ptr->numutxos = (uint16_t)utxoAdded.size();
+    ptr->total = total;
+    ptr->utxos = (NSPV_utxoresp*)calloc(ptr->numutxos, sizeof(ptr->utxos[0]));
+
+    for (uint16_t i = 0; i < ptr->numutxos; i++)
+    {
+        ptr->utxos[i].satoshis = utxoAdded[i].nValue;
+        ptr->utxos[i].txid = utxoAdded[i].txid;
+        ptr->utxos[i].vout = utxoAdded[i].vout;
+    }
+   
+    len = (int32_t)(sizeof(*ptr) - sizeof(ptr->utxos)/*subtract not serialized part of NSPV_utxoresp*/ + sizeof(*ptr->utxos)*ptr->numutxos);
+    if (len < maxlen) 
+        return len;  // good length
+    else
+    {
+        NSPV_utxosresp_purge(ptr);
+        return 0;
+    }
+}
+
+int32_t NSPV_getaddresstxids(struct NSPV_txidsresp *ptr,char *coinaddr,bool isCC,int32_t skipcount,uint32_t filter)
+{
+    int32_t maxlen,txheight,ind=0,n = 0,len = 0; CTransaction tx; uint256 hashBlock;
+    std::vector<std::pair<CAddressIndexKey, CAmount> > txids;
+    SetCCtxids(txids,coinaddr,isCC);
+    ptr->nodeheight = chainActive.LastTip()->GetHeight();
+    maxlen = MAX_BLOCK_SIZE(ptr->nodeheight) - 512;
+    maxlen /= sizeof(*ptr->txids);
+    strncpy(ptr->coinaddr,coinaddr,sizeof(ptr->coinaddr)-1);
+    ptr->CCflag = isCC;
+    ptr->filter = filter;
+    if ( skipcount < 0 )
+        skipcount = 0;
+    if ( (ptr->numtxids= (int32_t)txids.size()) >= 0 && ptr->numtxids < maxlen )
+    {
+        if ( skipcount >= ptr->numtxids )
+            skipcount = ptr->numtxids-1;
+        ptr->skipcount = skipcount;
+        if ( ptr->numtxids-skipcount > 0 )
+        {
+            ptr->txids = (struct NSPV_txidresp *)calloc(ptr->numtxids-skipcount,sizeof(*ptr->txids));
+            for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=txids.begin(); it!=txids.end(); it++)
+            {
+                if ( n >= skipcount )
+                {
+                    ptr->txids[ind].txid = it->first.txhash;
+                    ptr->txids[ind].vout = (int32_t)it->first.index;
+                    ptr->txids[ind].satoshis = (int64_t)it->second;
+                    ptr->txids[ind].height = (int64_t)it->first.blockHeight;
+                    ind++;
+                }
+                n++;
+            }
+        }
+        ptr->numtxids = ind;
+        len = (int32_t)(sizeof(*ptr) + sizeof(*ptr->txids)*ptr->numtxids - sizeof(ptr->txids));
+        return(len);
+    }
+    if ( ptr->txids != 0 )
+        free(ptr->txids);
+    memset(ptr,0,sizeof(*ptr));
+    return(0);
+}
+
+int32_t NSPV_mempoolfuncs(bits256 *satoshisp,int32_t *vindexp,std::vector<uint256> &txids,char *coinaddr,bool isCC,uint8_t funcid,uint256 txid,int32_t vout)
+{
+    int32_t num = 0,vini = 0,vouti = 0; uint8_t evalcode=0,func=0;  std::vector<uint8_t> vopret; char destaddr[64];
+    *vindexp = -1;
+    memset(satoshisp,0,sizeof(*satoshisp));
+    if ( funcid == NSPV_CC_TXIDS)
+    {
+        std::vector<std::pair<CAddressIndexKey, CAmount> > tmp_txids; uint256 tmp_txid,hashBlock;
+        int32_t n=0,skipcount=vout>>16; uint8_t eval=(vout>>8)&0xFF, func=vout&0xFF;
+
+        CTransaction tx;
+        SetCCtxids(tmp_txids,coinaddr,isCC);
+        if ( skipcount < 0 ) skipcount = 0;
+        if ( skipcount >= tmp_txids.size() )
+            skipcount = tmp_txids.size()-1;
+        if ( tmp_txids.size()-skipcount > 0 )
+        {
+            for (std::vector<std::pair<CAddressIndexKey, CAmount> >::const_iterator it=tmp_txids.begin(); it!=tmp_txids.end(); it++)
+            {
+                if (txid!=zeroid || func!=0)
+                {
+                    myGetTransaction(it->first.txhash,tx,hashBlock);
+                    std::vector<std::pair<uint8_t, vscript_t>>  oprets; uint256 tokenid,txid;
+                    std::vector<uint8_t> vopret,vOpretExtra; uint8_t *script,e,f,tokenevalcode;
+                    std::vector<CPubKey> pubkeys;
+
+                    if (DecodeTokenOpRet(tx.vout[tx.vout.size()-1].scriptPubKey,tokenevalcode,tokenid,pubkeys,oprets)!=0 && GetOpretBlob(oprets, OPRETID_CHANNELSDATA, vOpretExtra) && tokenevalcode==EVAL_TOKENS && vOpretExtra.size()>0)
+                    {
+                        vopret=vOpretExtra;
+                    }
+                    else GetOpReturnData(tx.vout[tx.vout.size()-1].scriptPubKey, vopret);
+                    script = (uint8_t *)vopret.data();
+                    if ( vopret.size() > 2 && script[0]==eval )
+                    {
+                        switch (eval)
+                        {
+                            case EVAL_CHANNELS:EVAL_PEGS:EVAL_ORACLES:EVAL_GAMES:EVAL_IMPORTGATEWAY:EVAL_ROGUE:
+                                E_UNMARSHAL(vopret,ss >> e; ss >> f; ss >> tmp_txid;);
+                                if (e!=eval || (txid!=zeroid && txid!=tmp_txid) || (func!=0 && f!=func)) continue;
+                                break;
+                            case EVAL_TOKENS:EVAL_DICE:EVAL_DILITHIUM:EVAL_FAUCET:EVAL_LOTO:EVAL_PAYMENTS:EVAL_REWARDS:
+                                E_UNMARSHAL(vopret,ss >> e; ss >> f;);
+                                if (e!=eval || (func!=0 && f!=func)) continue;
+                                break;
+                            default:
+                                break;
+                        }
+                    }                        
+                }
+                if ( n >= skipcount ) txids.push_back(it->first.txhash);
+                n++;
+            }
+            return (n-skipcount);
+        }
+        return (0);
+    }
+    if ( mempool.size() == 0 )
+        return(0);
+    if ( funcid == NSPV_MEMPOOL_CCEVALCODE )
+    {
+        isCC = true;
+        evalcode = vout & 0xff;
+        func = (vout >> 8) & 0xff;
+    }
+    LOCK(mempool.cs);
+    BOOST_FOREACH(const CTxMemPoolEntry &e,mempool.mapTx)
+    {
+        const CTransaction &tx = e.GetTx();
+        const uint256 &hash = tx.GetHash();
+        if ( funcid == NSPV_MEMPOOL_ALL )
+        {
+            txids.push_back(hash);
+            num++;
+            continue;
+        }
+        else if ( funcid == NSPV_MEMPOOL_INMEMPOOL )
+        {
+            if ( hash == txid )
+            {
+                txids.push_back(hash);
+                return(++num);
+            }
+            continue;
+        }
+        else if ( funcid == NSPV_MEMPOOL_CCEVALCODE )
+        {
+            if ( tx.vout.size() > 1 )
+            {
+                CScript scriptPubKey = tx.vout[tx.vout.size()-1].scriptPubKey;
+                if ( GetOpReturnData(scriptPubKey,vopret) != 0 )
+                {
+                    if ( vopret[0] == evalcode && vopret[1] == func )
+                    {
+                        txids.push_back(hash);
+                        num++;
+                    }
+                }
+            }
+            continue;
+        }
+        if ( funcid == NSPV_MEMPOOL_ISSPENT )
+        {
+            BOOST_FOREACH(const CTxIn &txin,tx.vin)
+            {
+                //LogPrintf("%s/v%d ",uint256_str(str,txin.prevout.hash),txin.prevout.n);
+                if ( txin.prevout.n == vout && txin.prevout.hash == txid )
+                {
+                    txids.push_back(hash);
+                    *vindexp = vini;
+                    return(++num);
+                }
+                vini++;
+            }
+        }
+        else if ( funcid == NSPV_MEMPOOL_ADDRESS )
+        {
+            BOOST_FOREACH(const CTxOut &txout,tx.vout)
+            {
+                if ( txout.scriptPubKey.IsPayToCryptoCondition() == isCC )
+                {
+                    Getscriptaddress(destaddr,txout.scriptPubKey);
+                    if ( strcmp(destaddr,coinaddr) == 0 )
+                    {
+                        txids.push_back(hash);
+                        *vindexp = vouti;
+                        if ( num < 4 )
+                            satoshisp->ulongs[num] = txout.nValue;
+                        num++;
+                    }
+                }
+                vouti++;
+            }
+        }
+        //LogPrintf("are vins for %s\n",uint256_str(str,hash));
+    }
+    return(num);
+}
+
+int32_t NSPV_mempooltxids(struct NSPV_mempoolresp *ptr,char *coinaddr,uint8_t isCC,uint8_t funcid,uint256 txid,int32_t vout)
+{
+    std::vector<uint256> txids; bits256 satoshis; uint256 tmp,tmpdest; int32_t i,len = 0;
+    ptr->nodeheight = chainActive.LastTip()->GetHeight();
+    strncpy(ptr->coinaddr,coinaddr,sizeof(ptr->coinaddr)-1);
+    ptr->CCflag = isCC;
+    ptr->txid = txid;
+    ptr->vout = vout;
+    ptr->funcid = funcid;
+    if ( NSPV_mempoolfuncs(&satoshis,&ptr->vindex,txids,coinaddr,isCC,funcid,txid,vout) >= 0 )
+    {
+        if ( (ptr->numtxids= (int32_t)txids.size()) >= 0 )
+        {
+            if ( ptr->numtxids > 0 )
+            {
+                ptr->txids = (uint256 *)calloc(ptr->numtxids,sizeof(*ptr->txids));
+                for (i=0; i<ptr->numtxids; i++)
+                {
+                    tmp = txids[i];
+                    iguana_rwbignum(0,(uint8_t *)&tmp,sizeof(*ptr->txids),(uint8_t *)&ptr->txids[i]);
+                }
+            }
+            if ( funcid == NSPV_MEMPOOL_ADDRESS )
+            {
+                memcpy(&tmp,&satoshis,sizeof(tmp));
+                iguana_rwbignum(0,(uint8_t *)&tmp,sizeof(ptr->txid),(uint8_t *)&ptr->txid);
+            }
+            len = (int32_t)(sizeof(*ptr) + sizeof(*ptr->txids)*ptr->numtxids - sizeof(ptr->txids));
+            return(len);
+        }
+    }
+    if ( ptr->txids != 0 )
+        free(ptr->txids);
+    memset(ptr,0,sizeof(*ptr));
+    return(0);
+}
+
+int32_t NSPV_remoterpc(struct NSPV_remoterpcresp *ptr,char *json,int n)
+{
+    std::vector<uint256> txids; int32_t i,len = 0; UniValue result; std::string response;
+    UniValue request(UniValue::VOBJ),rpc_result(UniValue::VOBJ); JSONRequest jreq; CPubKey mypk;
+
+    try
+    {
+        request.read(json,n);
+        jreq.parse(request);
+        strcpy(ptr->method,jreq.strMethod.c_str());
+        len+=sizeof(ptr->method);
+        std::map<std::string, bool>::iterator it = nspv_remote_commands.find(jreq.strMethod);
+        if (it==nspv_remote_commands.end())
+            throw JSONRPCError(RPC_METHOD_NOT_FOUND, "Method not supported!");
+        const CRPCCommand *cmd=tableRPC[jreq.strMethod];
+        if (!cmd)
+            throw JSONRPCError(RPC_METHOD_NOT_FOUND, "Method not found");
+        if (it->second)
+        {
+            if (!request.exists("mypk"))
+                throw JSONRPCError(RPC_PARSE_ERROR, "No pubkey supplied in remote rpc request, necessary for this type of rpc");
+            std::string str=request["mypk"].get_str();
+            mypk=pubkey2pk(ParseHex(str));
+            if (!mypk.IsValid())
+                throw JSONRPCError(RPC_PARSE_ERROR, "Not valid pubkey passed in remote rpc call");
+        }
+        if ((result = cmd->actor(jreq.params,false,mypk)).isObject() || result.isArray())
+        {
+            rpc_result = JSONRPCReplyObj(result, NullUniValue, jreq.id);
+            response=rpc_result.write();
+            memcpy(ptr->json,response.c_str(),response.size());
+            len+=response.size();
+            return (len);
+        }
+        else throw JSONRPCError(RPC_MISC_ERROR, "Error in executing RPC on remote node");        
+    }
+    catch (const UniValue& objError)
+    {
+        rpc_result = JSONRPCReplyObj(NullUniValue, objError, jreq.id);
+        response=rpc_result.write();
+    }
+    catch (const runtime_error& e)
+    {
+        rpc_result = JSONRPCReplyObj(NullUniValue,JSONRPCError(RPC_PARSE_ERROR, e.what()), jreq.id);
+        response=rpc_result.write();
+    }
+    catch (const std::exception& e)
+    {
+        rpc_result = JSONRPCReplyObj(NullUniValue,JSONRPCError(RPC_PARSE_ERROR, e.what()), jreq.id);
+        response=rpc_result.write();
+    }
+    memcpy(ptr->json,response.c_str(),response.size());
+    len+=response.size();
+    return (len);
+}
+
+uint8_t *NSPV_getrawtx(CTransaction &tx,uint256 &hashBlock,int32_t *txlenp,uint256 txid)
+{
+    uint8_t *rawtx = 0;
+    *txlenp = 0;
+    {
+        if (!GetTransaction(txid, tx, hashBlock, false))
+        {
+            //LogPrintf("error getting transaction %s\n",txid.GetHex().c_str());
+            return(0);
+        }
+        string strHex = EncodeHexTx(tx);
+        *txlenp = (int32_t)strHex.size() >> 1;
+        if ( *txlenp > 0 )
+        {
+            rawtx = (uint8_t *)calloc(1,*txlenp);
+            decode_hex(rawtx,*txlenp,(char *)strHex.c_str());
+        }
+    }
+    return(rawtx);
+}
+
+int32_t NSPV_sendrawtransaction(struct NSPV_broadcastresp *ptr,uint8_t *data,int32_t n)
+{
+    CTransaction tx;
+    ptr->retcode = 0;
+    if ( NSPV_txextract(tx,data,n) == 0 )
+    {
+        //LOCK(cs_main);
+        ptr->txid = tx.GetHash();
+        //LogPrintf("try to addmempool transaction %s\n",ptr->txid.GetHex().c_str());
+        if ( myAddtomempool(tx) != 0 )
+        {
+            ptr->retcode = 1;
+            //int32_t i;
+            //for (i=0; i<n; i++)
+            //    LogPrintf("%02x",data[i]);
+            LogPrintf(" relay transaction %s retcode.%d\n",ptr->txid.GetHex().c_str(),ptr->retcode);
+            RelayTransaction(tx);
+        } else ptr->retcode = -3;
+
+    } else ptr->retcode = -1;
+    return(sizeof(*ptr));
+}
+
+int32_t NSPV_gettxproof(struct NSPV_txproof *ptr,int32_t vout,uint256 txid,int32_t height)
+{
+    int32_t flag = 0,len = 0; CTransaction _tx; uint256 hashBlock; CBlock block; CBlockIndex *pindex;
+    ptr->height = -1;
+    if ( (ptr->tx= NSPV_getrawtx(_tx,hashBlock,&ptr->txlen,txid)) != 0 )
+    {
+        ptr->txid = txid;
+        ptr->vout = vout;
+        ptr->hashblock = hashBlock;
+        if ( height == 0 )
+            ptr->height = komodo_blockheight(hashBlock);
+        else
+        {
+            ptr->height = height;
+            if ( (pindex= komodo_chainactive(height)) != 0 && komodo_blockload(block,pindex) == 0 )
+            {
+                BOOST_FOREACH(const CTransaction&tx, block.vtx)
+                {
+                    if ( tx.GetHash() == txid )
+                    {
+                        flag = 1;
+                        break;
+                    }
+                }
+                if ( flag != 0 )
+                {
+                    set<uint256> setTxids;
+                    CDataStream ssMB(SER_NETWORK, PROTOCOL_VERSION);
+                    setTxids.insert(txid);
+                    CMerkleBlock mb(block, setTxids);
+                    ssMB << mb;
+                    std::vector<uint8_t> proof(ssMB.begin(), ssMB.end());
+                    ptr->txprooflen = (int32_t)proof.size();
+                    //LogPrintf("%s txproof.(%s)\n",txid.GetHex().c_str(),HexStr(proof).c_str());
+                    if ( ptr->txprooflen > 0 )
+                    {
+                        ptr->txproof = (uint8_t *)calloc(1,ptr->txprooflen);
+                        memcpy(ptr->txproof,&proof[0],ptr->txprooflen);
+                    }
+                    //LogPrintf("gettxproof slen.%d\n",(int32_t)(sizeof(*ptr) - sizeof(ptr->tx) - sizeof(ptr->txproof) + ptr->txlen + ptr->txprooflen));
+                }
+            }
+        }
+        ptr->unspentvalue = CCgettxout(txid,vout,1,1);
+    }
+    return(sizeof(*ptr) - sizeof(ptr->tx) - sizeof(ptr->txproof) + ptr->txlen + ptr->txprooflen);
+}
+
+int32_t NSPV_getntzsproofresp(struct NSPV_ntzsproofresp *ptr,uint256 prevntztxid,uint256 nextntztxid)
+{
+    int32_t i; uint256 hashBlock,bhash0,bhash1,desttxid0,desttxid1; CTransaction tx;
+    ptr->prevtxid = prevntztxid;
+    ptr->prevntz = NSPV_getrawtx(tx,hashBlock,&ptr->prevtxlen,ptr->prevtxid);
+    ptr->prevtxidht = komodo_blockheight(hashBlock);
+    if ( NSPV_notarizationextract(0,&ptr->common.prevht,&bhash0,&desttxid0,tx) < 0 )
+        return(-2);
+    else if ( komodo_blockheight(bhash0) != ptr->common.prevht )
+        return(-3);
+    
+    ptr->nexttxid = nextntztxid;
+    ptr->nextntz = NSPV_getrawtx(tx,hashBlock,&ptr->nexttxlen,ptr->nexttxid);
+    ptr->nexttxidht = komodo_blockheight(hashBlock);
+    if ( NSPV_notarizationextract(0,&ptr->common.nextht,&bhash1,&desttxid1,tx) < 0 )
+        return(-5);
+    else if ( komodo_blockheight(bhash1) != ptr->common.nextht )
+        return(-6);
+
+    else if ( ptr->common.prevht > ptr->common.nextht || (ptr->common.nextht - ptr->common.prevht) > 1440 )
+    {
+        LogPrintf("illegal prevht.%d nextht.%d\n",ptr->common.prevht,ptr->common.nextht);
+        return(-7);
+    }
+    //LogPrintf("%s -> prevht.%d, %s -> nexht.%d\n",ptr->prevtxid.GetHex().c_str(),ptr->common.prevht,ptr->nexttxid.GetHex().c_str(),ptr->common.nextht);
+    ptr->common.numhdrs = (ptr->common.nextht - ptr->common.prevht + 1);
+    ptr->common.hdrs = (struct NSPV_equihdr *)calloc(ptr->common.numhdrs,sizeof(*ptr->common.hdrs));
+    //LogPrintf("prev.%d next.%d allocate numhdrs.%d\n",prevht,nextht,ptr->common.numhdrs);
+    for (i=0; i<ptr->common.numhdrs; i++)
+    {
+        //hashBlock = NSPV_hdrhash(&ptr->common.hdrs[i]);
+        //LogPrintf("hdr[%d] %s\n",prevht+i,hashBlock.GetHex().c_str());
+        if ( NSPV_setequihdr(&ptr->common.hdrs[i],ptr->common.prevht+i) < 0 )
+        {
+            LogPrintf("error setting hdr.%d\n",ptr->common.prevht+i);
+            free(ptr->common.hdrs);
+            ptr->common.hdrs = 0;
+            return(-1);
+        }
+    }
+    //LogPrintf("sizeof ptr %ld, common.%ld lens.%d %d\n",sizeof(*ptr),sizeof(ptr->common),ptr->prevtxlen,ptr->nexttxlen);
+    return(sizeof(*ptr) + sizeof(*ptr->common.hdrs)*ptr->common.numhdrs - sizeof(ptr->common.hdrs) - sizeof(ptr->prevntz) - sizeof(ptr->nextntz) + ptr->prevtxlen + ptr->nexttxlen);
+}
+
+int32_t NSPV_getspentinfo(struct NSPV_spentinfo *ptr,uint256 txid,int32_t vout)
+{
+    int32_t len = 0;
+    ptr->txid = txid;
+    ptr->vout = vout;
+    ptr->spentvini = -1;
+    len = (int32_t)(sizeof(*ptr) - sizeof(ptr->spent.tx) - sizeof(ptr->spent.txproof));
+    if ( CCgetspenttxid(ptr->spent.txid,ptr->spentvini,ptr->spent.height,txid,vout) == 0 )
+    {
+        if ( NSPV_gettxproof(&ptr->spent,0,ptr->spent.txid,ptr->spent.height) > 0 )
+            len += ptr->spent.txlen + ptr->spent.txprooflen;
+        else
+        {
+            NSPV_txproof_purge(&ptr->spent);
+            return(-1);
+        }
+    }
+    return(len);
+}
+
+void komodo_nSPVreq(CNode *pfrom,std::vector<uint8_t> request) // received a request
+{
+    int32_t len,slen,ind,reqheight,n; std::vector<uint8_t> response; uint32_t timestamp = (uint32_t)time(NULL);
+    if ( (len= request.size()) > 0 )
+    {
+        if ( (ind= request[0]>>1) >= sizeof(pfrom->prevtimes)/sizeof(*pfrom->prevtimes) )
+            ind = (int32_t)(sizeof(pfrom->prevtimes)/sizeof(*pfrom->prevtimes)) - 1;
+        if ( pfrom->prevtimes[ind] > timestamp )
+            pfrom->prevtimes[ind] = 0;
+        if ( request[0] == NSPV_INFO ) // info
+        {
+            //LogPrintf("check info %u vs %u, ind.%d\n",timestamp,pfrom->prevtimes[ind],ind);
+            if ( timestamp > pfrom->prevtimes[ind] )
+            {
+                struct NSPV_inforesp I;
+                if ( len == 1+sizeof(reqheight) )
+                    iguana_rwnum(0,&request[1],sizeof(reqheight),&reqheight);
+                else reqheight = 0;
+                //LogPrintf("request height.%d\n",reqheight);
+                memset(&I,0,sizeof(I));
+                if ( (slen= NSPV_getinfo(&I,reqheight)) > 0 )
+                {
+                    response.resize(1 + slen);
+                    response[0] = NSPV_INFORESP;
+                    //LogPrintf("slen.%d version.%d\n",slen,I.version);
+                    if ( NSPV_rwinforesp(1,&response[1],&I) == slen )
+                    {
+                        //LogPrintf("send info resp to id %d\n",(int32_t)pfrom->id);
+                        pfrom->PushMessage("nSPV",response);
+                        pfrom->prevtimes[ind] = timestamp;
+                    }
+                    NSPV_inforesp_purge(&I);
+                }
+            }
+        }
+        else if ( request[0] == NSPV_UTXOS )
+        {
+            //LogPrintf("utxos: %u > %u, ind.%d, len.%d\n",timestamp,pfrom->prevtimes[ind],ind,len);
+            if ( timestamp > pfrom->prevtimes[ind] )
+            {
+                struct NSPV_utxosresp U;
+                if ( len < 64+5 && (request[1] == len-3 || request[1] == len-7 || request[1] == len-11) )
+                {
+                    int32_t skipcount = 0; char coinaddr[64]; uint8_t filter; uint8_t isCC = 0;
+                    memcpy(coinaddr,&request[2],request[1]);
+                    coinaddr[request[1]] = 0;
+                    if ( request[1] == len-3 )
+                        isCC = (request[len-1] != 0);
+                    else if ( request[1] == len-7 )
+                    {
+                        isCC = (request[len-5] != 0);
+                        iguana_rwnum(0,&request[len-4],sizeof(skipcount),&skipcount);
+                    }
+                    else
+                    {
+                        isCC = (request[len-9] != 0);
+                        iguana_rwnum(0,&request[len-8],sizeof(skipcount),&skipcount);
+                        iguana_rwnum(0,&request[len-4],sizeof(filter),&filter);
+                    }
+                    if ( 0 && isCC != 0 )
+                        LogPrintf("utxos %s isCC.%d skipcount.%d filter.%x\n",coinaddr,isCC,skipcount,filter);
+                    memset(&U,0,sizeof(U));
+                    if ( (slen= NSPV_getaddressutxos(&U,coinaddr,isCC,skipcount,filter)) > 0 )
+                    {
+                        response.resize(1 + slen);
+                        response[0] = NSPV_UTXOSRESP;
+                        if ( NSPV_rwutxosresp(1,&response[1],&U) == slen )
+                        {
+                            pfrom->PushMessage("nSPV",response);
+                            pfrom->prevtimes[ind] = timestamp;
+                        }
+                        NSPV_utxosresp_purge(&U);
+                    }
+                }
+            }
+        }
+        else if ( request[0] == NSPV_TXIDS )
+        {
+            if ( timestamp > pfrom->prevtimes[ind] )
+            {
+                struct NSPV_txidsresp T;
+                if ( len < 64+5 && (request[1] == len-3 || request[1] == len-7 || request[1] == len-11) )
+                {
+                    int32_t skipcount = 0; char coinaddr[64]; uint32_t filter; uint8_t isCC = 0;
+                    memcpy(coinaddr,&request[2],request[1]);
+                    coinaddr[request[1]] = 0;
+                    if ( request[1] == len-3 )
+                        isCC = (request[len-1] != 0);
+                    else if ( request[1] == len-7 )
+                    {
+                        isCC = (request[len-5] != 0);
+                        iguana_rwnum(0,&request[len-4],sizeof(skipcount),&skipcount);
+                    }
+                    else
+                    {
+                        isCC = (request[len-9] != 0);
+                        iguana_rwnum(0,&request[len-8],sizeof(skipcount),&skipcount);
+                        iguana_rwnum(0,&request[len-4],sizeof(filter),&filter);
+                    }
+                    if ( 0 && isCC != 0 )
+                        LogPrintf("txids %s isCC.%d skipcount.%d filter.%d\n",coinaddr,isCC,skipcount,filter);
+                    memset(&T,0,sizeof(T));
+                    if ( (slen= NSPV_getaddresstxids(&T,coinaddr,isCC,skipcount,filter)) > 0 )
+                    {
+//LogPrintf("slen.%d\n",slen);
+                        response.resize(1 + slen);
+                        response[0] = NSPV_TXIDSRESP;
+                        if ( NSPV_rwtxidsresp(1,&response[1],&T) == slen )
+                        {
+                            pfrom->PushMessage("nSPV",response);
+                            pfrom->prevtimes[ind] = timestamp;
+                        }
+                        NSPV_txidsresp_purge(&T);
+                    }
+                } else LogPrintf("len.%d req1.%d\n",len,request[1]);
+            }
+        }
+        else if ( request[0] == NSPV_MEMPOOL )
+        {
+            if ( timestamp > pfrom->prevtimes[ind] )
+            {
+                struct NSPV_mempoolresp M; char coinaddr[64];
+                if ( len < sizeof(M)+64 )
+                {
+                    int32_t vout; uint256 txid; uint8_t funcid,isCC = 0;
+                    n = 1;
+                    n += iguana_rwnum(0,&request[n],sizeof(isCC),&isCC);
+                    n += iguana_rwnum(0,&request[n],sizeof(funcid),&funcid);
+                    n += iguana_rwnum(0,&request[n],sizeof(vout),&vout);
+                    n += iguana_rwbignum(0,&request[n],sizeof(txid),(uint8_t *)&txid);
+                    slen = request[n++];
+                    if ( slen < 63 )
+                    {
+                        memcpy(coinaddr,&request[n],slen), n += slen;
+                        coinaddr[slen] = 0;
+                        if ( isCC != 0 )
+                            LogPrintf("(%s) isCC.%d funcid.%d %s/v%d len.%d slen.%d\n",coinaddr,isCC,funcid,txid.GetHex().c_str(),vout,len,slen);
+                        memset(&M,0,sizeof(M));
+                        if ( (slen= NSPV_mempooltxids(&M,coinaddr,isCC,funcid,txid,vout)) > 0 )
+                        {
+                            //LogPrintf("NSPV_mempooltxids slen.%d\n",slen);
+                            response.resize(1 + slen);
+                            response[0] = NSPV_MEMPOOLRESP;
+                            if ( NSPV_rwmempoolresp(1,&response[1],&M) == slen )
+                            {
+                                pfrom->PushMessage("nSPV",response);
+                                pfrom->prevtimes[ind] = timestamp;
+                            }
+                            NSPV_mempoolresp_purge(&M);
+                        }
+                    }
+                } else LogPrintf("len.%d req1.%d\n",len,request[1]);
+            }
+        }
+        else if ( request[0] == NSPV_NTZS )
+        {
+            if ( timestamp > pfrom->prevtimes[ind] )
+            {
+                struct NSPV_ntzsresp N; int32_t height;
+                if ( len == 1+sizeof(height) )
+                {
+                    iguana_rwnum(0,&request[1],sizeof(height),&height);
+                    memset(&N,0,sizeof(N));
+                    if ( (slen= NSPV_getntzsresp(&N,height)) > 0 )
+                    {
+                        response.resize(1 + slen);
+                        response[0] = NSPV_NTZSRESP;
+                        if ( NSPV_rwntzsresp(1,&response[1],&N) == slen )
+                        {
+                            pfrom->PushMessage("nSPV",response);
+                            pfrom->prevtimes[ind] = timestamp;
+                        }
+                        NSPV_ntzsresp_purge(&N);
+                    }
+                }
+            }
+        }
+        else if ( request[0] == NSPV_NTZSPROOF )
+        {
+            if ( timestamp > pfrom->prevtimes[ind] )
+            {
+                struct NSPV_ntzsproofresp P; uint256 prevntz,nextntz;
+                if ( len == 1+sizeof(prevntz)+sizeof(nextntz) )
+                {
+                    iguana_rwbignum(0,&request[1],sizeof(prevntz),(uint8_t *)&prevntz);
+                    iguana_rwbignum(0,&request[1+sizeof(prevntz)],sizeof(nextntz),(uint8_t *)&nextntz);
+                    memset(&P,0,sizeof(P));
+                    if ( (slen= NSPV_getntzsproofresp(&P,prevntz,nextntz)) > 0 )
+                    {
+                        // LogPrintf("slen.%d msg prev.%s next.%s\n",slen,prevntz.GetHex().c_str(),nextntz.GetHex().c_str());
+                        response.resize(1 + slen);
+                        response[0] = NSPV_NTZSPROOFRESP;
+                        if ( NSPV_rwntzsproofresp(1,&response[1],&P) == slen )
+                        {
+                            pfrom->PushMessage("nSPV",response);
+                            pfrom->prevtimes[ind] = timestamp;
+                        }
+                        NSPV_ntzsproofresp_purge(&P);
+                    } else LogPrintf("err.%d\n",slen);
+                }
+            }
+        }
+        else if ( request[0] == NSPV_TXPROOF )
+        {
+            if ( timestamp > pfrom->prevtimes[ind] )
+            {
+                struct NSPV_txproof P; uint256 txid; int32_t height,vout;
+                if ( len == 1+sizeof(txid)+sizeof(height)+sizeof(vout) )
+                {
+                    iguana_rwnum(0,&request[1],sizeof(height),&height);
+                    iguana_rwnum(0,&request[1+sizeof(height)],sizeof(vout),&vout);
+                    iguana_rwbignum(0,&request[1+sizeof(height)+sizeof(vout)],sizeof(txid),(uint8_t *)&txid);
+                    //LogPrintf("got txid %s/v%d ht.%d\n",txid.GetHex().c_str(),vout,height);
+                    memset(&P,0,sizeof(P));
+                    if ( (slen= NSPV_gettxproof(&P,vout,txid,height)) > 0 )
+                    {
+                        //LogPrintf("slen.%d\n",slen);
+                        response.resize(1 + slen);
+                        response[0] = NSPV_TXPROOFRESP;
+                        if ( NSPV_rwtxproof(1,&response[1],&P) == slen )
+                        {
+                            //LogPrintf("send response\n");
+                            pfrom->PushMessage("nSPV",response);
+                            pfrom->prevtimes[ind] = timestamp;
+                        }
+                        NSPV_txproof_purge(&P);
+                    } else LogPrintf("gettxproof error.%d\n",slen);
+                } else LogPrintf("txproof reqlen.%d\n",len);
+            }
+        }
+        else if ( request[0] == NSPV_SPENTINFO )
+        {
+            if ( timestamp > pfrom->prevtimes[ind] )
+            {
+                struct NSPV_spentinfo S; int32_t vout; uint256 txid;
+                if ( len == 1+sizeof(txid)+sizeof(vout) )
+                {
+                    iguana_rwnum(0,&request[1],sizeof(vout),&vout);
+                    iguana_rwbignum(0,&request[1+sizeof(vout)],sizeof(txid),(uint8_t *)&txid);
+                    memset(&S,0,sizeof(S));
+                    if ( (slen= NSPV_getspentinfo(&S,txid,vout)) > 0 )
+                    {
+                        response.resize(1 + slen);
+                        response[0] = NSPV_SPENTINFORESP;
+                        if ( NSPV_rwspentinfo(1,&response[1],&S) == slen )
+                        {
+                            pfrom->PushMessage("nSPV",response);
+                            pfrom->prevtimes[ind] = timestamp;
+                        }
+                        NSPV_spentinfo_purge(&S);
+                    }
+                }
+            }
+        }
+        else if ( request[0] == NSPV_BROADCAST )
+        {
+            if ( timestamp > pfrom->prevtimes[ind] )
+            {
+                struct NSPV_broadcastresp B; uint32_t n,offset; uint256 txid;
+                if ( len > 1+sizeof(txid)+sizeof(n) )
+                {
+                    iguana_rwbignum(0,&request[1],sizeof(txid),(uint8_t *)&txid);
+                    iguana_rwnum(0,&request[1+sizeof(txid)],sizeof(n),&n);
+                    memset(&B,0,sizeof(B));
+                    offset = 1 + sizeof(txid) + sizeof(n);
+                    if ( n < MAX_TX_SIZE_AFTER_SAPLING && request.size() == offset+n && (slen= NSPV_sendrawtransaction(&B,&request[offset],n)) > 0 )
+                    {
+                        response.resize(1 + slen);
+                        response[0] = NSPV_BROADCASTRESP;
+                        if ( NSPV_rwbroadcastresp(1,&response[1],&B) == slen )
+                        {
+                            pfrom->PushMessage("nSPV",response);
+                            pfrom->prevtimes[ind] = timestamp;
+                        }
+                        NSPV_broadcast_purge(&B);
+                    }
+                }
+            }
+        }
+        else if ( request[0] == NSPV_REMOTERPC )
+        {
+            if ( timestamp > pfrom->prevtimes[ind] )
+            {
+                struct NSPV_remoterpcresp R; int32_t p;
+                p = 1;
+                p+=iguana_rwnum(0,&request[p],sizeof(slen),&slen);
+                memset(&R,0,sizeof(R));
+                if (request.size() == p+slen && (slen=NSPV_remoterpc(&R,(char *)&request[p],slen))>0 )
+                {
+                    response.resize(1 + slen);
+                    response[0] = NSPV_REMOTERPCRESP;
+                    NSPV_rwremoterpcresp(1,&response[1],&R,slen);
+                    pfrom->PushMessage("nSPV",response);
+                    pfrom->prevtimes[ind] = timestamp;
+                    NSPV_remoterpc_purge(&R);
+                }                
+            }
+        }
+        else if (request[0] == NSPV_CCMODULEUTXOS)  // get cc module utxos from coinaddr for the requested amount, evalcode, funcid list and txid
+        {
+            //LogPrintf("utxos: %u > %u, ind.%d, len.%d\n",timestamp,pfrom->prevtimes[ind],ind,len);
+            if (timestamp > pfrom->prevtimes[ind])
+            {
+                struct NSPV_utxosresp U;
+                char coinaddr[64];
+                int64_t amount;
+                uint8_t evalcode;
+                char funcids[27];
+                uint256 filtertxid;
+                bool errorFormat = false;
+                const int32_t BITCOINADDRESSMINLEN = 20;
+
+                int32_t minreqlen = sizeof(uint8_t) + sizeof(uint8_t) + BITCOINADDRESSMINLEN + sizeof(amount) + sizeof(evalcode) + sizeof(uint8_t) + sizeof(filtertxid);
+                int32_t maxreqlen = sizeof(uint8_t) + sizeof(uint8_t) + sizeof(coinaddr)-1 + sizeof(amount) + sizeof(evalcode) + sizeof(uint8_t) + sizeof(funcids)-1 + sizeof(filtertxid);
+
+                if (len >= minreqlen && len <= maxreqlen)
+                {
+                    n = 1;
+                    int32_t addrlen = request[n++];
+                    if (addrlen < sizeof(coinaddr))
+                    {
+                        memcpy(coinaddr, &request[n], addrlen);
+                        coinaddr[addrlen] = 0;
+                        n += addrlen;
+                        iguana_rwnum(0, &request[n], sizeof(amount), &amount);
+                        n += sizeof(amount);
+                        iguana_rwnum(0, &request[n], sizeof(evalcode), &evalcode);
+                        n += sizeof(evalcode);
+
+                        int32_t funcidslen = request[n++];
+                        if (funcidslen < sizeof(funcids))
+                        {
+                            memcpy(funcids, &request[n], funcidslen);
+                            funcids[funcidslen] = 0;
+                            n += funcidslen;
+                            iguana_rwbignum(0, &request[n], sizeof(filtertxid), (uint8_t *)&filtertxid);
+                            std::cerr << __func__ << " " << "request addr=" << coinaddr << " amount=" << amount << " evalcode=" << (int)evalcode << " funcids=" << funcids << " filtertxid=" << filtertxid.GetHex() << std::endl;
+
+                            memset(&U, 0, sizeof(U));
+                            if ((slen = NSPV_getccmoduleutxos(&U, coinaddr, amount, evalcode, funcids, filtertxid)) > 0)
+                            {
+                                std::cerr << __func__ << " " << "created utxos, slen=" << slen << std::endl;
+                                response.resize(1 + slen);
+                                response[0] = NSPV_CCMODULEUTXOSRESP;
+                                if (NSPV_rwutxosresp(1, &response[1], &U) == slen)
+                                {
+                                    pfrom->PushMessage("nSPV", response);
+                                    pfrom->prevtimes[ind] = timestamp;
+                                    std::cerr << __func__ << " " << "returned nSPV response" << std::endl;
+                                }
+                                NSPV_utxosresp_purge(&U);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+#endif // KOMODO_NSPVFULLNODE_H
diff --git a/src/komodo_nSPV_superlite.h b/src/komodo_nSPV_superlite.h
new file mode 100644
index 00000000..731dc4e9
--- /dev/null
+++ b/src/komodo_nSPV_superlite.h
@@ -0,0 +1,981 @@
+
+/******************************************************************************
+ * Copyright © 2014-2019 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+
+#ifndef KOMODO_NSPVSUPERLITE_H
+#define KOMODO_NSPVSUPERLITE_H
+
+// nSPV client. VERY simplistic "single threaded" networking model. for production GUI best to multithread, etc.
+// no caching, no optimizations, no reducing the number of ntzsproofs needed by detecting overlaps, etc.
+// advantage is that it is simpler to implement and understand to create a design for a more performant version
+
+
+CAmount AmountFromValue(const UniValue& value);
+int32_t bitcoin_base58decode(uint8_t *data,char *coinaddr);
+
+uint32_t NSPV_lastinfo,NSPV_logintime,NSPV_tiptime;
+CKey NSPV_key;
+char NSPV_wifstr[64],NSPV_pubkeystr[67],NSPV_lastpeer[128];
+std::string NSPV_address;
+struct NSPV_inforesp NSPV_inforesult;
+struct NSPV_utxosresp NSPV_utxosresult;
+struct NSPV_txidsresp NSPV_txidsresult;
+struct NSPV_mempoolresp NSPV_mempoolresult;
+struct NSPV_spentinfo NSPV_spentresult;
+struct NSPV_ntzsresp NSPV_ntzsresult;
+struct NSPV_ntzsproofresp NSPV_ntzsproofresult;
+struct NSPV_txproof NSPV_txproofresult;
+struct NSPV_broadcastresp NSPV_broadcastresult;
+
+struct NSPV_ntzsresp NSPV_ntzsresp_cache[NSPV_MAXVINS];
+struct NSPV_ntzsproofresp NSPV_ntzsproofresp_cache[NSPV_MAXVINS * 2];
+struct NSPV_txproof NSPV_txproof_cache[NSPV_MAXVINS * 4];
+
+struct NSPV_ntzsresp *NSPV_ntzsresp_find(int32_t reqheight)
+{
+    int32_t i;
+    for (i=0; i<sizeof(NSPV_ntzsresp_cache)/sizeof(*NSPV_ntzsresp_cache); i++)
+        if ( NSPV_ntzsresp_cache[i].reqheight == reqheight )
+            return(&NSPV_ntzsresp_cache[i]);
+    return(0);
+}
+
+struct NSPV_ntzsresp *NSPV_ntzsresp_add(struct NSPV_ntzsresp *ptr)
+{
+    int32_t i;
+    for (i=0; i<sizeof(NSPV_ntzsresp_cache)/sizeof(*NSPV_ntzsresp_cache); i++)
+        if ( NSPV_ntzsresp_cache[i].reqheight == 0 )
+            break;
+    if ( i == sizeof(NSPV_ntzsresp_cache)/sizeof(*NSPV_ntzsresp_cache) )
+        i = (rand() % (sizeof(NSPV_ntzsresp_cache)/sizeof(*NSPV_ntzsresp_cache)));
+    NSPV_ntzsresp_purge(&NSPV_ntzsresp_cache[i]);
+    NSPV_ntzsresp_copy(&NSPV_ntzsresp_cache[i],ptr);
+    LogPrintf("ADD CACHE ntzsresp req.%d\n",ptr->reqheight);
+    return(&NSPV_ntzsresp_cache[i]);
+}
+
+struct NSPV_txproof *NSPV_txproof_find(uint256 txid)
+{
+    int32_t i; struct NSPV_txproof *backup = 0;
+    for (i=0; i<sizeof(NSPV_txproof_cache)/sizeof(*NSPV_txproof_cache); i++)
+        if ( NSPV_txproof_cache[i].txid == txid )
+        {
+            if ( NSPV_txproof_cache[i].txprooflen != 0 )
+                return(&NSPV_txproof_cache[i]);
+            else backup = &NSPV_txproof_cache[i];
+        }
+    return(backup);
+}
+
+struct NSPV_txproof *NSPV_txproof_add(struct NSPV_txproof *ptr)
+{
+    int32_t i;
+    for (i=0; i<sizeof(NSPV_txproof_cache)/sizeof(*NSPV_txproof_cache); i++)
+        if ( NSPV_txproof_cache[i].txid == ptr->txid )
+        {
+            if ( NSPV_txproof_cache[i].txprooflen == 0 && ptr->txprooflen != 0 )
+            {
+                NSPV_txproof_purge(&NSPV_txproof_cache[i]);
+                NSPV_txproof_copy(&NSPV_txproof_cache[i],ptr);
+                return(&NSPV_txproof_cache[i]);
+            }
+            else if ( NSPV_txproof_cache[i].txprooflen != 0 || ptr->txprooflen == 0 )
+                return(&NSPV_txproof_cache[i]);
+        }
+    for (i=0; i<sizeof(NSPV_txproof_cache)/sizeof(*NSPV_txproof_cache); i++)
+        if ( NSPV_txproof_cache[i].txlen == 0 )
+            break;
+    if ( i == sizeof(NSPV_txproof_cache)/sizeof(*NSPV_txproof_cache) )
+        i = (rand() % (sizeof(NSPV_txproof_cache)/sizeof(*NSPV_txproof_cache)));
+    NSPV_txproof_purge(&NSPV_txproof_cache[i]);
+    NSPV_txproof_copy(&NSPV_txproof_cache[i],ptr);
+    LogPrintf("ADD CACHE txproof %s\n",ptr->txid.GetHex().c_str());
+    return(&NSPV_txproof_cache[i]);
+}
+
+struct NSPV_ntzsproofresp *NSPV_ntzsproof_find(uint256 prevtxid,uint256 nexttxid)
+{
+    int32_t i;
+    for (i=0; i<sizeof(NSPV_ntzsproofresp_cache)/sizeof(*NSPV_ntzsproofresp_cache); i++)
+        if ( NSPV_ntzsproofresp_cache[i].prevtxid == prevtxid && NSPV_ntzsproofresp_cache[i].nexttxid == nexttxid )
+            return(&NSPV_ntzsproofresp_cache[i]);
+    return(0);
+}
+
+struct NSPV_ntzsproofresp *NSPV_ntzsproof_add(struct NSPV_ntzsproofresp *ptr)
+{
+    int32_t i;
+    for (i=0; i<sizeof(NSPV_ntzsproofresp_cache)/sizeof(*NSPV_ntzsproofresp_cache); i++)
+        if ( NSPV_ntzsproofresp_cache[i].common.hdrs == 0 )
+            break;
+    if ( i == sizeof(NSPV_ntzsproofresp_cache)/sizeof(*NSPV_ntzsproofresp_cache) )
+        i = (rand() % (sizeof(NSPV_ntzsproofresp_cache)/sizeof(*NSPV_ntzsproofresp_cache)));
+    NSPV_ntzsproofresp_purge(&NSPV_ntzsproofresp_cache[i]);
+    NSPV_ntzsproofresp_copy(&NSPV_ntzsproofresp_cache[i],ptr);
+    LogPrintf("ADD CACHE ntzsproof %s %s\n",ptr->prevtxid.GetHex().c_str(),ptr->nexttxid.GetHex().c_str());
+    return(&NSPV_ntzsproofresp_cache[i]);
+}
+
+// komodo_nSPVresp is called from async message processing
+
+void komodo_nSPVresp(CNode *pfrom,std::vector<uint8_t> response) // received a response
+{
+    struct NSPV_inforesp I; int32_t len; uint32_t timestamp = (uint32_t)time(NULL);
+    strncpy(NSPV_lastpeer,pfrom->addr.ToString().c_str(),sizeof(NSPV_lastpeer)-1);
+    if ( (len= response.size()) > 0 )
+    {
+        switch ( response[0] )
+        {
+            case NSPV_INFORESP:
+                LogPrintf("got version.%d info response %u size.%d height.%d\n",NSPV_inforesult.version,timestamp,(int32_t)response.size(),NSPV_inforesult.height); // update current height and ntrz status
+                I = NSPV_inforesult;
+                NSPV_inforesp_purge(&NSPV_inforesult);
+                NSPV_rwinforesp(0,&response[1],&NSPV_inforesult);
+                if ( NSPV_inforesult.height < I.height )
+                {
+                    LogPrintf("got old info response %u size.%d height.%d\n",timestamp,(int32_t)response.size(),NSPV_inforesult.height); // update current height and ntrz status
+                    NSPV_inforesp_purge(&NSPV_inforesult);
+                    NSPV_inforesult = I;
+                }
+                else if ( NSPV_inforesult.height > I.height )
+                {
+                    NSPV_lastinfo = timestamp - ASSETCHAINS_BLOCKTIME/4;
+                    // need to validate new header to make sure it is valid mainchain
+                    if ( NSPV_inforesult.height == NSPV_inforesult.hdrheight )
+                        NSPV_tiptime = NSPV_inforesult.H.nTime;
+                }
+                break;
+            case NSPV_UTXOSRESP:
+                NSPV_utxosresp_purge(&NSPV_utxosresult);
+                NSPV_rwutxosresp(0,&response[1],&NSPV_utxosresult);
+                LogPrintf("got utxos response %u size.%d\n",timestamp,(int32_t)response.size());
+                break;
+            case NSPV_TXIDSRESP:
+                NSPV_txidsresp_purge(&NSPV_txidsresult);
+                NSPV_rwtxidsresp(0,&response[1],&NSPV_txidsresult);
+                LogPrintf("got txids response %u size.%d %s CC.%d num.%d\n",timestamp,(int32_t)response.size(),NSPV_txidsresult.coinaddr,NSPV_txidsresult.CCflag,NSPV_txidsresult.numtxids);
+                break;
+            case NSPV_MEMPOOLRESP:
+                NSPV_mempoolresp_purge(&NSPV_mempoolresult);
+                NSPV_rwmempoolresp(0,&response[1],&NSPV_mempoolresult);
+                LogPrintf("got mempool response %u size.%d %s CC.%d num.%d funcid.%d %s/v%d\n",timestamp,(int32_t)response.size(),NSPV_mempoolresult.coinaddr,NSPV_mempoolresult.CCflag,NSPV_mempoolresult.numtxids,NSPV_mempoolresult.funcid,NSPV_mempoolresult.txid.GetHex().c_str(),NSPV_mempoolresult.vout);
+                break;
+           case NSPV_NTZSRESP:
+                NSPV_ntzsresp_purge(&NSPV_ntzsresult);
+                NSPV_rwntzsresp(0,&response[1],&NSPV_ntzsresult);
+                if ( NSPV_ntzsresp_find(NSPV_ntzsresult.reqheight) == 0 )
+                    NSPV_ntzsresp_add(&NSPV_ntzsresult);
+                LogPrintf("got ntzs response %u size.%d %s prev.%d, %s next.%d\n",timestamp,(int32_t)response.size(),NSPV_ntzsresult.prevntz.txid.GetHex().c_str(),NSPV_ntzsresult.prevntz.height,NSPV_ntzsresult.nextntz.txid.GetHex().c_str(),NSPV_ntzsresult.nextntz.height);
+                break;
+            case NSPV_NTZSPROOFRESP:
+                NSPV_ntzsproofresp_purge(&NSPV_ntzsproofresult);
+                NSPV_rwntzsproofresp(0,&response[1],&NSPV_ntzsproofresult);
+                if ( NSPV_ntzsproof_find(NSPV_ntzsproofresult.prevtxid,NSPV_ntzsproofresult.nexttxid) == 0 )
+                    NSPV_ntzsproof_add(&NSPV_ntzsproofresult);
+                LogPrintf("got ntzproof response %u size.%d prev.%d next.%d\n",timestamp,(int32_t)response.size(),NSPV_ntzsproofresult.common.prevht,NSPV_ntzsproofresult.common.nextht);
+                break;
+            case NSPV_TXPROOFRESP:
+                NSPV_txproof_purge(&NSPV_txproofresult);
+                NSPV_rwtxproof(0,&response[1],&NSPV_txproofresult);
+                if ( NSPV_txproof_find(NSPV_txproofresult.txid) == 0 )
+                    NSPV_txproof_add(&NSPV_txproofresult);
+                LogPrintf("got txproof response %u size.%d %s ht.%d\n",timestamp,(int32_t)response.size(),NSPV_txproofresult.txid.GetHex().c_str(),NSPV_txproofresult.height);
+                break;
+            case NSPV_SPENTINFORESP:
+                NSPV_spentinfo_purge(&NSPV_spentresult);
+                NSPV_rwspentinfo(0,&response[1],&NSPV_spentresult);
+                LogPrintf("got spentinfo response %u size.%d\n",timestamp,(int32_t)response.size());
+                break;
+            case NSPV_BROADCASTRESP:
+                NSPV_broadcast_purge(&NSPV_broadcastresult);
+                NSPV_rwbroadcastresp(0,&response[1],&NSPV_broadcastresult);
+                LogPrintf("got broadcast response %u size.%d %s retcode.%d\n",timestamp,(int32_t)response.size(),NSPV_broadcastresult.txid.GetHex().c_str(),NSPV_broadcastresult.retcode);
+                break;
+            case NSPV_CCMODULEUTXOSRESP:
+                NSPV_utxosresp_purge(&NSPV_utxosresult);
+                NSPV_rwutxosresp(0, &response[1], &NSPV_utxosresult);
+                LogPrintf( "got cc module utxos response %u size.%d\n", timestamp, (int32_t)response.size());
+                break;
+
+            default: LogPrintf("unexpected response %02x size.%d at %u\n",response[0],(int32_t)response.size(),timestamp);
+                break;
+        }
+    }
+}
+
+// superlite message issuing
+
+CNode *NSPV_req(CNode *pnode,uint8_t *msg,int32_t len,uint64_t mask,int32_t ind)
+{
+    int32_t n,flag = 0; CNode *pnodes[64]; uint32_t timestamp = (uint32_t)time(NULL);
+    if ( KOMODO_NSPV_FULLNODE )
+        return(0);
+    if ( pnode == 0 )
+    {
+        memset(pnodes,0,sizeof(pnodes));
+        //LOCK(cs_vNodes);
+        n = 0;
+        BOOST_FOREACH(CNode *ptr,vNodes)
+        {
+            if ( ptr->prevtimes[ind] > timestamp )
+                ptr->prevtimes[ind] = 0;
+            if ( ptr->hSocket == INVALID_SOCKET )
+                continue;
+            if ( (ptr->nServices & mask) == mask && timestamp > ptr->prevtimes[ind] )
+            {
+                flag = 1;
+                pnodes[n++] = ptr;
+                if ( n == sizeof(pnodes)/sizeof(*pnodes) )
+                    break;
+            } // else LogPrintf("nServices %llx vs mask %llx, t%u vs %u, ind.%d\n",(long long)ptr->nServices,(long long)mask,timestamp,ptr->prevtimes[ind],ind);
+        }
+        if ( n > 0 )
+            pnode = pnodes[rand() % n];
+    } else flag = 1;
+    if ( pnode != 0 )
+    {
+        std::vector<uint8_t> request;
+        request.resize(len);
+        memcpy(&request[0],msg,len);
+        if ( (0) && KOMODO_NSPV_SUPERLITE )
+            LogPrintf("pushmessage [%d] len.%d\n",msg[0],len);
+        pnode->PushMessage("getnSPV",request);
+        pnode->prevtimes[ind] = timestamp;
+        return(pnode);
+    } else LogPrintf("no pnodes\n");
+    return(0);
+}
+
+UniValue NSPV_logout()
+{
+    UniValue result(UniValue::VOBJ);
+    result.push_back(Pair("result","success"));
+    if ( NSPV_logintime != 0 )
+        LogPrintf("scrub wif and privkey from NSPV memory\n");
+    else result.push_back(Pair("status","wasnt logged in"));
+    memset(NSPV_ntzsproofresp_cache,0,sizeof(NSPV_ntzsproofresp_cache));
+    memset(NSPV_txproof_cache,0,sizeof(NSPV_txproof_cache));
+    memset(NSPV_ntzsresp_cache,0,sizeof(NSPV_ntzsresp_cache));
+    memset(NSPV_wifstr,0,sizeof(NSPV_wifstr));
+    memset(&NSPV_key,0,sizeof(NSPV_key));
+    NSPV_logintime = 0;
+    return(result);
+}
+
+// komodo_nSPV from main polling loop (really this belongs in its own file, but it is so small, it ended up here)
+
+void komodo_nSPV(CNode *pto) // polling loop from SendMessages
+{
+    uint8_t msg[256]; int32_t i,len=0; uint32_t timestamp = (uint32_t)time(NULL);
+    if ( NSPV_logintime != 0 && timestamp > NSPV_logintime+NSPV_AUTOLOGOUT )
+        NSPV_logout();
+    if ( (pto->nServices & NODE_NSPV) == 0 )
+        return;
+    if ( pto->prevtimes[NSPV_INFO>>1] > timestamp )
+        pto->prevtimes[NSPV_INFO>>1] = 0;
+    if ( KOMODO_NSPV_SUPERLITE )
+    {
+        if ( timestamp > NSPV_lastinfo + ASSETCHAINS_BLOCKTIME/2 && timestamp > pto->prevtimes[NSPV_INFO>>1] + 2*ASSETCHAINS_BLOCKTIME/3 )
+        {
+            int32_t reqht;
+            reqht = 0;
+            len = 0;
+            msg[len++] = NSPV_INFO;
+            len += iguana_rwnum(1,&msg[len],sizeof(reqht),&reqht);
+            //LogPrintf("issue getinfo\n");
+            NSPV_req(pto,msg,len,NODE_NSPV,NSPV_INFO>>1);
+        }
+    }
+}
+
+UniValue NSPV_txproof_json(struct NSPV_txproof *ptr)
+{
+    UniValue result(UniValue::VOBJ);
+    result.push_back(Pair("txid",ptr->txid.GetHex()));
+    result.push_back(Pair("height",(int64_t)ptr->height));
+    result.push_back(Pair("txlen",(int64_t)ptr->txlen));
+    result.push_back(Pair("txprooflen",(int64_t)ptr->txprooflen));
+    result.push_back(Pair("lastpeer",NSPV_lastpeer));
+    return(result);
+}
+
+UniValue NSPV_spentinfo_json(struct NSPV_spentinfo *ptr)
+{
+    UniValue result(UniValue::VOBJ);
+    result.push_back(Pair("result","success"));
+    result.push_back(Pair("txid",ptr->txid.GetHex()));
+    result.push_back(Pair("vout",(int64_t)ptr->vout));
+    result.push_back(Pair("spentheight",(int64_t)ptr->spent.height));
+    result.push_back(Pair("spenttxid",ptr->spent.txid.GetHex()));
+    result.push_back(Pair("spentvini",(int64_t)ptr->spentvini));
+    result.push_back(Pair("spenttxlen",(int64_t)ptr->spent.txlen));
+    result.push_back(Pair("spenttxprooflen",(int64_t)ptr->spent.txprooflen));
+    result.push_back(Pair("lastpeer",NSPV_lastpeer));
+    return(result);
+}
+
+UniValue NSPV_ntz_json(struct NSPV_ntz *ptr)
+{
+    UniValue result(UniValue::VOBJ);
+    result.push_back(Pair("notarized_height",(int64_t)ptr->height));
+    result.push_back(Pair("notarized_blockhash",ptr->blockhash.GetHex()));
+    result.push_back(Pair("notarization_txid",ptr->txid.GetHex()));
+    result.push_back(Pair("notarization_txidheight",(int64_t)ptr->txidheight));
+    result.push_back(Pair("notarization_desttxid",ptr->othertxid.GetHex()));
+    return(result);
+}
+
+UniValue NSPV_header_json(struct NSPV_equihdr *hdr,int32_t height)
+{
+    UniValue item(UniValue::VOBJ);
+    item.push_back(Pair("height",(int64_t)height));
+    item.push_back(Pair("blockhash",NSPV_hdrhash(hdr).GetHex()));
+    item.push_back(Pair("hashPrevBlock",hdr->hashPrevBlock.GetHex()));
+    item.push_back(Pair("hashMerkleRoot",hdr->hashMerkleRoot.GetHex()));
+    item.push_back(Pair("nTime",(int64_t)hdr->nTime));
+    item.push_back(Pair("nBits",(int64_t)hdr->nBits));
+    return(item);
+}
+
+UniValue NSPV_headers_json(struct NSPV_equihdr *hdrs,int32_t numhdrs,int32_t height)
+{
+    UniValue array(UniValue::VARR); int32_t i;
+    for (i=0; i<numhdrs; i++)
+        array.push_back(NSPV_header_json(&hdrs[i],height+i));
+    return(array);
+}
+
+UniValue NSPV_getinfo_json(struct NSPV_inforesp *ptr)
+{
+    UniValue result(UniValue::VOBJ); int32_t expiration; uint32_t timestamp = (uint32_t)time(NULL);
+    result.push_back(Pair("result","success"));
+    result.push_back(Pair("nSPV",KOMODO_NSPV==-1?"disabled":(KOMODO_NSPV_SUPERLITE?"superlite":"fullnode")));
+    if ( NSPV_address.size() != 0 )
+    {
+        result.push_back(Pair("address",NSPV_address));
+        result.push_back(Pair("pubkey",NSPV_pubkeystr));
+    }
+    if ( NSPV_logintime != 0 )
+    {
+        expiration = (NSPV_logintime + NSPV_AUTOLOGOUT - timestamp);
+        result.push_back(Pair("wifexpires",expiration));
+    }
+    result.push_back(Pair("height",(int64_t)ptr->height));
+    result.push_back(Pair("chaintip",ptr->blockhash.GetHex()));
+    result.push_back(Pair("notarization",NSPV_ntz_json(&ptr->notarization)));
+    result.push_back(Pair("header",NSPV_header_json(&ptr->H,ptr->hdrheight)));
+    result.push_back(Pair("protocolversion",(int64_t)ptr->version));
+    result.push_back(Pair("lastpeer",NSPV_lastpeer));
+    return(result);
+}
+
+UniValue NSPV_utxoresp_json(struct NSPV_utxoresp *utxos,int32_t numutxos)
+{
+    UniValue array(UniValue::VARR); int32_t i;
+    for (i=0; i<numutxos; i++)
+    {
+        UniValue item(UniValue::VOBJ);
+        item.push_back(Pair("height",(int64_t)utxos[i].height));
+        item.push_back(Pair("txid",utxos[i].txid.GetHex()));
+        item.push_back(Pair("vout",(int64_t)utxos[i].vout));
+        item.push_back(Pair("value",(double)utxos[i].satoshis/COIN));
+        if ( ASSETCHAINS_SYMBOL[0] == 0 )
+            item.push_back(Pair("interest",(double)utxos[i].extradata/COIN));
+        array.push_back(item);
+    }
+    return(array);
+}
+
+UniValue NSPV_utxosresp_json(struct NSPV_utxosresp *ptr)
+{
+    UniValue result(UniValue::VOBJ);
+    result.push_back(Pair("result","success"));
+    result.push_back(Pair("utxos",NSPV_utxoresp_json(ptr->utxos,ptr->numutxos)));
+    result.push_back(Pair("address",ptr->coinaddr));
+    result.push_back(Pair("isCC",ptr->CCflag));
+    result.push_back(Pair("height",(int64_t)ptr->nodeheight));
+    result.push_back(Pair("numutxos",(int64_t)ptr->numutxos));
+    result.push_back(Pair("balance",(double)ptr->total/COIN));
+    if ( ASSETCHAINS_SYMBOL[0] == 0 )
+        result.push_back(Pair("interest",(double)ptr->interest/COIN));
+    result.push_back(Pair("filter",(int64_t)ptr->filter));
+    result.push_back(Pair("lastpeer",NSPV_lastpeer));
+    return(result);
+}
+
+UniValue NSPV_txidresp_json(struct NSPV_txidresp *utxos,int32_t numutxos)
+{
+    UniValue array(UniValue::VARR); int32_t i;
+    for (i=0; i<numutxos; i++)
+    {
+        UniValue item(UniValue::VOBJ);
+        item.push_back(Pair("height",(int64_t)utxos[i].height));
+        item.push_back(Pair("txid",utxos[i].txid.GetHex()));
+        item.push_back(Pair("value",(double)utxos[i].satoshis/COIN));
+        if ( utxos[i].satoshis > 0 )
+            item.push_back(Pair("vout",(int64_t)utxos[i].vout));
+        else item.push_back(Pair("vin",(int64_t)utxos[i].vout));
+        array.push_back(item);
+    }
+    return(array);
+}
+
+UniValue NSPV_txidsresp_json(struct NSPV_txidsresp *ptr)
+{
+    UniValue result(UniValue::VOBJ);
+    result.push_back(Pair("result","success"));
+    result.push_back(Pair("txids",NSPV_txidresp_json(ptr->txids,ptr->numtxids)));
+    result.push_back(Pair("address",ptr->coinaddr));
+    result.push_back(Pair("isCC",ptr->CCflag));
+    result.push_back(Pair("height",(int64_t)ptr->nodeheight));
+    result.push_back(Pair("numtxids",(int64_t)ptr->numtxids));
+    result.push_back(Pair("filter",(int64_t)ptr->filter));
+    result.push_back(Pair("lastpeer",NSPV_lastpeer));
+    return(result);
+}
+
+UniValue NSPV_mempoolresp_json(struct NSPV_mempoolresp *ptr)
+{
+    UniValue result(UniValue::VOBJ),array(UniValue::VARR); int32_t i;
+    result.push_back(Pair("result","success"));
+    for (i=0; i<ptr->numtxids; i++)
+        array.push_back(ptr->txids[i].GetHex().c_str());
+    result.push_back(Pair("txids",array));
+    result.push_back(Pair("address",ptr->coinaddr));
+    result.push_back(Pair("isCC",ptr->CCflag));
+    result.push_back(Pair("height",(int64_t)ptr->nodeheight));
+    result.push_back(Pair("numtxids",(int64_t)ptr->numtxids));
+    result.push_back(Pair("txid",ptr->txid.GetHex().c_str()));
+    result.push_back(Pair("vout",(int64_t)ptr->vout));
+    result.push_back(Pair("funcid",(int64_t)ptr->funcid));
+    result.push_back(Pair("lastpeer",NSPV_lastpeer));
+    return(result);
+}
+
+UniValue NSPV_ntzsresp_json(struct NSPV_ntzsresp *ptr)
+{
+    UniValue result(UniValue::VOBJ);
+    result.push_back(Pair("result","success"));
+    result.push_back(Pair("prev",NSPV_ntz_json(&ptr->prevntz)));
+    result.push_back(Pair("next",NSPV_ntz_json(&ptr->nextntz)));
+    result.push_back(Pair("lastpeer",NSPV_lastpeer));
+    return(result);
+}
+
+UniValue NSPV_ntzsproof_json(struct NSPV_ntzsproofresp *ptr)
+{
+    UniValue result(UniValue::VOBJ);
+    result.push_back(Pair("result","success"));
+    result.push_back(Pair("prevht",(int64_t)ptr->common.prevht));
+    result.push_back(Pair("nextht",(int64_t)ptr->common.nextht));
+    result.push_back(Pair("prevtxid",ptr->prevtxid.GetHex()));
+    result.push_back(Pair("prevtxidht",(int64_t)ptr->prevtxidht));
+    result.push_back(Pair("prevtxlen",(int64_t)ptr->prevtxlen));
+    result.push_back(Pair("nexttxid",ptr->nexttxid.GetHex()));
+    result.push_back(Pair("nexttxidht",(int64_t)ptr->nexttxidht));
+    result.push_back(Pair("nexttxlen",(int64_t)ptr->nexttxlen));
+    result.push_back(Pair("numhdrs",(int64_t)ptr->common.numhdrs));
+    result.push_back(Pair("headers",NSPV_headers_json(ptr->common.hdrs,ptr->common.numhdrs,ptr->common.prevht)));
+    result.push_back(Pair("lastpeer",NSPV_lastpeer));
+    //LogPrintf("ntzs_proof %s %d, %s %d\n",ptr->prevtxid.GetHex().c_str(),ptr->common.prevht,ptr->nexttxid.GetHex().c_str(),ptr->common.nextht);
+    return(result);
+}
+
+UniValue NSPV_broadcast_json(struct NSPV_broadcastresp *ptr,uint256 txid)
+{
+    UniValue result(UniValue::VOBJ);
+    result.push_back(Pair("result","success"));
+    result.push_back(Pair("expected",txid.GetHex()));
+    result.push_back(Pair("broadcast",ptr->txid.GetHex()));
+    result.push_back(Pair("retcode",(int64_t)ptr->retcode));
+    switch ( ptr->retcode )
+    {
+        case 1: result.push_back(Pair("type","broadcast and mempool")); break;
+        case 0: result.push_back(Pair("type","broadcast")); break;
+        case -1: result.push_back(Pair("type","decode error")); break;
+        case -2: result.push_back(Pair("type","timeout")); break;
+        case -3: result.push_back(Pair("type","error adding to mempool")); break;
+        default: result.push_back(Pair("type","unknown")); break;
+    }
+    result.push_back(Pair("lastpeer",NSPV_lastpeer));
+    return(result);
+}
+
+UniValue NSPV_login(char *wifstr)
+{
+    UniValue result(UniValue::VOBJ); char coinaddr[64]; uint8_t data[128]; int32_t len,valid = 0;
+    NSPV_logout();
+    len = bitcoin_base58decode(data,wifstr);
+    if ( strlen(wifstr) < 64 && (len == 38 && data[len-5] == 1) || (len == 37 && data[len-5] != 1) )
+        valid = 1;
+    if ( valid == 0 || data[0] != 188 )
+    {
+        result.push_back(Pair("result","error"));
+        result.push_back(Pair("error","invalid wif"));
+        result.push_back(Pair("len",(int64_t)len));
+        result.push_back(Pair("prefix",(int64_t)data[0]));
+        return(result);
+    }
+    memset(NSPV_wifstr,0,sizeof(NSPV_wifstr));
+    NSPV_logintime = (uint32_t)time(NULL);
+    if ( strcmp(NSPV_wifstr,wifstr) != 0 )
+    {
+        strncpy(NSPV_wifstr,wifstr,sizeof(NSPV_wifstr)-1);
+        NSPV_key = DecodeSecret(wifstr);
+    }
+    result.push_back(Pair("result","success"));
+    result.push_back(Pair("status","wif will expire in 777 seconds"));
+    CPubKey pubkey = NSPV_key.GetPubKey();
+    CKeyID vchAddress = pubkey.GetID();
+    NSPV_address = EncodeDestination(vchAddress);
+    result.push_back(Pair("address",NSPV_address));
+    result.push_back(Pair("pubkey",HexStr(pubkey)));
+    strcpy(NSPV_pubkeystr,HexStr(pubkey).c_str());
+    if ( KOMODO_NSPV_SUPERLITE )
+        decode_hex(NOTARY_PUBKEY33,33,NSPV_pubkeystr);
+    result.push_back(Pair("wifprefix",(int64_t)data[0]));
+    result.push_back(Pair("compressed",(int64_t)(data[len-5] == 1)));
+    memset(data,0,sizeof(data));
+    return(result);
+}
+
+UniValue NSPV_getinfo_req(int32_t reqht)
+{
+    uint8_t msg[512]; int32_t i,iter,len = 0; struct NSPV_inforesp I;
+    NSPV_inforesp_purge(&NSPV_inforesult);
+    msg[len++] = NSPV_INFO;
+    len += iguana_rwnum(1,&msg[len],sizeof(reqht),&reqht);
+    for (iter=0; iter<3; iter++)
+    if ( NSPV_req(0,msg,len,NODE_NSPV,msg[0]>>1) != 0 )
+    {
+        for (i=0; i<NSPV_POLLITERS; i++)
+        {
+            usleep(NSPV_POLLMICROS);
+            if ( NSPV_inforesult.height != 0 )
+                return(NSPV_getinfo_json(&NSPV_inforesult));
+        }
+    } else sleep(1);
+    memset(&I,0,sizeof(I));
+    return(NSPV_getinfo_json(&NSPV_inforesult));
+}
+
+uint32_t NSPV_blocktime(int32_t hdrheight)
+{
+    uint32_t timestamp; struct NSPV_inforesp old = NSPV_inforesult;
+    if ( hdrheight > 0 )
+    {
+        NSPV_getinfo_req(hdrheight);
+        if ( NSPV_inforesult.hdrheight == hdrheight )
+        {
+            timestamp = NSPV_inforesult.H.nTime;
+            NSPV_inforesult = old;
+            LogPrintf("NSPV_blocktime ht.%d -> t%u\n",hdrheight,timestamp);
+            return(timestamp);
+        }
+    }
+    NSPV_inforesult = old;
+    return(0);
+}
+
+UniValue NSPV_addressutxos(char *coinaddr,int32_t CCflag,int32_t skipcount,int32_t filter)
+{
+    UniValue result(UniValue::VOBJ); uint8_t msg[512]; int32_t i,iter,slen,len = 0;
+    //LogPrintf("utxos %s NSPV addr %s\n",coinaddr,NSPV_address.c_str());
+    //if ( NSPV_utxosresult.nodeheight >= NSPV_inforesult.height && strcmp(coinaddr,NSPV_utxosresult.coinaddr) == 0 && CCflag == NSPV_utxosresult.CCflag  && skipcount == NSPV_utxosresult.skipcount && filter == NSPV_utxosresult.filter )
+    //    return(NSPV_utxosresp_json(&NSPV_utxosresult));
+    if ( skipcount < 0 )
+        skipcount = 0;
+    NSPV_utxosresp_purge(&NSPV_utxosresult);
+    if ( bitcoin_base58decode(msg,coinaddr) != 25 )
+    {
+        result.push_back(Pair("result","error"));
+        result.push_back(Pair("error","invalid address"));
+        return(result);
+    }
+    slen = (int32_t)strlen(coinaddr);
+    msg[len++] = NSPV_UTXOS;
+    msg[len++] = slen;
+    memcpy(&msg[len],coinaddr,slen), len += slen;
+    msg[len++] = (CCflag != 0);
+    len += iguana_rwnum(1,&msg[len],sizeof(skipcount),&skipcount);
+    len += iguana_rwnum(1,&msg[len],sizeof(filter),&filter);
+    for (iter=0; iter<3; iter++)
+    if ( NSPV_req(0,msg,len,NODE_ADDRINDEX,msg[0]>>1) != 0 )
+    {
+        for (i=0; i<NSPV_POLLITERS; i++)
+        {
+            usleep(NSPV_POLLMICROS);
+            if ( (NSPV_inforesult.height == 0 || NSPV_utxosresult.nodeheight >= NSPV_inforesult.height) && strcmp(coinaddr,NSPV_utxosresult.coinaddr) == 0 && CCflag == NSPV_utxosresult.CCflag )
+                return(NSPV_utxosresp_json(&NSPV_utxosresult));
+        }
+    } else sleep(1);
+    result.push_back(Pair("result","error"));
+    result.push_back(Pair("error","no utxos result"));
+    result.push_back(Pair("lastpeer",NSPV_lastpeer));
+    return(result);
+}
+
+UniValue NSPV_addresstxids(char *coinaddr,int32_t CCflag,int32_t skipcount,int32_t filter)
+{
+    UniValue result(UniValue::VOBJ); uint8_t msg[512]; int32_t i,iter,slen,len = 0;
+    if ( NSPV_txidsresult.nodeheight >= NSPV_inforesult.height && strcmp(coinaddr,NSPV_txidsresult.coinaddr) == 0 && CCflag == NSPV_txidsresult.CCflag && skipcount == NSPV_txidsresult.skipcount )
+        return(NSPV_txidsresp_json(&NSPV_txidsresult));
+    if ( skipcount < 0 )
+        skipcount = 0;
+    NSPV_txidsresp_purge(&NSPV_txidsresult);
+    if ( bitcoin_base58decode(msg,coinaddr) != 25 )
+    {
+        result.push_back(Pair("result","error"));
+        result.push_back(Pair("error","invalid address"));
+        return(result);
+    }
+    slen = (int32_t)strlen(coinaddr);
+    msg[len++] = NSPV_TXIDS;
+    msg[len++] = slen;
+    memcpy(&msg[len],coinaddr,slen), len += slen;
+    msg[len++] = (CCflag != 0);
+    len += iguana_rwnum(1,&msg[len],sizeof(skipcount),&skipcount);
+    len += iguana_rwnum(1,&msg[len],sizeof(filter),&filter);
+    //LogPrintf("skipcount.%d\n",skipcount);
+    for (iter=0; iter<3; iter++)
+    if ( NSPV_req(0,msg,len,NODE_ADDRINDEX,msg[0]>>1) != 0 )
+    {
+        for (i=0; i<NSPV_POLLITERS; i++)
+        {
+            usleep(NSPV_POLLMICROS);
+            if ( (NSPV_inforesult.height == 0 || NSPV_txidsresult.nodeheight >= NSPV_inforesult.height) && strcmp(coinaddr,NSPV_txidsresult.coinaddr) == 0 && CCflag == NSPV_txidsresult.CCflag )
+                return(NSPV_txidsresp_json(&NSPV_txidsresult));
+        }
+    } else sleep(1);
+    result.push_back(Pair("result","error"));
+    result.push_back(Pair("error","no txid result"));
+    result.push_back(Pair("lastpeer",NSPV_lastpeer));
+    return(result);
+}
+
+UniValue NSPV_ccaddresstxids(char *coinaddr,int32_t CCflag,int32_t skipcount,uint256 filtertxid,uint8_t evalcode, uint8_t func)
+{
+    UniValue result(UniValue::VOBJ); uint8_t msg[512],funcid=NSPV_CC_TXIDS; char zeroes[64]; int32_t i,iter,slen,len = 0,vout;
+    NSPV_mempoolresp_purge(&NSPV_mempoolresult);
+    memset(zeroes,0,sizeof(zeroes));
+    if ( coinaddr == 0 )
+        coinaddr = zeroes;
+    if ( coinaddr[0] != 0 && bitcoin_base58decode(msg,coinaddr) != 25 )
+    {
+        result.push_back(Pair("result","error"));
+        result.push_back(Pair("error","invalid address"));
+        return(result);
+    }
+    vout=skipcount << 16 | evalcode << 8 | func;
+    msg[len++] = NSPV_MEMPOOL;
+    msg[len++] = (CCflag != 0);
+    len += iguana_rwnum(1,&msg[len],sizeof(funcid),&funcid);
+    len += iguana_rwnum(1,&msg[len],sizeof(vout),&vout);
+    len += iguana_rwbignum(1,&msg[len],sizeof(filtertxid),(uint8_t *)&filtertxid);
+    slen = (int32_t)strlen(coinaddr);
+    msg[len++] = slen;
+    memcpy(&msg[len],coinaddr,slen), len += slen;
+    LogPrintf("(%s) func.%d CC.%d %s skipcount.%d len.%d\n",coinaddr,NSPV_CC_TXIDS,CCflag,filtertxid.GetHex().c_str(),skipcount,len);
+    for (iter=0; iter<3; iter++)
+    if ( NSPV_req(0,msg,len,NODE_NSPV,msg[0]>>1) != 0 )
+    {
+        for (i=0; i<NSPV_POLLITERS; i++)
+        {
+            usleep(NSPV_POLLMICROS);
+            if ( NSPV_mempoolresult.nodeheight >= NSPV_inforesult.height && strcmp(coinaddr,NSPV_mempoolresult.coinaddr) == 0 && CCflag == NSPV_mempoolresult.CCflag && filtertxid == NSPV_mempoolresult.txid && vout == NSPV_mempoolresult.vout && funcid == NSPV_mempoolresult.funcid )
+                return(NSPV_mempoolresp_json(&NSPV_mempoolresult));
+        }
+    } else sleep(1);
+    result.push_back(Pair("result","error"));
+    result.push_back(Pair("error","no txid result"));
+    result.push_back(Pair("lastpeer",NSPV_lastpeer));
+    return(result);
+}
+
+UniValue NSPV_mempooltxids(char *coinaddr,int32_t CCflag,uint8_t funcid,uint256 txid,int32_t vout)
+{
+    UniValue result(UniValue::VOBJ); uint8_t msg[512]; char zeroes[64]; int32_t i,iter,slen,len = 0;
+    NSPV_mempoolresp_purge(&NSPV_mempoolresult);
+    memset(zeroes,0,sizeof(zeroes));
+    if ( coinaddr == 0 )
+        coinaddr = zeroes;
+    if ( coinaddr[0] != 0 && bitcoin_base58decode(msg,coinaddr) != 25 )
+    {
+        result.push_back(Pair("result","error"));
+        result.push_back(Pair("error","invalid address"));
+        return(result);
+    }
+    msg[len++] = NSPV_MEMPOOL;
+    msg[len++] = (CCflag != 0);
+    len += iguana_rwnum(1,&msg[len],sizeof(funcid),&funcid);
+    len += iguana_rwnum(1,&msg[len],sizeof(vout),&vout);
+    len += iguana_rwbignum(1,&msg[len],sizeof(txid),(uint8_t *)&txid);
+    slen = (int32_t)strlen(coinaddr);
+    msg[len++] = slen;
+    memcpy(&msg[len],coinaddr,slen), len += slen;
+    LogPrintf("(%s) func.%d CC.%d %s/v%d len.%d\n",coinaddr,funcid,CCflag,txid.GetHex().c_str(),vout,len);
+    for (iter=0; iter<3; iter++)
+    if ( NSPV_req(0,msg,len,NODE_NSPV,msg[0]>>1) != 0 )
+    {
+        for (i=0; i<NSPV_POLLITERS; i++)
+        {
+            usleep(NSPV_POLLMICROS);
+            if ( NSPV_mempoolresult.nodeheight >= NSPV_inforesult.height && strcmp(coinaddr,NSPV_mempoolresult.coinaddr) == 0 && CCflag == NSPV_mempoolresult.CCflag && txid == NSPV_mempoolresult.txid && vout == NSPV_mempoolresult.vout && funcid == NSPV_mempoolresult.funcid )
+                return(NSPV_mempoolresp_json(&NSPV_mempoolresult));
+        }
+    } else sleep(1);
+    result.push_back(Pair("result","error"));
+    result.push_back(Pair("error","no txid result"));
+    result.push_back(Pair("lastpeer",NSPV_lastpeer));
+    return(result);
+}
+
+int32_t NSPV_coinaddr_inmempool(char const *logcategory,char *coinaddr,uint8_t CCflag)
+{
+    NSPV_mempooltxids(coinaddr,CCflag,NSPV_MEMPOOL_ADDRESS,zeroid,-1);
+    if ( NSPV_mempoolresult.txids != 0 && NSPV_mempoolresult.numtxids >= 1 && strcmp(NSPV_mempoolresult.coinaddr,coinaddr) == 0 && NSPV_mempoolresult.CCflag == CCflag )
+    {
+        LogPrint(logcategory,"found (%s) vout in mempool\n",coinaddr);
+        return(true);
+    } else return(false);
+}
+
+bool NSPV_spentinmempool(uint256 &spenttxid,int32_t &spentvini,uint256 txid,int32_t vout)
+{
+    NSPV_mempooltxids((char *)"",0,NSPV_MEMPOOL_ISSPENT,txid,vout);
+    if ( NSPV_mempoolresult.txids != 0 && NSPV_mempoolresult.numtxids == 1 && NSPV_mempoolresult.txid == txid )
+    {
+        spenttxid = NSPV_mempoolresult.txids[0];
+        spentvini = NSPV_mempoolresult.vindex;
+        return(true);
+    } else return(false);
+}
+
+bool NSPV_inmempool(uint256 txid)
+{
+    NSPV_mempooltxids((char *)"",0,NSPV_MEMPOOL_INMEMPOOL,txid,0);
+    if ( NSPV_mempoolresult.txids != 0 && NSPV_mempoolresult.numtxids == 1 && NSPV_mempoolresult.txids[0] == txid )
+        return(true);
+    else return(false);
+}
+
+bool NSPV_evalcode_inmempool(uint8_t evalcode,uint8_t funcid)
+{
+    int32_t vout;
+    vout = ((uint32_t)funcid << 8) | evalcode;
+    NSPV_mempooltxids((char *)"",1,NSPV_MEMPOOL_CCEVALCODE,zeroid,vout);
+    if ( NSPV_mempoolresult.txids != 0 && NSPV_mempoolresult.numtxids >= 1 && NSPV_mempoolresult.vout == vout )
+        return(true);
+    else return(false);
+}
+
+UniValue NSPV_notarizations(int32_t reqheight)
+{
+    uint8_t msg[512]; int32_t i,iter,len = 0; struct NSPV_ntzsresp N,*ptr;
+    if ( (ptr= NSPV_ntzsresp_find(reqheight)) != 0 )
+    {
+        LogPrintf("FROM CACHE NSPV_notarizations.%d\n",reqheight);
+        NSPV_ntzsresp_purge(&NSPV_ntzsresult);
+        NSPV_ntzsresp_copy(&NSPV_ntzsresult,ptr);
+        return(NSPV_ntzsresp_json(ptr));
+    }
+    msg[len++] = NSPV_NTZS;
+    len += iguana_rwnum(1,&msg[len],sizeof(reqheight),&reqheight);
+    for (iter=0; iter<3; iter++)
+    if ( NSPV_req(0,msg,len,NODE_NSPV,msg[0]>>1) != 0 )
+    {
+        for (i=0; i<NSPV_POLLITERS; i++)
+        {
+            usleep(NSPV_POLLMICROS);
+            if ( NSPV_ntzsresult.reqheight == reqheight )
+                return(NSPV_ntzsresp_json(&NSPV_ntzsresult));
+        }
+    } else sleep(1);
+    memset(&N,0,sizeof(N));
+    return(NSPV_ntzsresp_json(&N));
+}
+
+UniValue NSPV_txidhdrsproof(uint256 prevtxid,uint256 nexttxid)
+{
+    uint8_t msg[512]; int32_t i,iter,len = 0; struct NSPV_ntzsproofresp P,*ptr;
+    if ( (ptr= NSPV_ntzsproof_find(prevtxid,nexttxid)) != 0 )
+    {
+        LogPrintf("FROM CACHE NSPV_txidhdrsproof %s %s\n",ptr->prevtxid.GetHex().c_str(),ptr->nexttxid.GetHex().c_str());
+        NSPV_ntzsproofresp_purge(&NSPV_ntzsproofresult);
+        NSPV_ntzsproofresp_copy(&NSPV_ntzsproofresult,ptr);
+        return(NSPV_ntzsproof_json(ptr));
+    }
+    NSPV_ntzsproofresp_purge(&NSPV_ntzsproofresult);
+    msg[len++] = NSPV_NTZSPROOF;
+    len += iguana_rwbignum(1,&msg[len],sizeof(prevtxid),(uint8_t *)&prevtxid);
+    len += iguana_rwbignum(1,&msg[len],sizeof(nexttxid),(uint8_t *)&nexttxid);
+    for (iter=0; iter<3; iter++)
+    if ( NSPV_req(0,msg,len,NODE_NSPV,msg[0]>>1) != 0 )
+    {
+        for (i=0; i<NSPV_POLLITERS; i++)
+        {
+            usleep(NSPV_POLLMICROS);
+            if ( NSPV_ntzsproofresult.prevtxid == prevtxid && NSPV_ntzsproofresult.nexttxid == nexttxid )
+                return(NSPV_ntzsproof_json(&NSPV_ntzsproofresult));
+        }
+    } else sleep(1);
+    memset(&P,0,sizeof(P));
+    return(NSPV_ntzsproof_json(&P));
+}
+
+UniValue NSPV_hdrsproof(int32_t prevht,int32_t nextht)
+{
+    uint256 prevtxid,nexttxid;
+    NSPV_notarizations(prevht);
+    prevtxid = NSPV_ntzsresult.prevntz.txid;
+    NSPV_notarizations(nextht);
+    nexttxid = NSPV_ntzsresult.nextntz.txid;
+    return(NSPV_txidhdrsproof(prevtxid,nexttxid));
+}
+
+UniValue NSPV_txproof(int32_t vout,uint256 txid,int32_t height)
+{
+    uint8_t msg[512]; int32_t i,iter,len = 0; struct NSPV_txproof P,*ptr;
+    if ( (ptr= NSPV_txproof_find(txid)) != 0 )
+    {
+        LogPrintf("FROM CACHE NSPV_txproof %s\n",txid.GetHex().c_str());
+        NSPV_txproof_purge(&NSPV_txproofresult);
+        NSPV_txproof_copy(&NSPV_txproofresult,ptr);
+        return(NSPV_txproof_json(ptr));
+    }
+    NSPV_txproof_purge(&NSPV_txproofresult);
+    msg[len++] = NSPV_TXPROOF;
+    len += iguana_rwnum(1,&msg[len],sizeof(height),&height);
+    len += iguana_rwnum(1,&msg[len],sizeof(vout),&vout);
+    len += iguana_rwbignum(1,&msg[len],sizeof(txid),(uint8_t *)&txid);
+    LogPrintf("req txproof %s/v%d at height.%d\n",txid.GetHex().c_str(),vout,height);
+    for (iter=0; iter<3; iter++)
+    if ( NSPV_req(0,msg,len,NODE_NSPV,msg[0]>>1) != 0 )
+    {
+        for (i=0; i<NSPV_POLLITERS; i++)
+        {
+            usleep(NSPV_POLLMICROS);
+            if ( NSPV_txproofresult.txid == txid )
+                return(NSPV_txproof_json(&NSPV_txproofresult));
+        }
+    } else sleep(1);
+    LogPrintf("txproof timeout\n");
+    memset(&P,0,sizeof(P));
+    return(NSPV_txproof_json(&P));
+}
+
+UniValue NSPV_spentinfo(uint256 txid,int32_t vout)
+{
+    uint8_t msg[512]; int32_t i,iter,len = 0; struct NSPV_spentinfo I;
+    NSPV_spentinfo_purge(&NSPV_spentresult);
+    msg[len++] = NSPV_SPENTINFO;
+    len += iguana_rwnum(1,&msg[len],sizeof(vout),&vout);
+    len += iguana_rwbignum(1,&msg[len],sizeof(txid),(uint8_t *)&txid);
+    for (iter=0; iter<3; iter++)
+    if ( NSPV_req(0,msg,len,NODE_SPENTINDEX,msg[0]>>1) != 0 )
+    {
+        for (i=0; i<NSPV_POLLITERS; i++)
+        {
+            usleep(NSPV_POLLMICROS);
+            if ( NSPV_spentresult.txid == txid && NSPV_spentresult.vout == vout )
+                return(NSPV_spentinfo_json(&NSPV_spentresult));
+        }
+    } else sleep(1);
+    memset(&I,0,sizeof(I));
+    return(NSPV_spentinfo_json(&I));
+}
+
+UniValue NSPV_broadcast(char *hex)
+{
+    uint8_t *msg,*data; uint256 txid; int32_t i,n,iter,len = 0; struct NSPV_broadcastresp B;
+    NSPV_broadcast_purge(&NSPV_broadcastresult);
+    n = (int32_t)strlen(hex) >> 1;
+    data = (uint8_t *)malloc(n);
+    decode_hex(data,n,hex);
+    txid = NSPV_doublesha256(data,n);
+    msg = (uint8_t *)malloc(1 + sizeof(txid) + sizeof(n) + n);
+    msg[len++] = NSPV_BROADCAST;
+    len += iguana_rwbignum(1,&msg[len],sizeof(txid),(uint8_t *)&txid);
+    len += iguana_rwnum(1,&msg[len],sizeof(n),&n);
+    memcpy(&msg[len],data,n), len += n;
+    free(data);
+    //LogPrintf("send txid.%s\n",txid.GetHex().c_str());
+    for (iter=0; iter<3; iter++)
+    if ( NSPV_req(0,msg,len,NODE_NSPV,msg[0]>>1) != 0 )
+    {
+        for (i=0; i<NSPV_POLLITERS; i++)
+        {
+            usleep(NSPV_POLLMICROS);
+            if ( NSPV_broadcastresult.txid == txid )
+            {
+                free(msg);
+                return(NSPV_broadcast_json(&NSPV_broadcastresult,txid));
+            }
+        }
+    } else sleep(1);
+    free(msg);
+    memset(&B,0,sizeof(B));
+    B.retcode = -2;
+    return(NSPV_broadcast_json(&B,txid));
+}
+
+// gets cc utxos filtered by evalcode, funcid and txid in opret, for the specified amount
+// if amount == 0 returns total and no utxos
+// funcids is string of funcid symbols like "ct". The first symbol is considered as creation tx funcid and filtertxid will be compared to the creation tx id itself. 
+// For second+ funcids the filtertxid will be compared to txid in opret
+UniValue NSPV_ccmoduleutxos(char *coinaddr, int64_t amount, uint8_t evalcode, std::string funcids, uint256 filtertxid)
+{
+    UniValue result(UniValue::VOBJ); uint8_t msg[512]; int32_t i, iter, slen, len = 0;
+    uint8_t CCflag = 1;
+
+    NSPV_utxosresp_purge(&NSPV_utxosresult);
+    if (bitcoin_base58decode(msg, coinaddr) != 25)
+    {
+        result.push_back(Pair("result", "error"));
+        result.push_back(Pair("error", "invalid address"));
+        return(result);
+    }
+    msg[len++] = NSPV_CCMODULEUTXOS;
+
+    slen = (int32_t)strlen(coinaddr);
+    msg[len++] = slen;
+    memcpy(&msg[len], coinaddr, slen), len += slen;
+
+    len += iguana_rwnum(1, &msg[len], sizeof(amount), &amount);
+    len += iguana_rwnum(1, &msg[len], sizeof(evalcode), &evalcode);
+
+    slen = (int32_t)(funcids.size());
+    msg[len++] = slen;
+    memcpy(&msg[len], funcids.data(), slen), len += slen;
+
+    len += iguana_rwbignum(1, &msg[len], sizeof(filtertxid), (uint8_t *)&filtertxid);
+    for (iter = 0; iter<3; iter++)
+        if (NSPV_req(0, msg, len, NODE_ADDRINDEX, msg[0] >> 1) != 0)
+        {
+            for (i = 0; i<NSPV_POLLITERS; i++)
+            {
+                usleep(NSPV_POLLMICROS);
+                if ((NSPV_inforesult.height == 0 || NSPV_utxosresult.nodeheight >= NSPV_inforesult.height) && strcmp(coinaddr, NSPV_utxosresult.coinaddr) == 0 && CCflag == NSPV_utxosresult.CCflag)
+                    return(NSPV_utxosresp_json(&NSPV_utxosresult));
+            }
+        }
+        else sleep(1);
+        result.push_back(Pair("result", "error"));
+        result.push_back(Pair("error", "no utxos result"));
+        result.push_back(Pair("lastpeer", NSPV_lastpeer));
+        return(result);
+}
+
+#endif // KOMODO_NSPVSUPERLITE_H
diff --git a/src/komodo_nSPV_wallet.h b/src/komodo_nSPV_wallet.h
new file mode 100644
index 00000000..c91963e6
--- /dev/null
+++ b/src/komodo_nSPV_wallet.h
@@ -0,0 +1,540 @@
+
+/******************************************************************************
+ * Copyright © 2014-2019 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+
+#ifndef KOMODO_NSPVWALLET_H
+#define KOMODO_NSPVWALLET_H
+
+// nSPV wallet uses superlite functions (and some komodod built in functions) to implement nSPV_spend
+extern void TxToJSON(const CTransaction& tx, const uint256 hashBlock, UniValue& entry);
+
+int32_t NSPV_validatehdrs(struct NSPV_ntzsproofresp *ptr)
+{
+    int32_t i,height,txidht; CTransaction tx; uint256 blockhash,txid,desttxid;
+    if ( (ptr->common.nextht-ptr->common.prevht+1) != ptr->common.numhdrs )
+    {
+        LogPrintf("next.%d prev.%d -> %d vs %d\n",ptr->common.nextht,ptr->common.prevht,ptr->common.nextht-ptr->common.prevht+1,ptr->common.numhdrs);
+        return(-2);
+    }
+    else if ( NSPV_txextract(tx,ptr->nextntz,ptr->nexttxlen) < 0 )
+        return(-3);
+    else if ( tx.GetHash() != ptr->nexttxid )
+        return(-4);
+    else if ( NSPV_notarizationextract(1,&height,&blockhash,&desttxid,tx) < 0 )
+        return(-5);
+    else if ( height != ptr->common.nextht )
+        return(-6);
+    else if ( NSPV_hdrhash(&ptr->common.hdrs[ptr->common.numhdrs-1]) != blockhash )
+        return(-7);
+    for (i=ptr->common.numhdrs-1; i>0; i--)
+    {
+        blockhash = NSPV_hdrhash(&ptr->common.hdrs[i-1]);
+        if ( blockhash != ptr->common.hdrs[i].hashPrevBlock )
+            return(-i-13);
+    }
+    sleep(1); // need this to get past the once per second rate limiter per message
+    if ( NSPV_txextract(tx,ptr->prevntz,ptr->prevtxlen) < 0 )
+        return(-8);
+    else if ( tx.GetHash() != ptr->prevtxid )
+        return(-9);
+    else if ( NSPV_notarizationextract(1,&height,&blockhash,&desttxid,tx) < 0 )
+        return(-10);
+    else if ( height != ptr->common.prevht )
+        return(-11);
+    else if ( NSPV_hdrhash(&ptr->common.hdrs[0]) != blockhash )
+        return(-12);
+    return(0);
+}
+
+int32_t NSPV_gettransaction(int32_t skipvalidation,int32_t vout,uint256 txid,int32_t height,CTransaction &tx,uint256 &hashblock,int32_t &txheight,int32_t &currentheight,int64_t extradata,uint32_t tiptime,int64_t &rewardsum)
+{
+    struct NSPV_txproof *ptr; int32_t i,offset,retval; int64_t rewards = 0; uint32_t nLockTime; std::vector<uint8_t> proof;
+    retval = skipvalidation != 0 ? 0 : -1;
+
+    //LogPrintf("NSPV_gettx %s/v%d ht.%d\n",txid.GetHex().c_str(),vout,height);
+    if ( (ptr= NSPV_txproof_find(txid)) == 0 )
+    {
+        NSPV_txproof(vout,txid,height);
+        ptr = &NSPV_txproofresult;
+    }
+    hashblock=ptr->hashblock;
+    txheight=ptr->height;
+    currentheight=NSPV_inforesult.height;
+    if ( ptr->txid != txid )
+    {
+        LogPrintf("txproof error %s != %s\n",ptr->txid.GetHex().c_str(),txid.GetHex().c_str());
+        return(-1);
+    }
+    else if ( NSPV_txextract(tx,ptr->tx,ptr->txlen) < 0 || ptr->txlen <= 0 )
+        retval = -2000;
+    else if ( tx.GetHash() != txid )
+        retval = -2001;
+    else if ( skipvalidation == 0 && ptr->unspentvalue <= 0 )
+        retval = -2002;
+    else if ( ASSETCHAINS_SYMBOL[0] == 0 && tiptime != 0 )
+    {
+        rewards = komodo_interestnew(height,tx.vout[vout].nValue,tx.nLockTime,tiptime);
+        if ( rewards != extradata )
+            LogPrintf("extradata %.8f vs rewards %.8f\n",dstr(extradata),dstr(rewards));
+        rewardsum += rewards;
+    }
+    //char coinaddr[64];
+    //Getscriptaddress(coinaddr,tx.vout[0].scriptPubKey);  causes crash??
+    //LogPrintf("%s txid.%s vs hash.%s\n",coinaddr,txid.GetHex().c_str(),tx.GetHash().GetHex().c_str());
+    
+    if ( skipvalidation == 0 )
+    {
+        if ( ptr->txprooflen > 0 )
+        {
+            proof.resize(ptr->txprooflen);
+            memcpy(&proof[0],ptr->txproof,ptr->txprooflen);
+        }
+        NSPV_notarizations(height); // gets the prev and next notarizations
+        if ( NSPV_inforesult.notarization.height >= height && (NSPV_ntzsresult.prevntz.height == 0 || NSPV_ntzsresult.prevntz.height >= NSPV_ntzsresult.nextntz.height) )
+        {
+            LogPrintf("issue manual bracket\n");
+            NSPV_notarizations(height-1);
+            NSPV_notarizations(height+1);
+            NSPV_notarizations(height); // gets the prev and next notarizations
+        }
+        if ( NSPV_ntzsresult.prevntz.height != 0 && NSPV_ntzsresult.prevntz.height <= NSPV_ntzsresult.nextntz.height )
+        {
+            LogPrintf(">>>>> gettx ht.%d prev.%d next.%d\n",height,NSPV_ntzsresult.prevntz.height, NSPV_ntzsresult.nextntz.height);
+            offset = (height - NSPV_ntzsresult.prevntz.height);
+            if ( offset >= 0 && height <= NSPV_ntzsresult.nextntz.height )
+            {
+                //LogPrintf("call NSPV_txidhdrsproof %s %s\n",NSPV_ntzsresult.prevntz.txid.GetHex().c_str(),NSPV_ntzsresult.nextntz.txid.GetHex().c_str());
+                NSPV_txidhdrsproof(NSPV_ntzsresult.prevntz.txid,NSPV_ntzsresult.nextntz.txid);
+                usleep(10000);
+                if ( (retval= NSPV_validatehdrs(&NSPV_ntzsproofresult)) == 0 )
+                {
+                    std::vector<uint256> txids; uint256 proofroot;
+                    proofroot = BitcoinGetProofMerkleRoot(proof,txids);
+                    if ( proofroot != NSPV_ntzsproofresult.common.hdrs[offset].hashMerkleRoot || txids[0] != txid )
+                    {
+                        LogPrintf("txid.%s vs txids[0] %s\n",txid.GetHex().c_str(),txids[0].GetHex().c_str());
+                        LogPrintf("prooflen.%d proofroot.%s vs %s\n",(int32_t)proof.size(),proofroot.GetHex().c_str(),NSPV_ntzsproofresult.common.hdrs[offset].hashMerkleRoot.GetHex().c_str());
+                        retval = -2003;
+                    } else retval = 0;
+                }
+            } else retval = -2005;
+        } else retval = -2004;
+    }
+    return(retval);
+}
+
+int32_t NSPV_vinselect(int32_t *aboveip,int64_t *abovep,int32_t *belowip,int64_t *belowp,struct NSPV_utxoresp utxos[],int32_t numunspents,int64_t value)
+{
+    int32_t i,abovei,belowi; int64_t above,below,gap,atx_value;
+    abovei = belowi = -1;
+    for (above=below=i=0; i<numunspents; i++)
+    {
+        if ( (atx_value= utxos[i].satoshis) <= 0 )
+            continue;
+        if ( atx_value == value )
+        {
+            *aboveip = *belowip = i;
+            *abovep = *belowp = 0;
+            return(i);
+        }
+        else if ( atx_value > value )
+        {
+            gap = (atx_value - value);
+            if ( above == 0 || gap < above )
+            {
+                above = gap;
+                abovei = i;
+            }
+        }
+        else
+        {
+            gap = (value - atx_value);
+            if ( below == 0 || gap < below )
+            {
+                below = gap;
+                belowi = i;
+            }
+        }
+        //printf("value %.8f gap %.8f abovei.%d %.8f belowi.%d %.8f\n",dstr(value),dstr(gap),abovei,dstr(above),belowi,dstr(below));
+    }
+    *aboveip = abovei;
+    *abovep = above;
+    *belowip = belowi;
+    *belowp = below;
+    //printf("above.%d below.%d\n",abovei,belowi);
+    if ( abovei >= 0 && belowi >= 0 )
+    {
+        if ( above < (below >> 1) )
+            return(abovei);
+        else return(belowi);
+    }
+    else if ( abovei >= 0 )
+        return(abovei);
+    else return(belowi);
+}
+
+int64_t NSPV_addinputs(struct NSPV_utxoresp *used,CMutableTransaction &mtx,int64_t total,int32_t maxinputs,struct NSPV_utxoresp *ptr,int32_t num)
+{
+    int32_t abovei,belowi,ind,vout,i,n = 0; int64_t threshold,above,below; int64_t remains,totalinputs = 0; CTransaction tx; struct NSPV_utxoresp utxos[NSPV_MAXVINS],*up;
+    memset(utxos,0,sizeof(utxos));
+    if ( maxinputs > NSPV_MAXVINS )
+        maxinputs = NSPV_MAXVINS;
+    if ( maxinputs > 0 )
+        threshold = total/maxinputs;
+    else threshold = total;
+    for (i=0; i<num; i++)
+    {
+        if ( num < NSPV_MAXVINS || ptr[i].satoshis > threshold )
+            utxos[n++] = ptr[i];
+    }
+    remains = total;
+    //LogPrintf("threshold %.8f n.%d for total %.8f\n",(double)threshold/COIN,n,(double)total/COIN);
+    for (i=0; i<maxinputs && n>0; i++)
+    {
+        below = above = 0;
+        abovei = belowi = -1;
+        if ( NSPV_vinselect(&abovei,&above,&belowi,&below,utxos,n,remains) < 0 )
+        {
+            LogPrintf("error finding unspent i.%d of %d, %.8f vs %.8f\n",i,n,(double)remains/COIN,(double)total/COIN);
+            return(0);
+        }
+        if ( belowi < 0 || abovei >= 0 )
+            ind = abovei;
+        else ind = belowi;
+        if ( ind < 0 )
+        {
+            LogPrintf("error finding unspent i.%d of %d, %.8f vs %.8f, abovei.%d belowi.%d ind.%d\n",i,n,(double)remains/COIN,(double)total/COIN,abovei,belowi,ind);
+            return(0);
+        }
+        //LogPrintf("i.%d ind.%d abovei.%d belowi.%d n.%d\n",i,ind,abovei,belowi,n);
+        up = &utxos[ind];
+        mtx.vin.push_back(CTxIn(up->txid,up->vout,CScript()));
+        used[i] = *up;
+        totalinputs += up->satoshis;
+        remains -= up->satoshis;
+        utxos[ind] = utxos[--n];
+        memset(&utxos[n],0,sizeof(utxos[n]));
+        //LogPrintf("totalinputs %.8f vs total %.8f i.%d vs max.%d\n",(double)totalinputs/COIN,(double)total/COIN,i,maxinputs);
+        if ( totalinputs >= total || (i+1) >= maxinputs )
+            break;
+    }
+    //LogPrintf("totalinputs %.8f vs total %.8f\n",(double)totalinputs/COIN,(double)total/COIN);
+    if ( totalinputs >= total )
+        return(totalinputs);
+    return(0);
+}
+
+bool NSPV_SignTx(CMutableTransaction &mtx,int32_t vini,int64_t utxovalue,const CScript scriptPubKey,uint32_t nTime)
+{
+    CTransaction txNewConst(mtx); SignatureData sigdata; CBasicKeyStore keystore; int64_t branchid = NSPV_BRANCHID;
+    if ( NSPV_logintime == 0 || time(NULL) > NSPV_logintime+NSPV_AUTOLOGOUT )
+    {
+        LogPrintf("need to be logged in to get myprivkey\n");
+        return false;
+    }
+    keystore.AddKey(NSPV_key);
+    if ( nTime != 0 && nTime < KOMODO_SAPLING_ACTIVATION )
+    {
+        LogPrintf("use legacy sig validation\n");
+        branchid = 0;
+    }
+    if ( ProduceSignature(TransactionSignatureCreator(&keystore,&txNewConst,vini,utxovalue,SIGHASH_ALL),scriptPubKey,sigdata,branchid) != 0 )
+    {
+        UpdateTransaction(mtx,vini,sigdata);
+        LogPrintf("SIG_TXHASH %s vini.%d %.8f\n",SIG_TXHASH.GetHex().c_str(),vini,(double)utxovalue/COIN);
+        return(true);
+    }  //else LogPrintf("sigerr SIG_TXHASH %s vini.%d %.8f\n",SIG_TXHASH.GetHex().c_str(),vini,(double)utxovalue/COIN);
+    return(false);
+}
+
+std::string NSPV_signtx(int64_t &rewardsum,int64_t &interestsum,UniValue &retcodes,CMutableTransaction &mtx,uint64_t txfee,CScript opret,struct NSPV_utxoresp used[])
+{
+    CTransaction vintx; std::string hex; uint256 hashBlock; int64_t interest=0,change,totaloutputs=0,totalinputs=0; int32_t i,utxovout,n,validation,txheight,currentheight;
+    n = mtx.vout.size();
+    for (i=0; i<n; i++)
+        totaloutputs += mtx.vout[i].nValue;
+    n = mtx.vin.size();
+    for (i=0; i<n; i++)
+    {
+        totalinputs += used[i].satoshis;
+        interest += used[i].extradata;
+    }
+    interestsum = interest;
+    if ( (totalinputs+interest) >= totaloutputs+2*txfee )
+    {
+        change = (totalinputs+interest) - (totaloutputs+txfee);
+        mtx.vout.push_back(CTxOut(change,CScript() << ParseHex(NSPV_pubkeystr) << OP_CHECKSIG));
+    }
+    if ( opret.size() > 0 )
+        mtx.vout.push_back(CTxOut(0,opret));
+    for (i=0; i<n; i++)
+    {
+        utxovout = mtx.vin[i].prevout.n;
+        if ( i > 0 )
+            sleep(1);
+        validation = NSPV_gettransaction(0,utxovout,mtx.vin[i].prevout.hash,used[i].height,vintx,hashBlock,txheight,currentheight,used[i].extradata,NSPV_tiptime,rewardsum);
+        retcodes.push_back(validation);
+        if ( validation != -1 ) // most others are degraded security
+        {
+            if ( vintx.vout[utxovout].nValue != used[i].satoshis )
+            {
+                LogPrintf("vintx mismatch %.8f != %.8f\n",(double)vintx.vout[utxovout].nValue/COIN,(double)used[i].satoshis/COIN);
+                return("");
+            }
+            else if ( utxovout != used[i].vout )
+            {
+                LogPrintf("vintx vout mismatch %d != %d\n",utxovout,used[i].vout);
+                return("");
+            }
+            else if ( NSPV_SignTx(mtx,i,vintx.vout[utxovout].nValue,vintx.vout[utxovout].scriptPubKey,0) == 0 )
+            {
+                LogPrintf("signing error for vini.%d\n",i);
+                return("");
+            }
+        } else LogPrintf("couldnt find txid.%s/v%d or it was spent\n",mtx.vin[i].prevout.hash.GetHex().c_str(),utxovout); // of course much better handling is needed
+    }
+    LogPrintf("sign %d inputs %.8f + interest %.8f -> %d outputs %.8f change %.8f\n",(int32_t)mtx.vin.size(),(double)totalinputs/COIN,(double)interest/COIN,(int32_t)mtx.vout.size(),(double)totaloutputs/COIN,(double)change/COIN);
+    return(EncodeHexTx(mtx));
+}
+
+UniValue NSPV_spend(char *srcaddr,char *destaddr,int64_t satoshis) // what its all about!
+{
+    UniValue result(UniValue::VOBJ),retcodes(UniValue::VARR); std::vector<uint8_t> data; CScript scriptPubKey; uint8_t *ptr,rmd160[128]; int32_t len; int64_t txfee = 10000;
+    if ( NSPV_logintime == 0 || time(NULL) > NSPV_logintime+NSPV_AUTOLOGOUT )
+    {
+        result.push_back(Pair("result","error"));
+        result.push_back(Pair("error","wif expired"));
+        return(result);
+    }
+    if ( strcmp(srcaddr,NSPV_address.c_str()) != 0 )
+    {
+        result.push_back(Pair("result","error"));
+        result.push_back(Pair("error","invalid address"));
+        result.push_back(Pair("mismatched",srcaddr));
+        return(result);
+    }
+    else if ( bitcoin_base58decode(rmd160,destaddr) != 25 )
+    {
+        if ( (len= is_hexstr(destaddr,0)) > 0 )
+        {
+            len >>= 1;
+            data.resize(len);
+            decode_hex(&data[0],len,destaddr);
+            if ( data[len-1] == OP_CHECKCRYPTOCONDITION )
+            {
+                data.resize(--len);
+                scriptPubKey = CScript() << data << OP_CHECKCRYPTOCONDITION;
+            }
+            else
+            {
+                result.push_back(Pair("result","error"));
+                result.push_back(Pair("error","only CC hex allowed for now"));
+                return(result);            }
+        }
+        else
+        {
+            result.push_back(Pair("result","error"));
+            result.push_back(Pair("error","invalid destaddr/CCvout hex"));
+            return(result);
+        }
+    }
+    else
+    {
+        data.resize(20);
+        memcpy(&data[0],&rmd160[1],20);
+        scriptPubKey = (CScript() << OP_DUP << OP_HASH160 << ParseHex(HexStr(data)) << OP_EQUALVERIFY << OP_CHECKSIG);
+    }
+    if ( NSPV_inforesult.height == 0 )
+    {
+        result.push_back(Pair("result","error"));
+        result.push_back(Pair("error","couldnt getinfo"));
+        return(result);
+    }
+    if ( NSPV_utxosresult.CCflag != 0 || strcmp(NSPV_utxosresult.coinaddr,srcaddr) != 0 || NSPV_utxosresult.nodeheight < NSPV_inforesult.height )
+        NSPV_addressutxos(srcaddr,0,0,0);
+    if ( NSPV_utxosresult.CCflag != 0 || strcmp(NSPV_utxosresult.coinaddr,srcaddr) != 0 || NSPV_utxosresult.nodeheight < NSPV_inforesult.height )
+    {
+        result.push_back(Pair("result","error"));
+        result.push_back(Pair("address",NSPV_utxosresult.coinaddr));
+        result.push_back(Pair("srcaddr",srcaddr));
+        result.push_back(Pair("nodeheight",(int64_t)NSPV_utxosresult.nodeheight));
+        result.push_back(Pair("infoheight",(int64_t)NSPV_inforesult.height));
+        result.push_back(Pair("error","couldnt get addressutxos"));
+        return(result);
+    }
+    if ( NSPV_utxosresult.total < satoshis+txfee )
+    {
+        result.push_back(Pair("result","error"));
+        result.push_back(Pair("error","not enough funds"));
+        result.push_back(Pair("balance",(double)NSPV_utxosresult.total/COIN));
+        result.push_back(Pair("amount",(double)satoshis/COIN));
+        return(result);
+    }
+    printf("%s numutxos.%d balance %.8f\n",NSPV_utxosresult.coinaddr,NSPV_utxosresult.numutxos,(double)NSPV_utxosresult.total/COIN);
+    CScript opret; std::string hex; struct NSPV_utxoresp used[NSPV_MAXVINS]; CMutableTransaction mtx; CTransaction tx; int64_t rewardsum=0,interestsum=0;
+    mtx.fOverwintered = true;
+    mtx.nExpiryHeight = 0;
+    mtx.nVersionGroupId = SAPLING_VERSION_GROUP_ID;
+    mtx.nVersion = SAPLING_TX_VERSION;
+    if ( ASSETCHAINS_SYMBOL[0] == 0 ) {
+        if ( !komodo_hardfork_active((uint32_t)chainActive.LastTip()->nTime) )
+            mtx.nLockTime = (uint32_t)time(NULL) - 777;
+        else
+            mtx.nLockTime = (uint32_t)chainActive.Tip()->GetMedianTimePast();
+    }
+        
+    memset(used,0,sizeof(used));
+
+    if ( NSPV_addinputs(used,mtx,satoshis+txfee,64,NSPV_utxosresult.utxos,NSPV_utxosresult.numutxos) > 0 )
+    {
+        mtx.vout.push_back(CTxOut(satoshis,scriptPubKey));
+        if ( NSPV_logintime == 0 || time(NULL) > NSPV_logintime+NSPV_AUTOLOGOUT )
+        {
+            result.push_back(Pair("result","error"));
+            result.push_back(Pair("error","wif expired"));
+            return(result);
+        }
+        hex = NSPV_signtx(rewardsum,interestsum,retcodes,mtx,txfee,opret,used);
+        if ( ASSETCHAINS_SYMBOL[0] == 0 )
+        {
+            char numstr[64];
+            sprintf(numstr,"%.8f",(double)interestsum/COIN);
+            result.push_back(Pair("rewards",numstr));
+            sprintf(numstr,"%.8f",(double)rewardsum/COIN);
+            result.push_back(Pair("validated",numstr));
+        }
+        if ( hex.size() > 0 )
+        {
+            if ( DecodeHexTx(tx,hex) != 0 )
+            {
+                TxToJSON(tx,uint256(),result);
+                result.push_back(Pair("result","success"));
+                result.push_back(Pair("hex",hex));
+                result.push_back(Pair("retcodes",retcodes));
+            }
+            else
+            {
+                result.push_back(Pair("result","error"));
+                result.push_back(Pair("error","couldnt decode"));
+                result.push_back(Pair("hex",hex));
+            }
+        }
+        else
+        {
+            result.push_back(Pair("result","error"));
+            result.push_back(Pair("retcodes",retcodes));
+            result.push_back(Pair("error","signing error"));
+        }
+        return(result);
+    }
+    else
+    {
+        result.push_back(Pair("result","error"));
+        result.push_back(Pair("error","couldnt create tx"));
+        return(result);
+    }
+}
+
+int64_t NSPV_AddNormalinputs(CMutableTransaction &mtx,CPubKey mypk,int64_t total,int32_t maxinputs,struct NSPV_CCmtxinfo *ptr)
+{
+    char coinaddr[64]; int32_t CCflag = 0;
+    if ( ptr != 0 )
+    {
+        mtx.fOverwintered = true;
+        mtx.nExpiryHeight = 0;
+        mtx.nVersionGroupId = SAPLING_VERSION_GROUP_ID;
+        mtx.nVersion = SAPLING_TX_VERSION;
+        Getscriptaddress(coinaddr,CScript() << ParseHex(HexStr(mypk)) << OP_CHECKSIG);
+        // if ( strcmp(ptr->U.coinaddr,coinaddr) != 0 )
+        // {
+            NSPV_addressutxos(coinaddr,CCflag,0,0);
+            NSPV_utxosresp_purge(&ptr->U);
+            NSPV_utxosresp_copy(&ptr->U,&NSPV_utxosresult);
+        // }
+        LogPrintf("%s numutxos.%d\n",ptr->U.coinaddr,ptr->U.numutxos);
+        memset(ptr->used,0,sizeof(ptr->used));
+        return(NSPV_addinputs(ptr->used,mtx,total,maxinputs,ptr->U.utxos,ptr->U.numutxos));
+    } else return(0);
+}
+
+void NSPV_utxos2CCunspents(struct NSPV_utxosresp *ptr,std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > &outputs)
+{
+    CAddressUnspentKey key; CAddressUnspentValue value; int32_t i,type; uint160 hashBytes; std::string addrstr(ptr->coinaddr);
+    if ( ptr->utxos != NULL && ptr->numutxos > 0 )
+    {
+        CBitcoinAddress address(addrstr);
+        if ( address.GetIndexKey(hashBytes, type, ptr->CCflag) == 0 )
+        {
+            LogPrintf("couldnt get indexkey\n");
+            return;
+        }
+        for (i = 0; i < ptr->numutxos; i ++)
+        {
+            key.type = type;
+            key.hashBytes = hashBytes;
+            key.txhash = ptr->utxos[i].txid;
+            key.index = ptr->utxos[i].vout;
+            value.satoshis = ptr->utxos[i].satoshis;
+            value.blockHeight = ptr->utxos[i].height;
+            outputs.push_back(std::make_pair(key, value));
+        }
+    }
+}
+
+void NSPV_txids2CCtxids(struct NSPV_txidsresp *ptr,std::vector<std::pair<CAddressIndexKey, CAmount> > &txids)
+{
+    CAddressIndexKey key; int64_t value; int32_t i,type; uint160 hashBytes; std::string addrstr(ptr->coinaddr);
+    if ( ptr->txids != NULL && ptr->numtxids > 0 )
+    {
+        CBitcoinAddress address(addrstr);
+        if ( address.GetIndexKey(hashBytes, type, ptr->CCflag) == 0 )
+        {
+            LogPrintf("couldnt get indexkey\n");
+            return;
+        }
+        for (i = 0; i < ptr->numtxids; i ++)
+        {
+            key.type = type;
+            key.hashBytes = hashBytes;
+            key.txhash = ptr->txids[i].txid;
+            key.index = ptr->txids[i].vout;
+            key.blockHeight = ptr->txids[i].height;
+            value = ptr->txids[i].satoshis;
+            txids.push_back(std::make_pair(key, value));
+        }
+    }
+}
+
+void NSPV_CCunspents(std::vector<std::pair<CAddressUnspentKey, CAddressUnspentValue> > &outputs,char *coinaddr,bool ccflag)
+{
+    int32_t filter = 0;
+    NSPV_addressutxos(coinaddr,ccflag,0,filter);
+    NSPV_utxos2CCunspents(&NSPV_utxosresult,outputs);
+}
+
+void NSPV_CCtxids(std::vector<std::pair<CAddressIndexKey, CAmount> > &txids,char *coinaddr,bool ccflag)
+{
+    int32_t filter = 0;
+    NSPV_addresstxids(coinaddr,ccflag,0,filter);
+    NSPV_txids2CCtxids(&NSPV_txidsresult,txids);
+}
+
+void NSPV_CCtxids(std::vector<uint256> &txids,char *coinaddr,bool ccflag, uint8_t evalcode,uint256 filtertxid, uint8_t func)
+{
+    NSPV_ccaddresstxids(coinaddr,ccflag,0,filtertxid,evalcode,func);
+    for(int i=0;i<NSPV_mempoolresult.numtxids;i++) txids.push_back(NSPV_mempoolresult.txids[i]);
+}
+
+#endif // KOMODO_NSPVWALLET_H
diff --git a/src/komodo_notary.h b/src/komodo_notary.h
index 235b6150..123dca23 100644
--- a/src/komodo_notary.h
+++ b/src/komodo_notary.h
@@ -74,7 +74,7 @@ int32_t getkmdseason(int32_t height)
             return(i+1);
     }
     return(0);
-};
+}
 
 int32_t getacseason(uint32_t timestamp)
 {
@@ -86,7 +86,7 @@ int32_t getacseason(uint32_t timestamp)
             return(i+1);
     }
     return(0);
-};
+}
 
 int32_t komodo_notaries(uint8_t pubkeys[64][33],int32_t height,uint32_t timestamp)
 {
diff --git a/src/komodo_utils.h b/src/komodo_utils.h
index 65f41f84..7417a996 100644
--- a/src/komodo_utils.h
+++ b/src/komodo_utils.h
@@ -1365,8 +1365,9 @@ void komodo_statefname(char *fname,char *symbol,char *str)
     if ( (n= (int32_t)strlen(ASSETCHAINS_SYMBOL)) != 0 )
     {
         len = (int32_t)strlen(fname);
-        if ( strcmp(ASSETCHAINS_SYMBOL,&fname[len - n]) == 0 )
+        if ( !mapArgs.count("-datadir") && strcmp(ASSETCHAINS_SYMBOL,&fname[len - n]) == 0 )
             fname[len - n] = 0;
+        else if(mapArgs.count("-datadir")) printf("DEBUG - komodo_utils:1363: custom datadir\n");
         else
         {
             if ( strcmp(symbol,"REGTEST") != 0 )
@@ -1384,8 +1385,8 @@ void komodo_statefname(char *fname,char *symbol,char *str)
     }
     if ( symbol != 0 && symbol[0] != 0 && strcmp("KMD",symbol) != 0 )
     {
-        strcat(fname,symbol);
-        //LogPrintf("statefname.(%s) -> (%s)\n",symbol,fname);
+        if(!mapArgs.count("-datadir")) strcat(fname,symbol);
+        //printf("statefname.(%s) -> (%s)\n",symbol,fname);
 #ifdef _WIN32
         strcat(fname,"\\");
 #else
@@ -1423,6 +1424,7 @@ void komodo_configfile(char *symbol,uint16_t rpcport)
 #else
         sprintf(fname,"%s/%s",GetDataDir(false).string().c_str(),buf);
 #endif
+        if(mapArgs.count("-conf")) sprintf(fname, "%s", GetConfigFile().string().c_str());
         if ( (fp= fopen(fname,"rb")) == 0 )
         {
 #ifndef FROM_CLI
@@ -1479,8 +1481,11 @@ uint16_t komodo_userpass(char *userpass,char *symbol)
         sprintf(confname,"komodo.conf");
 #endif
     }
-    else sprintf(confname,"%s.conf",symbol);
-    komodo_statefname(fname,symbol,confname);
+    else if(!mapArgs.count("-conf")) {
+        sprintf(confname,"%s.conf",symbol);
+        komodo_statefname(fname,symbol,confname);
+    } else sprintf(fname,"%s",GetDataDir().string().c_str());
+    
     if ( (fp= fopen(fname,"rb")) != 0 )
     {
         port = _komodo_userpass(username,password,fp);
@@ -1694,11 +1699,15 @@ int8_t equihash_params_possible(uint64_t n, uint64_t k)
 
 void komodo_args(char *argv0)
 {
-    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], ccEnablesHeight[512] = {0};
+    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], ccEnablesHeight[512] = {0}; CTransaction earlytx; uint256 hashBlock;
+
     IS_KOMODO_NOTARY = GetBoolArg("-notary", false);
     IS_STAKED_NOTARY = GetArg("-stakednotary", -1);
+    KOMODO_NSPV = GetArg("-nSPV",0);
     memset(ccenables,0,sizeof(ccenables));
     memset(disablebits,0,sizeof(disablebits));
+    memset(ccEnablesHeight,0,sizeof(ccEnablesHeight));
     if ( GetBoolArg("-gen", false) != 0 )
     {
         KOMODO_MININGTHREADS = GetArg("-genproclimit",-1);
@@ -1789,7 +1798,7 @@ void komodo_args(char *argv0)
     {
         LogPrintf("KOMODO_REWIND %d\n",KOMODO_REWIND);
     }
-    KOMODO_EARLYTXID = Parseuint256(GetArg("-earlytxid","0").c_str());
+    KOMODO_EARLYTXID = Parseuint256(GetArg("-earlytxid","0").c_str());    
     ASSETCHAINS_EARLYTXIDCONTRACT = GetArg("-ac_earlytxidcontract",0);
     if ( name.c_str()[0] != 0 )
     {
@@ -1877,7 +1886,9 @@ void komodo_args(char *argv0)
         ASSETCHAINS_CODAPORT = GetArg("-ac_coda",0);
         ASSETCHAINS_MARMARA = GetArg("-ac_marmara",0);
         ASSETCHAINS_CBOPRET = GetArg("-ac_cbopret",0);
-        //LogPrintf("ASSETCHAINS_CBOPRET.%llx\n",(long long)ASSETCHAINS_CBOPRET);
+        ASSETCHAINS_CBMATURITY = GetArg("-ac_cbmaturity",0);
+        ASSETCHAINS_ADAPTIVEPOW = GetArg("-ac_adaptivepow",0);
+        //fprintf(stderr,"ASSETCHAINS_CBOPRET.%llx\n",(long long)ASSETCHAINS_CBOPRET);
         if ( ASSETCHAINS_CBOPRET != 0 )
         {
             SplitStr(GetArg("-ac_prices",""),  ASSETCHAINS_PRICES);
@@ -1945,7 +1956,7 @@ void komodo_args(char *argv0)
                 }
             }*/
         }
-        if ( ASSETCHAINS_BEAMPORT != 0 && ASSETCHAINS_CODAPORT != 0 )
+        if ( ASSETCHAINS_BEAMPORT != 0 )
         {
             LogPrintf("can only have one of -ac_beam or -ac_coda\n");
             StartShutdown();
@@ -1959,18 +1970,33 @@ void komodo_args(char *argv0)
                 StartShutdown();
             }
         }
-        else if ( ASSETCHAINS_SELFIMPORT == "BEAM" && ASSETCHAINS_BEAMPORT == 0 )
+        else if ( ASSETCHAINS_SELFIMPORT == "BEAM" )
         {
-            LogPrintf("missing -ac_beam for BEAM rpcport\n");
-            StartShutdown();
+            if (ASSETCHAINS_BEAMPORT == 0)
+            {
+                fprintf(stderr,"missing -ac_beam for BEAM rpcport\n");
+                StartShutdown();
+            }
         }
-        else if ( ASSETCHAINS_SELFIMPORT == "CODA" && ASSETCHAINS_CODAPORT == 0 )
+        else if ( ASSETCHAINS_SELFIMPORT == "CODA" )
         {
-            LogPrintf("missing -ac_coda for CODA rpcport\n");
-            StartShutdown();
+            if (ASSETCHAINS_CODAPORT == 0)
+            {
+                fprintf(stderr,"missing -ac_coda for CODA rpcport\n");
+                StartShutdown();
+            }
+        }
+        else if ( ASSETCHAINS_SELFIMPORT == "PEGSCC")
+        {
+            Split(GetArg("-ac_pegsccparams",""), sizeof(ASSETCHAINS_PEGSCCPARAMS)/sizeof(*ASSETCHAINS_PEGSCCPARAMS), ASSETCHAINS_PEGSCCPARAMS, 0);
+            if (ASSETCHAINS_ENDSUBSIDY[0]!=1 || ASSETCHAINS_COMMISSION!=0)
+            {
+                fprintf(stderr,"when using import for pegsCC these must be set: -ac_end=1 -ac_perc=0\n");
+                StartShutdown();
+            }
         }
         // else it can be gateway coin
-        else if (!ASSETCHAINS_SELFIMPORT.empty() && (ASSETCHAINS_ENDSUBSIDY[0]!=1 || ASSETCHAINS_SUPPLY>10 || ASSETCHAINS_COMMISSION!=0))
+        else if (!ASSETCHAINS_SELFIMPORT.empty() && (ASSETCHAINS_ENDSUBSIDY[0]!=1 || ASSETCHAINS_SUPPLY>0 || ASSETCHAINS_COMMISSION!=0))
         {
             LogPrintf("when using gateway import these must be set: -ac_end=1 -ac_supply=0 -ac_perc=0\n");
             StartShutdown();
@@ -2048,7 +2074,7 @@ void komodo_args(char *argv0)
             LogPrintf("-ac_script and -ac_marmara are mutually exclusive\n");
             StartShutdown();
         }
-        if ( ASSETCHAINS_ENDSUBSIDY[0] != 0 || ASSETCHAINS_REWARD[0] != 0 || ASSETCHAINS_HALVING[0] != 0 || ASSETCHAINS_DECAY[0] != 0 || ASSETCHAINS_COMMISSION != 0 || ASSETCHAINS_PUBLIC != 0 || ASSETCHAINS_PRIVATE != 0 || ASSETCHAINS_TXPOW != 0 || ASSETCHAINS_FOUNDERS != 0 || ASSETCHAINS_SCRIPTPUB.size() > 1 || ASSETCHAINS_SELFIMPORT.size() > 0 || ASSETCHAINS_OVERRIDE_PUBKEY33[0] != 0 || ASSETCHAINS_TIMELOCKGTE != _ASSETCHAINS_TIMELOCKOFF|| ASSETCHAINS_ALGO != ASSETCHAINS_EQUIHASH || ASSETCHAINS_LWMAPOS != 0 || ASSETCHAINS_LASTERA > 0 || ASSETCHAINS_BEAMPORT != 0 || ASSETCHAINS_CODAPORT != 0 || ASSETCHAINS_MARMARA != 0 || nonz > 0 || ASSETCHAINS_CCLIB.size() > 0 || ASSETCHAINS_FOUNDERS_REWARD != 0 || ASSETCHAINS_NOTARY_PAY[0] != 0 || ASSETCHAINS_BLOCKTIME != 60 || ASSETCHAINS_CBOPRET != 0 || Mineropret.size() != 0 || (ASSETCHAINS_NK[0] != 0 && ASSETCHAINS_NK[1] != 0) || KOMODO_SNAPSHOT_INTERVAL != 0 || ASSETCHAINS_EARLYTXIDCONTRACT != 0 )
+        if ( ASSETCHAINS_ENDSUBSIDY[0] != 0 || ASSETCHAINS_REWARD[0] != 0 || ASSETCHAINS_HALVING[0] != 0 || ASSETCHAINS_DECAY[0] != 0 || ASSETCHAINS_COMMISSION != 0 || ASSETCHAINS_PUBLIC != 0 || ASSETCHAINS_PRIVATE != 0 || ASSETCHAINS_TXPOW != 0 || ASSETCHAINS_FOUNDERS != 0 || ASSETCHAINS_SCRIPTPUB.size() > 1 || ASSETCHAINS_SELFIMPORT.size() > 0 || ASSETCHAINS_OVERRIDE_PUBKEY33[0] != 0 || ASSETCHAINS_TIMELOCKGTE != _ASSETCHAINS_TIMELOCKOFF|| ASSETCHAINS_ALGO != ASSETCHAINS_EQUIHASH || ASSETCHAINS_LWMAPOS != 0 || ASSETCHAINS_LASTERA > 0 || ASSETCHAINS_BEAMPORT != 0 || ASSETCHAINS_CODAPORT != 0 || ASSETCHAINS_MARMARA != 0 || nonz > 0 || ASSETCHAINS_CCLIB.size() > 0 || ASSETCHAINS_FOUNDERS_REWARD != 0 || ASSETCHAINS_NOTARY_PAY[0] != 0 || ASSETCHAINS_BLOCKTIME != 60 || ASSETCHAINS_CBOPRET != 0 || Mineropret.size() != 0 || (ASSETCHAINS_NK[0] != 0 && ASSETCHAINS_NK[1] != 0) || KOMODO_SNAPSHOT_INTERVAL != 0 || ASSETCHAINS_EARLYTXIDCONTRACT != 0 || ASSETCHAINS_CBMATURITY != 0 || ASSETCHAINS_ADAPTIVEPOW != 0 )
         {
             LogPrintf("perc %.4f%% ac_pub=[%02x%02x%02x...] acsize.%d\n",dstr(ASSETCHAINS_COMMISSION)*100,ASSETCHAINS_OVERRIDE_PUBKEY33[0],ASSETCHAINS_OVERRIDE_PUBKEY33[1],ASSETCHAINS_OVERRIDE_PUBKEY33[2],(int32_t)ASSETCHAINS_SCRIPTPUB.size());
             extraptr = extrabuf;
@@ -2133,6 +2159,7 @@ void komodo_args(char *argv0)
                 extraptr[extralen++] = 'c';
             if ( ASSETCHAINS_MARMARA != 0 )
                 extraptr[extralen++] = ASSETCHAINS_MARMARA;
+LogPrintf("extralen.%d before disable bits\n",extralen);
             if ( nonz > 0 )
             {
                 memcpy(&extraptr[extralen],disablebits,sizeof(disablebits));
@@ -2192,6 +2219,12 @@ void komodo_args(char *argv0)
             {
                 extralen += iguana_rwnum(1,&extraptr[extralen],sizeof(ASSETCHAINS_EARLYTXIDCONTRACT),(void *)&ASSETCHAINS_EARLYTXIDCONTRACT);
             }
+            if ( ASSETCHAINS_CBMATURITY != 0 )
+            {
+                extralen += iguana_rwnum(1,&extraptr[extralen],sizeof(ASSETCHAINS_CBMATURITY),(void *)&ASSETCHAINS_CBMATURITY);
+            }
+            if ( ASSETCHAINS_ADAPTIVEPOW != 0 )
+                extraptr[extralen++] = ASSETCHAINS_ADAPTIVEPOW;
         }
         
         addn = GetArg("-seednode","");
@@ -2243,9 +2276,17 @@ void komodo_args(char *argv0)
             if ( (port= komodo_userpass(ASSETCHAINS_USERPASS,ASSETCHAINS_SYMBOL)) != 0 )
                 ASSETCHAINS_RPCPORT = port;
             else komodo_configfile(ASSETCHAINS_SYMBOL,ASSETCHAINS_P2PPORT + 1);
-            if (ASSETCHAINS_LASTERA == 0 || is_STAKED(ASSETCHAINS_SYMBOL) != 0)
+
+            if (ASSETCHAINS_CBMATURITY != 0)
+                COINBASE_MATURITY = ASSETCHAINS_CBMATURITY;
+            else if (ASSETCHAINS_LASTERA == 0 || is_STAKED(ASSETCHAINS_SYMBOL) != 0)
                 COINBASE_MATURITY = 1;
-            //LogPrintf("ASSETCHAINS_RPCPORT (%s) %u\n",ASSETCHAINS_SYMBOL,ASSETCHAINS_RPCPORT);
+            if (COINBASE_MATURITY < 1)
+            {
+                LogPrintf("ac_cbmaturity must be >0, shutting down\n");
+                StartShutdown();
+            }
+            //fprintf(stderr,"ASSETCHAINS_RPCPORT (%s) %u\n",ASSETCHAINS_SYMBOL,ASSETCHAINS_RPCPORT);
         }
         if ( ASSETCHAINS_RPCPORT == 0 )
             ASSETCHAINS_RPCPORT = ASSETCHAINS_P2PPORT + 1;
@@ -2267,10 +2308,18 @@ void komodo_args(char *argv0)
             //LogPrintf("created (%s)\n",fname);
         } else LogPrintf("error creating (%s)\n",fname);
 #endif
-        if ( KOMODO_CCACTIVATE != 0 && ASSETCHAINS_CC < 2 )
+        if ( ASSETCHAINS_CC < 2 )
         {
-            ASSETCHAINS_CC = 2;
-            LogPrintf("smart utxo CC contracts will activate at height.%d\n",KOMODO_CCACTIVATE);
+            if ( KOMODO_CCACTIVATE != 0 )
+            {
+                ASSETCHAINS_CC = 2;
+                fprintf(stderr,"smart utxo CC contracts will activate at height.%d\n",KOMODO_CCACTIVATE);
+            }
+            else if ( ccEnablesHeight[0] != 0 )
+            {
+                ASSETCHAINS_CC = 2;
+                fprintf(stderr,"smart utxo CC contract %d will activate at height.%d\n",(int32_t)ccEnablesHeight[0],(int32_t)ccEnablesHeight[1]);
+            }
         }
     }
     else
diff --git a/src/main.cpp b/src/main.cpp
index 635db70b..868768e6 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -354,7 +354,10 @@ namespace {
 
     int GetHeight()
     {
-        return chainActive.LastTip()->GetHeight();
+        CBlockIndex *pindex;
+        if ( (pindex= chainActive.LastTip()) != 0 )
+            return pindex->GetHeight();
+        else return(0);
     }
 
     void UpdatePreferredDownload(CNode* node, CNodeState* state)
@@ -737,6 +740,7 @@ bool komodo_dailysnapshot(int32_t height)
             for (unsigned int j = tx.vin.size(); j-- > 0;) 
             {
                 uint256 blockhash; CTransaction txin;
+                if (tx.IsPegsImport() && j==0) continue;
                 if ( !tx.IsCoinImport() && !tx.IsCoinBase() && myGetTransaction(tx.vin[j].prevout.hash,txin,blockhash) ) 
                 {
                     int vout = tx.vin[j].prevout.n;
@@ -1028,6 +1032,7 @@ bool AreInputsStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs,
 
     for (unsigned int i = 0; i < tx.vin.size(); i++)
     {
+        if (tx.IsPegsImport() && i==0) continue;
         const CTxOut& prev = mapInputs.GetOutputFor(tx.vin[i]);
 
         vector<vector<unsigned char> > vSolutions;
@@ -1105,6 +1110,7 @@ unsigned int GetP2SHSigOpCount(const CTransaction& tx, const CCoinsViewCache& in
     unsigned int nSigOps = 0;
     for (unsigned int i = 0; i < tx.vin.size(); i++)
     {
+        if (tx.IsPegsImport() && i==0) continue;
         const CTxOut &prevout = inputs.GetOutputFor(tx.vin[i]);
         if (prevout.scriptPubKey.IsPayToScriptHash())
             nSigOps += prevout.scriptPubKey.GetSigOpCount(tx.vin[i].scriptSig);
@@ -1116,7 +1122,7 @@ unsigned int GetP2SHSigOpCount(const CTransaction& tx, const CCoinsViewCache& in
  * Ensure that a coinbase transaction is structured according to the consensus rules of the
  * chain
  */
-bool ContextualCheckCoinbaseTransaction(const CBlock *block,CBlockIndex * const previndex,const CTransaction& tx, const int nHeight,int32_t validateprices)
+bool ContextualCheckCoinbaseTransaction(int32_t slowflag,const CBlock *block,CBlockIndex * const previndex,const CTransaction& tx, const int nHeight,int32_t validateprices)
 {
     // if time locks are on, ensure that this coin base is time locked exactly as it should be
     if (((uint64_t)(tx.GetValueOut()) >= ASSETCHAINS_TIMELOCKGTE) ||
@@ -1157,7 +1163,7 @@ bool ContextualCheckCoinbaseTransaction(const CBlock *block,CBlockIndex * const
     {
         
     }
-    else if ( ASSETCHAINS_CBOPRET != 0 && validateprices != 0 && nHeight > 0 && tx.vout.size() > 0 )
+    else if ( slowflag != 0 && ASSETCHAINS_CBOPRET != 0 && validateprices != 0 && nHeight > 0 && tx.vout.size() > 0 )
     {
         if ( komodo_opretvalidate(block,previndex,nHeight,tx.vout[tx.vout.size()-1].scriptPubKey) < 0 )
             return(false);
@@ -1174,7 +1180,7 @@ bool ContextualCheckCoinbaseTransaction(const CBlock *block,CBlockIndex * const
  *    and ContextualCheckBlock (which calls this function).
  * 3. The isInitBlockDownload argument is only to assist with testing.
  */
-bool ContextualCheckTransaction(const CBlock *block, CBlockIndex * const previndex,
+bool ContextualCheckTransaction(int32_t slowflag,const CBlock *block, CBlockIndex * const previndex,
         const CTransaction& tx,
         CValidationState &state,
         const int nHeight,
@@ -1310,7 +1316,7 @@ bool ContextualCheckTransaction(const CBlock *block, CBlockIndex * const prevind
 
     if (tx.IsCoinBase())
     {
-        if (!ContextualCheckCoinbaseTransaction(block,previndex,tx, nHeight,validateprices))
+        if (!ContextualCheckCoinbaseTransaction(slowflag,block,previndex,tx, nHeight,validateprices))
             return state.DoS(100, error("CheckTransaction(): invalid script data for coinbase time lock"),
                                 REJECT_INVALID, "bad-txns-invalid-script-data-for-coinbase-time-lock");
     }
@@ -1821,7 +1827,7 @@ bool AcceptToMemoryPool(CTxMemPool& pool, CValidationState &state, const CTransa
     
     // DoS level set to 10 to be more forgiving.
     // Check transaction contextually against the set of consensus rules which apply in the next block to be mined.
-    if (!ContextualCheckTransaction(0,0,tx, state, nextBlockHeight, (dosLevel == -1) ? 10 : dosLevel))
+    if (!ContextualCheckTransaction(0,0,0,tx, state, nextBlockHeight, (dosLevel == -1) ? 10 : dosLevel))
     {
         return error("AcceptToMemoryPool: ContextualCheckTransaction failed");
     }
@@ -1902,7 +1908,7 @@ bool AcceptToMemoryPool(CTxMemPool& pool, CValidationState &state, const CTransa
                 return state.Invalid(false, REJECT_DUPLICATE, "already have coins");
             }
 
-            if (tx.IsCoinImport())
+            if (tx.IsCoinImport() || tx.IsPegsImport())
             {
                 // Inverse of normal case; if input exists, it's been spent
                 if (ExistsImportTombstone(tx, view))
@@ -1977,7 +1983,7 @@ bool AcceptToMemoryPool(CTxMemPool& pool, CValidationState &state, const CTransa
         // Keep track of transactions that spend a coinbase, which we re-scan
         // during reorgs to ensure COINBASE_MATURITY is still met.
         bool fSpendsCoinbase = false;
-        if (!tx.IsCoinImport()) {
+        if (!tx.IsCoinImport() && !tx.IsPegsImport()) {
             BOOST_FOREACH(const CTxIn &txin, tx.vin) {
                 const CCoins *coins = view.AccessCoins(txin.prevout.hash);
                 if (coins->IsCoinBase()) {
@@ -2017,7 +2023,7 @@ bool AcceptToMemoryPool(CTxMemPool& pool, CValidationState &state, const CTransa
         // Continuously rate-limit free (really, very-low-fee) transactions
         // This mitigates 'penny-flooding' -- sending thousands of free transactions just to
         // be annoying or make others' transactions take longer to confirm.
-        if (fLimitFree && nFees < ::minRelayTxFee.GetFee(nSize) && !tx.IsCoinImport())
+        if (fLimitFree && nFees < ::minRelayTxFee.GetFee(nSize) && !tx.IsCoinImport() && !tx.IsPegsImport())
         {
             static CCriticalSection csFreeLimiter;
             static double dFreeCount;
@@ -2040,7 +2046,7 @@ bool AcceptToMemoryPool(CTxMemPool& pool, CValidationState &state, const CTransa
             dFreeCount += nSize;
         }
         
-        if (!tx.IsCoinImport() && fRejectAbsurdFee && nFees > ::minRelayTxFee.GetFee(nSize) * 10000 && nFees > nValueOut/19)
+        if (!tx.IsCoinImport() && !tx.IsPegsImport() && fRejectAbsurdFee && nFees > ::minRelayTxFee.GetFee(nSize) * 10000 && nFees > nValueOut/19)
         {
             string errmsg = strprintf("absurdly high fees %s, %d > %d",
                                       hash.ToString(),
@@ -2211,6 +2217,18 @@ bool myAddtomempool(CTransaction &tx, CValidationState *pstate, bool fSkipExpiry
 bool myGetTransaction(const uint256 &hash, CTransaction &txOut, uint256 &hashBlock)
 {
     memset(&hashBlock,0,sizeof(hashBlock));
+    if ( KOMODO_NSPV_SUPERLITE )
+    {
+        int64_t rewardsum = 0; int32_t i,retval,txheight,currentheight,height=0,vout = 0;
+        for (i=0; i<NSPV_U.U.numutxos; i++)
+            if ( NSPV_U.U.utxos[i].txid == hash )
+            {
+                height = NSPV_U.U.utxos[i].height;
+                break;
+            }
+        retval = NSPV_gettransaction(1,vout,hash,height,txOut,hashBlock,txheight,currentheight,0,0,rewardsum);
+        return(retval != -1);
+    }
     // need a GetTransaction without lock so the validation code for assets can run without deadlock
     {
         //LogPrintf("check mempool %s\n",hash.GetHex().c_str());
@@ -2246,7 +2264,25 @@ bool myGetTransaction(const uint256 &hash, CTransaction &txOut, uint256 &hashBlo
             return true;
         }
     }
-    //LogPrintf("not found on disk %s\n",hash.GetHex().c_str());
+    //fprintf(stderr,"not found on disk %s\n",hash.GetHex().c_str());
+    return false;
+}
+
+bool NSPV_myGetTransaction(const uint256 &hash, CTransaction &txOut, uint256 &hashBlock, int32_t &txheight, int32_t &currentheight)
+{
+    memset(&hashBlock,0,sizeof(hashBlock));
+    if ( KOMODO_NSPV_SUPERLITE )
+    {
+        int64_t rewardsum = 0; int32_t i,retval,height=0,vout = 0;
+        for (i=0; i<NSPV_U.U.numutxos; i++)
+            if ( NSPV_U.U.utxos[i].txid == hash )
+            {
+                height = NSPV_U.U.utxos[i].height;
+                break;
+            }
+        retval = NSPV_gettransaction(1,vout,hash,height,txOut,hashBlock,txheight,currentheight,0,0,rewardsum);
+        return(retval != -1);
+    }
     return false;
 }
 
@@ -2404,7 +2440,7 @@ bool ReadBlockFromDisk(CBlock& block, const CBlockIndex* pindex,bool checkPOW)
 
 //uint64_t komodo_moneysupply(int32_t height);
 extern char ASSETCHAINS_SYMBOL[KOMODO_ASSETCHAIN_MAXLEN];
-extern uint64_t ASSETCHAINS_ENDSUBSIDY[ASSETCHAINS_MAX_ERAS], ASSETCHAINS_REWARD[ASSETCHAINS_MAX_ERAS], ASSETCHAINS_HALVING[ASSETCHAINS_MAX_ERAS];
+extern uint64_t ASSETCHAINS_ENDSUBSIDY[ASSETCHAINS_MAX_ERAS+1], ASSETCHAINS_REWARD[ASSETCHAINS_MAX_ERAS+1], ASSETCHAINS_HALVING[ASSETCHAINS_MAX_ERAS+1];
 extern uint32_t ASSETCHAINS_MAGIC;
 extern uint64_t ASSETCHAINS_LINEAR,ASSETCHAINS_COMMISSION,ASSETCHAINS_SUPPLY;
 extern uint8_t ASSETCHAINS_PUBLIC,ASSETCHAINS_PRIVATE;
@@ -2686,6 +2722,7 @@ void UpdateCoins(const CTransaction& tx, CCoinsViewCache& inputs, CTxUndo &txund
     {
         txundo.vprevout.reserve(tx.vin.size());
         BOOST_FOREACH(const CTxIn &txin, tx.vin) {
+            if (tx.IsPegsImport() && txin.prevout.n==10e8) continue;
             CCoinsModifier coins = inputs.ModifyCoins(txin.prevout.hash);
             unsigned nPos = txin.prevout.n;
 
@@ -2709,7 +2746,7 @@ void UpdateCoins(const CTransaction& tx, CCoinsViewCache& inputs, CTxUndo &txund
     inputs.ModifyCoins(tx.GetHash())->FromTx(tx, nHeight); // add outputs
 
     // Unorthodox state
-    if (tx.IsCoinImport()) {
+    if (tx.IsCoinImport() || tx.IsPegsImport()) {
         // add a tombstone for the burnTx
         AddImportTombstone(tx, inputs, nHeight);
     }
@@ -2753,6 +2790,11 @@ namespace Consensus {
         CAmount nFees = 0;
         for (unsigned int i = 0; i < tx.vin.size(); i++)
         {
+            if (tx.IsPegsImport() && i==0)
+            {
+                nValueIn=GetCoinImportValue(tx);
+                continue;
+            }
             const COutPoint &prevout = tx.vin[i].prevout;
             const CCoins *coins = inputs.AccessCoins(prevout.hash);
             assert(coins);
@@ -2864,6 +2906,7 @@ bool ContextualCheckInputs(
         // still computed and checked, and any change will be caught at the next checkpoint.
         if (fScriptChecks) {
             for (unsigned int i = 0; i < tx.vin.size(); i++) {
+                if (tx.IsPegsImport() && i==0) continue;
                 const COutPoint &prevout = tx.vin[i].prevout;
                 const CCoins* coins = inputs.AccessCoins(prevout.hash);
                 assert(coins);
@@ -2899,7 +2942,7 @@ bool ContextualCheckInputs(
         }
     }
 
-    if (tx.IsCoinImport())
+    if (tx.IsCoinImport() || tx.IsPegsImport())
     {
         LOCK(cs_main);
         ServerTransactionSignatureChecker checker(&tx, 0, 0, false, txdata);
@@ -3185,10 +3228,12 @@ bool DisconnectBlock(CBlock& block, CValidationState& state, CBlockIndex* pindex
 
         // restore inputs
         if (!tx.IsMint()) {
-            const CTxUndo &txundo = blockUndo.vtxundo[i-1];
+            CTxUndo &txundo = blockUndo.vtxundo[i-1];
+            if (tx.IsPegsImport()) txundo.vprevout.insert(txundo.vprevout.begin(),CTxInUndo());
             if (txundo.vprevout.size() != tx.vin.size())
                 return error("DisconnectBlock(): transaction and undo data inconsistent");
             for (unsigned int j = tx.vin.size(); j-- > 0;) {
+                if (tx.IsPegsImport() && j==0)  continue;
                 const COutPoint &out = tx.vin[j].prevout;
                 const CTxInUndo &undo = txundo.vprevout[j];
                 if (!ApplyTxInUndo(undo, view, out))
@@ -3223,7 +3268,7 @@ bool DisconnectBlock(CBlock& block, CValidationState& state, CBlockIndex* pindex
                 }
             }
         }
-        else if (tx.IsCoinImport())
+        else if (tx.IsCoinImport() || tx.IsPegsImport())
         {
             RemoveImportTombstone(tx, view);
         }
@@ -3373,6 +3418,8 @@ bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pin
 {
     CDiskBlockPos blockPos;
     const CChainParams& chainparams = Params();
+    if ( KOMODO_NSPV_SUPERLITE )
+        return(true);
     if ( KOMODO_STOPAT != 0 && pindex->GetHeight() > KOMODO_STOPAT )
         return(false);
     //LogPrintf("connectblock ht.%d\n",(int32_t)pindex->GetHeight());
@@ -3398,7 +3445,7 @@ bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pin
     }
     if ( fCheckPOW != 0 && (pindex->nStatus & BLOCK_VALID_CONTEXT) != BLOCK_VALID_CONTEXT ) // Activate Jan 15th, 2019
     {
-        if ( !ContextualCheckBlock(block, state, pindex->pprev) )
+        if ( !ContextualCheckBlock(1,block, state, pindex->pprev) )
         {
             LogPrintf("ContextualCheckBlock failed ht.%d\n",(int32_t)pindex->GetHeight());
             if ( pindex->nTime > 1547510400 )
@@ -3576,6 +3623,7 @@ bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pin
             {
                 for (size_t j = 0; j < tx.vin.size(); j++) 
                 {
+                    if (tx.IsPegsImport() && j==0) continue;
                     const CTxIn input = tx.vin[j];
                     const CTxOut &prevout = view.GetOutputFor(tx.vin[j]);
 
@@ -3966,7 +4014,8 @@ bool static FlushStateToDisk(CValidationState &state, FlushStateMode mode) {
 
 void FlushStateToDisk() {
     CValidationState state;
-    FlushStateToDisk(state, FLUSH_STATE_ALWAYS);
+    if ( KOMODO_NSPV_FULLNODE )
+        FlushStateToDisk(state, FLUSH_STATE_ALWAYS);
 }
 
 void PruneAndFlush() {
@@ -4121,7 +4170,7 @@ bool static DisconnectTip(CValidationState &state, bool fBare = false) {
         {
 #ifdef ENABLE_WALLET
              // new staking tx cannot be accepted to mempool and expires in 1 block, so no need for this! :D
-             if ( !GetBoolArg("-disablewallet", false) )
+             if ( !GetBoolArg("-disablewallet", false) && KOMODO_NSPV_FULLNODE )
                  pwalletMain->EraseFromWallet(tx.GetHash());
 #endif
         } else SyncWithWallets(tx, NULL);
@@ -4222,8 +4271,11 @@ bool static ConnectTip(CValidationState &state, CBlockIndex *pindexNew, CBlock *
     // Get the current commitment tree
     SproutMerkleTree oldSproutTree;
     SaplingMerkleTree oldSaplingTree;
-    assert(pcoinsTip->GetSproutAnchorAt(pcoinsTip->GetBestAnchor(SPROUT), oldSproutTree));
-    assert(pcoinsTip->GetSaplingAnchorAt(pcoinsTip->GetBestAnchor(SAPLING), oldSaplingTree));
+    if ( KOMODO_NSPV_FULLNODE )
+    {
+        assert(pcoinsTip->GetSproutAnchorAt(pcoinsTip->GetBestAnchor(SPROUT), oldSproutTree));
+        assert(pcoinsTip->GetSaplingAnchorAt(pcoinsTip->GetBestAnchor(SAPLING), oldSaplingTree));
+    }
     // Apply the block atomically to the chain state.
     int64_t nTime2 = GetTimeMicros(); nTimeReadFromDisk += nTime2 - nTime1;
     int64_t nTime3;
@@ -4248,13 +4300,17 @@ bool static ConnectTip(CValidationState &state, CBlockIndex *pindexNew, CBlock *
         mapBlockSource.erase(pindexNew->GetBlockHash());
         nTime3 = GetTimeMicros(); nTimeConnectTotal += nTime3 - nTime2;
         LogPrint("bench", "  - Connect total: %.2fms [%.2fs]\n", (nTime3 - nTime2) * 0.001, nTimeConnectTotal * 0.000001);
-        assert(view.Flush());
+        if ( KOMODO_NSPV_FULLNODE )
+            assert(view.Flush());
     }
     int64_t nTime4 = GetTimeMicros(); nTimeFlush += nTime4 - nTime3;
     LogPrint("bench", "  - Flush: %.2fms [%.2fs]\n", (nTime4 - nTime3) * 0.001, nTimeFlush * 0.000001);
     // Write the chain state to disk, if necessary.
-    if (!FlushStateToDisk(state, FLUSH_STATE_IF_NEEDED))
-        return false;
+    if ( KOMODO_NSPV_FULLNODE )
+    {
+        if (!FlushStateToDisk(state, FLUSH_STATE_IF_NEEDED))
+            return false;
+    }
     int64_t nTime5 = GetTimeMicros(); nTimeChainState += nTime5 - nTime4;
     LogPrint("bench", "  - Writing chainstate: %.2fms [%.2fs]\n", (nTime5 - nTime4) * 0.001, nTimeChainState * 0.000001);
     // Remove conflicting transactions from the mempool.
@@ -4266,14 +4322,17 @@ bool static ConnectTip(CValidationState &state, CBlockIndex *pindexNew, CBlock *
 
     // Update chainActive & related variables.
     UpdateTip(pindexNew);
-    // Tell wallet about transactions that went from mempool
-    // to conflicted:
-    BOOST_FOREACH(const CTransaction &tx, txConflicted) {
-        SyncWithWallets(tx, NULL);
-    }
-    // ... and about transactions that got confirmed:
-    BOOST_FOREACH(const CTransaction &tx, pblock->vtx) {
-        SyncWithWallets(tx, pblock);
+    if ( KOMODO_NSPV_FULLNODE )
+    {
+        // Tell wallet about transactions that went from mempool
+        // to conflicted:
+        BOOST_FOREACH(const CTransaction &tx, txConflicted) {
+            SyncWithWallets(tx, NULL);
+        }
+        // ... and about transactions that got confirmed:
+        BOOST_FOREACH(const CTransaction &tx, pblock->vtx) {
+            SyncWithWallets(tx, pblock);
+        }
     }
     // Update cached incremental witnesses
     GetMainSignals().ChainTip(pindexNew, pblock, oldSproutTree, oldSaplingTree, true);
@@ -4291,19 +4350,22 @@ bool static ConnectTip(CValidationState &state, CBlockIndex *pindexNew, CBlock *
         komodo_broadcast(pblock,8);
     else if ( ASSETCHAINS_SYMBOL[0] != 0 )
         komodo_broadcast(pblock,4);*/
-    if ( ASSETCHAINS_CBOPRET != 0 )
-        komodo_pricesupdate(pindexNew->GetHeight(),pblock);
-    if ( ASSETCHAINS_SAPLING <= 0 && pindexNew->nTime > KOMODO_SAPLING_ACTIVATION - 24*3600 )
-        komodo_activate_sapling(pindexNew);
-    if ( ASSETCHAINS_CC != 0 && KOMODO_SNAPSHOT_INTERVAL != 0 && (pindexNew->GetHeight() % KOMODO_SNAPSHOT_INTERVAL) == 0 && pindexNew->GetHeight() >= KOMODO_SNAPSHOT_INTERVAL )
+    if ( KOMODO_NSPV_FULLNODE )
     {
-        uint64_t start = time(NULL);
-        if ( !komodo_dailysnapshot(pindexNew->GetHeight()) )
+        if ( ASSETCHAINS_CBOPRET != 0 )
+            komodo_pricesupdate(pindexNew->GetHeight(),pblock);
+        if ( ASSETCHAINS_SAPLING <= 0 && pindexNew->nTime > KOMODO_SAPLING_ACTIVATION - 24*3600 )
+            komodo_activate_sapling(pindexNew);
+        if ( ASSETCHAINS_CC != 0 && KOMODO_SNAPSHOT_INTERVAL != 0 && (pindexNew->GetHeight() % KOMODO_SNAPSHOT_INTERVAL) == 0 && pindexNew->GetHeight() >= KOMODO_SNAPSHOT_INTERVAL )
         {
-            LogPrintf( "daily snapshot failed, please reindex your chain\n");
-            StartShutdown();
+            uint64_t start = time(NULL);
+            if ( !komodo_dailysnapshot(pindexNew->GetHeight()) )
+            {
+                LogPrintf("daily snapshot failed, please reindex your chain\n");
+                StartShutdown();
+            }
+            LogPrintf("snapshot completed in: %d seconds\n", (int32_t)(time(NULL)-start));
         }
-        LogPrintf( "snapshot completed in: %lu seconds\n", time(NULL)-start);
     }
     return true;
 }
@@ -5050,7 +5112,15 @@ bool CheckBlockHeader(int32_t *futureblockp,int32_t height,CBlockIndex *pindex,
         }
     }
     *futureblockp = 0;
-    if (blockhdr.GetBlockTime() > GetAdjustedTime() + 60)
+    if ( ASSETCHAINS_ADAPTIVEPOW > 0 )
+    {
+        if (blockhdr.GetBlockTime() > GetAdjustedTime() + 4)
+        {
+            //LogPrintf("CheckBlockHeader block from future %d error",blockhdr.GetBlockTime() - GetAdjustedTime());
+            return false;
+        }
+    }
+    else if (blockhdr.GetBlockTime() > GetAdjustedTime() + 60)
     {
         /*CBlockIndex *tipindex;
         //LogPrintf("ht.%d future block %u vs time.%u + 60\n",height,(uint32_t)blockhdr.GetBlockTime(),(uint32_t)GetAdjustedTime());
@@ -5312,10 +5382,23 @@ bool ContextualCheckBlockHeader(const CBlockHeader& block, CValidationState& sta
     }
 
     // Check timestamp against prev
-    if (block.GetBlockTime() <= pindexPrev->GetMedianTimePast())
+    if ( ASSETCHAINS_ADAPTIVEPOW <= 0 || nHeight < 30 )
     {
-        return state.Invalid(error("%s: block's timestamp is too early", __func__),
-                        REJECT_INVALID, "time-too-old");
+        if (block.GetBlockTime() <= pindexPrev->GetMedianTimePast() )
+        {
+            LogPrintf("ht.%d too early %u vs %u\n",(int32_t)nHeight,(uint32_t)block.GetBlockTime(),(uint32_t)pindexPrev->GetMedianTimePast());
+            return state.Invalid(error("%s: block's timestamp is too early", __func__),
+                                 REJECT_INVALID, "time-too-old");
+        }
+    }
+    else
+    {
+        if ( block.GetBlockTime() <= pindexPrev->nTime )
+        {
+            LogPrintf("ht.%d too early2 %u vs %u\n",(int32_t)nHeight,(uint32_t)block.GetBlockTime(),(uint32_t)pindexPrev->nTime);
+            return state.Invalid(error("%s: block's timestamp is too early2", __func__),
+                                 REJECT_INVALID, "time-too-old");
+        }
     }
 
     // Check that timestamp is not too far in the future
@@ -5371,7 +5454,7 @@ bool ContextualCheckBlockHeader(const CBlockHeader& block, CValidationState& sta
     return true;
 }
 
-bool ContextualCheckBlock(const CBlock& block, CValidationState& state, CBlockIndex * const pindexPrev)
+bool ContextualCheckBlock(int32_t slowflag,const CBlock& block, CValidationState& state, CBlockIndex * const pindexPrev)
 {
     const int nHeight = pindexPrev == NULL ? 0 : pindexPrev->GetHeight() + 1;
     const Consensus::Params& consensusParams = Params().GetConsensus();
@@ -5382,7 +5465,7 @@ bool ContextualCheckBlock(const CBlock& block, CValidationState& state, CBlockIn
         const CTransaction& tx = block.vtx[i];
 
         // Check transaction contextually against consensus rules at block height
-        if (!ContextualCheckTransaction(&block,pindexPrev,tx, state, nHeight, 100)) {
+        if (!ContextualCheckTransaction(slowflag,&block,pindexPrev,tx, state, nHeight, 100)) {
             return false; // Failure reason has been set in validation state object
         }
 
@@ -5551,7 +5634,7 @@ bool AcceptBlock(int32_t *futureblockp,CBlock& block, CValidationState& state, C
 
     // See method docstring for why this is always disabled
     auto verifier = libzcash::ProofVerifier::Disabled();
-    bool fContextualCheckBlock = ContextualCheckBlock(block, state, pindex->pprev);
+    bool fContextualCheckBlock = ContextualCheckBlock(0,block, state, pindex->pprev);
     if ( (!CheckBlock(futureblockp,pindex->GetHeight(),pindex,block, state, verifier,0)) || !fContextualCheckBlock )
     {
         static int32_t saplinght = -1;
@@ -5800,7 +5883,7 @@ bool TestBlockValidity(CValidationState &state, const CBlock& block, CBlockIndex
         //LogPrintf("TestBlockValidity failure B checkPOW.%d\n",fCheckPOW);
         return false;
     }
-    if (!ContextualCheckBlock(block, state, pindexPrev))
+    if (!ContextualCheckBlock(0,block, state, pindexPrev))
     {
         //LogPrintf("TestBlockValidity failure C checkPOW.%d\n",fCheckPOW);
         return false;
@@ -6529,22 +6612,24 @@ bool InitBlockIndex() {
     {
         return true;
     }
-    // Use the provided setting for -txindex in the new database
-    fTxIndex = GetBoolArg("-txindex", true);
-    pblocktree->WriteFlag("txindex", fTxIndex);
-    // Use the provided setting for -addressindex in the new database
-    fAddressIndex = GetBoolArg("-addressindex", DEFAULT_ADDRESSINDEX);
-    pblocktree->WriteFlag("addressindex", fAddressIndex);
-
-    // Use the provided setting for -timestampindex in the new database
-    fTimestampIndex = GetBoolArg("-timestampindex", DEFAULT_TIMESTAMPINDEX);
-    pblocktree->WriteFlag("timestampindex", fTimestampIndex);
-
-    fSpentIndex = GetBoolArg("-spentindex", DEFAULT_SPENTINDEX);
-    pblocktree->WriteFlag("spentindex", fSpentIndex);
-    LogPrintf("fAddressIndex.%d/%d fSpentIndex.%d/%d\n",fAddressIndex,DEFAULT_ADDRESSINDEX,fSpentIndex,DEFAULT_SPENTINDEX);
-    LogPrintf("Initializing databases...\n");
-
+    if ( pblocktree != 0 )
+    {
+        // Use the provided setting for -txindex in the new database
+        fTxIndex = GetBoolArg("-txindex", true);
+        pblocktree->WriteFlag("txindex", fTxIndex);
+        // Use the provided setting for -addressindex in the new database
+        fAddressIndex = GetBoolArg("-addressindex", DEFAULT_ADDRESSINDEX);
+        pblocktree->WriteFlag("addressindex", fAddressIndex);
+        
+        // Use the provided setting for -timestampindex in the new database
+        fTimestampIndex = GetBoolArg("-timestampindex", DEFAULT_TIMESTAMPINDEX);
+        pblocktree->WriteFlag("timestampindex", fTimestampIndex);
+        
+        fSpentIndex = GetBoolArg("-spentindex", DEFAULT_SPENTINDEX);
+        pblocktree->WriteFlag("spentindex", fSpentIndex);
+        fprintf(stderr,"fAddressIndex.%d/%d fSpentIndex.%d/%d\n",fAddressIndex,DEFAULT_ADDRESSINDEX,fSpentIndex,DEFAULT_SPENTINDEX);
+        LogPrintf("Initializing databases...\n");
+    }
     // Only add the genesis block if not reindexing (in which case we reuse the one already on disk)
     if (!fReindex) {
         try {
@@ -6565,7 +6650,9 @@ bool InitBlockIndex() {
             if (!ActivateBestChain(true, state, &block))
                 return error("LoadBlockIndex(): genesis block cannot be activated");
             // Force a chainstate write so that when we VerifyDB in a moment, it doesn't check stale data
-            return FlushStateToDisk(state, FLUSH_STATE_ALWAYS);
+            if ( KOMODO_NSPV_FULLNODE )
+                return FlushStateToDisk(state, FLUSH_STATE_ALWAYS);
+            else return(true);
         } catch (const std::runtime_error& e) {
             return error("LoadBlockIndex(): failed to initialize block database: %s", e.what());
         }
@@ -7125,6 +7212,12 @@ void static ProcessGetData(CNode* pfrom)
     }
 }
 
+#include "komodo_nSPV_defs.h"
+#include "komodo_nSPV.h"            // shared defines, structs, serdes, purge functions
+#include "komodo_nSPV_fullnode.h"   // nSPV fullnode handling of the getnSPV request messages
+#include "komodo_nSPV_superlite.h"  // nSPV superlite client, issuing requests and handling nSPV responses
+#include "komodo_nSPV_wallet.h"     // nSPV_send and support functions, really all the rest is to support this
+
 bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv, int64_t nTimeReceived)
 {
     int32_t nProtocolVersion;
@@ -7305,6 +7398,15 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv,
     {
         pfrom->SetRecvVersion(min(pfrom->nVersion, PROTOCOL_VERSION));
 
+        if ( KOMODO_NSPV_SUPERLITE )
+        {
+            if ( (pfrom->nServices & NODE_NSPV) == 0 )
+            {
+                // fprintf(stderr,"invalid nServices.%llx nSPV peer.%d\n",(long long)pfrom->nServices,pfrom->id);
+                pfrom->fDisconnect = true;
+                return false;
+            }
+        }
         // Mark this node as currently connected, so we update its timestamp later.
         if (pfrom->fNetworkNode) {
             LOCK(cs_main);
@@ -7394,8 +7496,127 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv,
         if (pfrom->fOneShot)
             pfrom->fDisconnect = true;
     }
+    else if (strCommand == "ping")
+    {
+        if (pfrom->nVersion > BIP0031_VERSION)
+        {
+            uint64_t nonce = 0;
+            vRecv >> nonce;
+            // Echo the message back with the nonce. This allows for two useful features:
+            //
+            // 1) A remote node can quickly check if the connection is operational
+            // 2) Remote nodes can measure the latency of the network thread. If this node
+            //    is overloaded it won't respond to pings quickly and the remote node can
+            //    avoid sending us more work, like chain download requests.
+            //
+            // The nonce stops the remote getting confused between different pings: without
+            // it, if the remote node sends a ping once per second and this node takes 5
+            // seconds to respond to each, the 5th ping the remote sends would appear to
+            // return very quickly.
+            pfrom->PushMessage("pong", nonce);
+        }
+    }
+    
+    
+    else if (strCommand == "pong")
+    {
+        int64_t pingUsecEnd = nTimeReceived;
+        uint64_t nonce = 0;
+        size_t nAvail = vRecv.in_avail();
+        bool bPingFinished = false;
+        std::string sProblem;
+        
+        if (nAvail >= sizeof(nonce)) {
+            vRecv >> nonce;
+            
+            // Only process pong message if there is an outstanding ping (old ping without nonce should never pong)
+            if (pfrom->nPingNonceSent != 0) {
+                if (nonce == pfrom->nPingNonceSent) {
+                    // Matching pong received, this ping is no longer outstanding
+                    bPingFinished = true;
+                    int64_t pingUsecTime = pingUsecEnd - pfrom->nPingUsecStart;
+                    if (pingUsecTime > 0) {
+                        // Successful ping time measurement, replace previous
+                        pfrom->nPingUsecTime = pingUsecTime;
+                        pfrom->nMinPingUsecTime = std::min(pfrom->nMinPingUsecTime, pingUsecTime);
+                    } else {
+                        // This should never happen
+                        sProblem = "Timing mishap";
+                    }
+                } else {
+                    // Nonce mismatches are normal when pings are overlapping
+                    sProblem = "Nonce mismatch";
+                    if (nonce == 0) {
+                        // This is most likely a bug in another implementation somewhere; cancel this ping
+                        bPingFinished = true;
+                        sProblem = "Nonce zero";
+                    }
+                }
+            } else {
+                sProblem = "Unsolicited pong without ping";
+            }
+        } else {
+            // This is most likely a bug in another implementation somewhere; cancel this ping
+            bPingFinished = true;
+            sProblem = "Short payload";
+        }
+        
+        if (!(sProblem.empty())) {
+            LogPrint("net", "pong peer=%d %s: %s, %x expected, %x received, %u bytes\n",
+                     pfrom->id,
+                     pfrom->cleanSubVer,
+                     sProblem,
+                     pfrom->nPingNonceSent,
+                     nonce,
+                     nAvail);
+        }
+        if (bPingFinished) {
+            pfrom->nPingNonceSent = 0;
+        }
+    }
 
-
+    // This asymmetric behavior for inbound and outbound connections was introduced
+    // to prevent a fingerprinting attack: an attacker can send specific fake addresses
+    // to users' AddrMan and later request them by sending getaddr messages.
+    // Making nodes which are behind NAT and can only make outgoing connections ignore
+    // the getaddr message mitigates the attack.
+    else if ((strCommand == "getaddr") && (pfrom->fInbound))
+    {
+        // Only send one GetAddr response per connection to reduce resource waste
+        //  and discourage addr stamping of INV announcements.
+        if (pfrom->fSentAddr) {
+            LogPrint("net", "Ignoring repeated \"getaddr\". peer=%d\n", pfrom->id);
+            return true;
+        }
+        pfrom->fSentAddr = true;
+        
+        pfrom->vAddrToSend.clear();
+        vector<CAddress> vAddr = addrman.GetAddr();
+        BOOST_FOREACH(const CAddress &addr, vAddr)
+        pfrom->PushAddress(addr);
+    }
+    else if (strCommand == "getnSPV")
+    {
+        if ( KOMODO_NSPV == 0 )//&& KOMODO_INSYNC != 0 )
+        {
+            std::vector<uint8_t> payload;
+            vRecv >> payload;
+            komodo_nSPVreq(pfrom,payload);
+        }
+        return(true);
+    }
+    else if (strCommand == "nSPV")
+    {
+        if ( KOMODO_NSPV_SUPERLITE )
+        {
+            std::vector<uint8_t> payload;
+            vRecv >> payload;
+            komodo_nSPVresp(pfrom,payload);
+        }
+        return(true);
+    }
+    else if ( KOMODO_NSPV_SUPERLITE )
+        return(true);
     else if (strCommand == "inv")
     {
         vector<CInv> vInv;
@@ -7807,28 +8028,6 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv,
     }
 
 
-    // This asymmetric behavior for inbound and outbound connections was introduced
-    // to prevent a fingerprinting attack: an attacker can send specific fake addresses
-    // to users' AddrMan and later request them by sending getaddr messages.
-    // Making nodes which are behind NAT and can only make outgoing connections ignore
-    // the getaddr message mitigates the attack.
-    else if ((strCommand == "getaddr") && (pfrom->fInbound))
-    {
-        // Only send one GetAddr response per connection to reduce resource waste
-        //  and discourage addr stamping of INV announcements.
-        if (pfrom->fSentAddr) {
-            LogPrint("net", "Ignoring repeated \"getaddr\". peer=%d\n", pfrom->id);
-            return true;
-        }
-        pfrom->fSentAddr = true;
-
-        pfrom->vAddrToSend.clear();
-        vector<CAddress> vAddr = addrman.GetAddr();
-        BOOST_FOREACH(const CAddress &addr, vAddr)
-        pfrom->PushAddress(addr);
-    }
-
-
     else if (strCommand == "mempool")
     {
         LOCK2(cs_main, pfrom->cs_filter);
@@ -7853,88 +8052,6 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv,
         if (vInv.size() > 0)
             pfrom->PushMessage("inv", vInv);
     }
-
-
-    else if (strCommand == "ping")
-    {
-        if (pfrom->nVersion > BIP0031_VERSION)
-        {
-            uint64_t nonce = 0;
-            vRecv >> nonce;
-            // Echo the message back with the nonce. This allows for two useful features:
-            //
-            // 1) A remote node can quickly check if the connection is operational
-            // 2) Remote nodes can measure the latency of the network thread. If this node
-            //    is overloaded it won't respond to pings quickly and the remote node can
-            //    avoid sending us more work, like chain download requests.
-            //
-            // The nonce stops the remote getting confused between different pings: without
-            // it, if the remote node sends a ping once per second and this node takes 5
-            // seconds to respond to each, the 5th ping the remote sends would appear to
-            // return very quickly.
-            pfrom->PushMessage("pong", nonce);
-        }
-    }
-
-
-    else if (strCommand == "pong")
-    {
-        int64_t pingUsecEnd = nTimeReceived;
-        uint64_t nonce = 0;
-        size_t nAvail = vRecv.in_avail();
-        bool bPingFinished = false;
-        std::string sProblem;
-
-        if (nAvail >= sizeof(nonce)) {
-            vRecv >> nonce;
-
-            // Only process pong message if there is an outstanding ping (old ping without nonce should never pong)
-            if (pfrom->nPingNonceSent != 0) {
-                if (nonce == pfrom->nPingNonceSent) {
-                    // Matching pong received, this ping is no longer outstanding
-                    bPingFinished = true;
-                    int64_t pingUsecTime = pingUsecEnd - pfrom->nPingUsecStart;
-                    if (pingUsecTime > 0) {
-                        // Successful ping time measurement, replace previous
-                        pfrom->nPingUsecTime = pingUsecTime;
-                        pfrom->nMinPingUsecTime = std::min(pfrom->nMinPingUsecTime, pingUsecTime);
-                    } else {
-                        // This should never happen
-                        sProblem = "Timing mishap";
-                    }
-                } else {
-                    // Nonce mismatches are normal when pings are overlapping
-                    sProblem = "Nonce mismatch";
-                    if (nonce == 0) {
-                        // This is most likely a bug in another implementation somewhere; cancel this ping
-                        bPingFinished = true;
-                        sProblem = "Nonce zero";
-                    }
-                }
-            } else {
-                sProblem = "Unsolicited pong without ping";
-            }
-        } else {
-            // This is most likely a bug in another implementation somewhere; cancel this ping
-            bPingFinished = true;
-            sProblem = "Short payload";
-        }
-
-        if (!(sProblem.empty())) {
-            LogPrint("net", "pong peer=%d %s: %s, %x expected, %x received, %u bytes\n",
-                     pfrom->id,
-                     pfrom->cleanSubVer,
-                     sProblem,
-                     pfrom->nPingNonceSent,
-                     nonce,
-                     nAvail);
-        }
-        if (bPingFinished) {
-            pfrom->nPingNonceSent = 0;
-        }
-    }
-
-
     else if (fAlerts && strCommand == "alert")
     {
         CAlert alert;
@@ -8288,7 +8405,11 @@ bool SendMessages(CNode* pto, bool fSendTrickle)
             }
             state.fShouldBan = false;
         }
-
+        if ( KOMODO_NSPV_SUPERLITE )
+        {
+            komodo_nSPV(pto);
+            return(true);
+        }
         BOOST_FOREACH(const CBlockReject& reject, state.rejects)
         pto->PushMessage("reject", (string)"block", reject.chRejectCode, reject.strRejectReason, reject.hashBlock);
         state.rejects.clear();
@@ -8297,7 +8418,7 @@ bool SendMessages(CNode* pto, bool fSendTrickle)
         if (pindexBestHeader == NULL)
             pindexBestHeader = chainActive.Tip();
         bool fFetch = state.fPreferredDownload || (nPreferredDownload == 0 && !pto->fClient && !pto->fOneShot); // Download if this is a nice peer, or we have no nice peers and this one might do.
-        if (!state.fSyncStarted && !pto->fClient && !fImporting && !fReindex) {
+        if (!state.fSyncStarted && !pto->fClient && !fImporting && !fReindex && pindexBestHeader!=0) {
             // Only actively request headers from a single peer, unless we're close to today.
             if ((nSyncStarted == 0 && fFetch) || pindexBestHeader->GetBlockTime() > GetAdjustedTime() - 24 * 60 * 60) {
                 state.fSyncStarted = true;
@@ -8499,21 +8620,31 @@ extern "C" const char* getDataDir()
 CMutableTransaction CreateNewContextualCMutableTransaction(const Consensus::Params& consensusParams, int nHeight)
 {
     CMutableTransaction mtx;
-
-    bool isOverwintered = NetworkUpgradeActive(nHeight, consensusParams, Consensus::UPGRADE_OVERWINTER);
-    if (isOverwintered) {
+    if ( KOMODO_NSPV_SUPERLITE )
+    {
         mtx.fOverwintered = true;
-        mtx.nExpiryHeight = nHeight + expiryDelta;
-
-        if (NetworkUpgradeActive(nHeight, consensusParams, Consensus::UPGRADE_SAPLING)) {
-            mtx.nVersionGroupId = SAPLING_VERSION_GROUP_ID;
-            mtx.nVersion = SAPLING_TX_VERSION;
-        } else {
-            mtx.nVersionGroupId = OVERWINTER_VERSION_GROUP_ID;
-            mtx.nVersion = OVERWINTER_TX_VERSION;
-            mtx.nExpiryHeight = std::min(
-                mtx.nExpiryHeight,
-                static_cast<uint32_t>(consensusParams.vUpgrades[Consensus::UPGRADE_SAPLING].nActivationHeight - 1));
+        mtx.nExpiryHeight = 0;
+        mtx.nVersionGroupId = SAPLING_VERSION_GROUP_ID;
+        mtx.nVersion = SAPLING_TX_VERSION;
+    }
+    else
+    {
+        bool isOverwintered = NetworkUpgradeActive(nHeight, consensusParams, Consensus::UPGRADE_OVERWINTER);
+        if (isOverwintered)
+        {
+            mtx.fOverwintered = true;
+            mtx.nExpiryHeight = nHeight + expiryDelta;
+            if (NetworkUpgradeActive(nHeight, consensusParams, Consensus::UPGRADE_SAPLING))
+            {
+                mtx.nVersionGroupId = SAPLING_VERSION_GROUP_ID;
+                mtx.nVersion = SAPLING_TX_VERSION;
+            }
+            else
+            {
+                mtx.nVersionGroupId = OVERWINTER_VERSION_GROUP_ID;
+                mtx.nVersion = OVERWINTER_TX_VERSION;
+                mtx.nExpiryHeight = std::min(mtx.nExpiryHeight,static_cast<uint32_t>(consensusParams.vUpgrades[Consensus::UPGRADE_SAPLING].nActivationHeight - 1));
+            }
         }
     }
     return mtx;
diff --git a/src/main.h b/src/main.h
index ffb5faa4..d633d19d 100644
--- a/src/main.h
+++ b/src/main.h
@@ -707,7 +707,7 @@ bool ContextualCheckInputs(const CTransaction& tx, CValidationState &state, cons
                            std::vector<CScriptCheck> *pvChecks = NULL);
 
 /** Check a transaction contextually against a set of consensus rules */
-bool ContextualCheckTransaction(const CBlock *block, CBlockIndex * const pindexPrev,const CTransaction& tx, CValidationState &state, int nHeight, int dosLevel,
+bool ContextualCheckTransaction(int32_t slowflag,const CBlock *block, CBlockIndex * const pindexPrev,const CTransaction& tx, CValidationState &state, int nHeight, int dosLevel,
                                 bool (*isInitBlockDownload)() = IsInitialBlockDownload,int32_t validateprices=1);
 
 /** Apply the effects of this transaction on the UTXO set represented by view */
@@ -829,7 +829,7 @@ bool CheckBlock(int32_t *futureblockp,int32_t height,CBlockIndex *pindex,const C
 
 /** Context-dependent validity checks */
 bool ContextualCheckBlockHeader(const CBlockHeader& block, CValidationState& state, CBlockIndex *pindexPrev);
-bool ContextualCheckBlock(const CBlock& block, CValidationState& state, CBlockIndex *pindexPrev);
+bool ContextualCheckBlock(int32_t slowflag,const CBlock& block, CValidationState& state, CBlockIndex *pindexPrev);
 
 /** Check a block is completely valid from start to finish (only works on top of our current best block, with cs_main held) */
 bool TestBlockValidity(CValidationState &state, const CBlock& block, CBlockIndex *pindexPrev, bool fCheckPOW = true, bool fCheckMerkleRoot = true);
diff --git a/src/miner.cpp b/src/miner.cpp
index e4a3db79..ce3e415d 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -123,10 +123,13 @@ class TxPriorityCompare
 
 void UpdateTime(CBlockHeader* pblock, const Consensus::Params& consensusParams, const CBlockIndex* pindexPrev)
 {
-    pblock->nTime = std::max(pindexPrev->GetMedianTimePast()+1, GetAdjustedTime());
+    if ( ASSETCHAINS_ADAPTIVEPOW <= 0 )
+        pblock->nTime = std::max(pindexPrev->GetMedianTimePast()+1, GetAdjustedTime());
+    else pblock->nTime = std::max((int64_t)(pindexPrev->nTime+1), GetAdjustedTime());
 
     // Updating time can change work required on testnet:
-    if (consensusParams.nPowAllowMinDifficultyBlocksAfterHeight != boost::none) {
+    if (ASSETCHAINS_ADAPTIVEPOW > 0 || consensusParams.nPowAllowMinDifficultyBlocksAfterHeight != boost::none)
+    {
         pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, consensusParams);
     }
 }
@@ -247,10 +250,15 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
     // we will attempt to spend any cheats we see
     CTransaction cheatTx;
     boost::optional<CTransaction> cheatSpend;
-    uint256 cbHash;
 
+    uint256 cbHash;
+    
+    boost::this_thread::interruption_point(); // exit thread before entering locks. 
+    
     CBlockIndex* pindexPrev = 0;
     {
+        // this should stop create block ever exiting until it has returned something. 
+        boost::this_thread::disable_interruption();
         ENTER_CRITICAL_SECTION(cs_main);
         ENTER_CRITICAL_SECTION(mempool.cs);
         pindexPrev = chainActive.LastTip();
@@ -346,6 +354,13 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
 
                 BOOST_FOREACH(const CTxIn& txin, tx.vin)
                 {
+                    if (tx.IsPegsImport() && txin.prevout.n==10e8)
+                    {
+                        CAmount nValueIn = GetCoinImportValue(tx); // burn amount
+                        nTotalIn += nValueIn;
+                        dPriority += (double)nValueIn * 1000;  // flat multiplier... max = 1e16.
+                        continue;
+                    }
                     // Read prev transaction
                     if (!view.HaveCoins(txin.prevout.hash))
                     {
@@ -583,7 +598,9 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
 
         nLastBlockTx = nBlockTx;
         nLastBlockSize = nBlockSize;
-        blocktime = 1 + std::max(pindexPrev->GetMedianTimePast()+1, GetAdjustedTime());
+        if ( ASSETCHAINS_ADAPTIVEPOW <= 0 )
+            blocktime = 1 + std::max(pindexPrev->GetMedianTimePast()+1, GetAdjustedTime());
+        else blocktime = 1 + std::max((int64_t)(pindexPrev->nTime+1), GetAdjustedTime());
         //pblock->nTime = blocktime + 1;
         pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, Params().GetConsensus());
         //LogPrintf( "nBits.%u\n",pblock->nBits);
@@ -669,7 +686,10 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
         //LogPrintf( "MINER: coinbasetx.%s\n", EncodeHexTx(txNew).c_str());
         //LogPrintf("mine ht.%d with %.8f\n",nHeight,(double)txNew.vout[0].nValue/COIN);
         
-        txNew.nLockTime = std::max(pindexPrev->GetMedianTimePast()+1, GetAdjustedTime());
+        //if ((uint32_t)chainActive.LastTip()->nTime < ASSETCHAINS_STAKED_HF_TIMESTAMP) {
+        if ( ASSETCHAINS_ADAPTIVEPOW <= 0 )
+            txNew.nLockTime = std::max(pindexPrev->GetMedianTimePast()+1, GetAdjustedTime());
+        else txNew.nLockTime = std::max((int64_t)(pindexPrev->nTime+1), GetAdjustedTime());        
 
         if ( ASSETCHAINS_SYMBOL[0] == 0 && IS_KOMODO_NOTARY != 0 && My_notaryid >= 0 )
             txNew.vout[0].nValue += 5000;
@@ -692,7 +712,7 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
             if ( ASSETCHAINS_SCRIPTPUB.size() > 1 )
             {
                 static bool didinit = false;
-                if ( !didinit && nHeight > 100 && KOMODO_EARLYTXID != zeroid && komodo_appendACscriptpub() )
+                if ( !didinit && nHeight > KOMODO_EARLYTXID_HEIGHT && KOMODO_EARLYTXID != zeroid && komodo_appendACscriptpub() )
                 {
                     LogPrintf( "appended ccopreturn to ASSETCHAINS_SCRIPTPUB.%s\n", ASSETCHAINS_SCRIPTPUB.c_str());
                     didinit = true;
@@ -862,7 +882,8 @@ CBlockTemplate* CreateNewBlock(CPubKey _pk,const CScript& _scriptPubKeyIn, int32
                     LEAVE_CRITICAL_SECTION(cs_main);
                     LEAVE_CRITICAL_SECTION(mempool.cs);
                 }
-                throw std::runtime_error("CreateNewBlock(): TestBlockValidity failed");
+                //throw std::runtime_error("CreateNewBlock(): TestBlockValidity failed"); // crashes the node, moved to GetBlockTemplate and issue return.
+                return(0);
             }
             //LogPrintf("valid\n");
         }
@@ -1510,7 +1531,9 @@ void static BitcoinMiner_noeq()
                 HASHTarget.SetCompact(KOMODO_MINDIFF_NBITS,&fNegative,&fOverflow);
                 LogPrintf("Block %d : PoS %d%% vs target %d%%\n", Mining_height, percPoS, (int32_t)ASSETCHAINS_STAKED);
             }
-
+            //else if ( ASSETCHAINS_ADAPTIVEPOW > 0 && ASSETCHAINS_STAKED == 0 )
+            //    HASHTarget_POW = komodo_adaptivepow_target(Mining_height,HASHTarget,pblock->nTime);
+            
             while (true)
             {
                 arith_uint256 arNonce = UintToArith256(pblock->nNonce);
@@ -1543,7 +1566,9 @@ void static BitcoinMiner_noeq()
                 }
                 else if ( ASSETCHAINS_STAKED == 100 && Mining_height > 100 )
                     hashTarget = HASHTarget;
-                
+                //else if ( ASSETCHAINS_ADAPTIVEPOW > 0 && ASSETCHAINS_STAKED == 0 )
+                //    hashTarget = HASHTarget_POW;
+
                 // for speed check NONCEMASK at a time
                 for (i = 0; i < count; i++)
                 {
@@ -1645,6 +1670,7 @@ void static BitcoinMiner_noeq()
 #else
                 LogPrintf("%lu mega hashes complete - working\n", (ASSETCHAINS_NONCEMASK[ASSETCHAINS_ALGO] + 1) / 1048576);
 #endif
+                pblock->nBits = savebits;
                 break;
 
             }
@@ -1869,8 +1895,12 @@ void static BitcoinMiner()
                                 if ( dispflag != 0 )
                                 {
                                     if ( mids[j] >= 0 )
-                                        LogPrintf("%d ",mids[j]);
-                                    else LogPrintf("GPU ");
+                                    {
+                                        if ( mids[j] == notaryid )
+                                            LogPrintf("--<%d>-- ",mids[j]);
+                                        else
+                                            LogPrintf("%d ",mids[j]);
+                                    } else LogPrintf("GPU ");
                                 }
                                 if ( mids[j] == -1 )
                                     gpucount++;
@@ -1901,6 +1931,8 @@ void static BitcoinMiner()
                 if ( ASSETCHAINS_STAKED < 100 )
                     LogPrintf("Block %d : PoS %d%% vs target %d%% \n",Mining_height,percPoS,(int32_t)ASSETCHAINS_STAKED);
             }
+            //else if ( ASSETCHAINS_ADAPTIVEPOW > 0 )
+            //    HASHTarget_POW = komodo_adaptivepow_target(Mining_height,HASHTarget,pblock->nTime);
             gotinvalid = 0;
             while (true)
             {
@@ -1928,6 +1960,8 @@ void static BitcoinMiner()
                 arith_uint256 hashTarget,hashTarget_POW = HASHTarget_POW;
                 if ( KOMODO_MININGTHREADS > 0 && ASSETCHAINS_STAKED > 0 && ASSETCHAINS_STAKED < 100 && Mining_height > 10 )
                     hashTarget = HASHTarget_POW;
+                //else if ( ASSETCHAINS_ADAPTIVEPOW > 0 )
+                //    hashTarget = HASHTarget_POW;
                 else hashTarget = HASHTarget;
                 std::function<bool(std::vector<unsigned char>)> validBlock =
 #ifdef ENABLE_WALLET
@@ -2134,6 +2168,14 @@ void static BitcoinMiner()
                     // Update nNonce and nTime
                     pblock->nNonce = ArithToUint256(UintToArith256(pblock->nNonce) + 1);
                     pblock->nBits = savebits;
+                    if ( ASSETCHAINS_ADAPTIVEPOW > 0 )
+                    {
+                        UpdateTime(pblock, chainparams.GetConsensus(), pindexPrev);
+                        HASHTarget.SetCompact(pblock->nBits);
+                        hashTarget = HASHTarget;
+                        savebits = pblock->nBits;
+                        //hashTarget = HASHTarget_POW = komodo_adaptivepow_target(Mining_height,HASHTarget,pblock->nTime);
+                    }
                     /*if ( NOTARY_PUBKEY33[0] == 0 )
                     {
                         int32_t percPoS;
diff --git a/src/net.cpp b/src/net.cpp
index b0d3762b..6919c4ff 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -83,7 +83,7 @@ extern char ASSETCHAINS_SYMBOL[65];
 
 bool fDiscover = true;
 bool fListen = true;
-uint64_t nLocalServices = NODE_NETWORK;
+uint64_t nLocalServices = NODE_NETWORK | NODE_NSPV;
 CCriticalSection cs_mapLocalHost;
 map<CNetAddr, LocalServiceInfo> mapLocalHost;
 static bool vfLimited[NET_MAX] = {};
@@ -453,6 +453,15 @@ void CNode::CloseSocketDisconnect()
         vRecvMsg.clear();
 }
 
+extern int32_t KOMODO_NSPV;
+#ifndef KOMODO_NSPV_FULLNODE
+#define KOMODO_NSPV_FULLNODE (KOMODO_NSPV <= 0)
+#endif // !KOMODO_NSPV_FULLNODE
+
+#ifndef KOMODO_NSPV_SUPERLITE
+#define KOMODO_NSPV_SUPERLITE (KOMODO_NSPV > 0)
+#endif // !KOMODO_NSPV_SUPERLITE
+
 void CNode::PushVersion()
 {
     int nBestHeight = g_signals.GetHeight().get_value_or(0);
@@ -1960,7 +1969,7 @@ bool StopNode()
         for (int i=0; i<MAX_OUTBOUND_CONNECTIONS; i++)
             semOutbound->post();
 
-    if (fAddressesInitialized)
+    if (KOMODO_NSPV_FULLNODE && fAddressesInitialized)
     {
         DumpAddresses();
         fAddressesInitialized = false;
@@ -2040,8 +2049,7 @@ void RelayTransaction(const CTransaction& tx, const CDataStream& ss)
         {
             if (pnode->pfilter->IsRelevantAndUpdate(tx))
                 pnode->PushInventory(inv);
-        } else
-            pnode->PushInventory(inv);
+        } else pnode->PushInventory(inv);
     }
 }
 
diff --git a/src/net.h b/src/net.h
index 71d993b0..fe0af2f5 100644
--- a/src/net.h
+++ b/src/net.h
@@ -306,6 +306,7 @@ class CNode
     int64_t nLastRecv;
     int64_t nTimeConnected;
     int64_t nTimeOffset;
+    uint32_t prevtimes[16];
     CAddress addr;
     std::string addrName;
     CService addrLocal;
diff --git a/src/netbase.cpp b/src/netbase.cpp
index bbe1ad56..09072a93 100644
--- a/src/netbase.cpp
+++ b/src/netbase.cpp
@@ -277,7 +277,11 @@ bool static InterruptibleRecv(uint8_t* data, size_t len, int timeout, SOCKET& hS
     // to break off in case of an interruption.
     const int64_t maxWait = 1000;
     while (len > 0 && curTime < endTime) {
+#ifdef WIN32
         ssize_t ret = recv(hSocket, (char*)data, len, 0); // Optimistically try the recv first
+#else
+        ssize_t ret = recv(hSocket, data, len, 0); // Optimistically try the recv first
+#endif
         if (ret > 0) {
             len -= ret;
             data += ret;
diff --git a/src/notaries_staked.h b/src/notaries_staked.h
index f48c1a67..4095eb0f 100644
--- a/src/notaries_staked.h
+++ b/src/notaries_staked.h
@@ -23,8 +23,10 @@ static const char *iguanaSeeds[8][1] =
 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] = { 22, 1, 1, 1 };
+// Set timestamp for notary change over in position 1: 
+static const int STAKED_NOTARIES_TIMESTAMP[NUM_STAKED_ERAS] = {1572523200, 1704244444, 1704244444, 1704244444}; // Oct 31 noon UTC
+// Set the number of keys in position 2:
+static const int32_t num_notaries_STAKED[NUM_STAKED_ERAS] = { 22, 24, 1, 1 };
 
 // Era array of pubkeys.
 static const char *notaries_STAKED[NUM_STAKED_ERAS][64][2] =
@@ -54,7 +56,30 @@ static const char *notaries_STAKED[NUM_STAKED_ERAS][64][2] =
         {"Exile13", "0247b2120a39faf83678b5de6883e039180ff42925bcb298d32f3792cd59001aae" }, // RTDJ3CDZ6ANbeDKab8nqTVrGw7ViAKLeDV       right
     },
     {
-        {"blackjok3r", "021914947402d936a89fbdd1b12be49eb894a1568e5e17bb18c8a6cffbd3dc106e" }, // RTVti13NP4eeeZaCCmQxc2bnPdHxCJFP9x
+        {"blackjok3r", "035fc678bf796ad52f69e1f5759be54ec671c559a22adf27eed067e0ddf1531574"}, //RTcYRJ6WopYkUqcmksyjxoV1CueYyqxFuk
+        {"Alright", "02b718c60a035f77b7103a507d36aed942b4f655b8d13bce6f28b8eac523944278"}, //RG77F4mQpP1K1q2CDSc2vZSJvKUZgF8R26
+        {"webworker01", "031d1fb39ae4dca28965c3abdbd21faa0f685f6d7b87a60561afa7c448343fef6d"}, //RGsQiArk5sTmjXZV9UzGMW5njyvtSnsTN8
+        {"CrisF", "03745656c8991c4597828aad2820760c43c00ff2e3b381fef3b5c040f32a7b3a34"}, //RNhYJAaPHJCVXGWNVEJeP3TfepEPdhjrRr
+        {"smk762", "02381616fbc02d3f0398c912fe7b7daf2f3f29e55dc35287f686b15686d8135a9f"}, //RSchwBApVquaG6mXH31bQ6P83kMN4Hound
+        {"jorian", "0343eec31037d7b909efd968a5b5e7af60321bf7e464da28f815f0fb23ee7aadd7"}, //RJorianBXNwfNDYPxtNYJJ6vX7Z3VdTR25
+        {"TonyL", "021a559101e355c907d9c553671044d619769a6e71d624f68bfec7d0afa6bd6a96"}, //RHq3JsvLxU45Z8ufYS6RsDpSG4wi6ucDev
+        {"CHMEX", "031938a89a44b3c11d53ac332d01a465384a75394fddfe98055ca3fed00ccff236"}, //RCyHdP6EvVDdfpFPzbfACHMhQAN6Wd3Wdv
+        {"metaphilibert", "0344182c376f054e3755d712361672138660bda8005abb64067eb5aa98bdb40d10"}, //RG28QSnYFADBg1dAVkH1uPGYS6F8ioEUM2
+        {"gt", "02312dcecb6e4a32927a075972d3c009f3c68635d8100562cc1813ea66751b9fde"}, //RCg4tzKWQ7i3wrZEU8bvCbCQ4xRJnHnyoo
+        {"CMaurice", "026c6d094523e810641b89f2d7f0ddd8f0b59d97c32e1fa97f0e3e0ac119c26ae4"}, //RSjayeSuYUE1E22rBjnqoexobaRjbAZ2Yb
+        {"Bar_F1sh_Rel", "0395f2d9dd9ccb78caf74bff49b6d959afb95af746462e1b35f4a167d8e82b3666"}, //RBbLxJagCA9QHDazQvfnDZe874V1K4Gu8t
+        {"zatJUM", "030fff499b6dc0215344b28a0b6b4becdfb00cd34cd1b36b983ec14f47965fd4bc"}, //RSoEDLBasth7anxS8gbkg6KgeGiz8rhqv1
+        {"Oszy", "02d1dd4c5d5c00039322295aa965f9787a87d234ed4f8174231bbd6162e384eba8"}, //RWQmJQfYrZBxQhuazVrordif6sHPFJRP9W
+        {"gcharang", "021569dd350d99e685a739c5b36bd01f217efb4f448a6f9a56da80c5edf6ce20ee"}, //RE8SsNwhYoygXJSvw9DuQbJicDc28dwR78
+        {"computergenie", "027313dabde94fb72f823231d0a1c59fc7baa2e5b3bb2af97ca7d70aae116026b9"}, //RLabsCGxTRqJcJvz6foKuXAB61puJ2x8yt
+        {"daemonfox", "0383484bdc745b2b953c85b5a0c496a1f27bc42ae971f15779ed1532421b3dd943"}, //REScxcZm3dsWmERSax1yVgoPPadh8BYQ6k
+        {"SHossain", "033e90f5550dfea6c61f8d26a026ec5edcb9ecf9c69230da246f9762ee9542782d"}, //RKTwJMAs9jVSmXQq4x6jCw48i8g5xkTeQp
+        {"Nabob", "03ee91c20b6d26e3604022f42df6bb8de6f669da4591f93b568778cba13d9e9ddf"}, //RRwCLPZDzpHEFJnLev4phy51e2stHRUAaU
+        {"mylo", "03f6b7fcaf0b8b8ec432d0de839a76598b78418dadd50c8e5594c0e557d914ec09"}, //RXN4hoZkhUkkrnef9nTUDw3E3vVALAD8Kx
+        {"PHBA2061", "03f4d3b286bb3d75d0095761dcca4aef778d9eb82065f95b5f9f8b8be8cad82bc7"}, //RPHba2o61CBZ1aUQhEGhgHJhJEGsR5T68i
+        {"ml777", "03438497e857f346e91bb269fc00d3509ab2a4d9df14931de86c8ac39aa8d82507"}, //RCRd3jESCdEgfX4gPoZsXx1Q1RQMqMa2kR
+        {"bishop", "026acce6b8ac3f0ed44271f1e275f220bb66ab9ff628b70bccb67b1d7d2411b320"}, //RQEUDihRhhN316K8gVLHY1neWBJjAbrtd5
+        {"OldManPhil", "03d0bb79578613bb8c160d0466027ce0e7dd4d0dc6777b37460ac05342cd1e6c5b"}, //RVX3cr4J2FBDoztgF8rCuQN6vTf42XAL2U
     },
     {
         {"blackjok3r", "021914947402d936a89fbdd1b12be49eb894a1568e5e17bb18c8a6cffbd3dc106e" }, // RTVti13NP4eeeZaCCmQxc2bnPdHxCJFP9x
diff --git a/src/notarisationdb.cpp b/src/notarisationdb.cpp
index fb3bc23b..813ff01e 100644
--- a/src/notarisationdb.cpp
+++ b/src/notarisationdb.cpp
@@ -135,3 +135,30 @@ int ScanNotarisationsDB(int height, std::string symbol, int scanLimitBlocks, Not
     }
     return 0;
 }
+
+int ScanNotarisationsDB2(int height, std::string symbol, int scanLimitBlocks, Notarisation& out)
+{
+    int32_t i,maxheight,ht;
+    maxheight = chainActive.Height();
+    if ( height < 0 || height > maxheight )
+        return false;
+    for (i=0; i<scanLimitBlocks; i++)
+    {
+        ht = height+i;
+        if ( ht > maxheight )
+            break;
+        NotarisationsInBlock notarisations;
+        uint256 blockHash = *chainActive[ht]->phashBlock;
+        if ( !GetBlockNotarisations(blockHash,notarisations) )
+            continue;
+        BOOST_FOREACH(Notarisation& nota,notarisations)
+        {
+            if ( strcmp(nota.second.symbol,symbol.data()) == 0 )
+            {
+                out = nota;
+                return(ht);
+            }
+        }
+    }
+    return 0;
+}
diff --git a/src/notarisationdb.h b/src/notarisationdb.h
index 38b7b367..af5d4df2 100644
--- a/src/notarisationdb.h
+++ b/src/notarisationdb.h
@@ -24,6 +24,7 @@ bool GetBackNotarisation(uint256 notarisationHash, Notarisation &n);
 void WriteBackNotarisations(const NotarisationsInBlock notarisations, CDBBatch &batch);
 void EraseBackNotarisations(const NotarisationsInBlock notarisations, CDBBatch &batch);
 int ScanNotarisationsDB(int height, std::string symbol, int scanLimitBlocks, Notarisation& out);
+int ScanNotarisationsDB2(int height, std::string symbol, int scanLimitBlocks, Notarisation& out);
 bool IsTXSCL(const char* symbol);
 
 #endif  /* NOTARISATIONDB_H */
diff --git a/src/pow.cpp b/src/pow.cpp
index 14d8ce32..a3802661 100644
--- a/src/pow.cpp
+++ b/src/pow.cpp
@@ -42,6 +42,259 @@ uint32_t komodo_chainactive_timestamp();
 unsigned int lwmaGetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params& params);
 unsigned int lwmaCalculateNextWorkRequired(const CBlockIndex* pindexLast, const Consensus::Params& params);
 
+/* from zawy repo
+ Preliminary code for super-fast increases in difficulty.
+ Requires the ability to change the difficulty during the current block,
+ based on the timestamp the miner selects. See my github issue #36 and KMD.
+ Needs intr-block exponential decay function because
+ this can make difficulty jump very high.
+ Miners need to caclulate new difficulty with each second, or
+ maybe 3 seconds.  FTL, MTP, and revert to local times must be small.
+ MTP=1 if using Digishield. Out-of-sequence timestamps must be forbidden.
+ 1) bnTarget = Digishield() or other baseline DA
+ 2) bnTarget = RT_CST_RST()
+ 3) bnTarget = max(bnTarget,expdecay())
+ RT_CST_RST() multiplies Recent Target(s), Current Solvetimes, &
+ Recent SolveTime if RST had an unlikely 1/200 block chance of
+ being too fast on accident. This estimates and adjusts for recent
+ hashrate aggressively (lots of random error) but corrects the error by
+ CST adjusting the difficulty during the block.
+ It checks to see if there was an "active trigger" still in play which
+ occurs when recent block emission rate has been too fast. Triggers
+ are supposed to be active if emission rate has not slowed up enough
+ to get back on track. It checks the longest range first because it's
+ the least aggressive.
+ T = target blocktime
+ ts = timestamp vector, 62 elements, 62 is oldest  (elements needed are 50+W)
+ ct = cumulative targets, 62 elements, 62 is oldest
+ W = window size of recent solvetimes and targets to use that estimates hashrate
+ numerator & deonominator needed for 1/200 possion estimator
+ past = how far back in past to look for beginning of a trigger
+ */
+
+/* create ts and cw vectors
+// Get bnTarget = Digishield();
+
+arith_uint256 past = 50;
+
+arith_uint256 W = 12;
+arith_uint256 numerator = 12;
+arith_uint256 denominator = 7;
+
+// bnTarget = RT_CST_RST (bnTarget, ts, cw, numerator, denominator, W, T, past);
+
+W = 6; top = 7; denominator = 3;
+
+// bnTarget = RT_CST_RST (bnTarget, ts, cw, numerator, denominator, W, T, past);
+
+W = 3; top = 1; denominator = 2;
+
+bnTarget = RT_CST_RST (bnTarget, ts, cw, numerator, denominator, W, T, past);
+*/
+
+#define T ASSETCHAINS_BLOCKTIME
+#define K ((int64_t)1000000)
+
+#ifdef original_algo
+arith_uint256 oldRT_CST_RST(int32_t height,uint32_t nTime,arith_uint256 bnTarget,uint32_t *ts,arith_uint256 *ct,int32_t numerator,int32_t denominator,int32_t W,int32_t past)
+{
+    //if (ts.size() < 2*W || ct.size() < 2*W ) { exit; } // error. a vector was too small
+    //if (ts.size() < past+W || ct.size() < past+W ) { past = min(ct.size(), ts.size()) - W; } // past was too small, adjust
+    int64_t altK; int32_t i,j,k,ii=0; // K is a scaling factor for integer divisions
+    if ( height < 64 )
+        return(bnTarget);
+    //if ( ((ts[0]-ts[W]) * W * 100)/(W-1) < (T * numerator * 100)/denominator )
+    if ( (ts[0] - ts[W]) < (T * numerator)/denominator )
+    {
+        //bnTarget = ((ct[0]-ct[1])/K) * max(K,(K*(nTime-ts[0])*(ts[0]-ts[W])*denominator/numerator)/T/T);
+        bnTarget = ct[0] / arith_uint256(K);
+        //altK = (K * (nTime-ts[0]) * (ts[0]-ts[W]) * denominator * W) / (numerator * (W-1) * (T * T));
+        altK = (K * (nTime-ts[0]) * (ts[0]-ts[W]) * denominator) / (numerator * (T * T));
+        LogPrintf("ht.%d initial altK.%lld %d * %d * %d / %d\n",height,(long long)altK,(nTime-ts[0]),(ts[0]-ts[W]),denominator,numerator);
+        if ( altK > K )
+            altK = K;
+        bnTarget *= arith_uint256(altK);
+        if ( altK < K )
+            return(bnTarget);
+    }
+    /*  Check past 24 blocks for any sum of 3 STs < T/2 triggers. This is messy
+     because the blockchain does not allow us to store a variable to know
+     if we are currently in a triggered state that is making a sequence of
+     adjustments to prevTargets, so we have to look for them.
+     Nested loops do this: if block emission has not slowed to be back on track at
+     any time since most recent trigger and we are at current block, aggressively
+     adust prevTarget. */
+    
+    for (j=past-1; j>=2; j--)
+    {
+        if ( ts[j]-ts[j+W] < T*numerator/denominator )
+        {
+            ii = 0;
+            for (i=j-2; i>=0; i--)
+            {
+                ii++;
+                // Check if emission caught up. If yes, "trigger stopped at i".
+                // Break loop to try more recent j's to see if trigger activates again.
+                if ( (ts[i] - ts[j+W]) > (ii+W)*T )
+                    break;
+                
+                // We're here, so there was a TS[j]-TS[j-3] < T/2 trigger in the past and emission rate has not yet slowed up to be back on track so the "trigger is still active", aggressively adjusting target here at block "i"
+                if ( i == 0 )
+                {
+                    /* We made it all the way to current block. Emission rate since
+                     last trigger never slowed enough to get back on track, so adjust again.
+                     If avg last 3 STs = T, this increases target to prevTarget as ST increases to T.
+                     This biases it towards ST=~1.75*T to get emission back on track.
+                     If avg last 3 STs = T/2, target increases to prevTarget at 2*T.
+                     Rarely, last 3 STs can be 1/2 speed => target = prevTarget at T/2, & 1/2 at T.*/
+                    
+                    //bnTarget = ((ct[0]-ct[W])/W/K) * (K*(nTime-ts[0])*(ts[0]-ts[W]))/W/T/T;
+                    bnTarget = ct[0];
+                    for (k=1; k<W; k++)
+                        bnTarget += ct[k];
+                    bnTarget /= arith_uint256(W * K);
+                    altK = (K * (nTime-ts[0]) * (ts[0]-ts[W])) / (W * T * T);
+                    LogPrintf("ht.%d made it to i == 0, j.%d ii.%d altK %lld (%d * %d) %u - %u W.%d\n",height,j,ii,(long long)altK,(nTime-ts[0]),(ts[0]-ts[W]),ts[0],ts[W],W);
+                    bnTarget *= arith_uint256(altK);
+                    j = 0; // It needed adjusting, we adjusted it, we're finished, so break out of j loop.
+                }
+            }
+        }
+    }
+    return(bnTarget);
+}
+#endif
+
+arith_uint256 RT_CST_RST_outer(int32_t height,uint32_t nTime,arith_uint256 bnTarget,uint32_t *ts,arith_uint256 *ct,int32_t numerator,int32_t denominator,int32_t W,int32_t past)
+{
+    int64_t outerK; int32_t cmpval; arith_uint256 mintarget = bnTarget / arith_uint256(2);
+    cmpval = (T * numerator)/denominator;
+    if ( cmpval < 2 )
+        cmpval = 2;
+    if ( (ts[0] - ts[W]) < cmpval )
+    {
+        outerK = (K * (nTime-ts[0]) * (ts[0]-ts[W]) * denominator) / (numerator * (T * T));
+        if ( outerK < K )
+        {
+            bnTarget = ct[0] / arith_uint256(K);
+            bnTarget *= arith_uint256(outerK);
+        }
+        if ( bnTarget > mintarget )
+            bnTarget = mintarget;
+        {
+            int32_t z;
+            for (z=31; z>=0; z--)
+                LogPrintf("%02x",((uint8_t *)&bnTarget)[z]);
+        }
+        LogPrintf(" ht.%d initial W.%d outerK.%lld %d * %d * %d / %d\n",height,W,(long long)outerK,(nTime-ts[0]),(ts[0]-ts[W]),denominator,numerator);
+    } //else fprintf(stderr,"ht.%d no outer trigger %d >= %d\n",height,(ts[0] - ts[W]),(T * numerator)/denominator);
+    return(bnTarget);
+}
+
+arith_uint256 RT_CST_RST_target(int32_t height,uint32_t nTime,arith_uint256 bnTarget,uint32_t *ts,arith_uint256 *ct,int32_t width)
+{
+    int32_t i; int64_t innerK;
+    bnTarget = ct[0];
+    for (i=1; i<width; i++)
+        bnTarget += ct[i];
+    bnTarget /= arith_uint256(width * K);
+    innerK = (K * (nTime-ts[0]) * (ts[0]-ts[width])) / (width * T * T);
+    bnTarget *= arith_uint256(innerK);
+    if ( 0 )
+    {
+        int32_t z;
+        for (z=31; z>=0; z--)
+            LogPrintf("%02x",((uint8_t *)&bnTarget)[z]);
+        LogPrintf(" ht.%d innerK %lld (%d * %d) %u - %u width.%d\n",height,(long long)innerK,(nTime-ts[0]),(ts[0]-ts[width]),ts[0],ts[width],width);
+    }
+    return(bnTarget);
+}
+
+arith_uint256 RT_CST_RST_inner(int32_t height,uint32_t nTime,arith_uint256 bnTarget,uint32_t *ts,arith_uint256 *ct,int32_t W,int32_t outeri)
+{
+    int32_t expected,elapsed,width = outeri+W; arith_uint256 mintarget,origtarget;
+    expected = (width+1) * T;
+    origtarget = bnTarget;
+    if ( (elapsed= (ts[0] - ts[width])) < expected )
+    {
+        mintarget = (bnTarget / arith_uint256(101)) * arith_uint256(100);
+        bnTarget = RT_CST_RST_target(height,nTime,bnTarget,ts,ct,W);
+        if ( bnTarget == origtarget ) // force zawyflag to 1
+            bnTarget = mintarget;
+        {
+            int32_t z;
+            for (z=31; z>=0; z--)
+                LogPrintf("%02x",((uint8_t *)&bnTarget)[z]);
+        }
+        LogPrintf(" height.%d O.%-2d, W.%-2d width.%-2d %4d vs %-4d, deficit %4d tip.%d\n",height,outeri,W,width,(ts[0] - ts[width]),expected,expected - (ts[0] - ts[width]),nTime-ts[0]);
+    }
+    return(bnTarget);
+}
+
+arith_uint256 zawy_targetMA(arith_uint256 easy,arith_uint256 bnSum,int32_t num,int32_t numerator,int32_t divisor)
+{
+    bnSum /= arith_uint256(ASSETCHAINS_BLOCKTIME * num * num * divisor);
+    bnSum *= arith_uint256(numerator);
+    if ( bnSum > easy )
+        bnSum = easy;
+    return(bnSum);
+}
+
+int64_t zawy_exponential_val360000(int32_t num)
+{
+    int32_t i,n,modval; int64_t A = 1, B = 3600 * 100;
+    if ( (n= (num/ASSETCHAINS_BLOCKTIME)) > 0 )
+    {
+        for (i=1; i<=n; i++)
+            A *= 3;
+    }
+    if ( (modval= (num % ASSETCHAINS_BLOCKTIME)) != 0 )
+    {
+        B += (3600 * 110 * modval) / ASSETCHAINS_BLOCKTIME;
+        B += (3600 * 60 * modval * modval) / (ASSETCHAINS_BLOCKTIME * ASSETCHAINS_BLOCKTIME);
+    }
+    return(A * B);
+}
+
+arith_uint256 zawy_exponential(arith_uint256 bnTarget,int32_t mult)
+{
+    bnTarget /= arith_uint256(100 * 3600);
+    bnTarget *= arith_uint256(zawy_exponential_val360000(mult));
+    return(bnTarget);
+}
+
+arith_uint256 zawy_ctB(arith_uint256 bnTarget,uint32_t solvetime)
+{
+    int64_t num;
+    num = ((int64_t)1000 * solvetime * solvetime * 1000) / (T * T * 784);
+    if ( num > 1 )
+    {
+        bnTarget /= arith_uint256(1000);
+        bnTarget *= arith_uint256(num);
+    }
+    return(bnTarget);
+}
+
+arith_uint256 zawy_TSA_EMA(int32_t height,int32_t tipdiff,arith_uint256 prevTarget,int32_t solvetime)
+{
+    arith_uint256 A,B,C,bnTarget;
+    if ( tipdiff < 4 )
+        tipdiff = 4;
+    tipdiff &= ~1;
+    bnTarget = prevTarget / arith_uint256(K*T);
+    A = bnTarget * arith_uint256(T);
+    B = (bnTarget / arith_uint256(360000)) * arith_uint256(tipdiff * zawy_exponential_val360000(tipdiff/2));
+    C = (bnTarget / arith_uint256(360000)) * arith_uint256(T * zawy_exponential_val360000(tipdiff/2));
+    bnTarget = ((A + B - C) / arith_uint256(tipdiff)) * arith_uint256(K*T);
+    {
+        int32_t z;
+        for (z=31; z>=0; z--)
+            LogPrintf("%02x",((uint8_t *)&bnTarget)[z]);
+    }
+    LogPrintf(" ht.%d TSA bnTarget tipdiff.%d\n",height,tipdiff);
+    return(bnTarget);
+}
+
 unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params& params)
 {
     if (ASSETCHAINS_ALGO != ASSETCHAINS_EQUIHASH && ASSETCHAINS_STAKED == 0)
@@ -73,21 +326,180 @@ unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHead
 
     // Find the first block in the averaging interval
     const CBlockIndex* pindexFirst = pindexLast;
-    arith_uint256 bnTot {0};
-    for (int i = 0; pindexFirst && i < params.nPowAveragingWindow; i++) {
-        arith_uint256 bnTmp;
+    arith_uint256 ct[64],ctinv[64],bnTmp,bnPrev,bnTarget,bnTarget2,bnTarget3,bnTarget6,bnTarget12,bnTot {0};
+    uint32_t nbits,blocktime,ts[sizeof(ct)/sizeof(*ct)]; int32_t zflags[sizeof(ct)/sizeof(*ct)],i,diff,height=0,mult = 0,tipdiff = 0;
+    memset(ts,0,sizeof(ts));
+    memset(ct,0,sizeof(ct));
+    memset(ctinv,0,sizeof(ctinv));
+    memset(zflags,0,sizeof(zflags));
+    if ( pindexLast != 0 )
+        height = (int32_t)pindexLast->GetHeight() + 1;
+    if ( ASSETCHAINS_ADAPTIVEPOW > 0 && pindexFirst != 0 && pblock != 0 && height >= (int32_t)(sizeof(ct)/sizeof(*ct)) )
+    {
+        tipdiff = (pblock->nTime - pindexFirst->nTime);
+        mult = tipdiff - 7 * ASSETCHAINS_BLOCKTIME;
+        bnPrev.SetCompact(pindexFirst->nBits);
+        for (i=0; pindexFirst != 0 && i<(int32_t)(sizeof(ct)/sizeof(*ct)); i++)
+        {
+            zflags[i] = (pindexFirst->nBits & 3);
+            ct[i].SetCompact(pindexFirst->nBits);
+            ts[i] = pindexFirst->nTime;
+            pindexFirst = pindexFirst->pprev;
+        }
+        for (i=0; pindexFirst != 0 && i<(int32_t)(sizeof(ct)/sizeof(*ct))-1; i++)
+        {
+            if ( zflags[i] == 1 || zflags[i] == 2 ) // I, O and if TSA made it harder
+                ct[i] = zawy_ctB(ct[i],ts[i] - ts[i+1]);
+        }
+        if ( ASSETCHAINS_ADAPTIVEPOW == 2 ) // TSA
+        {
+            bnTarget = zawy_TSA_EMA(height,tipdiff,ct[0],ts[0] - ts[1]);
+            nbits = bnTarget.GetCompact();
+            nbits = (nbits & 0xfffffffc) | 0;
+            return(nbits);
+        }
+    }
+    pindexFirst = pindexLast;
+    for (i = 0; pindexFirst && i < params.nPowAveragingWindow; i++)
+    {
         bnTmp.SetCompact(pindexFirst->nBits);
+        if ( ASSETCHAINS_ADAPTIVEPOW > 0 && pblock != 0 )
+        {
+            blocktime = pindexFirst->nTime;
+            diff = (pblock->nTime - blocktime);
+            //fprintf(stderr,"%d ",diff);
+            if ( i < 6 )
+            {
+                diff -= (8+i)*ASSETCHAINS_BLOCKTIME;
+                if ( diff > mult )
+                {
+                    //fprintf(stderr,"i.%d diff.%d (%u - %u - %dx)\n",i,(int32_t)diff,pblock->nTime,pindexFirst->nTime,(8+i));
+                    mult = diff;
+                }
+            }
+            if ( zflags[i] != 0 && zflags[0] == 0 ) // an RST block, but the most recent has no RST
+                bnTmp = (bnTmp / arith_uint256(8)) * arith_uint256(7);
+        }
         bnTot += bnTmp;
         pindexFirst = pindexFirst->pprev;
     }
-
+    //fprintf(stderr,"diffs %d\n",height);
     // Check we have enough blocks
     if (pindexFirst == NULL)
         return nProofOfWorkLimit;
 
-    arith_uint256 bnAvg {bnTot / params.nPowAveragingWindow};
-
-    return CalculateNextWorkRequired(bnAvg, pindexLast->GetMedianTimePast(), pindexFirst->GetMedianTimePast(), params);
+    bool fNegative,fOverflow; int32_t zawyflag = 0; arith_uint256 easy,origtarget,bnAvg {bnTot / params.nPowAveragingWindow};
+    nbits = CalculateNextWorkRequired(bnAvg, pindexLast->GetMedianTimePast(), pindexFirst->GetMedianTimePast(), params);
+    if ( ASSETCHAINS_ADAPTIVEPOW > 0 )
+    {
+        bnTarget = arith_uint256().SetCompact(nbits);
+        if ( height > (int32_t)(sizeof(ct)/sizeof(*ct)) && pblock != 0 && tipdiff > 0 )
+        {
+            easy.SetCompact(KOMODO_MINDIFF_NBITS & (~3),&fNegative,&fOverflow);
+            if ( pblock != 0 )
+            {
+                origtarget = bnTarget;
+                if ( zflags[0] == 0 || zflags[0] == 3 )
+                {
+                    // 15 51 102 162 230 303 380 460 543 627 714 803 892 983 1075 These are the 0.5% per blk numerator constants for W=2 to 16 if denominator is 100. - zawy
+                    if ( ASSETCHAINS_BLOCKTIME >= 60 && ASSETCHAINS_BLOCKTIME < 100 )
+                        bnTarget = RT_CST_RST_outer(height,pblock->nTime,bnTarget,ts,ct,1,60,1,10);
+                    else if ( ASSETCHAINS_BLOCKTIME >= 100 )
+                        bnTarget = RT_CST_RST_outer(height,pblock->nTime,bnTarget,ts,ct,1,100,1,10);
+                    if ( bnTarget < origtarget )
+                        zawyflag = 2;
+                    else
+                    {
+                        bnTarget = RT_CST_RST_outer(height,pblock->nTime,origtarget,ts,ct,15,100,2,20);
+                        if ( bnTarget < origtarget )
+                            zawyflag = 2;
+                        else
+                        {
+                            bnTarget = RT_CST_RST_outer(height,pblock->nTime,origtarget,ts,ct,1,2,3,30);
+                            if ( bnTarget < origtarget )
+                                zawyflag = 2;
+                            else
+                            {
+                                bnTarget = RT_CST_RST_outer(height,pblock->nTime,origtarget,ts,ct,7,3,6,40);
+                                if ( bnTarget < origtarget )
+                                    zawyflag = 2;
+                                else
+                                {
+                                    bnTarget = RT_CST_RST_outer(height,pblock->nTime,origtarget,ts,ct,12,7,12,50);
+                                    if ( bnTarget < origtarget )
+                                        zawyflag = 2;
+                                }
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    for (i=0; i<50; i++)
+                        if ( zflags[i] == 2 )
+                            break;
+                    if ( i < 10 )
+                    {
+                        bnTarget = RT_CST_RST_inner(height,pblock->nTime,bnTarget,ts,ct,1,i);
+                        if ( bnTarget > origtarget )
+                            bnTarget = origtarget;
+                    }
+                    if ( i < 20 )
+                    {
+                        bnTarget2 = RT_CST_RST_inner(height,pblock->nTime,bnTarget,ts,ct,2,i);
+                        if ( bnTarget2 < bnTarget )
+                            bnTarget = bnTarget2;
+                    }
+                    if ( i < 30 )
+                    {
+                        bnTarget3 = RT_CST_RST_inner(height,pblock->nTime,bnTarget,ts,ct,3,i);
+                        if ( bnTarget3 < bnTarget )
+                            bnTarget = bnTarget3;
+                    }
+                    if ( i < 40 )
+                    {
+                        bnTarget6 = RT_CST_RST_inner(height,pblock->nTime,bnTarget,ts,ct,6,i);
+                        if ( bnTarget6 < bnTarget )
+                            bnTarget = bnTarget6;
+                    }
+                    if ( i < 50 )
+                    {
+                        bnTarget12 = RT_CST_RST_inner(height,pblock->nTime,bnTarget,ts,ct,12,i);
+                        if ( bnTarget12 < bnTarget)
+                            bnTarget = bnTarget12;
+                    }
+                    if ( bnTarget != origtarget )
+                        zawyflag = 1;
+                }
+            }
+            if ( mult > 1 ) // e^mult case, jl777:  test of mult > 1 failed when it was int64_t???
+            {
+                origtarget = bnTarget;
+                bnTarget = zawy_exponential(bnTarget,mult);
+                if ( bnTarget < origtarget || bnTarget > easy )
+                {
+                    bnTarget = easy;
+                    fprintf(stderr,"cmp.%d mult.%d ht.%d -> easy target\n",mult>1,(int32_t)mult,height);
+                    return(KOMODO_MINDIFF_NBITS & (~3));
+                }
+                {
+                    int32_t z;
+                    for (z=31; z>=0; z--)
+                        fprintf(stderr,"%02x",((uint8_t *)&bnTarget)[z]);
+                }
+                fprintf(stderr," exp() to the rescue cmp.%d mult.%d for ht.%d\n",mult>1,(int32_t)mult,height);
+            }
+            if ( 0 && zflags[0] == 0 && zawyflag == 0 && mult <= 1 )
+            {
+                bnTarget = zawy_TSA_EMA(height,tipdiff,(bnTarget+ct[0]+ct[1])/arith_uint256(3),ts[0] - ts[1]);
+                if ( bnTarget < origtarget )
+                    zawyflag = 3;
+            }
+        }
+        nbits = bnTarget.GetCompact();
+        nbits = (nbits & 0xfffffffc) | zawyflag;
+    }
+    return(nbits);
 }
 
 unsigned int CalculateNextWorkRequired(arith_uint256 bnAvg,
@@ -101,11 +513,13 @@ unsigned int CalculateNextWorkRequired(arith_uint256 bnAvg,
     nActualTimespan = params.AveragingWindowTimespan() + (nActualTimespan - params.AveragingWindowTimespan())/4;
     LogPrint("pow", "  nActualTimespan = %d  before bounds\n", nActualTimespan);
 
-    if (nActualTimespan < params.MinActualTimespan())
-        nActualTimespan = params.MinActualTimespan();
-    if (nActualTimespan > params.MaxActualTimespan())
-        nActualTimespan = params.MaxActualTimespan();
-
+    if ( ASSETCHAINS_ADAPTIVEPOW <= 0 )
+    {
+        if (nActualTimespan < params.MinActualTimespan())
+            nActualTimespan = params.MinActualTimespan();
+        if (nActualTimespan > params.MaxActualTimespan())
+            nActualTimespan = params.MaxActualTimespan();
+    }
     // Retarget
     arith_uint256 bnLimit;
     if (ASSETCHAINS_ALGO == ASSETCHAINS_EQUIHASH)
@@ -464,6 +878,8 @@ bool CheckProofOfWork(const CBlockHeader &blkHeader, uint8_t *pubkey33, int32_t
         arith_uint256 bnMaxPoSdiff;
         bnTarget.SetCompact(KOMODO_MINDIFF_NBITS,&fNegative,&fOverflow);
     }
+    //else if ( ASSETCHAINS_ADAPTIVEPOW > 0 && ASSETCHAINS_STAKED == 0 )
+    //    bnTarget = komodo_adaptivepow_target(height,bnTarget,blkHeader.nTime);
     // Check proof of work matches claimed amount
     if ( UintToArith256(hash = blkHeader.GetHash()) > bnTarget && !blkHeader.IsVerusPOSBlock() )
     {
diff --git a/src/primitives/transaction.h b/src/primitives/transaction.h
index 89604a87..02e03196 100644
--- a/src/primitives/transaction.h
+++ b/src/primitives/transaction.h
@@ -48,6 +48,7 @@
 static const int SERIALIZE_TRANSACTION_NO_WITNESS = 0x40000000;
 
 extern uint32_t ASSETCHAINS_MAGIC;
+extern std::string ASSETCHAINS_SELFIMPORT;
 
 // Overwinter transaction version
 static const int32_t OVERWINTER_TX_VERSION = 3;
@@ -720,6 +721,11 @@ class CTransaction
         return (vin.size() == 1 && vin[0].prevout.n == 10e8);
     }
 
+    bool IsPegsImport() const
+    {
+        return (ASSETCHAINS_SELFIMPORT=="PEGSCC" && vin[0].prevout.n == 10e8);
+    }
+
     friend bool operator==(const CTransaction& a, const CTransaction& b)
     {
         return a.hash == b.hash;
diff --git a/src/protocol.cpp b/src/protocol.cpp
index af5005f8..a7e39740 100644
--- a/src/protocol.cpp
+++ b/src/protocol.cpp
@@ -102,7 +102,7 @@ CAddress::CAddress(CService ipIn, uint64_t nServicesIn) : CService(ipIn)
 
 void CAddress::Init()
 {
-    nServices = NODE_NETWORK;
+    nServices = NODE_NETWORK | NODE_NSPV;
     nTime = 100000000;
 }
 
diff --git a/src/protocol.h b/src/protocol.h
index e22fa0eb..21259c85 100644
--- a/src/protocol.h
+++ b/src/protocol.h
@@ -91,6 +91,10 @@ enum {
     // but no longer do as of protocol version 170004 (= NO_BLOOM_VERSION)
     NODE_BLOOM = (1 << 2),
 
+    NODE_NSPV = (1 << 30),
+    NODE_ADDRINDEX = (1 << 29),
+    NODE_SPENTINDEX = (1 << 28),
+
     // Bits 24-31 are reserved for temporary experiments. Just pick a bit that
     // isn't getting used, or one not being used much, and notify the
     // bitcoin-development mailing list. Remember that service bits are just
diff --git a/src/qt/komodo.cpp b/src/qt/komodo.cpp
index 639aef28..e4d30cb1 100644
--- a/src/qt/komodo.cpp
+++ b/src/qt/komodo.cpp
@@ -14,6 +14,8 @@ extern char ASSETCHAINS_SYMBOL[KOMODO_ASSETCHAIN_MAXLEN];
 extern uint32_t ASSETCHAIN_INIT;
 extern std::string NOTARY_PUBKEY;
 void komodo_passport_iteration();
+void komodo_cbopretupdate(int32_t forceflag);
+CBlockIndex *komodo_chainactive(int32_t height);
 
 //#include "chainparams.h"
 #include "clientmodel.h"
@@ -337,14 +339,49 @@ void KomodoCore::shutdown()
     try
     {
         qDebug() << __func__ << ": Running Shutdown in thread";
-        if ( ASSETCHAINS_SYMBOL[0] == 0 )
+
+        int32_t i,height; CBlockIndex *pindex; bool fShutdown = ShutdownRequested(); const uint256 zeroid;
+
+        if (komodo_currentheight()>KOMODO_EARLYTXID_HEIGHT && KOMODO_EARLYTXID!=zeroid && ((height=tx_height(KOMODO_EARLYTXID))==0 || height>KOMODO_EARLYTXID_HEIGHT))
         {
-            if (!ShutdownRequested()) komodo_passport_iteration();
-            MilliSleep(1000);
-        } else MilliSleep(1000);
+            LogPrintf("error: earlytx must be before block height %d or tx does not exist\n",KOMODO_EARLYTXID_HEIGHT);
+            StartShutdown();
+        }
+
+        if ( ASSETCHAINS_CBOPRET != 0 )
+            komodo_pricesinit();
+
+        while (!fShutdown)
+        {
+            if ( ASSETCHAINS_SYMBOL[0] == 0 )
+            {
+                //if (!ShutdownRequested()) komodo_passport_iteration();
+                if ( KOMODO_NSPV_FULLNODE )
+                    komodo_passport_iteration();
+                MilliSleep(1000);
+            } 
+            else
+            {
+                //komodo_interestsum();
+                //komodo_longestchain();
+                if ( ASSETCHAINS_CBOPRET != 0 )
+                    komodo_cbopretupdate(0);
+                for (i=0; i<=ASSETCHAINS_BLOCKTIME/5; i++)
+                {
+                    fShutdown = ShutdownRequested();
+                    if ( fShutdown != 0 )
+                        break;
+                    MilliSleep(1000);
+                }
+            }
+            fShutdown = ShutdownRequested();
+        }
+        if (&threadGroup)
+        {
+            Interrupt(threadGroup);
+            threadGroup.join_all();
+        }
 
-        Interrupt(threadGroup);
-        threadGroup.join_all();
         Shutdown();
 
         qDebug() << __func__ << ": Shutdown finished";
@@ -656,23 +693,21 @@ int main(int argc, char *argv[])
         return EXIT_SUCCESS;
     }
 
+        // Check for -testnet or -regtest parameter (Params() calls are only valid after this clause)
+        if (!SelectParamsFromCommandLine()) {
+            LogPrintf("Error: Invalid combination of -regtest and -testnet.\n");
+            return EXIT_FAILURE;
+        }
+
         void komodo_args(char *argv0);
         komodo_args(argv[0]);
+        void chainparams_commandline();
+        chainparams_commandline();
+
         LogPrintf("call komodo_args.(%s) NOTARY_PUBKEY.(%s)\n",argv[0],NOTARY_PUBKEY.c_str());
-        while ( ASSETCHAIN_INIT == 0 )
-        {
-            //if ( komodo_is_issuer() != 0 )
-            //    komodo_passport_iteration();
-#ifdef WIN32
-            boost::this_thread::sleep_for(boost::chrono::seconds(1));
-#else
-            sleep(1);
-#endif
-        }
         LogPrintf("initialized %s\n",ASSETCHAINS_SYMBOL);
 
 
-
     /// 5. Now that settings and translations are available, ask user for data directory
     // User language is set up: pick a data directory
     if (!Intro::pickDataDirectory())
diff --git a/src/qt/rpcconsole.cpp b/src/qt/rpcconsole.cpp
index c266df6b..25fef341 100644
--- a/src/qt/rpcconsole.cpp
+++ b/src/qt/rpcconsole.cpp
@@ -448,6 +448,9 @@ RPCConsole::RPCConsole(const PlatformStyle *_platformStyle, QWidget *parent) :
     ui->lineEdit->installEventFilter(this);
     ui->messagesWidget->installEventFilter(this);
 
+    // Extend maximum permitted length of the text for console line to 1 Mb (for long hex transactions)
+    ui->lineEdit->setMaxLength(1024 * 1024);
+
     connect(ui->clearButton, SIGNAL(clicked()), this, SLOT(clear()));
     connect(ui->fontBiggerButton, SIGNAL(clicked()), this, SLOT(fontBigger()));
     connect(ui->fontSmallerButton, SIGNAL(clicked()), this, SLOT(fontSmaller()));
diff --git a/src/rest.cpp b/src/rest.cpp
index d8702c7c..c7fba69f 100644
--- a/src/rest.cpp
+++ b/src/rest.cpp
@@ -279,7 +279,7 @@ static bool rest_block_notxdetails(HTTPRequest* req, const std::string& strURIPa
 }
 
 // A bit of a hack - dependency on a function defined in rpc/blockchain.cpp
-UniValue getblockchaininfo(const UniValue& params, bool fHelp);
+UniValue getblockchaininfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
 
 static bool rest_chaininfo(HTTPRequest* req, const std::string& strURIPart)
 {
@@ -291,7 +291,7 @@ static bool rest_chaininfo(HTTPRequest* req, const std::string& strURIPart)
     switch (rf) {
     case RF_JSON: {
         UniValue rpcParams(UniValue::VARR);
-        UniValue chainInfoObject = getblockchaininfo(rpcParams, false);
+        UniValue chainInfoObject = getblockchaininfo(rpcParams, false, CPubKey());
         string strJSON = chainInfoObject.write() + "\n";
         req->WriteHeader("Content-Type", "application/json");
         req->WriteReply(HTTP_OK, strJSON);
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index ff5ebdc5..0adc9e69 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -339,7 +339,7 @@ UniValue blockToJSON(const CBlock& block, const CBlockIndex* blockindex, bool tx
     return result;
 }
 
-UniValue getblockcount(const UniValue& params, bool fHelp)
+UniValue getblockcount(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 0)
         throw runtime_error(
@@ -356,7 +356,7 @@ UniValue getblockcount(const UniValue& params, bool fHelp)
     return chainActive.Height();
 }
 
-UniValue getbestblockhash(const UniValue& params, bool fHelp)
+UniValue getbestblockhash(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 0)
         throw runtime_error(
@@ -373,7 +373,7 @@ UniValue getbestblockhash(const UniValue& params, bool fHelp)
     return chainActive.LastTip()->GetBlockHash().GetHex();
 }
 
-UniValue getdifficulty(const UniValue& params, bool fHelp)
+UniValue getdifficulty(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 0)
         throw runtime_error(
@@ -390,11 +390,14 @@ UniValue getdifficulty(const UniValue& params, bool fHelp)
     return GetNetworkDifficulty();
 }
 
+bool NSPV_spentinmempool(uint256 &spenttxid,int32_t &spentvini,uint256 txid,int32_t vout);
+bool NSPV_inmempool(uint256 txid);
+
 bool myIsutxo_spentinmempool(uint256 &spenttxid,int32_t &spentvini,uint256 txid,int32_t vout)
 {
-    //char *uint256_str(char *str,uint256); char str[65];
-    //LOCK(mempool.cs);
     int32_t vini = 0;
+    if ( KOMODO_NSPV_SUPERLITE )
+        return(NSPV_spentinmempool(spenttxid,spentvini,txid,vout));
     BOOST_FOREACH(const CTxMemPoolEntry &e,mempool.mapTx)
     {
         const CTransaction &tx = e.GetTx();
@@ -417,6 +420,10 @@ bool myIsutxo_spentinmempool(uint256 &spenttxid,int32_t &spentvini,uint256 txid,
 
 bool mytxid_inmempool(uint256 txid)
 {
+    if ( KOMODO_NSPV_SUPERLITE )
+    {
+        
+    }
     BOOST_FOREACH(const CTxMemPoolEntry &e,mempool.mapTx)
     {
         const CTransaction &tx = e.GetTx();
@@ -475,7 +482,7 @@ UniValue mempoolToJSON(bool fVerbose = false)
     }
 }
 
-UniValue getrawmempool(const UniValue& params, bool fHelp)
+UniValue getrawmempool(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() > 1)
         throw runtime_error(
@@ -516,7 +523,7 @@ UniValue getrawmempool(const UniValue& params, bool fHelp)
     return mempoolToJSON(fVerbose);
 }
 
-UniValue getblockdeltas(const UniValue& params, bool fHelp)
+UniValue getblockdeltas(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 1)
         throw runtime_error("");
@@ -539,7 +546,7 @@ UniValue getblockdeltas(const UniValue& params, bool fHelp)
     return blockToDeltasJSON(block, pblockindex);
 }
 
-UniValue getblockhashes(const UniValue& params, bool fHelp)
+UniValue getblockhashes(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() < 2)
         throw runtime_error(
@@ -612,7 +619,7 @@ UniValue getblockhashes(const UniValue& params, bool fHelp)
     return result;
 }
 
-UniValue getblockhash(const UniValue& params, bool fHelp)
+UniValue getblockhash(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 1)
         throw runtime_error(
@@ -637,7 +644,7 @@ UniValue getblockhash(const UniValue& params, bool fHelp)
     return pblockindex->GetBlockHash().GetHex();
 }
 
-UniValue getlastsegidstakes(const UniValue& params, bool fHelp)
+UniValue getlastsegidstakes(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 1)
         throw runtime_error(
@@ -713,7 +720,7 @@ UniValue getlastsegidstakes(const UniValue& params, bool fHelp)
     return(hash);
 }*/
 
-UniValue getblockheader(const UniValue& params, bool fHelp)
+UniValue getblockheader(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() < 1 || params.size() > 2)
         throw runtime_error(
@@ -771,7 +778,7 @@ UniValue getblockheader(const UniValue& params, bool fHelp)
     return blockheaderToJSON(pblockindex);
 }
 
-UniValue getblock(const UniValue& params, bool fHelp)
+UniValue getblock(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() < 1 || params.size() > 2)
         throw runtime_error(
@@ -884,7 +891,7 @@ UniValue getblock(const UniValue& params, bool fHelp)
     return blockToJSON(block, pblockindex, verbosity >= 2);
 }
 
-UniValue gettxoutsetinfo(const UniValue& params, bool fHelp)
+UniValue gettxoutsetinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 0)
         throw runtime_error(
@@ -923,7 +930,7 @@ UniValue gettxoutsetinfo(const UniValue& params, bool fHelp)
 }
 
 
-UniValue kvsearch(const UniValue& params, bool fHelp)
+UniValue kvsearch(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue ret(UniValue::VOBJ); uint32_t flags; uint8_t value[IGUANA_MAXSCRIPTSIZE*8],key[IGUANA_MAXSCRIPTSIZE*8]; int32_t duration,j,height,valuesize,keylen; uint256 refpubkey; static uint256 zeroes;
     if (fHelp || params.size() != 1 )
@@ -979,7 +986,7 @@ UniValue kvsearch(const UniValue& params, bool fHelp)
     return ret;
 }
 
-UniValue minerids(const UniValue& params, bool fHelp)
+UniValue minerids(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     uint32_t timestamp = 0; UniValue ret(UniValue::VOBJ); UniValue a(UniValue::VARR); uint8_t minerids[2000],pubkeys[65][33]; int32_t i,j,n,numnotaries,tally[129];
     if ( fHelp || params.size() != 1 )
@@ -1037,7 +1044,7 @@ UniValue minerids(const UniValue& params, bool fHelp)
     return ret;
 }
 
-UniValue notaries(const UniValue& params, bool fHelp)
+UniValue notaries(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue a(UniValue::VARR); uint32_t timestamp=0; UniValue ret(UniValue::VOBJ); int32_t i,j,n,m; char *hexstr;  uint8_t pubkeys[64][33]; char btcaddr[64],kmdaddr[64],*ptr;
     if ( fHelp || (params.size() != 1 && params.size() != 2) )
@@ -1097,7 +1104,7 @@ int32_t komodo_pending_withdraws(char *opretstr);
 int32_t pax_fiatstatus(uint64_t *available,uint64_t *deposited,uint64_t *issued,uint64_t *withdrawn,uint64_t *approved,uint64_t *redeemed,char *base);
 extern char CURRENCIES[][8];
 
-UniValue paxpending(const UniValue& params, bool fHelp)
+UniValue paxpending(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue ret(UniValue::VOBJ); UniValue a(UniValue::VARR); char opretbuf[10000*2]; int32_t opretlen,baseid; uint64_t available,deposited,issued,withdrawn,approved,redeemed;
     if ( fHelp || params.size() != 0 )
@@ -1128,7 +1135,7 @@ UniValue paxpending(const UniValue& params, bool fHelp)
     return ret;
 }
 
-UniValue paxprice(const UniValue& params, bool fHelp)
+UniValue paxprice(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if ( fHelp || params.size() > 4 || params.size() < 2 )
         throw runtime_error("paxprice \"base\" \"rel\" height\n");
@@ -1203,7 +1210,7 @@ UniValue paxprice(const UniValue& params, bool fHelp)
     return(0);
 }*/
 
-UniValue prices(const UniValue& params, bool fHelp)
+UniValue prices(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if ( fHelp || params.size() != 1 )
         throw runtime_error("prices maxsamples\n");
@@ -1329,7 +1336,7 @@ UniValue prices(const UniValue& params, bool fHelp)
 }
 
 // pricesbet rpc implementation
-UniValue pricesbet(const UniValue& params, bool fHelp)
+UniValue pricesbet(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 3)
         throw runtime_error("pricesbet amount leverage \"synthetic-expression\"\n"
@@ -1362,7 +1369,7 @@ UniValue pricesbet(const UniValue& params, bool fHelp)
 }
 
 // pricesaddfunding rpc implementation
-UniValue pricesaddfunding(const UniValue& params, bool fHelp)
+UniValue pricesaddfunding(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 2)
         throw runtime_error("pricesaddfunding bettxid amount\n"
@@ -1386,7 +1393,7 @@ UniValue pricesaddfunding(const UniValue& params, bool fHelp)
 }
 
 // rpc pricessetcostbasis implementation
-UniValue pricessetcostbasis(const UniValue& params, bool fHelp)
+UniValue pricessetcostbasis(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 1)
         throw runtime_error("pricessetcostbasis bettxid\n");
@@ -1406,7 +1413,7 @@ UniValue pricessetcostbasis(const UniValue& params, bool fHelp)
 }
 
 // pricescashout rpc implementation
-UniValue pricescashout(const UniValue& params, bool fHelp)
+UniValue pricescashout(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 1)
         throw runtime_error("pricescashout bettxid\n");
@@ -1426,7 +1433,7 @@ UniValue pricescashout(const UniValue& params, bool fHelp)
 }
 
 // pricesrekt rpc implementation
-UniValue pricesrekt(const UniValue& params, bool fHelp)
+UniValue pricesrekt(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 2)
         throw runtime_error("pricesrekt bettxid height\n");
@@ -1448,7 +1455,7 @@ UniValue pricesrekt(const UniValue& params, bool fHelp)
 }
 
 // pricesrekt rpc implementation
-UniValue pricesgetorderbook(const UniValue& params, bool fHelp)
+UniValue pricesgetorderbook(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 0)
         throw runtime_error("pricesgetorderbook\n");
@@ -1462,7 +1469,7 @@ UniValue pricesgetorderbook(const UniValue& params, bool fHelp)
 }
 
 // pricesrekt rpc implementation
-UniValue pricesrefillfund(const UniValue& params, bool fHelp)
+UniValue pricesrefillfund(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 1)
         throw runtime_error("pricesrefillfund amount\n");
@@ -1478,7 +1485,7 @@ UniValue pricesrefillfund(const UniValue& params, bool fHelp)
 }
 
 
-UniValue gettxout(const UniValue& params, bool fHelp)
+UniValue gettxout(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() < 2 || params.size() > 3)
         throw runtime_error(
@@ -1565,7 +1572,7 @@ UniValue gettxout(const UniValue& params, bool fHelp)
     return ret;
 }
 
-UniValue verifychain(const UniValue& params, bool fHelp)
+UniValue verifychain(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() > 2)
         throw runtime_error(
@@ -1654,7 +1661,7 @@ void NetworkUpgradeDescPushBack(
     }
 }
 
-UniValue getblockchaininfo(const UniValue& params, bool fHelp)
+UniValue getblockchaininfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 0)
         throw runtime_error(
@@ -1782,7 +1789,7 @@ struct CompareBlocksByHeight
 
 #include <pthread.h>
 
-UniValue getchaintips(const UniValue& params, bool fHelp)
+UniValue getchaintips(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 0)
         throw runtime_error(
@@ -1906,7 +1913,7 @@ UniValue mempoolInfoToJSON()
     return ret;
 }
 
-UniValue getmempoolinfo(const UniValue& params, bool fHelp)
+UniValue getmempoolinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 0)
         throw runtime_error(
@@ -1933,7 +1940,7 @@ inline CBlockIndex* LookupBlockIndex(const uint256& hash)
     return it == mapBlockIndex.end() ? nullptr : it->second;
 }
 
-UniValue getchaintxstats(const UniValue& params, bool fHelp)
+UniValue getchaintxstats(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() > 2)
         throw runtime_error(
@@ -2007,7 +2014,7 @@ UniValue getchaintxstats(const UniValue& params, bool fHelp)
     return ret;
 }
 
-UniValue invalidateblock(const UniValue& params, bool fHelp)
+UniValue invalidateblock(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 1)
         throw runtime_error(
@@ -2045,7 +2052,7 @@ UniValue invalidateblock(const UniValue& params, bool fHelp)
     return NullUniValue;
 }
 
-UniValue reconsiderblock(const UniValue& params, bool fHelp)
+UniValue reconsiderblock(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 1)
         throw runtime_error(
diff --git a/src/rpc/client.cpp b/src/rpc/client.cpp
index 4218c2e2..e6715308 100644
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@@ -109,6 +109,7 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "lockunspent", 1 },
     { "importprivkey", 2 },
     { "importprivkey", 3 },
+    { "importprivkey", 4 },
     { "importaddress", 2 },
     { "verifychain", 0 },
     { "verifychain", 1 },
@@ -151,6 +152,7 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "z_mergetoaddress", 2},
     { "z_mergetoaddress", 3},
     { "z_mergetoaddress", 4},
+    { "z_viewtransaction", 1},
     { "z_sendmany", 1},
     { "z_sendmany", 2},
     { "z_sendmany", 3},
diff --git a/src/rpc/crosschain.cpp b/src/rpc/crosschain.cpp
index e77f288f..779bddd3 100644
--- a/src/rpc/crosschain.cpp
+++ b/src/rpc/crosschain.cpp
@@ -47,9 +47,6 @@
 
 using namespace std;
 
-#define RETURN_IF_ERROR(CCerror) if ( CCerror != "" ) { ERR_RESULT(CCerror); return(result); }
-#define ERR_RESULT(x) result.push_back(Pair("result", "error")) , result.push_back(Pair("error", x));
-
 extern std::string CCerror;
 extern std::string ASSETCHAINS_SELFIMPORT;
 extern uint16_t ASSETCHAINS_CODAPORT, ASSETCHAINS_BEAMPORT;
@@ -68,7 +65,7 @@ extern std::string ASSETCHAINS_SELFIMPORT;
 //int32_t GetSelfimportProof(std::string source, CMutableTransaction &mtx, CScript &scriptPubKey, TxProof &proof, std::string rawsourcetx, int32_t &ivout, uint256 sourcetxid, uint64_t burnAmount);
 std::string MakeCodaImportTx(uint64_t txfee, std::string receipt, std::string srcaddr, std::vector<CTxOut> vouts);
 
-UniValue assetchainproof(const UniValue& params, bool fHelp)
+UniValue assetchainproof(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     uint256 hash;
 
@@ -84,7 +81,7 @@ UniValue assetchainproof(const UniValue& params, bool fHelp)
 }
 
 
-UniValue crosschainproof(const UniValue& params, bool fHelp)
+UniValue crosschainproof(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue ret(UniValue::VOBJ);
     //LogPrintf("crosschainproof needs to be implemented\n");
@@ -92,7 +89,7 @@ UniValue crosschainproof(const UniValue& params, bool fHelp)
 }
 
 
-UniValue height_MoM(const UniValue& params, bool fHelp)
+UniValue height_MoM(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     int32_t height,depth,notarized_height,MoMoMdepth,MoMoMoffset,kmdstarti,kmdendi; uint256 MoM,MoMoM,kmdtxid; uint32_t timestamp = 0; UniValue ret(UniValue::VOBJ); UniValue a(UniValue::VARR);
     if ( fHelp || params.size() != 1 )
@@ -132,7 +129,7 @@ UniValue height_MoM(const UniValue& params, bool fHelp)
     return ret;
 }
 
-UniValue MoMoMdata(const UniValue& params, bool fHelp)
+UniValue MoMoMdata(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if ( fHelp || params.size() != 3 )
         throw runtime_error("MoMoMdata symbol kmdheight ccid\n");
@@ -159,7 +156,7 @@ UniValue MoMoMdata(const UniValue& params, bool fHelp)
 }
 
 
-UniValue calc_MoM(const UniValue& params, bool fHelp)
+UniValue calc_MoM(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     int32_t height,MoMdepth; uint256 MoM; UniValue ret(UniValue::VOBJ); UniValue a(UniValue::VARR);
     if ( fHelp || params.size() != 2 )
@@ -179,7 +176,7 @@ UniValue calc_MoM(const UniValue& params, bool fHelp)
 }
 
 
-UniValue migrate_converttoexport(const UniValue& params, bool fHelp)
+UniValue migrate_converttoexport(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     std::vector<uint8_t> rawproof; uint8_t *ptr; uint8_t i; uint32_t ccid = ASSETCHAINS_CC; uint64_t txfee = 10000;
     if (fHelp || params.size() != 2)
@@ -244,7 +241,7 @@ UniValue migrate_converttoexport(const UniValue& params, bool fHelp)
 }
 
 // creates burn tx as an alternative to 'migrate_converttoexport()'
-UniValue migrate_createburntransaction(const UniValue& params, bool fHelp)
+UniValue migrate_createburntransaction(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue ret(UniValue::VOBJ);
     //uint8_t *ptr; 
@@ -431,7 +428,7 @@ void CheckBurnTxSource(uint256 burntxid, UniValue &info) {
     CTransaction burnTx;
     uint256 blockHash;
 
-    if (!GetTransaction(burntxid, burnTx, blockHash, true))
+    if (!myGetTransaction(burntxid, burnTx, blockHash))
         throw std::runtime_error("Cannot find burn transaction");
 
     if (blockHash.IsNull())
@@ -541,7 +538,7 @@ void CheckBurnTxSource(uint256 burntxid, UniValue &info) {
  * 3. migrate_completeimporttransaction
  */
 
-UniValue migrate_createimporttransaction(const UniValue& params, bool fHelp)
+UniValue migrate_createimporttransaction(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() < 2)
         throw runtime_error("migrate_createimporttransaction burnTx payouts [notarytxid-1]..[notarytxid-N]\n\n"
@@ -600,7 +597,7 @@ UniValue migrate_createimporttransaction(const UniValue& params, bool fHelp)
     return ret;
 }
 
-UniValue migrate_completeimporttransaction(const UniValue& params, bool fHelp)
+UniValue migrate_completeimporttransaction(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() < 1 || params.size() > 2)
         throw runtime_error("migrate_completeimporttransaction importTx [offset]\n\n"
@@ -642,7 +639,7 @@ UniValue migrate_completeimporttransaction(const UniValue& params, bool fHelp)
 // checks if burn tx exists and params stored in the burn tx match to the source chain
 // returns txproof
 // run it on the source chain
-UniValue migrate_checkburntransactionsource(const UniValue& params, bool fHelp)
+UniValue migrate_checkburntransactionsource(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 1)
         throw runtime_error("migrate_checkburntransactionsource burntxid\n\n"
@@ -660,7 +657,7 @@ UniValue migrate_checkburntransactionsource(const UniValue& params, bool fHelp)
     UniValue txids(UniValue::VARR);
     txids.push_back(burntxid.GetHex());
     nextparams.push_back(txids);
-    result.push_back(Pair("TxOutProof", gettxoutproof(nextparams, false)));  // get txoutproof
+    result.push_back(Pair("TxOutProof", gettxoutproof(nextparams, false, mypk)));  // get txoutproof
     result.push_back(Pair("result", "success"));  // get txoutproof
 
     return result;
@@ -669,7 +666,7 @@ UniValue migrate_checkburntransactionsource(const UniValue& params, bool fHelp)
 // creates a tx for the dest chain with txproof
 // used as a momom-backup manual import solution
 // run it on the dest chain
-UniValue migrate_createnotaryapprovaltransaction(const UniValue& params, bool fHelp)
+UniValue migrate_createnotaryapprovaltransaction(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 2)
         throw runtime_error("migrate_createnotaryapprovaltransaction burntxid txoutproof\n\n"
@@ -712,7 +709,7 @@ UniValue migrate_createnotaryapprovaltransaction(const UniValue& params, bool fH
 
 // creates a source 'quasi-burn' tx for AC_PUBKEY
 // run it on the same asset chain
-UniValue selfimport(const UniValue& params, bool fHelp)
+UniValue selfimport(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ);
     std::string destaddr;
@@ -755,6 +752,10 @@ UniValue selfimport(const UniValue& params, bool fHelp)
         // return(0);
         return -1;
     }
+    else if (source == "PEGSCC")
+    {
+        return -1;
+    }
     else if (source == "PUBKEY")
     {
         ImportProof proofNull;
@@ -792,7 +793,7 @@ UniValue selfimport(const UniValue& params, bool fHelp)
 bool GetNotarisationNotaries(uint8_t notarypubkeys[64][33], int8_t &numNN, const std::vector<CTxIn> &vin, std::vector<int8_t> &NotarisationNotaries);
 
 
-UniValue importdual(const UniValue& params, bool fHelp)
+UniValue importdual(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ);
     CMutableTransaction mtx;
@@ -834,6 +835,10 @@ UniValue importdual(const UniValue& params, bool fHelp)
         // confirm via ASSETCHAINS_CODAPORT that burnTx/hash is a valid CODA burn
         // return(0);
     }
+    else if (source == "PEGSCC")
+    {
+        return -1;
+    }
     RETURN_IF_ERROR(CCerror);
     if ( hex.size() > 0 )
     {
@@ -843,7 +848,7 @@ UniValue importdual(const UniValue& params, bool fHelp)
     return result;
 }
 
-UniValue importgatewayinfo(const UniValue& params, bool fHelp)
+UniValue importgatewayinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     uint256 txid;
 
@@ -855,7 +860,8 @@ UniValue importgatewayinfo(const UniValue& params, bool fHelp)
     return(ImportGatewayInfo(txid));
 }
 
-UniValue importgatewaybind(const UniValue& params, bool fHelp)
+
+UniValue importgatewaybind(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ);
     CMutableTransaction mtx; std::vector<unsigned char> pubkey;
@@ -867,7 +873,7 @@ UniValue importgatewaybind(const UniValue& params, bool fHelp)
     if ( fHelp || params.size() != 8) 
         throw runtime_error("use \'importgatewaybind coin orcletxid M N pubkeys pubtype p2shtype wiftype [taddr]\' to bind an import gateway\n");
     if ( ensure_CCrequirements(EVAL_IMPORTGATEWAY) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     CCerror = "";
     coin = params[0].get_str();
     oracletxid = Parseuint256(params[1].get_str().c_str()); 
@@ -908,7 +914,7 @@ UniValue importgatewaybind(const UniValue& params, bool fHelp)
     return result;
 }
 
-UniValue importgatewaydeposit(const UniValue& params, bool fHelp)
+UniValue importgatewaydeposit(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ);
     CMutableTransaction mtx; std::vector<uint8_t> rawproof;
@@ -920,7 +926,7 @@ UniValue importgatewaydeposit(const UniValue& params, bool fHelp)
     if ( fHelp || params.size() != 9) 
         throw runtime_error("use \'importgatewaydeposit bindtxid height coin burntxid nvout rawburntx rawproof destpub amount\' to import deposited coins\n");
     if ( ensure_CCrequirements(EVAL_IMPORTGATEWAY) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     CCerror = "";
     bindtxid = Parseuint256(params[0].get_str().c_str()); 
     height = atoi(params[1].get_str().c_str());
@@ -951,7 +957,7 @@ UniValue importgatewaydeposit(const UniValue& params, bool fHelp)
     return result;
 }
 
-UniValue importgatewaywithdraw(const UniValue& params, bool fHelp)
+UniValue importgatewaywithdraw(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ);
     CMutableTransaction mtx; std::vector<uint8_t> rawproof;
@@ -963,7 +969,7 @@ UniValue importgatewaywithdraw(const UniValue& params, bool fHelp)
     if ( fHelp || params.size() != 4) 
         throw runtime_error("use \'importgatewaywithdraw bindtxid coin withdrawpub amount\' to burn imported coins and withdraw them on external chain\n");
     if ( ensure_CCrequirements(EVAL_IMPORTGATEWAY) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     CCerror = "";
     bindtxid = Parseuint256(params[0].get_str().c_str()); 
     coin = params[1].get_str();
@@ -989,7 +995,7 @@ UniValue importgatewaywithdraw(const UniValue& params, bool fHelp)
     return result;
 }
 
-UniValue importgatewaypartialsign(const UniValue& params, bool fHelp)
+UniValue importgatewaypartialsign(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); std::string coin,parthex,hex; uint256 txid;
 
@@ -998,7 +1004,7 @@ UniValue importgatewaypartialsign(const UniValue& params, bool fHelp)
     if ( fHelp || params.size() != 3 )
         throw runtime_error("importgatewayspartialsign txidaddr refcoin hex\n");
     if ( ensure_CCrequirements(EVAL_IMPORTGATEWAY) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     txid = Parseuint256((char *)params[0].get_str().c_str());
     coin = params[1].get_str();
     parthex = params[2].get_str();
@@ -1012,7 +1018,7 @@ UniValue importgatewaypartialsign(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue importgatewaycompletesigning(const UniValue& params, bool fHelp)
+UniValue importgatewaycompletesigning(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); uint256 withdrawtxid; std::string txhex,hex,coin;
 
@@ -1021,7 +1027,7 @@ UniValue importgatewaycompletesigning(const UniValue& params, bool fHelp)
     if ( fHelp || params.size() != 3 )
         throw runtime_error("importgatewaycompletesigning withdrawtxid coin hex\n");
     if ( ensure_CCrequirements(EVAL_IMPORTGATEWAY) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     withdrawtxid = Parseuint256((char *)params[0].get_str().c_str());
     coin = params[1].get_str();
     txhex = params[2].get_str();
@@ -1035,13 +1041,13 @@ UniValue importgatewaycompletesigning(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue importgatewaymarkdone(const UniValue& params, bool fHelp)
+UniValue importgatewaymarkdone(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); uint256 completetxid; std::string hex,coin;
     if ( fHelp || params.size() != 2 )
         throw runtime_error("importgatewaymarkdone completesigningtx coin\n");
     if ( ensure_CCrequirements(EVAL_IMPORTGATEWAY) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     completetxid = Parseuint256((char *)params[0].get_str().c_str());
     coin = params[1].get_str();
     hex = ImportGatewayMarkDone(0,completetxid,coin);
@@ -1054,63 +1060,51 @@ UniValue importgatewaymarkdone(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue importgatewaypendingdeposits(const UniValue& params, bool fHelp)
-{
-    uint256 bindtxid; std::string coin;
-    if ( fHelp || params.size() != 2 )
-        throw runtime_error("importgatewaypendingdeposits bindtxid coin\n");
-    if ( ensure_CCrequirements(EVAL_IMPORTGATEWAY) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
-    bindtxid = Parseuint256((char *)params[0].get_str().c_str());
-    coin = params[1].get_str();
-    return(ImportGatewayPendingDeposits(bindtxid,coin));
-}
-
-UniValue importgatewaypendingwithdraws(const UniValue& params, bool fHelp)
+UniValue importgatewaypendingwithdraws(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     uint256 bindtxid; std::string coin;
     if ( fHelp || params.size() != 2 )
         throw runtime_error("importgatewaypendingwithdraws bindtxid coin\n");
     if ( ensure_CCrequirements(EVAL_IMPORTGATEWAY) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     bindtxid = Parseuint256((char *)params[0].get_str().c_str());
     coin = params[1].get_str();
     return(ImportGatewayPendingWithdraws(bindtxid,coin));
 }
 
-UniValue importgatewayprocessed(const UniValue& params, bool fHelp)
+UniValue importgatewayprocessed(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     uint256 bindtxid; std::string coin;
     if ( fHelp || params.size() != 2 )
         throw runtime_error("importgatewayprocessed bindtxid coin\n");
     if ( ensure_CCrequirements(EVAL_IMPORTGATEWAY) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     bindtxid = Parseuint256((char *)params[0].get_str().c_str());
     coin = params[1].get_str();
     return(ImportGatewayProcessedWithdraws(bindtxid,coin));
 }
 
-UniValue importgatewayexternaladdress(const UniValue& params, bool fHelp)
+UniValue importgatewayexternaladdress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     uint256 bindtxid; CPubKey pubkey;
 
     if ( fHelp || params.size() != 2)
         throw runtime_error("importgatewayexternaladdress bindtxid pubkey\n");
     if ( ensure_CCrequirements(EVAL_IMPORTGATEWAY) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     bindtxid = Parseuint256((char *)params[0].get_str().c_str());
     pubkey = ParseHex(params[1].get_str().c_str());
     return(ImportGatewayExternalAddress(bindtxid,pubkey));
 }
 
-UniValue importgatewaydumpprivkey(const UniValue& params, bool fHelp)
+UniValue importgatewaydumpprivkey(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     uint256 bindtxid;
 
     if ( fHelp || params.size() != 2)
         throw runtime_error("importgatewaydumpprivkey bindtxid address\n");
     if ( ensure_CCrequirements(EVAL_IMPORTGATEWAY) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     bindtxid = Parseuint256((char *)params[0].get_str().c_str());
     std::string strAddress = params[1].get_str();
     CTxDestination dest = DecodeDestination(strAddress);
@@ -1128,7 +1122,7 @@ UniValue importgatewaydumpprivkey(const UniValue& params, bool fHelp)
     return(ImportGatewayDumpPrivKey(bindtxid,vchSecret));
 }
 
-UniValue getNotarisationsForBlock(const UniValue& params, bool fHelp)
+UniValue getNotarisationsForBlock(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     // TODO take timestamp as param, and loop blockindex to get starting/finish height.
     if (fHelp || params.size() != 1)
@@ -1157,7 +1151,7 @@ UniValue getNotarisationsForBlock(const UniValue& params, bool fHelp)
     {
         UniValue item(UniValue::VOBJ); UniValue notaryarr(UniValue::VARR); std::vector<int8_t> NotarisationNotaries;
         uint256 hash; CTransaction tx;
-        if ( GetTransaction(n.first,tx,hash,false) )
+        if ( myGetTransaction(n.first,tx,hash) )
         {
             if ( is_STAKED(n.second.symbol) != 0 )
             {
@@ -1189,7 +1183,7 @@ UniValue getNotarisationsForBlock(const UniValue& params, bool fHelp)
     return out;
 }
 
-/*UniValue getNotarisationsForBlock(const UniValue& params, bool fHelp)
+/*UniValue getNotarisationsForBlock(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 1)
         throw runtime_error("getNotarisationsForBlock blockHash\n\n"
@@ -1212,7 +1206,7 @@ UniValue getNotarisationsForBlock(const UniValue& params, bool fHelp)
 }*/
 
 
-UniValue scanNotarisationsDB(const UniValue& params, bool fHelp)
+UniValue scanNotarisationsDB(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() < 2 || params.size() > 3)
         throw runtime_error("scanNotarisationsDB blockHeight symbol [blocksLimit=1440]\n\n"
@@ -1240,7 +1234,7 @@ UniValue scanNotarisationsDB(const UniValue& params, bool fHelp)
     return out;
 }
 
-UniValue getimports(const UniValue& params, bool fHelp)
+UniValue getimports(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 1)
         throw runtime_error(
@@ -1362,7 +1356,7 @@ UniValue getimports(const UniValue& params, bool fHelp)
 
 
 // outputs burn transactions in the wallet 
-UniValue getwalletburntransactions(const UniValue& params, bool fHelp)
+UniValue getwalletburntransactions(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() > 1)
         throw runtime_error(
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index af5cd398..c49a53b4 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -99,7 +99,7 @@ int64_t GetNetworkHashPS(int lookup, int height)
     return (int64_t)(workDiff.getdouble() / timeDiff);
 }
 
-UniValue getlocalsolps(const UniValue& params, bool fHelp)
+UniValue getlocalsolps(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp)
         throw runtime_error(
@@ -117,7 +117,7 @@ UniValue getlocalsolps(const UniValue& params, bool fHelp)
     return GetLocalSolPS();
 }
 
-UniValue getnetworksolps(const UniValue& params, bool fHelp)
+UniValue getnetworksolps(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() > 2)
         throw runtime_error(
@@ -139,7 +139,7 @@ UniValue getnetworksolps(const UniValue& params, bool fHelp)
     return GetNetworkHashPS(params.size() > 0 ? params[0].get_int() : 120, params.size() > 1 ? params[1].get_int() : -1);
 }
 
-UniValue getnetworkhashps(const UniValue& params, bool fHelp)
+UniValue getnetworkhashps(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() > 2)
         throw runtime_error(
@@ -164,7 +164,7 @@ UniValue getnetworkhashps(const UniValue& params, bool fHelp)
 
 #ifdef ENABLE_MINING
 extern bool VERUS_MINTBLOCKS;
-UniValue getgenerate(const UniValue& params, bool fHelp)
+UniValue getgenerate(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 0)
         throw runtime_error(
@@ -197,7 +197,7 @@ UniValue getgenerate(const UniValue& params, bool fHelp)
 extern uint8_t NOTARY_PUBKEY33[33];
 
 //Value generate(const Array& params, bool fHelp)
-UniValue generate(const UniValue& params, bool fHelp)
+UniValue generate(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() < 1 || params.size() > 1)
         throw runtime_error(
@@ -324,7 +324,7 @@ UniValue generate(const UniValue& params, bool fHelp)
 }
 
 
-UniValue setgenerate(const UniValue& params, bool fHelp)
+UniValue setgenerate(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() < 1 || params.size() > 2)
         throw runtime_error(
@@ -404,8 +404,53 @@ UniValue setgenerate(const UniValue& params, bool fHelp)
 }
 #endif
 
+CBlockIndex *komodo_chainactive(int32_t height);
+arith_uint256 zawy_ctB(arith_uint256 bnTarget,uint32_t solvetime);
 
-UniValue getmininginfo(const UniValue& params, bool fHelp)
+UniValue genminingCSV(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    int32_t i,z,height; uint32_t solvetime,prevtime=0; FILE *fp; char str[65],str2[65],fname[256]; uint256 hash; arith_uint256 bnTarget; CBlockIndex *pindex; bool fNegative,fOverflow; UniValue result(UniValue::VOBJ);
+    if (fHelp || params.size() != 0 )
+        throw runtime_error("genminingCSV\n");
+    LOCK(cs_main);
+    sprintf(fname,"%s_mining.csv",ASSETCHAINS_SYMBOL[0] == 0 ? "KMD" : ASSETCHAINS_SYMBOL);
+    if ( (fp= fopen(fname,"wb")) != 0 )
+    {
+        fprintf(fp,"height,nTime,nBits,bnTarget,bnTargetB,diff,solvetime\n");
+        height = komodo_nextheight();
+        for (i=0; i<height; i++)
+        {
+            if ( (pindex= komodo_chainactive(i)) != 0 )
+            {
+                bnTarget.SetCompact(pindex->nBits,&fNegative,&fOverflow);
+                solvetime = (prevtime==0) ? 0 : (int32_t)(pindex->nTime - prevtime);
+                for (z=0; z<16; z++)
+                    sprintf(&str[z<<1],"%02x",((uint8_t *)&bnTarget)[31-z]);
+                str[32] = 0;
+                //hash = pindex->GetBlockHash();
+                memset(&hash,0,sizeof(hash));
+                if ( i >= 64 && (pindex->nBits & 3) != 0 )
+                    hash = ArithToUint256(zawy_ctB(bnTarget,solvetime));
+                for (z=0; z<16; z++)
+                    sprintf(&str2[z<<1],"%02x",((uint8_t *)&hash)[31-z]);
+                str2[32] = 0; fprintf(fp,"%d,%u,%08x,%s,%s,%.1f,%d\n",i,pindex->nTime,pindex->nBits,str,str2,GetDifficulty(pindex),solvetime);
+                prevtime = pindex->nTime;
+            }
+        }
+        fclose(fp);
+        result.push_back(Pair("result", "success"));
+        result.push_back(Pair("created", fname));
+    }
+    else
+    {
+        result.push_back(Pair("result", "success"));
+        result.push_back(Pair("error", "couldnt create mining.csv"));
+        result.push_back(Pair("filename", fname));
+    }
+    return(result);
+}
+                            
+UniValue getmininginfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 0)
         throw runtime_error(
@@ -443,14 +488,14 @@ UniValue getmininginfo(const UniValue& params, bool fHelp)
     obj.push_back(Pair("genproclimit",     (int)GetArg("-genproclimit", -1)));
     if (ASSETCHAINS_ALGO == ASSETCHAINS_EQUIHASH)
     {
-        obj.push_back(Pair("localsolps"  , getlocalsolps(params, false)));
-        obj.push_back(Pair("networksolps", getnetworksolps(params, false)));
+        obj.push_back(Pair("localsolps"  , getlocalsolps(params, false, mypk)));
+        obj.push_back(Pair("networksolps", getnetworksolps(params, false, mypk)));
     }
     else
     {
-        obj.push_back(Pair("localhashps"  , GetBoolArg("-gen", false) ? getlocalsolps(params, false) : (double)0.0));
+        obj.push_back(Pair("localhashps"  , GetBoolArg("-gen", false) ? getlocalsolps(params, false, mypk) : (double)0.0));
     }
-    obj.push_back(Pair("networkhashps",    getnetworksolps(params, false)));
+    obj.push_back(Pair("networkhashps",    getnetworksolps(params, false, mypk)));
     obj.push_back(Pair("pooledtx",         (uint64_t)mempool.size()));
     obj.push_back(Pair("testnet",          Params().TestnetToBeDeprecatedFieldRPC()));
     obj.push_back(Pair("chain",            Params().NetworkIDString()));
@@ -467,7 +512,7 @@ UniValue getmininginfo(const UniValue& params, bool fHelp)
 
 
 // NOTE: Unlike wallet RPC (which use BTC values), mining RPCs follow GBT (BIP 22) in using satoshi amounts
-UniValue prioritisetransaction(const UniValue& params, bool fHelp)
+UniValue prioritisetransaction(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 3)
         throw runtime_error(
@@ -517,7 +562,7 @@ static UniValue BIP22ValidationResult(const CValidationState& state)
     return "valid?";
 }
 
-UniValue getblocktemplate(const UniValue& params, bool fHelp)
+UniValue getblocktemplate(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() > 1)
         throw runtime_error(
@@ -746,7 +791,8 @@ UniValue getblocktemplate(const UniValue& params, bool fHelp)
 #endif
         ENTER_CRITICAL_SECTION(cs_main);
         if (!pblocktemplate)
-            throw JSONRPCError(RPC_OUT_OF_MEMORY, "Out of memory or no available utxo for staking");
+            throw std::runtime_error("CreateNewBlock(): create block failed");
+            //throw JSONRPCError(RPC_OUT_OF_MEMORY, "Out of memory or no available utxo for staking");
 
         // Need to update only after we know CreateNewBlockWithKey succeeded
         pindexPrev = pindexPrevNew;
@@ -874,7 +920,7 @@ class submitblock_StateCatcher : public CValidationInterface
     };
 };
 
-UniValue submitblock(const UniValue& params, bool fHelp)
+UniValue submitblock(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() < 1 || params.size() > 2)
         throw runtime_error(
@@ -946,7 +992,7 @@ UniValue submitblock(const UniValue& params, bool fHelp)
     return BIP22ValidationResult(state);
 }
 
-UniValue estimatefee(const UniValue& params, bool fHelp)
+UniValue estimatefee(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 1)
         throw runtime_error(
@@ -978,7 +1024,7 @@ UniValue estimatefee(const UniValue& params, bool fHelp)
     return ValueFromAmount(feeRate.GetFeePerK());
 }
 
-UniValue estimatepriority(const UniValue& params, bool fHelp)
+UniValue estimatepriority(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 1)
         throw runtime_error(
@@ -1006,7 +1052,7 @@ UniValue estimatepriority(const UniValue& params, bool fHelp)
     return mempool.estimatePriority(nBlocks);
 }
 
-UniValue getblocksubsidy(const UniValue& params, bool fHelp)
+UniValue getblocksubsidy(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() > 1)
         throw runtime_error(
diff --git a/src/rpc/misc.cpp b/src/rpc/misc.cpp
index 03d7aca4..61147f70 100644
--- a/src/rpc/misc.cpp
+++ b/src/rpc/misc.cpp
@@ -78,7 +78,7 @@ int8_t StakedNotaryID(std::string &notaryname, char *Raddress);
 uint64_t komodo_notarypayamount(int32_t nHeight, int64_t notarycount);
 int32_t komodo_notaries(uint8_t pubkeys[64][33],int32_t height,uint32_t timestamp);
 
-#define KOMODO_VERSION "0.5.0"
+#define KOMODO_VERSION "0.5.1"
 #define VERUS_VERSION "0.4.0g"
 extern uint16_t ASSETCHAINS_P2PPORT,ASSETCHAINS_RPCPORT;
 extern uint32_t ASSETCHAINS_CC;
@@ -98,7 +98,7 @@ int32_t getera(int timestamp)
     return(0);
 }
 
-UniValue getiguanajson(const UniValue& params, bool fHelp)
+UniValue getiguanajson(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 0)
       throw runtime_error("getiguanajson\nreturns json for iguana, for the current ERA.");
@@ -138,7 +138,7 @@ UniValue getiguanajson(const UniValue& params, bool fHelp)
     return json;
 }
 
-UniValue getnotarysendmany(const UniValue& params, bool fHelp)
+UniValue getnotarysendmany(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() > 1)
       throw runtime_error(
@@ -166,7 +166,7 @@ UniValue getnotarysendmany(const UniValue& params, bool fHelp)
     return ret;
 }
 
-UniValue geterablockheights(const UniValue& params, bool fHelp)
+UniValue geterablockheights(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 0)
       throw runtime_error(
@@ -192,7 +192,7 @@ UniValue geterablockheights(const UniValue& params, bool fHelp)
     return(ret);
 }
 
-UniValue getinfo(const UniValue& params, bool fHelp)
+UniValue getinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     uint256 notarized_hash,notarized_desttxid; int32_t prevMoMheight,notarized_height,longestchain,kmdnotarized_height,txid_height;
     if (fHelp || params.size() != 0)
@@ -243,50 +243,54 @@ UniValue getinfo(const UniValue& params, bool fHelp)
     obj.push_back(Pair("prevMoMheight", prevMoMheight));
     obj.push_back(Pair("notarizedhash", notarized_hash.ToString()));
     obj.push_back(Pair("notarizedtxid", notarized_desttxid.ToString()));
-    txid_height = notarizedtxid_height(ASSETCHAINS_SYMBOL[0] != 0 ? (char *)"KMD" : (char *)"BTC",(char *)notarized_desttxid.ToString().c_str(),&kmdnotarized_height);
-    if ( txid_height > 0 )
-        obj.push_back(Pair("notarizedtxid_height", txid_height));
-    else obj.push_back(Pair("notarizedtxid_height", "mempool"));
-    if ( ASSETCHAINS_SYMBOL[0] != 0 )
-        obj.push_back(Pair("KMDnotarized_height", kmdnotarized_height));
-    obj.push_back(Pair("notarized_confirms", txid_height < kmdnotarized_height ? (kmdnotarized_height - txid_height + 1) : 0));
-    //LogPrintf("after notarized_confirms %u\n",(uint32_t)time(NULL));
+    if ( KOMODO_NSPV_FULLNODE )
+    {
+        txid_height = notarizedtxid_height(ASSETCHAINS_SYMBOL[0] != 0 ? (char *)"KMD" : (char *)"BTC",(char *)notarized_desttxid.ToString().c_str(),&kmdnotarized_height);
+        if ( txid_height > 0 )
+            obj.push_back(Pair("notarizedtxid_height", txid_height));
+        else obj.push_back(Pair("notarizedtxid_height", "mempool"));
+        if ( ASSETCHAINS_SYMBOL[0] != 0 )
+            obj.push_back(Pair("KMDnotarized_height", kmdnotarized_height));
+        obj.push_back(Pair("notarized_confirms", txid_height < kmdnotarized_height ? (kmdnotarized_height - txid_height + 1) : 0));
+        //fprintf(stderr,"after notarized_confirms %u\n",(uint32_t)time(NULL));
 #ifdef ENABLE_WALLET
-    if (pwalletMain) {
-        obj.push_back(Pair("walletversion", pwalletMain->GetVersion()));
-        if ( ASSETCHAINS_SYMBOL[0] == 0 )
-        {
-            obj.push_back(Pair("interest",       ValueFromAmount(KOMODO_INTERESTSUM)));
-            obj.push_back(Pair("balance",       ValueFromAmount(KOMODO_WALLETBALANCE))); //pwalletMain->GetBalance()
+        if (pwalletMain) {
+            obj.push_back(Pair("walletversion", pwalletMain->GetVersion()));
+            if ( ASSETCHAINS_SYMBOL[0] == 0 )
+            {
+                obj.push_back(Pair("interest",       ValueFromAmount(KOMODO_INTERESTSUM)));
+                obj.push_back(Pair("balance",       ValueFromAmount(KOMODO_WALLETBALANCE))); //pwalletMain->GetBalance()
+            }
+            else
+            {
+                obj.push_back(Pair("balance",       ValueFromAmount(pwalletMain->GetBalance()))); //
+            }
         }
-        else
-        {
-            obj.push_back(Pair("balance",       ValueFromAmount(pwalletMain->GetBalance()))); //
+#endif
+        //fprintf(stderr,"after wallet %u\n",(uint32_t)time(NULL));
+        obj.push_back(Pair("blocks",        (int)chainActive.Height()));
+        if ( (longestchain= KOMODO_LONGESTCHAIN) != 0 && chainActive.Height() > longestchain )
+            longestchain = chainActive.Height();
+        //fprintf(stderr,"after longestchain %u\n",(uint32_t)time(NULL));
+        obj.push_back(Pair("longestchain",        longestchain));
+        if ( chainActive.LastTip() != 0 )
+            obj.push_back(Pair("tiptime", (int)chainActive.LastTip()->nTime));
+        obj.push_back(Pair("difficulty",    (double)GetDifficulty()));
+#ifdef ENABLE_WALLET
+        if (pwalletMain) {
+            obj.push_back(Pair("keypoololdest", pwalletMain->GetOldestKeyPoolTime()));
+            obj.push_back(Pair("keypoolsize",   (int)pwalletMain->GetKeyPoolSize()));
         }
-    }
+        if (pwalletMain && pwalletMain->IsCrypted())
+            obj.push_back(Pair("unlocked_until", nWalletUnlockTime));
+        obj.push_back(Pair("paytxfee",      ValueFromAmount(payTxFee.GetFeePerK())));
 #endif
-    //LogPrintf("after wallet %u\n",(uint32_t)time(NULL));
-    obj.push_back(Pair("blocks",        (int)chainActive.Height()));
-    if ( (longestchain= KOMODO_LONGESTCHAIN) != 0 && chainActive.Height() > longestchain )
-        longestchain = chainActive.Height();
-    //LogPrintf("after longestchain %u\n",(uint32_t)time(NULL));
-    obj.push_back(Pair("longestchain",        longestchain));
+        obj.push_back(Pair("sapling", ASSETCHAINS_SAPLING));
+    }
     obj.push_back(Pair("timeoffset",    GetTimeOffset()));
-    if ( chainActive.LastTip() != 0 )
-        obj.push_back(Pair("tiptime", (int)chainActive.LastTip()->nTime));
     obj.push_back(Pair("connections",   (int)vNodes.size()));
     obj.push_back(Pair("proxy",         (proxy.IsValid() ? proxy.proxy.ToStringIPPort() : string())));
-    obj.push_back(Pair("difficulty",    (double)GetDifficulty()));
     obj.push_back(Pair("testnet",       Params().TestnetToBeDeprecatedFieldRPC()));
-#ifdef ENABLE_WALLET
-    if (pwalletMain) {
-        obj.push_back(Pair("keypoololdest", pwalletMain->GetOldestKeyPoolTime()));
-        obj.push_back(Pair("keypoolsize",   (int)pwalletMain->GetKeyPoolSize()));
-    }
-    if (pwalletMain && pwalletMain->IsCrypted())
-        obj.push_back(Pair("unlocked_until", nWalletUnlockTime));
-    obj.push_back(Pair("paytxfee",      ValueFromAmount(payTxFee.GetFeePerK())));
-#endif
     obj.push_back(Pair("relayfee",      ValueFromAmount(::minRelayTxFee.GetFeePerK())));
     obj.push_back(Pair("errors",        GetWarnings("statusbar")));
      if ( NOTARY_PUBKEY33[0] != 0 ) {
@@ -304,7 +308,6 @@ UniValue getinfo(const UniValue& params, bool fHelp)
     if ( ASSETCHAINS_CC != 0 )
         obj.push_back(Pair("CCid",        (int)ASSETCHAINS_CC));
     obj.push_back(Pair("name",        ASSETCHAINS_SYMBOL[0] == 0 ? "KMD" : ASSETCHAINS_SYMBOL));
-    obj.push_back(Pair("sapling", ASSETCHAINS_SAPLING));
 
     obj.push_back(Pair("p2pport",        ASSETCHAINS_P2PPORT));
     obj.push_back(Pair("rpcport",        ASSETCHAINS_RPCPORT));
@@ -414,7 +417,7 @@ class DescribeAddressVisitor : public boost::static_visitor<UniValue>
 };
 #endif
 
-UniValue coinsupply(const UniValue& params, bool fHelp)
+UniValue coinsupply(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     int32_t height = 0; int32_t currentHeight; int64_t blocks_per_year,zf1,zf3,zf12,sf1,sf3,sf12,sproutfunds,zfunds,supply1,supply3,supply12,supply = 0; UniValue result(UniValue::VOBJ);
     if (fHelp || params.size() > 1)
@@ -479,7 +482,7 @@ UniValue coinsupply(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue jumblr_deposit(const UniValue& params, bool fHelp)
+UniValue jumblr_deposit(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     int32_t retval; UniValue result(UniValue::VOBJ);
     if (fHelp || params.size() != 1)
@@ -499,7 +502,7 @@ UniValue jumblr_deposit(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue jumblr_secret(const UniValue& params, bool fHelp)
+UniValue jumblr_secret(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     int32_t retval; UniValue result(UniValue::VOBJ);
     if (fHelp || params.size() != 1)
@@ -517,7 +520,7 @@ UniValue jumblr_secret(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue jumblr_pause(const UniValue& params, bool fHelp)
+UniValue jumblr_pause(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     int32_t retval; UniValue result(UniValue::VOBJ);
     if (fHelp )
@@ -527,7 +530,7 @@ UniValue jumblr_pause(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue jumblr_resume(const UniValue& params, bool fHelp)
+UniValue jumblr_resume(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     int32_t retval; UniValue result(UniValue::VOBJ);
     if (fHelp )
@@ -537,7 +540,7 @@ UniValue jumblr_resume(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue validateaddress(const UniValue& params, bool fHelp)
+UniValue validateaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 1)
         throw runtime_error(
@@ -631,7 +634,7 @@ class DescribePaymentAddressVisitor : public boost::static_visitor<UniValue>
     }
 };
 
-UniValue z_validateaddress(const UniValue& params, bool fHelp)
+UniValue z_validateaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 1)
         throw runtime_error(
@@ -742,7 +745,7 @@ CScript _createmultisig_redeemScript(const UniValue& params)
     return result;
 }
 
-UniValue createmultisig(const UniValue& params, bool fHelp)
+UniValue createmultisig(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() < 2 || params.size() > 2)
     {
@@ -784,7 +787,7 @@ UniValue createmultisig(const UniValue& params, bool fHelp)
     return result;
 }
 
-UniValue verifymessage(const UniValue& params, bool fHelp)
+UniValue verifymessage(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 3)
         throw runtime_error(
@@ -840,7 +843,7 @@ UniValue verifymessage(const UniValue& params, bool fHelp)
     return (pubkey.GetID() == *keyID);
 }
 
-UniValue setmocktime(const UniValue& params, bool fHelp)
+UniValue setmocktime(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 1)
         throw runtime_error(
@@ -934,7 +937,7 @@ bool timestampSort(std::pair<CMempoolAddressDeltaKey, CMempoolAddressDelta> a,
     return a.second.time < b.second.time;
 }
 
-UniValue getaddressmempool(const UniValue& params, bool fHelp)
+UniValue getaddressmempool(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() > 2 || params.size() == 0)
         throw runtime_error(
@@ -1006,7 +1009,7 @@ UniValue getaddressmempool(const UniValue& params, bool fHelp)
     return result;
 }
 
-UniValue getaddressutxos(const UniValue& params, bool fHelp)
+UniValue getaddressutxos(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() > 2 || params.size() == 0)
         throw runtime_error(
@@ -1093,7 +1096,7 @@ UniValue getaddressutxos(const UniValue& params, bool fHelp)
     }
 }
 
-UniValue getaddressdeltas(const UniValue& params, bool fHelp)
+UniValue getaddressdeltas(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() > 2 || params.size() == 0 || !params[0].isObject())
         throw runtime_error(
@@ -1243,7 +1246,7 @@ CAmount checkburnaddress(CAmount &received, int64_t &nNotaryPay, int32_t &height
     return balance;
 }
 
-UniValue checknotarization(const UniValue& params, bool fHelp)
+UniValue checknotarization(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 0)
         throw runtime_error(
@@ -1273,7 +1276,7 @@ UniValue checknotarization(const UniValue& params, bool fHelp)
     return true;
 }
 
-UniValue getnotarypayinfo(const UniValue& params, bool fHelp)
+UniValue getnotarypayinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 0)
         throw runtime_error(
@@ -1319,7 +1322,7 @@ UniValue getnotarypayinfo(const UniValue& params, bool fHelp)
     return result;
 }
 
-UniValue getaddressbalance(const UniValue& params, bool fHelp)
+UniValue getaddressbalance(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp ||params.size() > 2 || params.size() == 0)
         throw runtime_error(
@@ -1378,7 +1381,7 @@ UniValue getaddressbalance(const UniValue& params, bool fHelp)
 
 UniValue komodo_snapshot(int top);
 
-UniValue getsnapshot(const UniValue& params, bool fHelp)
+UniValue getsnapshot(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); int64_t total; int32_t top = 0;
 
@@ -1435,7 +1438,7 @@ UniValue getsnapshot(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue getaddresstxids(const UniValue& params, bool fHelp)
+UniValue getaddresstxids(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() > 2 || params.size() < 1)
         throw runtime_error(
@@ -1519,7 +1522,7 @@ UniValue getaddresstxids(const UniValue& params, bool fHelp)
 
 }
 
-UniValue getspentinfo(const UniValue& params, bool fHelp)
+UniValue getspentinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
 
     if (fHelp || params.size() != 1 || !params[0].isObject())
@@ -1567,7 +1570,7 @@ UniValue getspentinfo(const UniValue& params, bool fHelp)
     return obj;
 }
 
-UniValue txnotarizedconfirmed(const UniValue& params, bool fHelp)
+UniValue txnotarizedconfirmed(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     bool notarizedconfirmed; uint256 txid;
 
@@ -1593,7 +1596,7 @@ UniValue txnotarizedconfirmed(const UniValue& params, bool fHelp)
     return result;
 }
 
-UniValue decodeccopret(const UniValue& params, bool fHelp)
+UniValue decodeccopret(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     CTransaction tx; uint256 tokenid,txid,hashblock;
     std::vector<uint8_t> vopret,vOpretExtra; uint8_t *script,tokenevalcode;
diff --git a/src/rpc/net.cpp b/src/rpc/net.cpp
index 2846da6c..949f3cb4 100644
--- a/src/rpc/net.cpp
+++ b/src/rpc/net.cpp
@@ -36,7 +36,7 @@
 
 using namespace std;
 
-UniValue getconnectioncount(const UniValue& params, bool fHelp)
+UniValue getconnectioncount(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 0)
         throw runtime_error(
@@ -54,7 +54,7 @@ UniValue getconnectioncount(const UniValue& params, bool fHelp)
     return (int)vNodes.size();
 }
 
-UniValue ping(const UniValue& params, bool fHelp)
+UniValue ping(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 0)
         throw runtime_error(
@@ -77,7 +77,7 @@ UniValue ping(const UniValue& params, bool fHelp)
     return NullUniValue;
 }
 
-UniValue getpeerinfo(const UniValue& params, bool fHelp)
+UniValue getpeerinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 0)
         throw runtime_error(
@@ -216,7 +216,7 @@ int32_t komodo_longestchain()
     return(KOMODO_LONGESTCHAIN);
 }
 
-UniValue addnode(const UniValue& params, bool fHelp)
+UniValue addnode(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     string strCommand;
     if (params.size() == 2)
@@ -266,7 +266,7 @@ UniValue addnode(const UniValue& params, bool fHelp)
     return NullUniValue;
 }
 
-UniValue disconnectnode(const UniValue& params, bool fHelp)
+UniValue disconnectnode(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 1)
         throw runtime_error(
@@ -288,7 +288,7 @@ UniValue disconnectnode(const UniValue& params, bool fHelp)
     return NullUniValue;
 }
 
-UniValue getaddednodeinfo(const UniValue& params, bool fHelp)
+UniValue getaddednodeinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() < 1 || params.size() > 2)
         throw runtime_error(
@@ -404,7 +404,7 @@ UniValue getaddednodeinfo(const UniValue& params, bool fHelp)
     return ret;
 }
 
-UniValue getnettotals(const UniValue& params, bool fHelp)
+UniValue getnettotals(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() > 0)
         throw runtime_error(
@@ -450,7 +450,7 @@ static UniValue GetNetworksInfo()
     return networks;
 }
 
-UniValue getdeprecationinfo(const UniValue& params, bool fHelp)
+UniValue getdeprecationinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     const CChainParams& chainparams = Params();
     if (fHelp || params.size() != 0 || chainparams.NetworkIDString() != "main")
@@ -477,7 +477,7 @@ UniValue getdeprecationinfo(const UniValue& params, bool fHelp)
     return obj;
 }
 
-UniValue getnetworkinfo(const UniValue& params, bool fHelp)
+UniValue getnetworkinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 0)
         throw runtime_error(
@@ -544,7 +544,7 @@ UniValue getnetworkinfo(const UniValue& params, bool fHelp)
     return obj;
 }
 
-UniValue setban(const UniValue& params, bool fHelp)
+UniValue setban(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     string strCommand;
     if (params.size() >= 2)
@@ -608,7 +608,7 @@ UniValue setban(const UniValue& params, bool fHelp)
     return NullUniValue;
 }
 
-UniValue listbanned(const UniValue& params, bool fHelp)
+UniValue listbanned(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 0)
         throw runtime_error(
@@ -637,7 +637,7 @@ UniValue listbanned(const UniValue& params, bool fHelp)
     return bannedAddresses;
 }
 
-UniValue clearbanned(const UniValue& params, bool fHelp)
+UniValue clearbanned(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 0)
         throw runtime_error(
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index f9d83938..379819db 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -206,7 +206,7 @@ void TxToJSONExpanded(const CTransaction& tx, const uint256 hashBlock, UniValue&
         UniValue in(UniValue::VOBJ);
         if (tx.IsCoinBase())
             in.push_back(Pair("coinbase", HexStr(txin.scriptSig.begin(), txin.scriptSig.end())));
-        else if (tx.IsCoinImport()) {
+        else if (tx.IsCoinImport() && txin.prevout.n==10e8) {
             in.push_back(Pair("is_import", "1"));
             ImportProof proof; CTransaction burnTx; std::vector<CTxOut> payouts; CTxDestination importaddress;
             if (UnmarshalImportTx(tx, proof, burnTx, payouts)) 
@@ -368,13 +368,13 @@ void TxToJSON(const CTransaction& tx, const uint256 hashBlock, UniValue& entry)
     entry.push_back(Pair("vin", vin));
     UniValue vout(UniValue::VARR);
     BlockMap::iterator it = mapBlockIndex.find(pcoinsTip->GetBestBlock());
-    CBlockIndex *tipindex,*pindex = it->second;
+    CBlockIndex *tipindex;//,*pindex = it->second;
     uint64_t interest;
     for (unsigned int i = 0; i < tx.vout.size(); i++) {
         const CTxOut& txout = tx.vout[i];
         UniValue out(UniValue::VOBJ);
         out.push_back(Pair("value", ValueFromAmount(txout.nValue)));
-        if ( ASSETCHAINS_SYMBOL[0] == 0 && pindex != 0 && tx.nLockTime >= 500000000 && (tipindex= chainActive.LastTip()) != 0 )
+        if ( KOMODO_NSPV_FULLNODE && ASSETCHAINS_SYMBOL[0] == 0 && tx.nLockTime >= 500000000 && (tipindex= chainActive.LastTip()) != 0 )
         {
             int64_t interest; int32_t txheight; uint32_t locktime;
             interest = komodo_accrued_interest(&txheight,&locktime,tx.GetHash(),i,0,txout.nValue,(int32_t)tipindex->GetHeight());
@@ -422,7 +422,7 @@ void TxToJSON(const CTransaction& tx, const uint256 hashBlock, UniValue& entry)
     }
 }
 
-UniValue getrawtransaction(const UniValue& params, bool fHelp)
+UniValue getrawtransaction(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() < 1 || params.size() > 2)
         throw runtime_error(
@@ -611,7 +611,7 @@ int32_t gettxout_scriptPubKey(uint8_t *scriptPubKey,int32_t maxsize,uint256 txid
     return(-1);
 }
 
-UniValue gettxoutproof(const UniValue& params, bool fHelp)
+UniValue gettxoutproof(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || (params.size() != 1 && params.size() != 2))
         throw runtime_error(
@@ -692,7 +692,7 @@ UniValue gettxoutproof(const UniValue& params, bool fHelp)
     return strHex;
 }
 
-UniValue verifytxoutproof(const UniValue& params, bool fHelp)
+UniValue verifytxoutproof(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 1)
         throw runtime_error(
@@ -725,7 +725,7 @@ UniValue verifytxoutproof(const UniValue& params, bool fHelp)
     return res;
 }
 
-UniValue createrawtransaction(const UniValue& params, bool fHelp)
+UniValue createrawtransaction(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     string examplescriptPubKey = "21021ce1eac70455c3e6c52d67c133549b8aed4a588fba594372e8048e65c4f0fcb6ac";
 
@@ -885,7 +885,7 @@ UniValue createrawtransaction(const UniValue& params, bool fHelp)
     return EncodeHexTx(rawTx);
 }
 
-UniValue decoderawtransaction(const UniValue& params, bool fHelp)
+UniValue decoderawtransaction(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 1)
         throw runtime_error(
@@ -980,7 +980,7 @@ UniValue decoderawtransaction(const UniValue& params, bool fHelp)
     return result;
 }
 
-UniValue decodescript(const UniValue& params, bool fHelp)
+UniValue decodescript(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 1)
         throw runtime_error(
@@ -1034,7 +1034,7 @@ static void TxInErrorToJSON(const CTxIn& txin, UniValue& vErrorsRet, const std::
     vErrorsRet.push_back(entry);
 }
 
-UniValue signrawtransaction(const UniValue& params, bool fHelp)
+UniValue signrawtransaction(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() < 1 || params.size() > 5)
         throw runtime_error(
@@ -1329,7 +1329,9 @@ UniValue signrawtransaction(const UniValue& params, bool fHelp)
     return result;
 }
 
-UniValue sendrawtransaction(const UniValue& params, bool fHelp)
+extern UniValue NSPV_broadcast(char *hex);
+
+UniValue sendrawtransaction(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() < 1 || params.size() > 2)
         throw runtime_error(
@@ -1364,30 +1366,35 @@ UniValue sendrawtransaction(const UniValue& params, bool fHelp)
     bool fOverrideFees = false;
     if (params.size() > 1)
         fOverrideFees = params[1].get_bool();
-
-    CCoinsViewCache &view = *pcoinsTip;
-    const CCoins* existingCoins = view.AccessCoins(hashTx);
-    bool fHaveMempool = mempool.exists(hashTx);
-    bool fHaveChain = existingCoins && existingCoins->nHeight < 1000000000;
-    if (!fHaveMempool && !fHaveChain) {
-        // push to local node and sync with wallets
-        CValidationState state;
-        bool fMissingInputs;
-        if (!AcceptToMemoryPool(mempool, state, tx, false, &fMissingInputs, !fOverrideFees)) {
-            if (state.IsInvalid()) {
-                throw JSONRPCError(RPC_TRANSACTION_REJECTED, strprintf("%i: %s", state.GetRejectCode(), state.GetRejectReason()));
-            } else {
-                if (fMissingInputs) {
-                    throw JSONRPCError(RPC_TRANSACTION_ERROR, "Missing inputs");
+    if ( KOMODO_NSPV_FULLNODE )
+    {
+        CCoinsViewCache &view = *pcoinsTip;
+        const CCoins* existingCoins = view.AccessCoins(hashTx);
+        bool fHaveMempool = mempool.exists(hashTx);
+        bool fHaveChain = existingCoins && existingCoins->nHeight < 1000000000;
+        if (!fHaveMempool && !fHaveChain) {
+            // push to local node and sync with wallets
+            CValidationState state;
+            bool fMissingInputs;
+            if (!AcceptToMemoryPool(mempool, state, tx, false, &fMissingInputs, !fOverrideFees)) {
+                if (state.IsInvalid()) {
+                    throw JSONRPCError(RPC_TRANSACTION_REJECTED, strprintf("%i: %s", state.GetRejectCode(), state.GetRejectReason()));
+                } else {
+                    if (fMissingInputs) {
+                        throw JSONRPCError(RPC_TRANSACTION_ERROR, "Missing inputs");
+                    }
+                    throw JSONRPCError(RPC_TRANSACTION_ERROR, state.GetRejectReason());
                 }
-                throw JSONRPCError(RPC_TRANSACTION_ERROR, state.GetRejectReason());
             }
+        } else if (fHaveChain) {
+            throw JSONRPCError(RPC_TRANSACTION_ALREADY_IN_CHAIN, "transaction already in block chain");
         }
-    } else if (fHaveChain) {
-        throw JSONRPCError(RPC_TRANSACTION_ALREADY_IN_CHAIN, "transaction already in block chain");
+        RelayTransaction(tx);
+    }
+    else
+    {
+        NSPV_broadcast((char *)params[0].get_str().c_str());
     }
-    RelayTransaction(tx);
-
     return hashTx.GetHex();
 }
 
diff --git a/src/rpc/server.cpp b/src/rpc/server.cpp
index 20229225..ab1099c4 100644
--- a/src/rpc/server.cpp
+++ b/src/rpc/server.cpp
@@ -206,7 +206,7 @@ std::string CRPCTable::help(const std::string& strCommand) const
             UniValue params;
             rpcfn_type pfn = pcmd->actor;
             if (setDone.insert(pfn).second)
-                (*pfn)(params, true);
+                (*pfn)(params, true, CPubKey());
         }
         catch (const std::exception& e)
         {
@@ -236,7 +236,7 @@ std::string CRPCTable::help(const std::string& strCommand) const
     return strRet;
 }
 
-UniValue help(const UniValue& params, bool fHelp)
+UniValue help(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() > 1)
         throw runtime_error(
@@ -264,7 +264,7 @@ void GenerateBitcoins(bool b, CWallet *pw);
 #endif
 
 
-UniValue stop(const UniValue& params, bool fHelp)
+UniValue stop(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     char buf[66+128];
    // Accept the deprecated and ignored 'detach' boolean argument
@@ -370,7 +370,6 @@ static const CRPCCommand vRPCCommands[] =
     { "crosschain",       "importgatewaypartialsign",  &importgatewaypartialsign,     true },
     { "crosschain",       "importgatewaycompletesigning",  &importgatewaycompletesigning,     true },
     { "crosschain",       "importgatewaymarkdone",  &importgatewaymarkdone,     true },
-    { "crosschain",       "importgatewaypendingdeposits",   &importgatewaypendingdeposits,      true },
     { "crosschain",       "importgatewaypendingwithdraws",   &importgatewaypendingwithdraws,      true },
     { "crosschain",       "importgatewayprocessed",   &importgatewayprocessed,  true },
 
@@ -385,6 +384,7 @@ static const CRPCCommand vRPCCommands[] =
     { "mining",             "prioritisetransaction",  &prioritisetransaction,  true  },
     { "mining",             "submitblock",            &submitblock,            true  },
     { "mining",             "getblocksubsidy",        &getblocksubsidy,        true  },
+    { "mining",             "genminingCSV",           &genminingCSV,           true  },
 
 #ifdef ENABLE_MINING
     /* Coin generation */
@@ -416,6 +416,21 @@ static const CRPCCommand vRPCCommands[] =
     { "FSM",   "FSMlist",      &FSMlist,    true },
     { "FSM",   "FSMinfo",      &FSMinfo,    true },
 
+    // fsm
+    { "nSPV",   "nspv_getinfo",         &nspv_getinfo, true },
+    { "nSPV",   "nspv_login",           &nspv_login, true },
+    { "nSPV",   "nspv_listunspent",     &nspv_listunspent,  true },
+    { "nSPV",   "nspv_mempool",         &nspv_mempool,  true },
+    { "nSPV",   "nspv_listtransactions",&nspv_listtransactions,  true },
+    { "nSPV",   "nspv_spentinfo",       &nspv_spentinfo,    true },
+    { "nSPV",   "nspv_notarizations",   &nspv_notarizations,    true },
+    { "nSPV",   "nspv_hdrsproof",       &nspv_hdrsproof,    true },
+    { "nSPV",   "nspv_txproof",         &nspv_txproof,    true },
+    { "nSPV",   "nspv_spend",           &nspv_spend,    true },
+    { "nSPV",   "nspv_broadcast",       &nspv_broadcast,    true },
+    { "nSPV",   "nspv_logout",          &nspv_logout,    true },
+    { "nSPV",   "nspv_listccmoduleunspent",     &nspv_listccmoduleunspent,  true },
+
     // rewards
     { "rewards",       "rewardslist",       &rewardslist,     true },
     { "rewards",       "rewardsinfo",       &rewardsinfo,     true },
@@ -460,6 +475,7 @@ static const CRPCCommand vRPCCommands[] =
     { "oracles",       "oraclesregister",  &oraclesregister,    true },
     { "oracles",       "oraclessubscribe", &oraclessubscribe,   true },
     { "oracles",       "oraclesdata",      &oraclesdata,        true },
+    { "oracles",       "oraclessample",   &oraclessample,     true },
     { "oracles",       "oraclessamples",   &oraclessamples,     true },
 
     // Prices
@@ -553,6 +569,18 @@ static const CRPCCommand vRPCCommands[] =
     //{ "tokens",       "tokenfillswap",    &tokenfillswap,     true },
     { "tokens",       "tokenconvert", &tokenconvert, true },
 
+    // pegs
+    { "pegs",       "pegscreate",     &pegscreate,      true },
+    { "pegs",       "pegsfund",         &pegsfund,      true },
+    { "pegs",       "pegsget",         &pegsget,        true },
+    { "pegs",       "pegsredeem",         &pegsredeem,        true },
+    { "pegs",       "pegsliquidate",         &pegsliquidate,        true },
+    { "pegs",       "pegsexchange",         &pegsexchange,        true },
+    { "pegs",       "pegsaccounthistory", &pegsaccounthistory,      true },
+    { "pegs",       "pegsaccountinfo", &pegsaccountinfo,      true },
+    { "pegs",       "pegsworstaccounts",         &pegsworstaccounts,      true },
+    { "pegs",       "pegsinfo",         &pegsinfo,      true },
+
     /* Address index */
     { "addressindex",       "getaddressmempool",      &getaddressmempool,      true  },
     { "addressindex",       "getaddressutxos",        &getaddressutxos,        false },
@@ -843,7 +871,7 @@ UniValue CRPCTable::execute(const std::string &strMethod, const UniValue &params
     try
     {
         // Execute
-        return pcmd->actor(params, false);
+        return pcmd->actor(params, false, CPubKey());
     }
     catch (const std::exception& e)
     {
diff --git a/src/rpc/server.h b/src/rpc/server.h
index 9ee71e35..0be2c208 100644
--- a/src/rpc/server.h
+++ b/src/rpc/server.h
@@ -34,6 +34,7 @@
 #include <boost/function.hpp>
 
 #include <univalue.h>
+#include <pubkey.h>
 
 class AsyncRPCQueue;
 class CRPCCommand;
@@ -133,7 +134,7 @@ void RPCUnregisterTimerInterface(RPCTimerInterface *iface);
  */
 void RPCRunLater(const std::string& name, boost::function<void(void)> func, int64_t nSeconds);
 
-typedef UniValue(*rpcfn_type)(const UniValue& params, bool fHelp);
+typedef UniValue(*rpcfn_type)(const UniValue& params, bool fHelp, const CPubKey& mypk);
 
 class CRPCCommand
 {
@@ -209,318 +210,342 @@ std::string JSONRPCExecBatch(const UniValue& vReq);
 
 extern std::string experimentalDisabledHelpMsg(const std::string& rpc, const std::string& enableArg);
 
-extern UniValue getconnectioncount(const UniValue& params, bool fHelp); // in rpcnet.cpp
-extern UniValue getaddressmempool(const UniValue& params, bool fHelp);
-extern UniValue getaddressutxos(const UniValue& params, bool fHelp);
-extern UniValue getaddressdeltas(const UniValue& params, bool fHelp);
-extern UniValue getaddresstxids(const UniValue& params, bool fHelp);
-extern UniValue getsnapshot(const UniValue& params, bool fHelp);
-extern UniValue getaddressbalance(const UniValue& params, bool fHelp);
-extern UniValue getpeerinfo(const UniValue& params, bool fHelp);
-extern UniValue checknotarization(const UniValue& params, bool fHelp);
-extern UniValue getnotarypayinfo(const UniValue& params, bool fHelp);
-extern UniValue ping(const UniValue& params, bool fHelp);
-extern UniValue addnode(const UniValue& params, bool fHelp);
-extern UniValue disconnectnode(const UniValue& params, bool fHelp);
-extern UniValue getaddednodeinfo(const UniValue& params, bool fHelp);
-extern UniValue getnettotals(const UniValue& params, bool fHelp);
-extern UniValue setban(const UniValue& params, bool fHelp);
-extern UniValue listbanned(const UniValue& params, bool fHelp);
-extern UniValue clearbanned(const UniValue& params, bool fHelp);
-
-extern UniValue dumpprivkey(const UniValue& params, bool fHelp); // in rpcdump.cpp
-extern UniValue importprivkey(const UniValue& params, bool fHelp);
-extern UniValue importaddress(const UniValue& params, bool fHelp);
-extern UniValue dumpwallet(const UniValue& params, bool fHelp);
-extern UniValue importwallet(const UniValue& params, bool fHelp);
-
-extern UniValue getgenerate(const UniValue& params, bool fHelp); // in rpcmining.cpp
-extern UniValue setgenerate(const UniValue& params, bool fHelp);
-extern UniValue generate(const UniValue& params, bool fHelp);
-extern UniValue getlocalsolps(const UniValue& params, bool fHelp);
-extern UniValue getnetworksolps(const UniValue& params, bool fHelp);
-extern UniValue getnetworkhashps(const UniValue& params, bool fHelp);
-extern UniValue getmininginfo(const UniValue& params, bool fHelp);
-extern UniValue prioritisetransaction(const UniValue& params, bool fHelp);
-extern UniValue getblocktemplate(const UniValue& params, bool fHelp);
-extern UniValue submitblock(const UniValue& params, bool fHelp);
-extern UniValue estimatefee(const UniValue& params, bool fHelp);
-extern UniValue estimatepriority(const UniValue& params, bool fHelp);
-extern UniValue coinsupply(const UniValue& params, bool fHelp);
-extern UniValue tokeninfo(const UniValue& params, bool fHelp);
-extern UniValue tokenlist(const UniValue& params, bool fHelp);
-extern UniValue tokenorders(const UniValue& params, bool fHelp);
-extern UniValue mytokenorders(const UniValue& params, bool fHelp);
-extern UniValue tokenbalance(const UniValue& params, bool fHelp);
-extern UniValue assetsaddress(const UniValue& params, bool fHelp);
-extern UniValue tokenaddress(const UniValue& params, bool fHelp);
-extern UniValue tokencreate(const UniValue& params, bool fHelp);
-extern UniValue tokentransfer(const UniValue& params, bool fHelp);
-extern UniValue tokenbid(const UniValue& params, bool fHelp);
-extern UniValue tokencancelbid(const UniValue& params, bool fHelp);
-extern UniValue tokenfillbid(const UniValue& params, bool fHelp);
-extern UniValue tokenask(const UniValue& params, bool fHelp);
-extern UniValue tokencancelask(const UniValue& params, bool fHelp);
-extern UniValue tokenfillask(const UniValue& params, bool fHelp);
-extern UniValue tokenconvert(const UniValue& params, bool fHelp);
-extern UniValue heiraddress(const UniValue& params, bool fHelp);
-extern UniValue heirfund(const UniValue& params, bool fHelp);
-extern UniValue heiradd(const UniValue& params, bool fHelp);
-extern UniValue heirclaim(const UniValue& params, bool fHelp);
-extern UniValue heirinfo(const UniValue& params, bool fHelp);
-extern UniValue heirlist(const UniValue& params, bool fHelp);
-extern UniValue channelsaddress(const UniValue& params, bool fHelp);
-extern UniValue oraclesaddress(const UniValue& params, bool fHelp);
-extern UniValue oracleslist(const UniValue& params, bool fHelp);
-extern UniValue oraclesinfo(const UniValue& params, bool fHelp);
-extern UniValue oraclescreate(const UniValue& params, bool fHelp);
-extern UniValue 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);
-extern UniValue oraclessamples(const UniValue& params, bool fHelp);
-extern UniValue pricesaddress(const UniValue& params, bool fHelp);
-extern UniValue priceslist(const UniValue& params, bool fHelp);
-extern UniValue mypriceslist(const UniValue& params, bool fHelp);
-extern UniValue pricesinfo(const UniValue& params, bool fHelp);
-extern UniValue pegsaddress(const UniValue& params, bool fHelp);
-extern UniValue marmaraaddress(const UniValue& params, bool fHelp);
-extern UniValue marmara_poolpayout(const UniValue& params, bool fHelp);
-extern UniValue marmara_receive(const UniValue& params, bool fHelp);
-extern UniValue marmara_issue(const UniValue& params, bool fHelp);
-extern UniValue marmara_transfer(const UniValue& params, bool fHelp);
-extern UniValue marmara_info(const UniValue& params, bool fHelp);
-extern UniValue marmara_creditloop(const UniValue& params, bool fHelp);
-extern UniValue marmara_settlement(const UniValue& params, bool fHelp);
-extern UniValue marmara_lock(const UniValue& params, bool fHelp);
-extern UniValue paymentsaddress(const UniValue& params, bool fHelp);
-extern UniValue payments_release(const UniValue& params, bool fHelp);
-extern UniValue payments_fund(const UniValue& params, bool fHelp);
-extern UniValue payments_merge(const UniValue& params, bool fHelp);
-extern UniValue payments_txidopret(const UniValue& params, bool fHelp);
-extern UniValue payments_create(const UniValue& params, bool fHelp);
-extern UniValue payments_airdrop(const UniValue& params, bool fHelp);
-extern UniValue payments_airdroptokens(const UniValue& params, bool fHelp);
-extern UniValue payments_info(const UniValue& params, bool fHelp);
-extern UniValue payments_list(const UniValue& params, bool fHelp);
-
-extern UniValue cclibaddress(const UniValue& params, bool fHelp);
-extern UniValue cclibinfo(const UniValue& params, bool fHelp);
-extern UniValue cclib(const UniValue& params, bool fHelp);
-extern UniValue gatewaysaddress(const UniValue& params, bool fHelp);
-extern UniValue gatewayslist(const UniValue& params, bool fHelp);
-extern UniValue gatewaysinfo(const UniValue& params, bool fHelp);
-extern UniValue gatewaysdumpprivkey(const UniValue& params, bool fHelp);
-extern UniValue gatewaysexternaladdress(const UniValue& params, bool fHelp);
-extern UniValue gatewaysbind(const UniValue& params, bool fHelp);
-extern UniValue gatewaysdeposit(const UniValue& params, bool fHelp);
-extern UniValue gatewaysclaim(const UniValue& params, bool fHelp);
-extern UniValue gatewayswithdraw(const UniValue& params, bool fHelp);
-extern UniValue gatewayspartialsign(const UniValue& params, bool fHelp);
-extern UniValue gatewayscompletesigning(const UniValue& params, bool fHelp);
-extern UniValue gatewaysmarkdone(const UniValue& params, bool fHelp);
-extern UniValue gatewayspendingdeposits(const UniValue& params, bool fHelp);
-extern UniValue gatewayspendingwithdraws(const UniValue& params, bool fHelp);
-extern UniValue gatewaysprocessed(const UniValue& params, bool fHelp);
-extern UniValue channelslist(const UniValue& params, bool fHelp);
-extern UniValue channelsinfo(const UniValue& params, bool fHelp);
-extern UniValue channelsopen(const UniValue& params, bool fHelp);
-extern UniValue channelspayment(const UniValue& params, bool fHelp);
-extern UniValue channelsclose(const UniValue& params, bool fHelp);
-extern UniValue channelsrefund(const UniValue& params, bool fHelp);
-
-//extern UniValue tokenswapask(const UniValue& params, bool fHelp);
-//extern UniValue tokenfillswap(const UniValue& params, bool fHelp);
-extern UniValue faucetfund(const UniValue& params, bool fHelp);
-extern UniValue faucetget(const UniValue& params, bool fHelp);
-extern UniValue faucetaddress(const UniValue& params, bool fHelp);
-extern UniValue faucetinfo(const UniValue& params, bool fHelp);
-extern UniValue rewardsinfo(const UniValue& params, bool fHelp);
-extern UniValue rewardslist(const UniValue& params, bool fHelp);
-extern UniValue rewardsaddress(const UniValue& params, bool fHelp);
-extern UniValue rewardscreatefunding(const UniValue& params, bool fHelp);
-extern UniValue rewardsaddfunding(const UniValue& params, bool fHelp);
-extern UniValue rewardslock(const UniValue& params, bool fHelp);
-extern UniValue rewardsunlock(const UniValue& params, bool fHelp);
-extern UniValue diceaddress(const UniValue& params, bool fHelp);
-extern UniValue dicefund(const UniValue& params, bool fHelp);
-extern UniValue dicelist(const UniValue& params, bool fHelp);
-extern UniValue diceinfo(const UniValue& params, bool fHelp);
-extern UniValue diceaddfunds(const UniValue& params, bool fHelp);
-extern UniValue dicebet(const UniValue& params, bool fHelp);
-extern UniValue dicefinish(const UniValue& params, bool fHelp);
-extern UniValue dicestatus(const UniValue& params, bool fHelp);
-extern UniValue lottoaddress(const UniValue& params, bool fHelp);
-extern UniValue FSMaddress(const UniValue& params, bool fHelp);
-extern UniValue FSMcreate(const UniValue& params, bool fHelp);
-extern UniValue FSMlist(const UniValue& params, bool fHelp);
-extern UniValue FSMinfo(const UniValue& params, bool fHelp);
-extern UniValue auctionaddress(const UniValue& params, bool fHelp);
-
-extern UniValue getnewaddress(const UniValue& params, bool fHelp); // in rpcwallet.cpp
-//extern UniValue getnewaddress64(const UniValue& params, bool fHelp); // in rpcwallet.cpp
-extern UniValue getaccountaddress(const UniValue& params, bool fHelp);
-extern UniValue getrawchangeaddress(const UniValue& params, bool fHelp);
-extern UniValue setaccount(const UniValue& params, bool fHelp);
-extern UniValue getaccount(const UniValue& params, bool fHelp);
-extern UniValue getaddressesbyaccount(const UniValue& params, bool fHelp);
-extern UniValue sendtoaddress(const UniValue& params, bool fHelp);
-extern UniValue signmessage(const UniValue& params, bool fHelp);
-extern UniValue verifymessage(const UniValue& params, bool fHelp);
-extern UniValue getreceivedbyaddress(const UniValue& params, bool fHelp);
-extern UniValue getreceivedbyaccount(const UniValue& params, bool fHelp);
-extern UniValue cleanwallettransactions(const UniValue& params, bool fHelp);
-extern UniValue getbalance(const UniValue& params, bool fHelp);
-extern UniValue getbalance64(const UniValue& params, bool fHelp);
-extern UniValue getunconfirmedbalance(const UniValue& params, bool fHelp);
-extern UniValue movecmd(const UniValue& params, bool fHelp);
-extern UniValue sendfrom(const UniValue& params, bool fHelp);
-extern UniValue sendmany(const UniValue& params, bool fHelp);
-extern UniValue addmultisigaddress(const UniValue& params, bool fHelp);
-extern UniValue createmultisig(const UniValue& params, bool fHelp);
-extern UniValue listreceivedbyaddress(const UniValue& params, bool fHelp);
-extern UniValue listreceivedbyaccount(const UniValue& params, bool fHelp);
-extern UniValue listtransactions(const UniValue& params, bool fHelp);
-extern UniValue listaddressgroupings(const UniValue& params, bool fHelp);
-extern UniValue listaccounts(const UniValue& params, bool fHelp);
-extern UniValue listsinceblock(const UniValue& params, bool fHelp);
-extern UniValue gettransaction(const UniValue& params, bool fHelp);
-extern UniValue backupwallet(const UniValue& params, bool fHelp);
-extern UniValue keypoolrefill(const UniValue& params, bool fHelp);
-extern UniValue walletpassphrase(const UniValue& params, bool fHelp);
-extern UniValue walletpassphrasechange(const UniValue& params, bool fHelp);
-extern UniValue walletlock(const UniValue& params, bool fHelp);
-extern UniValue encryptwallet(const UniValue& params, bool fHelp);
-extern UniValue validateaddress(const UniValue& params, bool fHelp);
-extern UniValue txnotarizedconfirmed(const UniValue& params, bool fHelp);
-extern UniValue decodeccopret(const UniValue& params, bool fHelp);
-extern UniValue getinfo(const UniValue& params, bool fHelp);
-extern UniValue getiguanajson(const UniValue& params, bool fHelp);
-extern UniValue getnotarysendmany(const UniValue& params, bool fHelp);
-extern UniValue geterablockheights(const UniValue& params, bool fHelp);
-extern UniValue setpubkey(const UniValue& params, bool fHelp);
-extern UniValue setstakingsplit(const UniValue& params, bool fHelp);
-extern UniValue getwalletinfo(const UniValue& params, bool fHelp);
-extern UniValue getblockchaininfo(const UniValue& params, bool fHelp);
-extern UniValue getnetworkinfo(const UniValue& params, bool fHelp);
-extern UniValue getdeprecationinfo(const UniValue& params, bool fHelp);
-extern UniValue setmocktime(const UniValue& params, bool fHelp);
-extern UniValue resendwallettransactions(const UniValue& params, bool fHelp);
-extern UniValue zc_benchmark(const UniValue& params, bool fHelp);
-extern UniValue zc_raw_keygen(const UniValue& params, bool fHelp);
-extern UniValue zc_raw_joinsplit(const UniValue& params, bool fHelp);
-extern UniValue zc_raw_receive(const UniValue& params, bool fHelp);
-extern UniValue zc_sample_joinsplit(const UniValue& params, bool fHelp);
-
-extern UniValue jumblr_deposit(const UniValue& params, bool fHelp);
-extern UniValue jumblr_secret(const UniValue& params, bool fHelp);
-extern UniValue jumblr_pause(const UniValue& params, bool fHelp);
-extern UniValue jumblr_resume(const UniValue& params, bool fHelp);
-
-extern UniValue getrawtransaction(const UniValue& params, bool fHelp); // in rcprawtransaction.cpp
-extern UniValue listunspent(const UniValue& params, bool fHelp);
-extern UniValue lockunspent(const UniValue& params, bool fHelp);
-extern UniValue listlockunspent(const UniValue& params, bool fHelp);
-extern UniValue createrawtransaction(const UniValue& params, bool fHelp);
-extern UniValue decoderawtransaction(const UniValue& params, bool fHelp);
-extern UniValue decodescript(const UniValue& params, bool fHelp);
-extern UniValue fundrawtransaction(const UniValue& params, bool fHelp);
-extern UniValue signrawtransaction(const UniValue& params, bool fHelp);
-extern UniValue sendrawtransaction(const UniValue& params, bool fHelp);
-extern UniValue gettxoutproof(const UniValue& params, bool fHelp);
-extern UniValue verifytxoutproof(const UniValue& params, bool fHelp);
-
-extern UniValue getblockcount(const UniValue& params, bool fHelp); // in rpcblockchain.cpp
-extern UniValue getbestblockhash(const UniValue& params, bool fHelp);
-extern UniValue getdifficulty(const UniValue& params, bool fHelp);
-extern UniValue settxfee(const UniValue& params, bool fHelp);
-extern UniValue getmempoolinfo(const UniValue& params, bool fHelp);
-extern UniValue getrawmempool(const UniValue& params, bool fHelp);
-extern UniValue getblockhashes(const UniValue& params, bool fHelp);
-extern UniValue getblockdeltas(const UniValue& params, bool fHelp);
-extern UniValue getblockhash(const UniValue& params, bool fHelp);
-extern UniValue getblockheader(const UniValue& params, bool fHelp);
-extern UniValue getlastsegidstakes(const UniValue& params, bool fHelp);
-extern UniValue getblock(const UniValue& params, bool fHelp);
-extern UniValue gettxoutsetinfo(const UniValue& params, bool fHelp);
-extern UniValue gettxout(const UniValue& params, bool fHelp);
-extern UniValue verifychain(const UniValue& params, bool fHelp);
-extern UniValue getchaintips(const UniValue& params, bool fHelp);
-extern UniValue invalidateblock(const UniValue& params, bool fHelp);
-extern UniValue reconsiderblock(const UniValue& params, bool fHelp);
-extern UniValue getspentinfo(const UniValue& params, bool fHelp);
-extern UniValue selfimport(const UniValue& params, bool fHelp);
-extern UniValue importdual(const UniValue& params, bool fHelp);
-extern UniValue importgatewayaddress(const UniValue& params, bool fHelp);
-extern UniValue importgatewayinfo(const UniValue& params, bool fHelp);
-extern UniValue importgatewaybind(const UniValue& params, bool fHelp);
-extern UniValue importgatewaydeposit(const UniValue& params, bool fHelp);
-extern UniValue importgatewaywithdraw(const UniValue& params, bool fHelp);
-extern UniValue importgatewaypartialsign(const UniValue& params, bool fHelp);
-extern UniValue importgatewaycompletesigning(const UniValue& params, bool fHelp);
-extern UniValue importgatewaymarkdone(const UniValue& params, bool fHelp);
-extern UniValue importgatewaypendingdeposits(const UniValue& params, bool fHelp);
-extern UniValue importgatewaypendingwithdraws(const UniValue& params, bool fHelp);
-extern UniValue importgatewayprocessed(const UniValue& params, bool fHelp);
-
-extern UniValue getblocksubsidy(const UniValue& params, bool fHelp);
-
-extern UniValue z_exportkey(const UniValue& params, bool fHelp); // in rpcdump.cpp
-extern UniValue z_importkey(const UniValue& params, bool fHelp); // in rpcdump.cpp
-extern UniValue z_exportviewingkey(const UniValue& params, bool fHelp); // in rpcdump.cpp
-extern UniValue z_importviewingkey(const UniValue& params, bool fHelp); // in rpcdump.cpp
-extern UniValue z_getnewaddress(const UniValue& params, bool fHelp); // in rpcwallet.cpp
-extern UniValue z_listaddresses(const UniValue& params, bool fHelp); // in rpcwallet.cpp
-extern UniValue z_exportwallet(const UniValue& params, bool fHelp); // in rpcdump.cpp
-extern UniValue z_importwallet(const UniValue& params, bool fHelp); // in rpcdump.cpp
-extern UniValue z_listreceivedbyaddress(const UniValue& params, bool fHelp); // in rpcwallet.cpp
-extern UniValue z_getbalance(const UniValue& params, bool fHelp); // in rpcwallet.cpp
-extern UniValue z_gettotalbalance(const UniValue& params, bool fHelp); // in rpcwallet.cpp
-extern UniValue z_mergetoaddress(const UniValue& params, bool fHelp); // in rpcwallet.cpp
-extern UniValue z_sendmany(const UniValue& params, bool fHelp); // in rpcwallet.cpp
-extern UniValue z_shieldcoinbase(const UniValue& params, bool fHelp); // in rpcwallet.cpp
-extern UniValue z_getoperationstatus(const UniValue& params, bool fHelp); // in rpcwallet.cpp
-extern UniValue z_getoperationresult(const UniValue& params, bool fHelp); // in rpcwallet.cpp
-extern UniValue z_listoperationids(const UniValue& params, bool fHelp); // in rpcwallet.cpp
-extern UniValue opreturn_burn(const UniValue& params, bool fHelp); // in rpcwallet.cpp
-extern UniValue z_validateaddress(const UniValue& params, bool fHelp); // in rpcmisc.cpp
-extern UniValue z_getpaymentdisclosure(const UniValue& params, bool fHelp); // in rpcdisclosure.cpp
-extern UniValue z_validatepaymentdisclosure(const UniValue &params, bool fHelp); // in rpcdisclosure.cpp
-
-extern UniValue MoMoMdata(const UniValue& params, bool fHelp);
-extern UniValue calc_MoM(const UniValue& params, bool fHelp);
-extern UniValue height_MoM(const UniValue& params, bool fHelp);
-extern UniValue assetchainproof(const UniValue& params, bool fHelp);
-extern UniValue crosschainproof(const UniValue& params, bool fHelp);
-extern UniValue getNotarisationsForBlock(const UniValue& params, bool fHelp);
-extern UniValue scanNotarisationsDB(const UniValue& params, bool fHelp);
-extern UniValue getimports(const UniValue& params, bool fHelp);
-extern UniValue getwalletburntransactions(const UniValue& params, bool fHelp);
-extern UniValue migrate_converttoexport(const UniValue& params, bool fHelp);
-extern UniValue migrate_createburntransaction(const UniValue& params, bool fHelp);
-extern UniValue migrate_createimporttransaction(const UniValue& params, bool fHelp);
-extern UniValue migrate_completeimporttransaction(const UniValue& params, bool fHelp);
-extern UniValue migrate_checkburntransactionsource(const UniValue& params, bool fHelp);
-extern UniValue migrate_createnotaryapprovaltransaction(const UniValue& params, bool fHelp);
-
-extern UniValue notaries(const UniValue& params, bool fHelp);
-extern UniValue minerids(const UniValue& params, bool fHelp);
-extern UniValue kvsearch(const UniValue& params, bool fHelp);
-extern UniValue kvupdate(const UniValue& params, bool fHelp);
-extern UniValue paxprice(const UniValue& params, bool fHelp);
-extern UniValue paxpending(const UniValue& params, bool fHelp);
-extern UniValue paxprices(const UniValue& params, bool fHelp);
-extern UniValue paxdeposit(const UniValue& params, bool fHelp);
-extern UniValue paxwithdraw(const UniValue& params, bool fHelp);
-
-extern UniValue prices(const UniValue& params, bool fHelp);
-extern UniValue pricesbet(const UniValue& params, bool fHelp);
-extern UniValue pricessetcostbasis(const UniValue& params, bool fHelp);
-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);
+extern UniValue getconnectioncount(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcnet.cpp
+extern UniValue getaddressmempool(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getaddressutxos(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getaddressdeltas(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getaddresstxids(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getsnapshot(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getaddressbalance(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getpeerinfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue checknotarization(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getnotarypayinfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue ping(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue addnode(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue disconnectnode(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getaddednodeinfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getnettotals(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue setban(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue listbanned(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue clearbanned(const UniValue& params, bool fHelp, const CPubKey& mypk);
+
+extern UniValue dumpprivkey(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcdump.cpp
+extern UniValue importprivkey(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue importaddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue dumpwallet(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue importwallet(const UniValue& params, bool fHelp, const CPubKey& mypk);
+
+extern UniValue getgenerate(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcmining.cpp
+extern UniValue setgenerate(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue generate(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getlocalsolps(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getnetworksolps(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getnetworkhashps(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getmininginfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue prioritisetransaction(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getblocktemplate(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue submitblock(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue estimatefee(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue estimatepriority(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue coinsupply(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue tokeninfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue tokenlist(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue tokenorders(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue mytokenorders(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue tokenbalance(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue assetsaddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue tokenaddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue tokencreate(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue tokentransfer(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue tokenbid(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue tokencancelbid(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue tokenfillbid(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue tokenask(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue tokencancelask(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue tokenfillask(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue tokenconvert(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue heiraddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue heirfund(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue heiradd(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue heirclaim(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue heirinfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue heirlist(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue channelsaddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue oraclesaddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue oracleslist(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue oraclesinfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue oraclescreate(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue oraclesfund(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue oraclesregister(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue oraclessubscribe(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue oraclesdata(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue oraclessample(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue oraclessamples(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue pricesaddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue priceslist(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue mypriceslist(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue pricesinfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue pegsaddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue marmaraaddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue marmara_poolpayout(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue marmara_receive(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue marmara_issue(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue marmara_transfer(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue marmara_info(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue marmara_creditloop(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue marmara_settlement(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue marmara_lock(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue paymentsaddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue payments_release(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue payments_fund(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue payments_merge(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue payments_txidopret(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue payments_create(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue payments_airdrop(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue payments_airdroptokens(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue payments_info(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue payments_list(const UniValue& params, bool fHelp, const CPubKey& mypk);
+
+extern UniValue cclibaddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue cclibinfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue cclib(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue gatewaysaddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue gatewayslist(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue gatewaysinfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue gatewaysdumpprivkey(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue gatewaysexternaladdress(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue gatewaysbind(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue gatewaysdeposit(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue gatewaysclaim(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue gatewayswithdraw(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue gatewayspartialsign(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue gatewayscompletesigning(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue gatewaysmarkdone(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue gatewayspendingdeposits(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue gatewayspendingwithdraws(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue gatewaysprocessed(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue channelslist(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue channelsinfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue channelsopen(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue channelspayment(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue channelsclose(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue channelsrefund(const UniValue& params, bool fHelp, const CPubKey& mypk);
+//extern UniValue tokenswapask(const UniValue& params, bool fHelp, const CPubKey& mypk);
+//extern UniValue tokenfillswap(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue faucetfund(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue faucetget(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue faucetaddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue faucetinfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue rewardsinfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue rewardslist(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue rewardsaddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue rewardscreatefunding(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue rewardsaddfunding(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue rewardslock(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue rewardsunlock(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue diceaddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue dicefund(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue dicelist(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue diceinfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue diceaddfunds(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue dicebet(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue dicefinish(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue dicestatus(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue lottoaddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue FSMaddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue FSMcreate(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue FSMlist(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue FSMinfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue auctionaddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue pegscreate(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue pegsfund(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue pegsget(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue pegsredeem(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue pegsliquidate(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue pegsexchange(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue pegsaccounthistory(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue pegsaccountinfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue pegsworstaccounts(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue pegsinfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
+
+extern UniValue getnewaddress(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcwallet.cpp
+//extern UniValue getnewaddress64(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcwallet.cpp
+extern UniValue getaccountaddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getrawchangeaddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue setaccount(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getaccount(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getaddressesbyaccount(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue sendtoaddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue signmessage(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue verifymessage(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getreceivedbyaddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getreceivedbyaccount(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue cleanwallettransactions(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getbalance(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getbalance64(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getunconfirmedbalance(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue movecmd(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue sendfrom(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue sendmany(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue addmultisigaddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue createmultisig(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue listreceivedbyaddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue listreceivedbyaccount(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue listtransactions(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue listaddressgroupings(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue listaccounts(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue listsinceblock(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue gettransaction(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue backupwallet(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue keypoolrefill(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue walletpassphrase(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue walletpassphrasechange(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue walletlock(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue encryptwallet(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue validateaddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue txnotarizedconfirmed(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue decodeccopret(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getinfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getiguanajson(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getnotarysendmany(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue geterablockheights(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue setpubkey(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue setstakingsplit(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getwalletinfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getblockchaininfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getnetworkinfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getdeprecationinfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue setmocktime(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue resendwallettransactions(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue zc_benchmark(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue zc_raw_keygen(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue zc_raw_joinsplit(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue zc_raw_receive(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue zc_sample_joinsplit(const UniValue& params, bool fHelp, const CPubKey& mypk);
+
+extern UniValue jumblr_deposit(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue jumblr_secret(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue jumblr_pause(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue jumblr_resume(const UniValue& params, bool fHelp, const CPubKey& mypk);
+
+extern UniValue getrawtransaction(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rcprawtransaction.cpp
+extern UniValue listunspent(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue lockunspent(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue listlockunspent(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue createrawtransaction(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue decoderawtransaction(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue decodescript(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue fundrawtransaction(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue signrawtransaction(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue sendrawtransaction(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue gettxoutproof(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue verifytxoutproof(const UniValue& params, bool fHelp, const CPubKey& mypk);
+
+extern UniValue getblockcount(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcblockchain.cpp
+extern UniValue getbestblockhash(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getdifficulty(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue settxfee(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getmempoolinfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getrawmempool(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getblockhashes(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getblockdeltas(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getblockhash(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getblockheader(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getlastsegidstakes(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getblock(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue gettxoutsetinfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue gettxout(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue verifychain(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getchaintips(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue invalidateblock(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue reconsiderblock(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getspentinfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue selfimport(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue importdual(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue importgatewayaddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue importgatewayinfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue importgatewaybind(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue importgatewaydeposit(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue importgatewaywithdraw(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue importgatewaypartialsign(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue importgatewaycompletesigning(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue importgatewaymarkdone(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue importgatewaypendingwithdraws(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue importgatewayprocessed(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue genminingCSV(const UniValue& params, bool fHelp, const CPubKey& mypk);
+
+extern UniValue nspv_getinfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue nspv_login(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue nspv_listtransactions(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue nspv_mempool(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue nspv_listunspent(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue nspv_spentinfo(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue nspv_notarizations(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue nspv_hdrsproof(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue nspv_txproof(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue nspv_spend(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue nspv_broadcast(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue nspv_logout(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue nspv_listccmoduleunspent(const UniValue& params, bool fHelp, const CPubKey& mypk);
+
+extern UniValue getblocksubsidy(const UniValue& params, bool fHelp, const CPubKey& mypk);
+
+extern UniValue z_exportkey(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcdump.cpp
+extern UniValue z_importkey(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcdump.cpp
+extern UniValue z_exportviewingkey(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcdump.cpp
+extern UniValue z_importviewingkey(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcdump.cpp
+extern UniValue z_getnewaddress(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcwallet.cpp
+extern UniValue z_listaddresses(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcwallet.cpp
+extern UniValue z_exportwallet(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcdump.cpp
+extern UniValue z_importwallet(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcdump.cpp
+extern UniValue z_listreceivedbyaddress(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcwallet.cpp
+extern UniValue z_getbalance(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcwallet.cpp
+extern UniValue z_gettotalbalance(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcwallet.cpp
+extern UniValue z_mergetoaddress(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcwallet.cpp
+extern UniValue z_sendmany(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcwallet.cpp
+extern UniValue z_shieldcoinbase(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcwallet.cpp
+extern UniValue z_getoperationstatus(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcwallet.cpp
+extern UniValue z_getoperationresult(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcwallet.cpp
+extern UniValue z_listoperationids(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcwallet.cpp
+extern UniValue opreturn_burn(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcwallet.cpp
+extern UniValue z_validateaddress(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcmisc.cpp
+extern UniValue z_getpaymentdisclosure(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcdisclosure.cpp
+extern UniValue z_validatepaymentdisclosure(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcdisclosure.cpp
+
+extern UniValue MoMoMdata(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue calc_MoM(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue height_MoM(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue assetchainproof(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue crosschainproof(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getNotarisationsForBlock(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue scanNotarisationsDB(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getimports(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue getwalletburntransactions(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue migrate_converttoexport(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue migrate_createburntransaction(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue migrate_createimporttransaction(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue migrate_completeimporttransaction(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue migrate_checkburntransactionsource(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue migrate_createnotaryapprovaltransaction(const UniValue& params, bool fHelp, const CPubKey& mypk);
+
+extern UniValue notaries(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue minerids(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue kvsearch(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue kvupdate(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue paxprice(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue paxpending(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue paxprices(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue paxdeposit(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue paxwithdraw(const UniValue& params, bool fHelp, const CPubKey& mypk);
+
+extern UniValue prices(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue pricesbet(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue pricessetcostbasis(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue pricescashout(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue pricesrekt(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue pricesaddfunding(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue pricesgetorderbook(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue pricesrefillfund(const UniValue& params, bool fHelp, const CPubKey& mypk);
 
 
 
diff --git a/src/rpc/testtransactions.cpp b/src/rpc/testtransactions.cpp
new file mode 100644
index 00000000..c41e97e1
--- /dev/null
+++ b/src/rpc/testtransactions.cpp
@@ -0,0 +1,268 @@
+// Copyright (c) 2010 Satoshi Nakamoto
+// Copyright (c) 2009-2014 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+/******************************************************************************
+ * Copyright © 2014-2019 The SuperNET Developers.                             *
+ *                                                                            *
+ * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at                  *
+ * the top-level directory of this distribution for the individual copyright  *
+ * holder information and the developer policies on copyright and licensing.  *
+ *                                                                            *
+ * Unless otherwise agreed in a custom licensing agreement, no part of the    *
+ * SuperNET software, including this file may be copied, modified, propagated *
+ * or distributed except according to the terms contained in the LICENSE file *
+ *                                                                            *
+ * Removal or modification of this copyright notice is prohibited.            *
+ *                                                                            *
+ ******************************************************************************/
+
+#include <stdexcept>
+
+#include "amount.h"
+#include "chain.h"
+#include "chainparams.h"
+#include "checkpoints.h"
+#include "crosschain.h"
+#include "base58.h"
+#include "consensus/validation.h"
+#include "cc/eval.h"
+#include "main.h"
+#include "primitives/transaction.h"
+#include "rpc/server.h"
+#include "streams.h"
+#include "sync.h"
+#include "util.h"
+#include "script/script.h"
+#include "script/script_error.h"
+#include "script/sign.h"
+#include "script/standard.h"
+
+#include <stdint.h>
+
+#include <univalue.h>
+
+#include <regex>
+
+
+#include "cc/CCinclude.h"
+#include "cc/CCPrices.h"
+
+using namespace std;
+
+int32_t ensure_CCrequirements(uint8_t evalcode);
+
+UniValue test_ac(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    // make fake token tx: 
+    struct CCcontract_info *cp, C;
+
+    if (fHelp || (params.size() != 4))
+        throw runtime_error("incorrect params\n");
+    if (ensure_CCrequirements(EVAL_HEIR) < 0)
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+
+    std::vector<unsigned char> pubkey1;
+    std::vector<unsigned char> pubkey2;
+
+    pubkey1 = ParseHex(params[0].get_str().c_str());
+    pubkey2 = ParseHex(params[1].get_str().c_str());
+
+    CPubKey pk1 = pubkey2pk(pubkey1);
+    CPubKey pk2 = pubkey2pk(pubkey2);
+
+    if (!pk1.IsValid() || !pk2.IsValid())
+        throw runtime_error("invalid pubkey\n");
+
+    int64_t txfee = 10000;
+    int64_t amount = atoll(params[2].get_str().c_str()) * COIN;
+    uint256 fundingtxid = Parseuint256((char *)params[3].get_str().c_str());
+
+    CPubKey myPubkey = pubkey2pk(Mypubkey());
+    CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
+
+    int64_t normalInputs = AddNormalinputs(mtx, myPubkey, txfee + amount, 60);
+
+    if (normalInputs < txfee + amount)
+        throw runtime_error("not enough normals\n");
+
+    mtx.vout.push_back(MakeCC1of2vout(EVAL_HEIR, amount, pk1, pk2));
+
+    CScript opret;
+    fundingtxid = revuint256(fundingtxid);
+
+    opret << OP_RETURN << E_MARSHAL(ss << (uint8_t)EVAL_HEIR << (uint8_t)'A' << fundingtxid << (uint8_t)0);
+
+    cp = CCinit(&C, EVAL_HEIR);
+    return(FinalizeCCTx(0, cp, mtx, myPubkey, txfee, opret));
+}
+
+UniValue test_heirmarker(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    // make fake token tx: 
+    struct CCcontract_info *cp, C;
+
+    if (fHelp || (params.size() != 1))
+        throw runtime_error("incorrect params\n");
+    if (ensure_CCrequirements(EVAL_HEIR) < 0)
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+
+    uint256 fundingtxid = Parseuint256((char *)params[0].get_str().c_str());
+
+    CPubKey myPubkey = pubkey2pk(Mypubkey());
+    CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
+
+    int64_t normalInputs = AddNormalinputs(mtx, myPubkey, 10000, 60);
+    if (normalInputs < 10000)
+        throw runtime_error("not enough normals\n");
+
+    mtx.vin.push_back(CTxIn(fundingtxid, 1));
+    mtx.vout.push_back(MakeCC1vout(EVAL_HEIR, 10000, myPubkey));
+
+    CScript opret;
+    fundingtxid = revuint256(fundingtxid);
+
+    opret << OP_RETURN << E_MARSHAL(ss << (uint8_t)EVAL_HEIR << (uint8_t)'C' << fundingtxid << (uint8_t)0);
+
+    cp = CCinit(&C, EVAL_HEIR);
+    return(FinalizeCCTx(0, cp, mtx, myPubkey, 10000, opret));
+}
+
+UniValue test_burntx(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    // make fake token tx: 
+    struct CCcontract_info *cp, C;
+
+    if (fHelp || (params.size() != 1))
+        throw runtime_error("incorrect params\n");
+    if (ensure_CCrequirements(EVAL_TOKENS) < 0)
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+
+    uint256 tokenid = Parseuint256((char *)params[0].get_str().c_str());
+
+    CPubKey myPubkey = pubkey2pk(Mypubkey());
+    CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
+
+    int64_t normalInputs = AddNormalinputs(mtx, myPubkey, 10000, 60);
+    if (normalInputs < 10000)
+        throw runtime_error("not enough normals\n");
+
+    CPubKey burnpk = pubkey2pk(ParseHex(CC_BURNPUBKEY));
+
+    mtx.vin.push_back(CTxIn(tokenid, 0));
+    mtx.vin.push_back(CTxIn(tokenid, 1));
+    mtx.vout.push_back(MakeTokensCC1vout(EVAL_TOKENS, 1, burnpk));
+
+    std::vector<CPubKey> voutPubkeys;
+    voutPubkeys.push_back(burnpk);
+
+    cp = CCinit(&C, EVAL_TOKENS);
+
+    std::vector<uint8_t> vopret;
+    GetNonfungibleData(tokenid, vopret);
+    if (vopret.size() > 0)
+        cp->additionalTokensEvalcode2 = vopret.begin()[0];
+
+    uint8_t tokenpriv[33];
+    char unspendableTokenAddr[64];
+    CPubKey unspPk = GetUnspendable(cp, tokenpriv);
+    GetCCaddress(cp, unspendableTokenAddr, unspPk);
+    CCaddr2set(cp, EVAL_TOKENS, unspPk, tokenpriv, unspendableTokenAddr);
+    return(FinalizeCCTx(0, cp, mtx, myPubkey, 10000, EncodeTokenOpRet(tokenid, voutPubkeys, std::make_pair(0, vscript_t()))));
+}
+
+UniValue test_proof(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    UniValue result(UniValue::VOBJ);
+    std::vector<uint8_t>proof;
+
+    if (fHelp || (params.size() != 2))
+        throw runtime_error("incorrect params\n");
+
+
+    proof = ParseHex(params[0].get_str());
+    uint256 cointxid = Parseuint256((char *)params[1].get_str().c_str());
+
+    std::vector<uint256> txids;
+
+    CMerkleBlock merkleBlock;
+    if (!E_UNMARSHAL(proof, ss >> merkleBlock)) {
+        result.push_back(Pair("error", "could not unmarshal proof"));
+        return result;
+    }
+    uint256 merkleRoot = merkleBlock.txn.ExtractMatches(txids);
+
+    result.push_back(Pair("source_root", merkleRoot.GetHex()));
+
+    for (int i = 0; i < txids.size(); i++)
+        std::cerr << "merkle block txid=" << txids[0].GetHex() << std::endl;
+
+
+    std::vector<bool> vMatches(txids.size());
+    for (auto v : vMatches) v = true;
+    CPartialMerkleTree verifTree(txids, vMatches);
+
+    result.push_back(Pair("verif_root", verifTree.ExtractMatches(txids).GetHex()));
+
+    if (std::find(txids.begin(), txids.end(), cointxid) == txids.end()) {
+        fprintf(stderr, "invalid proof for this cointxid\n");
+    }
+
+    std::vector<uint256> vMerkleTree;
+    bool f;
+    ::BuildMerkleTree(&f, txids, vMerkleTree);
+
+    std::vector<uint256> vMerkleBranch = ::GetMerkleBranch(0, txids.size(), vMerkleTree);
+
+    uint256 ourResult = SafeCheckMerkleBranch(zeroid, vMerkleBranch, 0);
+    result.push_back(Pair("SafeCheckMerkleBranch", ourResult.GetHex()));
+
+    return result;
+}
+
+extern CScript prices_costbasisopret(uint256 bettxid, CPubKey mypk, int32_t height, int64_t costbasis);
+UniValue test_pricesmarker(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    // make fake token tx: 
+    struct CCcontract_info *cp, C;
+
+    if (fHelp || (params.size() != 1))
+        throw runtime_error("incorrect params\n");
+    if (ensure_CCrequirements(EVAL_PRICES) < 0)
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+
+    uint256 bettxid = Parseuint256((char *)params[0].get_str().c_str());
+
+    cp = CCinit(&C, EVAL_PRICES);
+    CPubKey myPubkey = pubkey2pk(Mypubkey());
+    CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
+
+    int64_t normalInputs = AddNormalinputs(mtx, myPubkey, 10000, 60);
+    if (normalInputs < 10000)
+        throw runtime_error("not enough normals\n");
+
+    mtx.vin.push_back(CTxIn(bettxid, 1));
+    mtx.vout.push_back(CTxOut(1000, CScript() << ParseHex(HexStr(myPubkey)) << OP_CHECKSIG));
+
+    return(FinalizeCCTx(0, cp, mtx, myPubkey, 10000, prices_costbasisopret(bettxid, myPubkey, 100, 100)));
+}
+
+
+static const CRPCCommand commands[] =
+{ //  category              name                      actor (function)         okSafeMode
+  //  --------------------- ------------------------  -----------------------  ----------
+
+    /* Not shown in help */
+    { "hidden",             "test_ac",                &test_ac,                 true },
+    { "hidden",             "test_heirmarker",        &test_heirmarker,         true },
+    { "hidden",             "test_proof",             &test_proof,              true },
+    { "hidden",             "test_burntx",            &test_burntx,             true },
+    { "hidden",             "test_pricesmarker",      &test_pricesmarker,       true }
+};
+
+void RegisterTesttransactionsRPCCommands(CRPCTable &tableRPC)
+{
+    for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++)
+        tableRPC.appendCommand(commands[vcidx].name, &commands[vcidx]);
+}
diff --git a/src/script/sign.cpp b/src/script/sign.cpp
index ac67e724..032b39f2 100644
--- a/src/script/sign.cpp
+++ b/src/script/sign.cpp
@@ -35,31 +35,54 @@ using namespace std;
 
 typedef vector<unsigned char> valtype;
 extern uint8_t ASSETCHAINS_TXPOW;
+extern char NSPV_wifstr[],NSPV_pubkeystr[];
+extern int32_t KOMODO_NSPV;
+#ifndef KOMODO_NSPV_FULLNODE
+#define KOMODO_NSPV_FULLNODE (KOMODO_NSPV <= 0)
+#endif // !KOMODO_NSPV_FULLNODE
+#ifndef KOMODO_NSPV_SUPERLITE
+#define KOMODO_NSPV_SUPERLITE (KOMODO_NSPV > 0)
+#endif // !KOMODO_NSPV_SUPERLITE
+
+uint256 SIG_TXHASH;
 
 TransactionSignatureCreator::TransactionSignatureCreator(const CKeyStore* keystoreIn, const CTransaction* txToIn, unsigned int nInIn, const CAmount& amountIn, int nHashTypeIn) : BaseSignatureCreator(keystoreIn), txTo(txToIn), nIn(nInIn), nHashType(nHashTypeIn), amount(amountIn), checker(txTo, nIn, amountIn) {}
 
 bool TransactionSignatureCreator::CreateSig(std::vector<unsigned char>& vchSig, const CKeyID& address, const CScript& scriptCode, uint32_t consensusBranchId, CKey *pprivKey, void *extraData) const
 {
-    CKey key;
-    if (pprivKey)
-        key = *pprivKey;
-    else if (!keystore || !keystore->GetKey(address, key))
-        return false;
-    
-    uint256 hash;
+    CKey key; uint256 hash;
     try {
         hash = SignatureHash(scriptCode, *txTo, nIn, nHashType, amount, consensusBranchId);
     } catch (logic_error ex) {
+        {
+            LogPrintf("logic error\n");
         return false;
+        }
     }
-    
+    SIG_TXHASH = hash;
+    if ( KOMODO_NSPV_SUPERLITE )
+        key = DecodeSecret(NSPV_wifstr);
+    else if (pprivKey)
+        key = *pprivKey;
+    else if (!keystore || !keystore->GetKey(address, key))
+    {
+        fprintf(stderr,"keystore.%p error\n",keystore);
+        return false;
+    }
+    //fprintf(stderr,"privkey (%s) for %s\n",NSPV_wifstr,EncodeDestination(key.GetPubKey().GetID()).c_str());
+
     if (scriptCode.IsPayToCryptoCondition())
     {
         CC *cc = (CC *)extraData;
         // assume either 1of1 or 1of2. if the condition created by the
         if (!cc || cc_signTreeSecp256k1Msg32(cc, key.begin(), hash.begin()) == 0)
+        {
+            LogPrintf("CC tree error\n");
             return false;
+        }
         vchSig = CCSigVec(cc);
+        if ( KOMODO_NSPV_SUPERLITE )
+            memset((uint8_t *)key.begin(),0,32);
         return true;
     }
     else
@@ -67,7 +90,14 @@ bool TransactionSignatureCreator::CreateSig(std::vector<unsigned char>& vchSig,
         if ( ASSETCHAINS_TXPOW == 0 )
         {
             if (!key.Sign(hash, vchSig))
+            {
+                LogPrintf("key.Sign error\n");
                 return false;
+            }
+            else
+            {
+                //LogPrintf("signed success %s\n",(char *)HexStr(vchSig).c_str());
+            }
         }
         else
         {
@@ -77,7 +107,8 @@ bool TransactionSignatureCreator::CreateSig(std::vector<unsigned char>& vchSig,
     }
     
     vchSig.push_back((unsigned char)nHashType);
-    
+    if ( KOMODO_NSPV_SUPERLITE )
+        memset((uint8_t *)key.begin(),0,32);
     return true;
 }
 
@@ -85,7 +116,10 @@ static bool Sign1(const CKeyID& address, const BaseSignatureCreator& creator, co
 {
     vector<unsigned char> vchSig;
     if (!creator.CreateSig(vchSig, address, scriptCode, consensusBranchId))
+    {
+        LogPrintf("Sign1 creatsig error\n");
         return false;
+    }
     ret.push_back(vchSig);
     return true;
 }
@@ -337,7 +371,6 @@ static bool SignStep(const BaseSignatureCreator& creator, const CScript& scriptP
     }
     
     CKeyID keyID;
-    
     switch (whichTypeRet)
     {
         case TX_NONSTANDARD:
@@ -349,12 +382,18 @@ static bool SignStep(const BaseSignatureCreator& creator, const CScript& scriptP
         case TX_PUBKEYHASH:
             keyID = CKeyID(uint160(vSolutions[0]));
             if (!Sign1(keyID, creator, scriptPubKey, ret, consensusBranchId))
+            {
+                LogPrintf("sign1 error\n");
                 return false;
+            }
             else
             {
-                CPubKey vch;
-                creator.KeyStore().GetPubKey(keyID, vch);
-                ret.push_back(ToByteVector(vch));
+                if ( KOMODO_NSPV_FULLNODE )
+                {
+                    CPubKey vch;
+                    creator.KeyStore().GetPubKey(keyID, vch);
+                    ret.push_back(ToByteVector(vch));
+                } else ret.push_back(ParseHex(NSPV_pubkeystr));
             }
             return true;
         case TX_SCRIPTHASH:
@@ -411,7 +450,6 @@ bool ProduceSignature(const BaseSignatureCreator& creator, const CScript& fromPu
     }
     
     sigdata.scriptSig = PushAll(result);
-    
     // Test solution
     return solved && VerifyScript(sigdata.scriptSig, fromPubKey, STANDARD_SCRIPT_VERIFY_FLAGS, creator.Checker(), consensusBranchId);
 }
diff --git a/src/test-komodo/test_eval_notarisation.cpp b/src/test-komodo/test_eval_notarisation.cpp
index 0abac499..f0c48f95 100644
--- a/src/test-komodo/test_eval_notarisation.cpp
+++ b/src/test-komodo/test_eval_notarisation.cpp
@@ -56,7 +56,8 @@ namespace TestEvalNotarisation {
             }
     };
 
-    static auto noop = [&](CMutableTransaction &mtx){};
+    //static auto noop = [&](CMutableTransaction &mtx){};
+    static auto noop = [](CMutableTransaction &mtx){};
 
 
     template<typename Modifier>
diff --git a/src/test-komodo/testutils.cpp b/src/test-komodo/testutils.cpp
index a4aca37c..c17de8bb 100644
--- a/src/test-komodo/testutils.cpp
+++ b/src/test-komodo/testutils.cpp
@@ -76,7 +76,7 @@ void generateBlock(CBlock *block)
     SetMockTime(nMockTime+=100);  // CreateNewBlock can fail if not enough time passes
 
     try {
-        UniValue out = generate(params, false);
+        UniValue out = generate(params, false, CPubKey());
         blockId.SetHex(out[0].getValStr());
         if (block) ASSERT_TRUE(ReadBlockFromDisk(*block, mapBlockIndex[blockId], false));
     } catch (const UniValue& e) {
diff --git a/src/test/rpc_tests.cpp b/src/test/rpc_tests.cpp
index 7cb1ef01..d0e94ab5 100644
--- a/src/test/rpc_tests.cpp
+++ b/src/test/rpc_tests.cpp
@@ -46,7 +46,7 @@ UniValue CallRPC(string args)
     BOOST_CHECK(tableRPC[strMethod]);
     rpcfn_type method = tableRPC[strMethod]->actor;
     try {
-        UniValue result = (*method)(params, false);
+        UniValue result = (*method)(params, false, CPubKey());
         return result;
     }
     catch (const UniValue& objError) {
diff --git a/src/test/transaction_tests.cpp b/src/test/transaction_tests.cpp
index 65524a07..b6a6ebc2 100644
--- a/src/test/transaction_tests.cpp
+++ b/src/test/transaction_tests.cpp
@@ -491,7 +491,7 @@ void test_simple_joinsplit_invalidity(uint32_t consensusBranchId, CMutableTransa
         jsdesc->nullifiers[1] = GetRandHash();
 
         BOOST_CHECK(CheckTransactionWithoutProofVerification(newTx, state));
-        BOOST_CHECK(!ContextualCheckTransaction(newTx, state, 0, 100));
+        BOOST_CHECK(!ContextualCheckTransaction(0,newTx, state, 0, 100));
         BOOST_CHECK(state.GetRejectReason() == "bad-txns-invalid-joinsplit-signature");
 
         // Empty output script.
@@ -505,7 +505,7 @@ void test_simple_joinsplit_invalidity(uint32_t consensusBranchId, CMutableTransa
                                     ) == 0);
 
         BOOST_CHECK(CheckTransactionWithoutProofVerification(newTx, state));
-        BOOST_CHECK(ContextualCheckTransaction(newTx, state, 0, 100));
+        BOOST_CHECK(ContextualCheckTransaction(0,newTx, state, 0, 100));
     }
     {
         // Ensure that values within the joinsplit are well-formed.
diff --git a/src/timedata.cpp b/src/timedata.cpp
index aa431248..fe9371bd 100644
--- a/src/timedata.cpp
+++ b/src/timedata.cpp
@@ -94,7 +94,7 @@ void AddTimeData(const CNetAddr& ip, int64_t nOffsetSample)
         int64_t nMedian = vTimeOffsets.median();
         std::vector<int64_t> vSorted = vTimeOffsets.sorted();
         // Only let other nodes change our time by so much
-        if (abs64(nMedian) < 70 * 60)
+        if (abs64(nMedian) < 30) // thanks to zawy for pointing this out!! zcash issues 4021 //70 * 60)
         {
             nTimeOffset = nMedian;
         }
diff --git a/src/tui/lib/tuilib.py b/src/tui/lib/tuilib.py
index 9a2fed63..afb4fad6 100755
--- a/src/tui/lib/tuilib.py
+++ b/src/tui/lib/tuilib.py
@@ -21,6 +21,24 @@
     import readline
 
 
+class CustomProxy(Proxy):
+    def __init__(self,
+                 service_url=None,
+                 service_port=None,
+                 conf_file=None,
+                 timeout=3000):
+        config = dict()
+        if conf_file:
+            config = slickrpc.ConfigObj(conf_file)
+        if service_url:
+            config.update(self.url_to_conf(service_url))
+        if service_port:
+            config.update(rpcport=service_port)
+        elif not config.get('rpcport'):
+            config['rpcport'] = 7771
+        self.conn = self.prepare_connection(config, timeout=timeout)
+
+
 def colorize(string, color):
 
     colors = {
@@ -97,7 +115,7 @@ def def_credentials(chain):
             print("check "+coin_config_file)
             exit(1)
 
-    return(Proxy("http://%s:%s@127.0.0.1:%d"%(rpcuser, rpcpassword, int(rpcport))))
+    return(CustomProxy("http://%s:%s@127.0.0.1:%d"%(rpcuser, rpcpassword, int(rpcport))))
 
 
 def getinfo_tui(rpc_connection):
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 26462924..f1e43c56 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -124,7 +124,10 @@ bool CTxMemPool::addUnchecked(const uint256& hash, const CTxMemPoolEntry &entry,
     nRecentlyAddedSequence += 1;
     if (!tx.IsCoinImport()) {
         for (unsigned int i = 0; i < tx.vin.size(); i++)
+        {
+            if (tx.IsPegsImport() && i==0) continue;
             mapNextTx[tx.vin[i].prevout] = CInPoint(&tx, i);
+        }
     }
     BOOST_FOREACH(const JSDescription &joinsplit, tx.vjoinsplit) {
         BOOST_FOREACH(const uint256 &nf, joinsplit.nullifiers) {
@@ -150,6 +153,7 @@ void CTxMemPool::addAddressIndex(const CTxMemPoolEntry &entry, const CCoinsViewC
 
     uint256 txhash = tx.GetHash();
     for (unsigned int j = 0; j < tx.vin.size(); j++) {
+        if (tx.IsPegsImport() && j==0) continue; 
         const CTxIn input = tx.vin[j];
         const CTxOut &prevout = view.GetOutputFor(input);
 
@@ -255,6 +259,7 @@ void CTxMemPool::addSpentIndex(const CTxMemPoolEntry &entry, const CCoinsViewCac
 
     uint256 txhash = tx.GetHash();
     for (unsigned int j = 0; j < tx.vin.size(); j++) {
+        if (tx.IsPegsImport() && j==0) continue; 
         const CTxIn input = tx.vin[j];
         const CTxOut &prevout = view.GetOutputFor(input);
 
diff --git a/src/univalue/Makefile.am b/src/univalue/Makefile.am
index 532fa194..0f5ba599 100644
--- a/src/univalue/Makefile.am
+++ b/src/univalue/Makefile.am
@@ -12,6 +12,7 @@ pkgconfig_DATA = pc/libunivalue.pc
 
 libunivalue_la_SOURCES = \
 	lib/univalue.cpp \
+	lib/univalue_get.cpp \
 	lib/univalue_read.cpp \
 	lib/univalue_write.cpp
 
@@ -20,7 +21,7 @@ libunivalue_la_LDFLAGS = \
 	-no-undefined
 libunivalue_la_CXXFLAGS = -I$(top_srcdir)/include
 
-TESTS = test/unitester test/no_nul
+TESTS = test/object test/unitester test/no_nul
 
 GENBIN = gen/gen$(BUILD_EXEEXT)
 GEN_SRCS = gen/gen.cpp
@@ -52,6 +53,11 @@ test_no_nul_LDADD = libunivalue.la
 test_no_nul_CXXFLAGS = -I$(top_srcdir)/include
 test_no_nul_LDFLAGS = -static $(LIBTOOL_APP_LDFLAGS)
 
+test_object_SOURCES = test/object.cpp
+test_object_LDADD = libunivalue.la
+test_object_CXXFLAGS = -I$(top_srcdir)/include
+test_object_LDFLAGS = -static $(LIBTOOL_APP_LDFLAGS)
+
 TEST_FILES = \
 	$(TEST_DATA_DIR)/fail10.json \
 	$(TEST_DATA_DIR)/fail11.json \
@@ -88,6 +94,8 @@ TEST_FILES = \
 	$(TEST_DATA_DIR)/fail40.json \
 	$(TEST_DATA_DIR)/fail41.json \
 	$(TEST_DATA_DIR)/fail42.json \
+	$(TEST_DATA_DIR)/fail44.json \
+	$(TEST_DATA_DIR)/fail45.json \
 	$(TEST_DATA_DIR)/fail3.json \
 	$(TEST_DATA_DIR)/fail4.json \
 	$(TEST_DATA_DIR)/fail5.json \
@@ -98,6 +106,7 @@ TEST_FILES = \
 	$(TEST_DATA_DIR)/pass1.json \
 	$(TEST_DATA_DIR)/pass2.json \
 	$(TEST_DATA_DIR)/pass3.json \
+	$(TEST_DATA_DIR)/pass4.json \
 	$(TEST_DATA_DIR)/round1.json \
 	$(TEST_DATA_DIR)/round2.json \
 	$(TEST_DATA_DIR)/round3.json \
diff --git a/src/univalue/README.md b/src/univalue/README.md
new file mode 100644
index 00000000..7c62c339
--- /dev/null
+++ b/src/univalue/README.md
@@ -0,0 +1,21 @@
+
+# UniValue
+
+## Summary
+
+A universal value class, with JSON encoding and decoding.
+
+UniValue is an abstract data type that may be a null, boolean, string,
+number, array container, or a key/value dictionary container, nested to
+an arbitrary depth.
+
+This class is aligned with the JSON standard, [RFC
+7159](https://tools.ietf.org/html/rfc7159.html).
+
+## Library usage
+
+This is a fork of univalue used by Bitcoin Core. It is not maintained for usage
+by other projects. Notably, the API may break in non-backward-compatible ways.
+
+Other projects looking for a maintained library should use the upstream
+univalue at https://github.com/jgarzik/univalue.
diff --git a/src/univalue/gen/gen.cpp b/src/univalue/gen/gen.cpp
new file mode 100644
index 00000000..85fe2092
--- /dev/null
+++ b/src/univalue/gen/gen.cpp
@@ -0,0 +1,82 @@
+// Copyright 2014 BitPay Inc.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+//
+// To re-create univalue_escapes.h:
+// $ g++ -o gen gen.cpp
+// $ ./gen > univalue_escapes.h
+//
+
+#include <stdio.h>
+#include <string.h>
+#include "univalue.h"
+
+static bool initEscapes;
+static std::string escapes[256];
+
+static void initJsonEscape()
+{
+    // Escape all lower control characters (some get overridden with smaller sequences below)
+    for (int ch=0x00; ch<0x20; ++ch) {
+        char tmpbuf[20];
+        snprintf(tmpbuf, sizeof(tmpbuf), "\\u%04x", ch);
+        escapes[ch] = std::string(tmpbuf);
+    }
+
+    escapes[(int)'"'] = "\\\"";
+    escapes[(int)'\\'] = "\\\\";
+    escapes[(int)'\b'] = "\\b";
+    escapes[(int)'\f'] = "\\f";
+    escapes[(int)'\n'] = "\\n";
+    escapes[(int)'\r'] = "\\r";
+    escapes[(int)'\t'] = "\\t";
+    escapes[(int)'\x7f'] = "\\u007f"; // U+007F DELETE
+
+    initEscapes = true;
+}
+
+static void outputEscape()
+{
+	printf(	"// Automatically generated file. Do not modify.\n"
+		"#ifndef BITCOIN_UNIVALUE_UNIVALUE_ESCAPES_H\n"
+		"#define BITCOIN_UNIVALUE_UNIVALUE_ESCAPES_H\n"
+		"static const char *escapes[256] = {\n");
+
+	for (unsigned int i = 0; i < 256; i++) {
+		if (escapes[i].empty()) {
+			printf("\tNULL,\n");
+		} else {
+			printf("\t\"");
+
+			unsigned int si;
+			for (si = 0; si < escapes[i].size(); si++) {
+				char ch = escapes[i][si];
+				switch (ch) {
+				case '"':
+					printf("\\\"");
+					break;
+				case '\\':
+					printf("\\\\");
+					break;
+				default:
+					printf("%c", escapes[i][si]);
+					break;
+				}
+			}
+
+			printf("\",\n");
+		}
+	}
+
+	printf(	"};\n"
+		"#endif // BITCOIN_UNIVALUE_UNIVALUE_ESCAPES_H\n");
+}
+
+int main (int argc, char *argv[])
+{
+	initJsonEscape();
+	outputEscape();
+	return 0;
+}
+
diff --git a/src/univalue/include/univalue.h b/src/univalue/include/univalue.h
index 8863f87b..e5e7849d 100644
--- a/src/univalue/include/univalue.h
+++ b/src/univalue/include/univalue.h
@@ -3,10 +3,11 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#ifndef UNIVALUE_H__
-#define UNIVALUE_H__
+#ifndef __UNIVALUE_H__
+#define __UNIVALUE_H__
 
 #include <stdint.h>
+#include <string.h>
 
 #include <string>
 #include <vector>
@@ -73,7 +74,8 @@ class UniValue {
     size_t size() const { return values.size(); }
 
     bool getBool() const { return isTrue(); }
-    bool checkObject(const std::map<std::string,UniValue::VType>& memberTypes);
+    void getObjMap(std::map<std::string,UniValue>& kv) const;
+    bool checkObject(const std::map<std::string,UniValue::VType>& memberTypes) const;
     const UniValue& operator[](const std::string& key) const;
     const UniValue& operator[](size_t index) const;
     bool exists(const std::string& key) const { size_t i; return findKey(key, i); }
@@ -108,8 +110,13 @@ class UniValue {
         UniValue tmpVal(val_);
         return push_back(tmpVal);
     }
+    bool push_back(double val_) {
+        UniValue tmpVal(val_);
+        return push_back(tmpVal);
+    }
     bool push_backV(const std::vector<UniValue>& vec);
 
+    void __pushKV(const std::string& key, const UniValue& val);
     bool pushKV(const std::string& key, const UniValue& val);
     bool pushKV(const std::string& key, const std::string& val_) {
         UniValue tmpVal(VSTR, val_);
@@ -127,6 +134,10 @@ class UniValue {
         UniValue tmpVal(val_);
         return pushKV(key, tmpVal);
     }
+    bool pushKV(const std::string& key, bool val_) {
+        UniValue tmpVal((bool)val_);
+        return pushKV(key, tmpVal);
+    }
     bool pushKV(const std::string& key, int val_) {
         UniValue tmpVal((int64_t)val_);
         return pushKV(key, tmpVal);
@@ -141,7 +152,7 @@ class UniValue {
                       unsigned int indentLevel = 0) const;
 
     bool read(const char *raw, size_t len);
-    bool read(const char *raw);
+    bool read(const char *raw) { return read(raw, strlen(raw)); }
     bool read(const std::string& rawStr) {
         return read(rawStr.data(), rawStr.size());
     }
@@ -152,7 +163,7 @@ class UniValue {
     std::vector<std::string> keys;
     std::vector<UniValue> values;
 
-    bool findKey(const std::string& key, size_t& ret) const;
+    bool findKey(const std::string& key, size_t& retIdx) const;
     void writeArray(unsigned int prettyIndent, unsigned int indentLevel, std::string& s) const;
     void writeObject(unsigned int prettyIndent, unsigned int indentLevel, std::string& s) const;
 
@@ -304,4 +315,4 @@ extern const UniValue NullUniValue;
 
 const UniValue& find_value( const UniValue& obj, const std::string& name);
 
-#endif // UNIVALUE_H__
+#endif // __UNIVALUE_H__
diff --git a/src/univalue/lib/univalue.cpp b/src/univalue/lib/univalue.cpp
index 9c6d8027..d7236b85 100644
--- a/src/univalue/lib/univalue.cpp
+++ b/src/univalue/lib/univalue.cpp
@@ -19,6 +19,7 @@ namespace
 {
 static bool ParsePrechecks(const std::string& str)
 {
+    //fprintf(stderr,"Parse.(%s)\n",str.c_str());
     if (str.empty()) // No empty string allowed
         return false;
     if (str.size() >= 1 && (json_isspace(str[0]) || json_isspace(str[str.size()-1]))) // No padding allowed
@@ -74,8 +75,6 @@ bool ParseDouble(const std::string& str, double *out)
 }
 }
 
-using namespace std;
-
 const UniValue NullUniValue;
 
 void UniValue::clear()
@@ -101,15 +100,15 @@ bool UniValue::setBool(bool val_)
     return true;
 }
 
-static bool validNumStr(const string& s)
+static bool validNumStr(const std::string& s)
 {
-    string tokenVal;
+    std::string tokenVal;
     unsigned int consumed;
     enum jtokentype tt = getJsonToken(tokenVal, consumed, s.data(), s.data() + s.size());
     return (tt == JTOK_NUMBER);
 }
 
-bool UniValue::setNumStr(const string& val_)
+bool UniValue::setNumStr(const std::string& val_)
 {
     if (!validNumStr(val_))
         return false;
@@ -122,7 +121,7 @@ bool UniValue::setNumStr(const string& val_)
 
 bool UniValue::setInt(uint64_t val_)
 {
-    ostringstream oss;
+    std::ostringstream oss;
 
     oss << val_;
 
@@ -131,7 +130,7 @@ bool UniValue::setInt(uint64_t val_)
 
 bool UniValue::setInt(int64_t val_)
 {
-    ostringstream oss;
+    std::ostringstream oss;
 
     oss << val_;
 
@@ -140,7 +139,7 @@ bool UniValue::setInt(int64_t val_)
 
 bool UniValue::setInt(uint32_t val_)
 {
-    ostringstream oss;
+    std::ostringstream oss;
 
     oss << val_;
 
@@ -149,7 +148,7 @@ bool UniValue::setInt(uint32_t val_)
 
 bool UniValue::setFloat(double val_)
 {
-    ostringstream oss;
+    std::ostringstream oss;
 
     oss << std::setprecision(16) << val_;
 
@@ -158,7 +157,7 @@ bool UniValue::setFloat(double val_)
     return ret;
 }
 
-bool UniValue::setStr(const string& val_)
+bool UniValue::setStr(const std::string& val_)
 {
     clear();
     typ = VSTR;
@@ -199,13 +198,22 @@ bool UniValue::push_backV(const std::vector<UniValue>& vec)
     return true;
 }
 
+void UniValue::__pushKV(const std::string& key, const UniValue& val_)
+{
+    keys.push_back(key);
+    values.push_back(val_);
+}
+
 bool UniValue::pushKV(const std::string& key, const UniValue& val_)
 {
     if (typ != VOBJ)
         return false;
 
-    keys.push_back(key);
-    values.push_back(val_);
+    size_t idx;
+    if (findKey(key, idx))
+        values[idx] = val_;
+    else
+        __pushKV(key, val_);
     return true;
 }
 
@@ -214,19 +222,27 @@ bool UniValue::pushKVs(const UniValue& obj)
     if (typ != VOBJ || obj.typ != VOBJ)
         return false;
 
-    for (unsigned int i = 0; i < obj.keys.size(); i++) {
-        keys.push_back(obj.keys[i]);
-        values.push_back(obj.values.at(i));
-    }
+    for (size_t i = 0; i < obj.keys.size(); i++)
+        __pushKV(obj.keys[i], obj.values.at(i));
 
     return true;
 }
 
-bool UniValue::findKey(const std::string& key, size_t& ret) const
+void UniValue::getObjMap(std::map<std::string,UniValue>& kv) const
+{
+    if (typ != VOBJ)
+        return;
+
+    kv.clear();
+    for (size_t i = 0; i < keys.size(); i++)
+        kv[keys[i]] = values[i];
+}
+
+bool UniValue::findKey(const std::string& key, size_t& retIdx) const
 {
     for (size_t i = 0; i < keys.size(); i++) {
         if (keys[i] == key) {
-            ret = i;
+            retIdx = i;
             return true;
         }
     }
@@ -234,11 +250,14 @@ bool UniValue::findKey(const std::string& key, size_t& ret) const
     return false;
 }
 
-bool UniValue::checkObject(const std::map<std::string,UniValue::VType>& t)
+bool UniValue::checkObject(const std::map<std::string,UniValue::VType>& t) const
 {
+    if (typ != VOBJ)
+        return false;
+
     for (std::map<std::string,UniValue::VType>::const_iterator it = t.begin();
          it != t.end(); ++it) {
-        size_t idx;
+        size_t idx = 0;
         if (!findKey(it->first, idx))
             return false;
 
@@ -254,7 +273,7 @@ const UniValue& UniValue::operator[](const std::string& key) const
     if (typ != VOBJ)
         return NullUniValue;
 
-    size_t index;
+    size_t index = 0;
     if (!findKey(key, index))
         return NullUniValue;
 
@@ -319,7 +338,10 @@ bool UniValue::get_bool() const
 const std::string& UniValue::get_str() const
 {
     if (typ != VSTR)
+    {
+        //fprintf(stderr,"typ.%d VSTR %d\n",(int32_t)typ,(int32_t)VSTR);
         throw std::runtime_error("JSON value is not a string as expected");
+    }
     return getValStr();
 }
 
@@ -366,4 +388,3 @@ const UniValue& UniValue::get_array() const
         throw std::runtime_error("JSON value is not an array as expected");
     return *this;
 }
-
diff --git a/src/univalue/lib/univalue_get.cpp b/src/univalue/lib/univalue_get.cpp
new file mode 100644
index 00000000..0ad61465
--- /dev/null
+++ b/src/univalue/lib/univalue_get.cpp
@@ -0,0 +1,147 @@
+// Copyright 2014 BitPay Inc.
+// Copyright 2015 Bitcoin Core Developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <stdint.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdexcept>
+#include <vector>
+#include <limits>
+#include <string>
+
+#include "univalue.h"
+
+namespace
+{
+static bool ParsePrechecks(const std::string& str)
+{
+    if (str.empty()) // No empty string allowed
+        return false;
+    if (str.size() >= 1 && (json_isspace(str[0]) || json_isspace(str[str.size()-1]))) // No padding allowed
+        return false;
+    if (str.size() != strlen(str.c_str())) // No embedded NUL characters allowed
+        return false;
+    return true;
+}
+
+bool ParseInt32(const std::string& str, int32_t *out)
+{
+    if (!ParsePrechecks(str))
+        return false;
+    char *endp = NULL;
+    errno = 0; // strtol will not set errno if valid
+    long int n = strtol(str.c_str(), &endp, 10);
+    if(out) *out = (int32_t)n;
+    // Note that strtol returns a *long int*, so even if strtol doesn't report an over/underflow
+    // we still have to check that the returned value is within the range of an *int32_t*. On 64-bit
+    // platforms the size of these types may be different.
+    return endp && *endp == 0 && !errno &&
+        n >= std::numeric_limits<int32_t>::min() &&
+        n <= std::numeric_limits<int32_t>::max();
+}
+
+bool ParseInt64(const std::string& str, int64_t *out)
+{
+    if (!ParsePrechecks(str))
+        return false;
+    char *endp = NULL;
+    errno = 0; // strtoll will not set errno if valid
+    long long int n = strtoll(str.c_str(), &endp, 10);
+    if(out) *out = (int64_t)n;
+    // Note that strtoll returns a *long long int*, so even if strtol doesn't report a over/underflow
+    // we still have to check that the returned value is within the range of an *int64_t*.
+    return endp && *endp == 0 && !errno &&
+        n >= std::numeric_limits<int64_t>::min() &&
+        n <= std::numeric_limits<int64_t>::max();
+}
+
+bool ParseDouble(const std::string& str, double *out)
+{
+    if (!ParsePrechecks(str))
+        return false;
+    if (str.size() >= 2 && str[0] == '0' && str[1] == 'x') // No hexadecimal floats allowed
+        return false;
+    std::istringstream text(str);
+    text.imbue(std::locale::classic());
+    double result;
+    text >> result;
+    if(out) *out = result;
+    return text.eof() && !text.fail();
+}
+}
+
+const std::vector<std::string>& UniValue::getKeys() const
+{
+    if (typ != VOBJ)
+        throw std::runtime_error("JSON value is not an object as expected");
+    return keys;
+}
+
+const std::vector<UniValue>& UniValue::getValues() const
+{
+    if (typ != VOBJ && typ != VARR)
+        throw std::runtime_error("JSON value is not an object or array as expected");
+    return values;
+}
+
+bool UniValue::get_bool() const
+{
+    if (typ != VBOOL)
+        throw std::runtime_error("JSON value is not a boolean as expected");
+    return getBool();
+}
+
+const std::string& UniValue::get_str() const
+{
+    if (typ != VSTR)
+        throw std::runtime_error("JSON value is not a string as expected");
+    return getValStr();
+}
+
+int UniValue::get_int() const
+{
+    if (typ != VNUM)
+        throw std::runtime_error("JSON value is not an integer as expected");
+    int32_t retval;
+    if (!ParseInt32(getValStr(), &retval))
+        throw std::runtime_error("JSON integer out of range");
+    return retval;
+}
+
+int64_t UniValue::get_int64() const
+{
+    if (typ != VNUM)
+        throw std::runtime_error("JSON value is not an integer as expected");
+    int64_t retval;
+    if (!ParseInt64(getValStr(), &retval))
+        throw std::runtime_error("JSON integer out of range");
+    return retval;
+}
+
+double UniValue::get_real() const
+{
+    if (typ != VNUM)
+        throw std::runtime_error("JSON value is not a number as expected");
+    double retval;
+    if (!ParseDouble(getValStr(), &retval))
+        throw std::runtime_error("JSON double out of range");
+    return retval;
+}
+
+const UniValue& UniValue::get_obj() const
+{
+    if (typ != VOBJ)
+        throw std::runtime_error("JSON value is not an object as expected");
+    return *this;
+}
+
+const UniValue& UniValue::get_array() const
+{
+    if (typ != VARR)
+        throw std::runtime_error("JSON value is not an array as expected");
+    return *this;
+}
+
diff --git a/src/univalue/lib/univalue_read.cpp b/src/univalue/lib/univalue_read.cpp
index 7a9acdd7..4dcfb315 100644
--- a/src/univalue/lib/univalue_read.cpp
+++ b/src/univalue/lib/univalue_read.cpp
@@ -8,7 +8,13 @@
 #include "univalue.h"
 #include "univalue_utffilter.h"
 
-using namespace std;
+/*
+ * According to stackexchange, the original json test suite wanted
+ * to limit depth to 22.  Widely-deployed PHP bails at depth 512,
+ * so we will follow PHP's lead, which should be more than sufficient
+ * (further stackexchange comments indicate depth > 32 rarely occurs).
+ */
+static const size_t MAX_JSON_DEPTH = 512;
 
 static bool json_isdigit(int ch)
 {
@@ -42,7 +48,7 @@ static const char *hatoui(const char *first, const char *last,
     return first;
 }
 
-enum jtokentype getJsonToken(string& tokenVal, unsigned int& consumed,
+enum jtokentype getJsonToken(std::string& tokenVal, unsigned int& consumed,
                             const char *raw, const char *end)
 {
     tokenVal.clear();
@@ -114,7 +120,7 @@ enum jtokentype getJsonToken(string& tokenVal, unsigned int& consumed,
     case '8':
     case '9': {
         // part 1: int
-        string numStr;
+        std::string numStr;
 
         const char *first = raw;
 
@@ -174,11 +180,11 @@ enum jtokentype getJsonToken(string& tokenVal, unsigned int& consumed,
     case '"': {
         raw++;                                // skip "
 
-        string valStr;
+        std::string valStr;
         JSONUTF8StringFilter writer(valStr);
 
-        while (raw < end) {
-            if ((unsigned char)*raw < 0x20)
+        while (true) {
+            if (raw >= end || (unsigned char)*raw < 0x20)
                 return JTOK_ERR;
 
             else if (*raw == '\\') {
@@ -255,9 +261,9 @@ bool UniValue::read(const char *raw, size_t size)
     clear();
 
     uint32_t expectMask = 0;
-    vector<UniValue*> stack;
+    std::vector<UniValue*> stack;
 
-    string tokenVal;
+    std::string tokenVal;
     unsigned int consumed;
     enum jtokentype tok = JTOK_NONE;
     enum jtokentype last_tok = JTOK_NONE;
@@ -325,6 +331,9 @@ bool UniValue::read(const char *raw, size_t size)
                 stack.push_back(newTop);
             }
 
+            if (stack.size() > MAX_JSON_DEPTH)
+                return false;
+
             if (utyp == VOBJ)
                 setExpect(OBJ_NAME);
             else
@@ -449,6 +458,6 @@ bool UniValue::read(const char *raw, size_t size)
     return true;
 }
 
-bool UniValue::read(const char *raw) {
-    return read(raw, strlen(raw));
-}
+// bool UniValue::read(const char *raw) {
+//     return read(raw, strlen(raw));
+// }
\ No newline at end of file
diff --git a/src/univalue/lib/univalue_utffilter.h b/src/univalue/lib/univalue_utffilter.h
index b4a9ddc0..20d40430 100644
--- a/src/univalue/lib/univalue_utffilter.h
+++ b/src/univalue/lib/univalue_utffilter.h
@@ -13,7 +13,7 @@
 class JSONUTF8StringFilter
 {
 public:
-    JSONUTF8StringFilter(std::string &s):
+    explicit JSONUTF8StringFilter(std::string &s):
         str(s), is_valid(true), codepoint(0), state(0), surpair(0)
     {
     }
diff --git a/src/univalue/lib/univalue_write.cpp b/src/univalue/lib/univalue_write.cpp
index cf278359..827eb9b2 100644
--- a/src/univalue/lib/univalue_write.cpp
+++ b/src/univalue/lib/univalue_write.cpp
@@ -8,11 +8,9 @@
 #include "univalue.h"
 #include "univalue_escapes.h"
 
-using namespace std;
-
-static string json_escape(const string& inS)
+static std::string json_escape(const std::string& inS)
 {
-    string outS;
+    std::string outS;
     outS.reserve(inS.size() * 2);
 
     for (unsigned int i = 0; i < inS.size(); i++) {
@@ -28,10 +26,10 @@ static string json_escape(const string& inS)
     return outS;
 }
 
-string UniValue::write(unsigned int prettyIndent,
-                       unsigned int indentLevel) const
+std::string UniValue::write(unsigned int prettyIndent,
+                            unsigned int indentLevel) const
 {
-    string s;
+    std::string s;
     s.reserve(1024);
 
     unsigned int modIndent = indentLevel;
@@ -62,12 +60,12 @@ string UniValue::write(unsigned int prettyIndent,
     return s;
 }
 
-static void indentStr(unsigned int prettyIndent, unsigned int indentLevel, string& s)
+static void indentStr(unsigned int prettyIndent, unsigned int indentLevel, std::string& s)
 {
     s.append(prettyIndent * indentLevel, ' ');
 }
 
-void UniValue::writeArray(unsigned int prettyIndent, unsigned int indentLevel, string& s) const
+void UniValue::writeArray(unsigned int prettyIndent, unsigned int indentLevel, std::string& s) const
 {
     s += "[";
     if (prettyIndent)
@@ -89,7 +87,7 @@ void UniValue::writeArray(unsigned int prettyIndent, unsigned int indentLevel, s
     s += "]";
 }
 
-void UniValue::writeObject(unsigned int prettyIndent, unsigned int indentLevel, string& s) const
+void UniValue::writeObject(unsigned int prettyIndent, unsigned int indentLevel, std::string& s) const
 {
     s += "{";
     if (prettyIndent)
diff --git a/src/univalue/test/fail44.json b/src/univalue/test/fail44.json
new file mode 100644
index 00000000..80edcedd
--- /dev/null
+++ b/src/univalue/test/fail44.json
@@ -0,0 +1 @@
+"This file ends without a newline or close-quote.
\ No newline at end of file
diff --git a/src/univalue/test/fail45.json b/src/univalue/test/fail45.json
new file mode 100644
index 00000000..03a30d88
--- /dev/null
+++ b/src/univalue/test/fail45.json
@@ -0,0 +1 @@
+[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
diff --git a/src/univalue/test/object.cpp b/src/univalue/test/object.cpp
new file mode 100644
index 00000000..70ccc0d0
--- /dev/null
+++ b/src/univalue/test/object.cpp
@@ -0,0 +1,408 @@
+// Copyright (c) 2014 BitPay Inc.
+// Copyright (c) 2014-2016 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <stdint.h>
+#include <vector>
+#include <string>
+#include <map>
+#include <cassert>
+#include <stdexcept>
+#include <univalue.h>
+
+#define BOOST_FIXTURE_TEST_SUITE(a, b)
+#define BOOST_AUTO_TEST_CASE(funcName) void funcName()
+#define BOOST_AUTO_TEST_SUITE_END()
+#define BOOST_CHECK(expr) assert(expr)
+#define BOOST_CHECK_EQUAL(v1, v2) assert((v1) == (v2))
+#define BOOST_CHECK_THROW(stmt, excMatch) { \
+        try { \
+            (stmt); \
+            assert(0 && "No exception caught"); \
+        } catch (excMatch & e) { \
+	} catch (...) { \
+	    assert(0 && "Wrong exception caught"); \
+	} \
+    }
+#define BOOST_CHECK_NO_THROW(stmt) { \
+        try { \
+            (stmt); \
+	} catch (...) { \
+	    assert(0); \
+	} \
+    }
+
+BOOST_FIXTURE_TEST_SUITE(univalue_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(univalue_constructor)
+{
+    UniValue v1;
+    BOOST_CHECK(v1.isNull());
+
+    UniValue v2(UniValue::VSTR);
+    BOOST_CHECK(v2.isStr());
+
+    UniValue v3(UniValue::VSTR, "foo");
+    BOOST_CHECK(v3.isStr());
+    BOOST_CHECK_EQUAL(v3.getValStr(), "foo");
+
+    UniValue numTest;
+    BOOST_CHECK(numTest.setNumStr("82"));
+    BOOST_CHECK(numTest.isNum());
+    BOOST_CHECK_EQUAL(numTest.getValStr(), "82");
+
+    uint64_t vu64 = 82;
+    UniValue v4(vu64);
+    BOOST_CHECK(v4.isNum());
+    BOOST_CHECK_EQUAL(v4.getValStr(), "82");
+
+    int64_t vi64 = -82;
+    UniValue v5(vi64);
+    BOOST_CHECK(v5.isNum());
+    BOOST_CHECK_EQUAL(v5.getValStr(), "-82");
+
+    int vi = -688;
+    UniValue v6(vi);
+    BOOST_CHECK(v6.isNum());
+    BOOST_CHECK_EQUAL(v6.getValStr(), "-688");
+
+    double vd = -7.21;
+    UniValue v7(vd);
+    BOOST_CHECK(v7.isNum());
+    BOOST_CHECK_EQUAL(v7.getValStr(), "-7.21");
+
+    std::string vs("yawn");
+    UniValue v8(vs);
+    BOOST_CHECK(v8.isStr());
+    BOOST_CHECK_EQUAL(v8.getValStr(), "yawn");
+
+    const char *vcs = "zappa";
+    UniValue v9(vcs);
+    BOOST_CHECK(v9.isStr());
+    BOOST_CHECK_EQUAL(v9.getValStr(), "zappa");
+}
+
+BOOST_AUTO_TEST_CASE(univalue_typecheck)
+{
+    UniValue v1;
+    BOOST_CHECK(v1.setNumStr("1"));
+    BOOST_CHECK(v1.isNum());
+    BOOST_CHECK_THROW(v1.get_bool(), std::runtime_error);
+
+    UniValue v2;
+    BOOST_CHECK(v2.setBool(true));
+    BOOST_CHECK_EQUAL(v2.get_bool(), true);
+    BOOST_CHECK_THROW(v2.get_int(), std::runtime_error);
+
+    UniValue v3;
+    BOOST_CHECK(v3.setNumStr("32482348723847471234"));
+    BOOST_CHECK_THROW(v3.get_int64(), std::runtime_error);
+    BOOST_CHECK(v3.setNumStr("1000"));
+    BOOST_CHECK_EQUAL(v3.get_int64(), 1000);
+
+    UniValue v4;
+    BOOST_CHECK(v4.setNumStr("2147483648"));
+    BOOST_CHECK_EQUAL(v4.get_int64(), 2147483648);
+    BOOST_CHECK_THROW(v4.get_int(), std::runtime_error);
+    BOOST_CHECK(v4.setNumStr("1000"));
+    BOOST_CHECK_EQUAL(v4.get_int(), 1000);
+    BOOST_CHECK_THROW(v4.get_str(), std::runtime_error);
+    BOOST_CHECK_EQUAL(v4.get_real(), 1000);
+    BOOST_CHECK_THROW(v4.get_array(), std::runtime_error);
+    BOOST_CHECK_THROW(v4.getKeys(), std::runtime_error);
+    BOOST_CHECK_THROW(v4.getValues(), std::runtime_error);
+    BOOST_CHECK_THROW(v4.get_obj(), std::runtime_error);
+
+    UniValue v5;
+    BOOST_CHECK(v5.read("[true, 10]"));
+    BOOST_CHECK_NO_THROW(v5.get_array());
+    std::vector<UniValue> vals = v5.getValues();
+    BOOST_CHECK_THROW(vals[0].get_int(), std::runtime_error);
+    BOOST_CHECK_EQUAL(vals[0].get_bool(), true);
+
+    BOOST_CHECK_EQUAL(vals[1].get_int(), 10);
+    BOOST_CHECK_THROW(vals[1].get_bool(), std::runtime_error);
+}
+
+BOOST_AUTO_TEST_CASE(univalue_set)
+{
+    UniValue v(UniValue::VSTR, "foo");
+    v.clear();
+    BOOST_CHECK(v.isNull());
+    BOOST_CHECK_EQUAL(v.getValStr(), "");
+
+    BOOST_CHECK(v.setObject());
+    BOOST_CHECK(v.isObject());
+    BOOST_CHECK_EQUAL(v.size(), 0);
+    BOOST_CHECK_EQUAL(v.getType(), UniValue::VOBJ);
+    BOOST_CHECK(v.empty());
+
+    BOOST_CHECK(v.setArray());
+    BOOST_CHECK(v.isArray());
+    BOOST_CHECK_EQUAL(v.size(), 0);
+
+    BOOST_CHECK(v.setStr("zum"));
+    BOOST_CHECK(v.isStr());
+    BOOST_CHECK_EQUAL(v.getValStr(), "zum");
+
+    BOOST_CHECK(v.setFloat(-1.01));
+    BOOST_CHECK(v.isNum());
+    BOOST_CHECK_EQUAL(v.getValStr(), "-1.01");
+
+    BOOST_CHECK(v.setInt((int)1023));
+    BOOST_CHECK(v.isNum());
+    BOOST_CHECK_EQUAL(v.getValStr(), "1023");
+
+    BOOST_CHECK(v.setInt((int64_t)-1023LL));
+    BOOST_CHECK(v.isNum());
+    BOOST_CHECK_EQUAL(v.getValStr(), "-1023");
+
+    BOOST_CHECK(v.setInt((uint64_t)1023ULL));
+    BOOST_CHECK(v.isNum());
+    BOOST_CHECK_EQUAL(v.getValStr(), "1023");
+
+    BOOST_CHECK(v.setNumStr("-688"));
+    BOOST_CHECK(v.isNum());
+    BOOST_CHECK_EQUAL(v.getValStr(), "-688");
+
+    BOOST_CHECK(v.setBool(false));
+    BOOST_CHECK_EQUAL(v.isBool(), true);
+    BOOST_CHECK_EQUAL(v.isTrue(), false);
+    BOOST_CHECK_EQUAL(v.isFalse(), true);
+    BOOST_CHECK_EQUAL(v.getBool(), false);
+
+    BOOST_CHECK(v.setBool(true));
+    BOOST_CHECK_EQUAL(v.isBool(), true);
+    BOOST_CHECK_EQUAL(v.isTrue(), true);
+    BOOST_CHECK_EQUAL(v.isFalse(), false);
+    BOOST_CHECK_EQUAL(v.getBool(), true);
+
+    BOOST_CHECK(!v.setNumStr("zombocom"));
+
+    BOOST_CHECK(v.setNull());
+    BOOST_CHECK(v.isNull());
+}
+
+BOOST_AUTO_TEST_CASE(univalue_array)
+{
+    UniValue arr(UniValue::VARR);
+
+    UniValue v((int64_t)1023LL);
+    BOOST_CHECK(arr.push_back(v));
+
+    std::string vStr("zippy");
+    BOOST_CHECK(arr.push_back(vStr));
+
+    const char *s = "pippy";
+    BOOST_CHECK(arr.push_back(s));
+
+    std::vector<UniValue> vec;
+    v.setStr("boing");
+    vec.push_back(v);
+
+    v.setStr("going");
+    vec.push_back(v);
+
+    BOOST_CHECK(arr.push_backV(vec));
+
+    BOOST_CHECK(arr.push_back((uint64_t) 400ULL));
+    BOOST_CHECK(arr.push_back((int64_t) -400LL));
+    BOOST_CHECK(arr.push_back((int) -401));
+    BOOST_CHECK(arr.push_back(-40.1));
+
+    BOOST_CHECK_EQUAL(arr.empty(), false);
+    BOOST_CHECK_EQUAL(arr.size(), 9);
+
+    BOOST_CHECK_EQUAL(arr[0].getValStr(), "1023");
+    BOOST_CHECK_EQUAL(arr[1].getValStr(), "zippy");
+    BOOST_CHECK_EQUAL(arr[2].getValStr(), "pippy");
+    BOOST_CHECK_EQUAL(arr[3].getValStr(), "boing");
+    BOOST_CHECK_EQUAL(arr[4].getValStr(), "going");
+    BOOST_CHECK_EQUAL(arr[5].getValStr(), "400");
+    BOOST_CHECK_EQUAL(arr[6].getValStr(), "-400");
+    BOOST_CHECK_EQUAL(arr[7].getValStr(), "-401");
+    BOOST_CHECK_EQUAL(arr[8].getValStr(), "-40.1");
+
+    BOOST_CHECK_EQUAL(arr[999].getValStr(), "");
+
+    arr.clear();
+    BOOST_CHECK(arr.empty());
+    BOOST_CHECK_EQUAL(arr.size(), 0);
+}
+
+BOOST_AUTO_TEST_CASE(univalue_object)
+{
+    UniValue obj(UniValue::VOBJ);
+    std::string strKey, strVal;
+    UniValue v;
+
+    strKey = "age";
+    v.setInt(100);
+    BOOST_CHECK(obj.pushKV(strKey, v));
+
+    strKey = "first";
+    strVal = "John";
+    BOOST_CHECK(obj.pushKV(strKey, strVal));
+
+    strKey = "last";
+    const char *cVal = "Smith";
+    BOOST_CHECK(obj.pushKV(strKey, cVal));
+
+    strKey = "distance";
+    BOOST_CHECK(obj.pushKV(strKey, (int64_t) 25));
+
+    strKey = "time";
+    BOOST_CHECK(obj.pushKV(strKey, (uint64_t) 3600));
+
+    strKey = "calories";
+    BOOST_CHECK(obj.pushKV(strKey, (int) 12));
+
+    strKey = "temperature";
+    BOOST_CHECK(obj.pushKV(strKey, (double) 90.012));
+
+    strKey = "moon";
+    BOOST_CHECK(obj.pushKV(strKey, true));
+
+    strKey = "spoon";
+    BOOST_CHECK(obj.pushKV(strKey, false));
+
+    UniValue obj2(UniValue::VOBJ);
+    BOOST_CHECK(obj2.pushKV("cat1", 9000));
+    BOOST_CHECK(obj2.pushKV("cat2", 12345));
+
+    BOOST_CHECK(obj.pushKVs(obj2));
+
+    BOOST_CHECK_EQUAL(obj.empty(), false);
+    BOOST_CHECK_EQUAL(obj.size(), 11);
+
+    BOOST_CHECK_EQUAL(obj["age"].getValStr(), "100");
+    BOOST_CHECK_EQUAL(obj["first"].getValStr(), "John");
+    BOOST_CHECK_EQUAL(obj["last"].getValStr(), "Smith");
+    BOOST_CHECK_EQUAL(obj["distance"].getValStr(), "25");
+    BOOST_CHECK_EQUAL(obj["time"].getValStr(), "3600");
+    BOOST_CHECK_EQUAL(obj["calories"].getValStr(), "12");
+    BOOST_CHECK_EQUAL(obj["temperature"].getValStr(), "90.012");
+    BOOST_CHECK_EQUAL(obj["moon"].getValStr(), "1");
+    BOOST_CHECK_EQUAL(obj["spoon"].getValStr(), "");
+    BOOST_CHECK_EQUAL(obj["cat1"].getValStr(), "9000");
+    BOOST_CHECK_EQUAL(obj["cat2"].getValStr(), "12345");
+
+    BOOST_CHECK_EQUAL(obj["nyuknyuknyuk"].getValStr(), "");
+
+    BOOST_CHECK(obj.exists("age"));
+    BOOST_CHECK(obj.exists("first"));
+    BOOST_CHECK(obj.exists("last"));
+    BOOST_CHECK(obj.exists("distance"));
+    BOOST_CHECK(obj.exists("time"));
+    BOOST_CHECK(obj.exists("calories"));
+    BOOST_CHECK(obj.exists("temperature"));
+    BOOST_CHECK(obj.exists("moon"));
+    BOOST_CHECK(obj.exists("spoon"));
+    BOOST_CHECK(obj.exists("cat1"));
+    BOOST_CHECK(obj.exists("cat2"));
+
+    BOOST_CHECK(!obj.exists("nyuknyuknyuk"));
+
+    std::map<std::string, UniValue::VType> objTypes;
+    objTypes["age"] = UniValue::VNUM;
+    objTypes["first"] = UniValue::VSTR;
+    objTypes["last"] = UniValue::VSTR;
+    objTypes["distance"] = UniValue::VNUM;
+    objTypes["time"] = UniValue::VNUM;
+    objTypes["calories"] = UniValue::VNUM;
+    objTypes["temperature"] = UniValue::VNUM;
+    objTypes["moon"] = UniValue::VBOOL;
+    objTypes["spoon"] = UniValue::VBOOL;
+    objTypes["cat1"] = UniValue::VNUM;
+    objTypes["cat2"] = UniValue::VNUM;
+    BOOST_CHECK(obj.checkObject(objTypes));
+
+    objTypes["cat2"] = UniValue::VSTR;
+    BOOST_CHECK(!obj.checkObject(objTypes));
+
+    obj.clear();
+    BOOST_CHECK(obj.empty());
+    BOOST_CHECK_EQUAL(obj.size(), 0);
+    BOOST_CHECK_EQUAL(obj.getType(), UniValue::VNULL);
+
+    BOOST_CHECK_EQUAL(obj.setObject(), true);
+    UniValue uv;
+    uv.setInt(42);
+    obj.__pushKV("age", uv);
+    BOOST_CHECK_EQUAL(obj.size(), 1);
+    BOOST_CHECK_EQUAL(obj["age"].getValStr(), "42");
+
+    uv.setInt(43);
+    obj.pushKV("age", uv);
+    BOOST_CHECK_EQUAL(obj.size(), 1);
+    BOOST_CHECK_EQUAL(obj["age"].getValStr(), "43");
+
+    obj.pushKV("name", "foo bar");
+
+    std::map<std::string,UniValue> kv;
+    obj.getObjMap(kv);
+    BOOST_CHECK_EQUAL(kv["age"].getValStr(), "43");
+    BOOST_CHECK_EQUAL(kv["name"].getValStr(), "foo bar");
+
+}
+
+static const char *json1 =
+"[1.10000000,{\"key1\":\"str\\u0000\",\"key2\":800,\"key3\":{\"name\":\"martian http://test.com\"}}]";
+
+BOOST_AUTO_TEST_CASE(univalue_readwrite)
+{
+    UniValue v;
+    BOOST_CHECK(v.read(json1));
+
+    std::string strJson1(json1);
+    BOOST_CHECK(v.read(strJson1));
+
+    BOOST_CHECK(v.isArray());
+    BOOST_CHECK_EQUAL(v.size(), 2);
+
+    BOOST_CHECK_EQUAL(v[0].getValStr(), "1.10000000");
+
+    UniValue obj = v[1];
+    BOOST_CHECK(obj.isObject());
+    BOOST_CHECK_EQUAL(obj.size(), 3);
+
+    BOOST_CHECK(obj["key1"].isStr());
+    std::string correctValue("str");
+    correctValue.push_back('\0');
+    BOOST_CHECK_EQUAL(obj["key1"].getValStr(), correctValue);
+    BOOST_CHECK(obj["key2"].isNum());
+    BOOST_CHECK_EQUAL(obj["key2"].getValStr(), "800");
+    BOOST_CHECK(obj["key3"].isObject());
+
+    BOOST_CHECK_EQUAL(strJson1, v.write());
+
+    /* Check for (correctly reporting) a parsing error if the initial
+       JSON construct is followed by more stuff.  Note that whitespace
+       is, of course, exempt.  */
+
+    BOOST_CHECK(v.read("  {}\n  "));
+    BOOST_CHECK(v.isObject());
+    BOOST_CHECK(v.read("  []\n  "));
+    BOOST_CHECK(v.isArray());
+
+    BOOST_CHECK(!v.read("@{}"));
+    BOOST_CHECK(!v.read("{} garbage"));
+    BOOST_CHECK(!v.read("[]{}"));
+    BOOST_CHECK(!v.read("{}[]"));
+    BOOST_CHECK(!v.read("{} 42"));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+int main (int argc, char *argv[])
+{
+    univalue_constructor();
+    univalue_typecheck();
+    univalue_set();
+    univalue_array();
+    univalue_object();
+    univalue_readwrite();
+    return 0;
+}
+
diff --git a/src/univalue/test/pass4.json b/src/univalue/test/pass4.json
new file mode 100644
index 00000000..f5a680b3
--- /dev/null
+++ b/src/univalue/test/pass4.json
@@ -0,0 +1 @@
+[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
diff --git a/src/univalue/test/unitester.cpp b/src/univalue/test/unitester.cpp
index aa6f91c1..2308afbc 100644
--- a/src/univalue/test/unitester.cpp
+++ b/src/univalue/test/unitester.cpp
@@ -17,8 +17,7 @@
 #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
 #endif
 
-using namespace std;
-string srcdir(JSON_TEST_SRC);
+std::string srcdir(JSON_TEST_SRC);
 static bool test_failed = false;
 
 #define d_assert(expr) { if (!(expr)) { test_failed = true; fprintf(stderr, "%s failed\n", filename.c_str()); } }
@@ -30,9 +29,9 @@ static std::string rtrim(std::string s)
     return s;
 }
 
-static void runtest(string filename, const string& jdata)
+static void runtest(std::string filename, const std::string& jdata)
 {
-        string prefix = filename.substr(0, 4);
+        std::string prefix = filename.substr(0, 4);
 
         bool wantPass = (prefix == "pass") || (prefix == "roun");
         bool wantFail = (prefix == "fail");
@@ -56,19 +55,19 @@ static void runtest(string filename, const string& jdata)
 
 static void runtest_file(const char *filename_)
 {
-        string basename(filename_);
-        string filename = srcdir + "/" + basename;
+        std::string basename(filename_);
+        std::string filename = srcdir + "/" + basename;
         FILE *f = fopen(filename.c_str(), "r");
         assert(f != NULL);
 
-        string jdata;
+        std::string jdata;
 
         char buf[4096];
         while (!feof(f)) {
                 int bread = fread(buf, 1, sizeof(buf), f);
                 assert(!ferror(f));
 
-                string s(buf, bread);
+                std::string s(buf, bread);
                 jdata += s;
         }
 
@@ -114,6 +113,8 @@ static const char *filenames[] = {
         "fail40.json",               // invalid unicode: broken UTF-8
         "fail41.json",               // invalid unicode: unfinished UTF-8
         "fail42.json",               // valid json with garbage following a nul byte
+        "fail44.json",               // unterminated string
+        "fail45.json",               // nested beyond max depth
         "fail3.json",
         "fail4.json",                // extra comma
         "fail5.json",
@@ -124,6 +125,7 @@ static const char *filenames[] = {
         "pass1.json",
         "pass2.json",
         "pass3.json",
+        "pass4.json",
         "round1.json",              // round-trip test
         "round2.json",              // unicode
         "round3.json",              // bare string
diff --git a/src/util.cpp b/src/util.cpp
index 09d204ea..d79f7368 100644
--- a/src/util.cpp
+++ b/src/util.cpp
@@ -543,8 +543,10 @@ boost::filesystem::path GetDefaultDataDir()
 {
     namespace fs = boost::filesystem;
     char symbol[KOMODO_ASSETCHAIN_MAXLEN];
-    if ( ASSETCHAINS_SYMBOL[0] != 0 )
+    if ( ASSETCHAINS_SYMBOL[0] != 0 ){
         strcpy(symbol,ASSETCHAINS_SYMBOL);
+    }
+    
     else symbol[0] = 0;
     // Windows < Vista: C:\Documents and Settings\Username\Application Data\Zcash
     // Windows >= Vista: C:\Users\Username\AppData\Roaming\Zcash
@@ -666,8 +668,9 @@ const boost::filesystem::path &GetDataDir(bool fNetSpecific)
 
     // This can be called during exceptions by LogPrintf(), so we cache the
     // value so we don't have to do memory allocations after that.
-    if (!path.empty())
+    if (!path.empty()){
         return path;
+    }
 
     if (mapArgs.count("-datadir")) {
         path = fs::system_complete(mapArgs["-datadir"]);
@@ -696,8 +699,9 @@ void ClearDatadirCache()
 boost::filesystem::path GetConfigFile()
 {
     char confname[512];
-    if ( ASSETCHAINS_SYMBOL[0] != 0 )
+    if ( !mapArgs.count("-conf") && ASSETCHAINS_SYMBOL[0] != 0 ){
         sprintf(confname,"%s.conf",ASSETCHAINS_SYMBOL);
+    }
     else
     {
 #ifdef __APPLE__
@@ -707,8 +711,9 @@ boost::filesystem::path GetConfigFile()
 #endif
     }
     boost::filesystem::path pathConfigFile(GetArg("-conf",confname));
-    if (!pathConfigFile.is_complete())
+    if (!pathConfigFile.is_complete()){
         pathConfigFile = GetDataDir(false) / pathConfigFile;
+    }
 
     return pathConfigFile;
 }
diff --git a/src/version.h b/src/version.h
index c9c3bbc5..121e2fe9 100644
--- a/src/version.h
+++ b/src/version.h
@@ -33,8 +33,8 @@ static const int INIT_PROTO_VERSION = 209;
 static const int GETHEADERS_VERSION = 31800;
 
 //! disconnect from peers older than this proto version
-static const int MIN_PEER_PROTO_VERSION = 170007;
-static const int STAKEDMIN_PEER_PROTO_VERSION = 170007;
+static const int MIN_PEER_PROTO_VERSION = 170008;
+static const int STAKEDMIN_PEER_PROTO_VERSION = 170008;
 
 //! nTime field added to CAddress, starting with this version;
 //! if possible, avoid requesting addresses nodes older than this
@@ -49,4 +49,4 @@ static const int MEMPOOL_GD_VERSION = 60002;
 //! "filter*" commands are disabled without NODE_BLOOM after and including this version
 static const int NO_BLOOM_VERSION = 170004;
 
-#endif // BITCOIN_VERSION_H
\ No newline at end of file
+#endif // BITCOIN_VERSION_H
diff --git a/src/wallet/asyncrpcoperation_mergetoaddress.cpp b/src/wallet/asyncrpcoperation_mergetoaddress.cpp
index 139a731a..b8c952f7 100644
--- a/src/wallet/asyncrpcoperation_mergetoaddress.cpp
+++ b/src/wallet/asyncrpcoperation_mergetoaddress.cpp
@@ -50,7 +50,7 @@ int32_t komodo_blockheight(uint256 hash);
 
 using namespace libzcash;
 
-extern UniValue sendrawtransaction(const UniValue& params, bool fHelp);
+extern UniValue sendrawtransaction(const UniValue& params, bool fHelp, const CPubKey& mypk);
 
 int mta_find_output(UniValue obj, int n)
 {
@@ -403,7 +403,7 @@ bool AsyncRPCOperation_mergetoaddress::main_impl()
         if (!testmode) {
             UniValue params = UniValue(UniValue::VARR);
             params.push_back(signedtxn);
-            UniValue sendResultValue = sendrawtransaction(params, false);
+            UniValue sendResultValue = sendrawtransaction(params, false, CPubKey());
             if (sendResultValue.isNull()) {
                 throw JSONRPCError(RPC_WALLET_ERROR, "sendrawtransaction did not return an error or a txid.");
             }
@@ -780,7 +780,7 @@ bool AsyncRPCOperation_mergetoaddress::main_impl()
 }
 
 
-extern UniValue signrawtransaction(const UniValue& params, bool fHelp);
+extern UniValue signrawtransaction(const UniValue& params, bool fHelp, const CPubKey& mypk);
 
 /**
  * Sign and send a raw transaction.
@@ -797,7 +797,7 @@ void AsyncRPCOperation_mergetoaddress::sign_send_raw_transaction(UniValue obj)
 
     UniValue params = UniValue(UniValue::VARR);
     params.push_back(rawtxn);
-    UniValue signResultValue = signrawtransaction(params, false);
+    UniValue signResultValue = signrawtransaction(params, false, CPubKey());
     UniValue signResultObject = signResultValue.get_obj();
     UniValue completeValue = find_value(signResultObject, "complete");
     bool complete = completeValue.get_bool();
@@ -817,7 +817,7 @@ void AsyncRPCOperation_mergetoaddress::sign_send_raw_transaction(UniValue obj)
         params.clear();
         params.setArray();
         params.push_back(signedtxn);
-        UniValue sendResultValue = sendrawtransaction(params, false);
+        UniValue sendResultValue = sendrawtransaction(params, false, CPubKey());
         if (sendResultValue.isNull()) {
             throw JSONRPCError(RPC_WALLET_ERROR, "Send raw transaction did not return an error or a txid.");
         }
diff --git a/src/wallet/asyncrpcoperation_sendmany.cpp b/src/wallet/asyncrpcoperation_sendmany.cpp
index 98344162..b81851a8 100644
--- a/src/wallet/asyncrpcoperation_sendmany.cpp
+++ b/src/wallet/asyncrpcoperation_sendmany.cpp
@@ -58,8 +58,8 @@ int32_t komodo_dpowconfs(int32_t height,int32_t numconfs);
 int32_t komodo_blockheight(uint256 hash);
 int tx_height( const uint256 &hash );
 bool komodo_hardfork_active(uint32_t time);
-extern UniValue signrawtransaction(const UniValue& params, bool fHelp);
-extern UniValue sendrawtransaction(const UniValue& params, bool fHelp);
+extern UniValue signrawtransaction(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue sendrawtransaction(const UniValue& params, bool fHelp, const CPubKey& mypk);
 
 int find_output(UniValue obj, int n) {
     UniValue outputMapValue = find_value(obj, "outputmap");
@@ -378,7 +378,7 @@ bool AsyncRPCOperation_sendmany::main_impl() {
             {
                 //if ((uint32_t)chainActive.LastTip()->nTime < ASSETCHAINS_STAKED_HF_TIMESTAMP)
                 if ( !komodo_hardfork_active((uint32_t)chainActive.LastTip()->nTime) )
-                builder_.SetLockTime((uint32_t)time(NULL) - 60); // set lock time for Komodo interest
+                    builder_.SetLockTime((uint32_t)time(NULL) - 60); // set lock time for Komodo interest
                 else
                     builder_.SetLockTime((uint32_t)chainActive.Tip()->GetMedianTimePast());
             }
@@ -395,7 +395,7 @@ bool AsyncRPCOperation_sendmany::main_impl() {
             {
                 //if ((uint32_t)chainActive.LastTip()->nTime < ASSETCHAINS_STAKED_HF_TIMESTAMP)
                 if ( !komodo_hardfork_active((uint32_t)chainActive.LastTip()->nTime) )
-                rawTx.nLockTime = (uint32_t)time(NULL) - 60; // jl777
+                    rawTx.nLockTime = (uint32_t)time(NULL) - 60; // jl777
                 else
                     rawTx.nLockTime = (uint32_t)chainActive.Tip()->GetMedianTimePast();
             }
@@ -530,7 +530,7 @@ bool AsyncRPCOperation_sendmany::main_impl() {
         if (!testmode) {
             UniValue params = UniValue(UniValue::VARR);
             params.push_back(signedtxn);
-            UniValue sendResultValue = sendrawtransaction(params, false);
+            UniValue sendResultValue = sendrawtransaction(params, false, CPubKey());
             if (sendResultValue.isNull()) {
                 throw JSONRPCError(RPC_WALLET_ERROR, "sendrawtransaction did not return an error or a txid.");
             }
@@ -601,7 +601,7 @@ bool AsyncRPCOperation_sendmany::main_impl() {
     mtx.joinSplitPubKey = joinSplitPubKey_;
     //if ((uint32_t)chainActive.LastTip()->nTime < ASSETCHAINS_STAKED_HF_TIMESTAMP)
     if ( !komodo_hardfork_active((uint32_t)chainActive.LastTip()->nTime) )
-    mtx.nLockTime = (uint32_t)time(NULL) - 60; // jl777
+        mtx.nLockTime = (uint32_t)time(NULL) - 60; // jl777
     else
         mtx.nLockTime = (uint32_t)chainActive.Tip()->GetMedianTimePast();
 
@@ -997,7 +997,7 @@ void AsyncRPCOperation_sendmany::sign_send_raw_transaction(UniValue obj)
 
     UniValue params = UniValue(UniValue::VARR);
     params.push_back(rawtxn);
-    UniValue signResultValue = signrawtransaction(params, false);
+    UniValue signResultValue = signrawtransaction(params, false, CPubKey());
     UniValue signResultObject = signResultValue.get_obj();
     UniValue completeValue = find_value(signResultObject, "complete");
     bool complete = completeValue.get_bool();
@@ -1017,7 +1017,7 @@ void AsyncRPCOperation_sendmany::sign_send_raw_transaction(UniValue obj)
         params.clear();
         params.setArray();
         params.push_back(signedtxn);
-        UniValue sendResultValue = sendrawtransaction(params, false);
+        UniValue sendResultValue = sendrawtransaction(params, false, CPubKey());
         if (sendResultValue.isNull()) {
             throw JSONRPCError(RPC_WALLET_ERROR, "Send raw transaction did not return an error or a txid.");
         }
@@ -1377,7 +1377,7 @@ void AsyncRPCOperation_sendmany::add_taddr_outputs_to_tx() {
     }
     //if ((uint32_t)chainActive.LastTip()->nTime < ASSETCHAINS_STAKED_HF_TIMESTAMP)
     if ( !komodo_hardfork_active((uint32_t)chainActive.LastTip()->nTime) )
-    rawTx.nLockTime = (uint32_t)time(NULL) - 60; // jl777
+        rawTx.nLockTime = (uint32_t)time(NULL) - 60; // jl777
     else
         rawTx.nLockTime = (uint32_t)chainActive.Tip()->GetMedianTimePast();
 
@@ -1408,7 +1408,7 @@ void AsyncRPCOperation_sendmany::add_taddr_change_output_to_tx(CBitcoinAddress *
     rawTx.vout.push_back(out);
     //if ((uint32_t)chainActive.LastTip()->nTime < ASSETCHAINS_STAKED_HF_TIMESTAMP)
     if ( !komodo_hardfork_active((uint32_t)chainActive.LastTip()->nTime) )
-    rawTx.nLockTime = (uint32_t)time(NULL) - 60; // jl777
+        rawTx.nLockTime = (uint32_t)time(NULL) - 60; // jl777
     else
         rawTx.nLockTime = (uint32_t)chainActive.Tip()->GetMedianTimePast();
     tx_ = CTransaction(rawTx);
diff --git a/src/wallet/asyncrpcoperation_shieldcoinbase.cpp b/src/wallet/asyncrpcoperation_shieldcoinbase.cpp
index d7c8a8e1..729fa02d 100644
--- a/src/wallet/asyncrpcoperation_shieldcoinbase.cpp
+++ b/src/wallet/asyncrpcoperation_shieldcoinbase.cpp
@@ -265,8 +265,8 @@ bool ShieldToAddress::operator()(const libzcash::SproutPaymentAddress &zaddr) co
 }
 
 
-extern UniValue signrawtransaction(const UniValue& params, bool fHelp);
-extern UniValue sendrawtransaction(const UniValue& params, bool fHelp);
+extern UniValue signrawtransaction(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue sendrawtransaction(const UniValue& params, bool fHelp, const CPubKey& mypk);
 
 bool ShieldToAddress::operator()(const libzcash::SaplingPaymentAddress &zaddr) const {
     m_op->builder_.SetFee(m_op->fee_);
@@ -312,7 +312,7 @@ bool ShieldToAddress::operator()(const libzcash::SaplingPaymentAddress &zaddr) c
     if (!m_op->testmode) {
         UniValue params = UniValue(UniValue::VARR);
         params.push_back(signedtxn);
-        UniValue sendResultValue = sendrawtransaction(params, false);
+        UniValue sendResultValue = sendrawtransaction(params, false, CPubKey());
         if (sendResultValue.isNull()) {
             throw JSONRPCError(RPC_WALLET_ERROR, "sendrawtransaction did not return an error or a txid.");
         }
@@ -354,7 +354,7 @@ void AsyncRPCOperation_shieldcoinbase::sign_send_raw_transaction(UniValue obj)
 
     UniValue params = UniValue(UniValue::VARR);
     params.push_back(rawtxn);
-    UniValue signResultValue = signrawtransaction(params, false);
+    UniValue signResultValue = signrawtransaction(params, false, CPubKey());
     UniValue signResultObject = signResultValue.get_obj();
     UniValue completeValue = find_value(signResultObject, "complete");
     bool complete = completeValue.get_bool();
@@ -374,7 +374,7 @@ void AsyncRPCOperation_shieldcoinbase::sign_send_raw_transaction(UniValue obj)
         params.clear();
         params.setArray();
         params.push_back(signedtxn);
-        UniValue sendResultValue = sendrawtransaction(params, false);
+        UniValue sendResultValue = sendrawtransaction(params, false, CPubKey());
         if (sendResultValue.isNull()) {
             throw JSONRPCError(RPC_WALLET_ERROR, "Send raw transaction did not return an error or a txid.");
         }
diff --git a/src/wallet/rpcdisclosure.cpp b/src/wallet/rpcdisclosure.cpp
index d85f0d21..14276303 100644
--- a/src/wallet/rpcdisclosure.cpp
+++ b/src/wallet/rpcdisclosure.cpp
@@ -51,7 +51,7 @@ bool EnsureWalletIsAvailable(bool avoidException);
 /**
  * RPC call to generate a payment disclosure
  */
-UniValue z_getpaymentdisclosure(const UniValue& params, bool fHelp)
+UniValue z_getpaymentdisclosure(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -158,7 +158,7 @@ UniValue z_getpaymentdisclosure(const UniValue& params, bool fHelp)
 /**
  * RPC call to validate a payment disclosure data blob.
  */
-UniValue z_validatepaymentdisclosure(const UniValue& params, bool fHelp)
+UniValue z_validatepaymentdisclosure(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
diff --git a/src/wallet/rpcdump.cpp b/src/wallet/rpcdump.cpp
index 81ee8247..3f72df1e 100644
--- a/src/wallet/rpcdump.cpp
+++ b/src/wallet/rpcdump.cpp
@@ -89,7 +89,7 @@ std::string DecodeDumpString(const std::string &str) {
     return ret.str();
 }
 
-UniValue convertpassphrase(const UniValue& params, bool fHelp)
+UniValue convertpassphrase(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() < 1 || params.size() > 1)
         throw runtime_error(
@@ -148,20 +148,21 @@ UniValue convertpassphrase(const UniValue& params, bool fHelp)
     return ret;
 }
 
-UniValue importprivkey(const UniValue& params, bool fHelp)
+UniValue importprivkey(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
 
-    if (fHelp || params.size() < 1 || params.size() > 4)
+    if (fHelp || params.size() < 1 || params.size() > 5)
         throw runtime_error(
-            "importprivkey \"komodoprivkey\" ( \"label\" rescan height)\n"
+            "importprivkey \"komodoprivkey\" ( \"label\" rescan height secret_key)\n"
             "\nAdds a private key (as returned by dumpprivkey) to your wallet.\n"
             "\nArguments:\n"
             "1. \"komodoprivkey\"   (string, required) The private key (see dumpprivkey)\n"
             "2. \"label\"            (string, optional, default=\"\") An optional label\n"
             "3. rescan               (boolean, optional, default=true) Rescan the wallet for transactions\n"
             "4. height               (integer, optional, default=0) start at block height?\n"
+            "5. secret_key           (integer, optional, default=188) used to import WIFs of other coins\n" 
             "\nNote: This call can take minutes to complete if rescan is true.\n"
             "\nExamples:\n"
             "\nDump a private key\n"
@@ -174,6 +175,10 @@ UniValue importprivkey(const UniValue& params, bool fHelp)
             + HelpExampleRpc("importprivkey", "\"mykey\", \"testing\", false") +
             "\nImport with rescan from a block height\n"
             + HelpExampleCli("importprivkey", "\"mykey\" \"testing\" true 1000") +
+            "\nImport a BTC WIF with rescan\n"
+            + HelpExampleCli("importprivkey", "\"BTCWIF\" \"testing\" true 0 128") +
+            "\nImport a BTC WIF without rescan\n"
+            + HelpExampleCli("importprivkey", "\"BTCWIF\" \"testing\" false 0 128") +
             "\nAs a JSON-RPC call\n"
             + HelpExampleRpc("importprivkey", "\"mykey\", \"testing\", true, 1000")
         );
@@ -185,6 +190,8 @@ UniValue importprivkey(const UniValue& params, bool fHelp)
     string strSecret = params[0].get_str();
     string strLabel = "";
     int32_t height = 0;
+    uint8_t secret_key = 0;
+    CKey key;
     if (params.size() > 1)
         strLabel = params[1].get_str();
 
@@ -195,10 +202,18 @@ UniValue importprivkey(const UniValue& params, bool fHelp)
     if ( fRescan && params.size() == 4 )
         height = params[3].get_int();
 
+
+    if (params.size() > 4)
+    {
+        auto secret_key = AmountFromValue(params[4])/100000000;
+        key = DecodeCustomSecret(strSecret, secret_key);
+    } else {
+        key = DecodeSecret(strSecret);
+    }
+
     if ( height < 0 || height > chainActive.Height() )
         throw JSONRPCError(RPC_WALLET_ERROR, "Rescan height is out of range.");
     
-    CKey key = DecodeSecret(strSecret);
     if (!key.IsValid()) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid private key encoding");
 
     CPubKey pubkey = key.GetPubKey();
@@ -229,7 +244,7 @@ UniValue importprivkey(const UniValue& params, bool fHelp)
     return EncodeDestination(vchAddress);
 }
 
-UniValue importaddress(const UniValue& params, bool fHelp)
+UniValue importaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -302,7 +317,7 @@ UniValue importaddress(const UniValue& params, bool fHelp)
     return NullUniValue;
 }
 
-UniValue z_importwallet(const UniValue& params, bool fHelp)
+UniValue z_importwallet(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -325,7 +340,7 @@ UniValue z_importwallet(const UniValue& params, bool fHelp)
 	return importwallet_impl(params, fHelp, true);
 }
 
-UniValue importwallet(const UniValue& params, bool fHelp)
+UniValue importwallet(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -457,7 +472,7 @@ UniValue importwallet_impl(const UniValue& params, bool fHelp, bool fImportZKeys
     return NullUniValue;
 }
 
-UniValue dumpprivkey(const UniValue& params, bool fHelp)
+UniValue dumpprivkey(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -499,7 +514,7 @@ UniValue dumpprivkey(const UniValue& params, bool fHelp)
 
 
 
-UniValue z_exportwallet(const UniValue& params, bool fHelp)
+UniValue z_exportwallet(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -520,7 +535,7 @@ UniValue z_exportwallet(const UniValue& params, bool fHelp)
 	return dumpwallet_impl(params, fHelp, true);
 }
 
-UniValue dumpwallet(const UniValue& params, bool fHelp)
+UniValue dumpwallet(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -657,7 +672,7 @@ UniValue dumpwallet_impl(const UniValue& params, bool fHelp, bool fDumpZKeys)
 }
 
 
-UniValue z_importkey(const UniValue& params, bool fHelp)
+UniValue z_importkey(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -748,7 +763,7 @@ UniValue z_importkey(const UniValue& params, bool fHelp)
     return NullUniValue;
 }
 
-UniValue z_importviewingkey(const UniValue& params, bool fHelp)
+UniValue z_importviewingkey(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -866,7 +881,7 @@ UniValue z_importviewingkey(const UniValue& params, bool fHelp)
     return NullUniValue;
 }
 
-UniValue z_exportkey(const UniValue& params, bool fHelp)
+UniValue z_exportkey(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -905,7 +920,7 @@ UniValue z_exportkey(const UniValue& params, bool fHelp)
     return EncodeSpendingKey(sk.get());
 }
 
-UniValue z_exportviewingkey(const UniValue& params, bool fHelp)
+UniValue z_exportviewingkey(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -956,3 +971,220 @@ UniValue z_exportviewingkey(const UniValue& params, bool fHelp)
 
     return EncodeViewingKey(vk);
 }
+
+extern int32_t KOMODO_NSPV;
+#ifndef KOMODO_NSPV_FULLNODE
+#define KOMODO_NSPV_FULLNODE (KOMODO_NSPV <= 0)
+#endif // !KOMODO_NSPV_FULLNODE
+#ifndef KOMODO_NSPV_SUPERLITE
+#define KOMODO_NSPV_SUPERLITE (KOMODO_NSPV > 0)
+#endif // !KOMODO_NSPV_SUPERLITE
+uint256 zeroid;
+UniValue NSPV_getinfo_req(int32_t reqht);
+UniValue NSPV_login(char *wifstr);
+UniValue NSPV_logout();
+UniValue NSPV_addresstxids(char *coinaddr,int32_t CCflag,int32_t skipcount,int32_t filter);
+UniValue NSPV_addressutxos(char *coinaddr,int32_t CCflag,int32_t skipcount,int32_t filter);
+UniValue NSPV_mempooltxids(char *coinaddr,int32_t CCflag,uint8_t funcid,uint256 txid,int32_t vout);
+UniValue NSPV_broadcast(char *hex);
+UniValue NSPV_spend(char *srcaddr,char *destaddr,int64_t satoshis);
+UniValue NSPV_spentinfo(uint256 txid,int32_t vout);
+UniValue NSPV_notarizations(int32_t height);
+UniValue NSPV_hdrsproof(int32_t prevheight,int32_t nextheight);
+UniValue NSPV_txproof(int32_t vout,uint256 txid,int32_t height);
+UniValue NSPV_ccmoduleutxos(char *coinaddr, int64_t amount, uint8_t evalcode, std::string funcids, uint256 filtertxid);
+
+uint256 Parseuint256(const char *hexstr);
+extern std::string NSPV_address;
+
+UniValue nspv_getinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    int32_t reqht = 0;
+    if ( fHelp || params.size() > 1 )
+        throw runtime_error("nspv_getinfo [hdrheight]\n");
+    if ( KOMODO_NSPV_FULLNODE )
+        throw runtime_error("-nSPV=1 must be set to use nspv\n");
+    if ( params.size() == 1 )
+        reqht = atoi((char *)params[0].get_str().c_str());
+    return(NSPV_getinfo_req(reqht));
+}
+
+UniValue nspv_logout(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    if ( fHelp || params.size() != 0 )
+        throw runtime_error("nspv_logout\n");
+    if ( KOMODO_NSPV_FULLNODE )
+        throw runtime_error("-nSPV=1 must be set to use nspv\n");
+    return(NSPV_logout());
+}
+
+UniValue nspv_login(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    if ( fHelp || params.size() != 1 )
+        throw runtime_error("nspv_login wif\n");
+    if ( KOMODO_NSPV_FULLNODE )
+        throw runtime_error("-nSPV=1 must be set to use nspv\n");
+    return(NSPV_login((char *)params[0].get_str().c_str()));
+}
+
+UniValue nspv_listunspent(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    int32_t skipcount = 0,CCflag = 0;
+    if ( fHelp || params.size() > 3 )
+        throw runtime_error("nspv_listunspent [address [isCC [skipcount]]]\n");
+    if ( KOMODO_NSPV_FULLNODE )
+        throw runtime_error("-nSPV=1 must be set to use nspv\n");
+    if ( params.size() == 0 )
+    {
+        if ( NSPV_address.size() != 0 )
+            return(NSPV_addressutxos((char *)NSPV_address.c_str(),0,0,0));
+        else throw runtime_error("nspv_listunspent [address [isCC [skipcount]]]\n");
+    }
+    if ( params.size() >= 1 )
+    {
+        if ( params.size() >= 2 )
+            CCflag = atoi((char *)params[1].get_str().c_str());
+        if ( params.size() == 3 )
+            skipcount = atoi((char *)params[2].get_str().c_str());
+        return(NSPV_addressutxos((char *)params[0].get_str().c_str(),CCflag,skipcount,0));
+    }
+    else throw runtime_error("nspv_listunspent [address [isCC [skipcount]]]\n");
+}
+
+UniValue nspv_mempool(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    int32_t vout = 0,CCflag = 0; uint256 txid; uint8_t funcid; char *coinaddr;
+    memset(&txid,0,sizeof(txid));
+    if ( fHelp || params.size() > 5 )
+        throw runtime_error("nspv_mempool func(0 all, 1 address recv, 2 txid/vout spent, 3 txid inmempool) address isCC [txid vout]]]\n");
+    if ( KOMODO_NSPV_FULLNODE )
+        throw runtime_error("-nSPV=1 must be set to use nspv\n");
+    funcid = atoi((char *)params[0].get_str().c_str());
+    coinaddr = (char *)params[1].get_str().c_str();
+    CCflag = atoi((char *)params[2].get_str().c_str());
+    if ( params.size() > 3 )
+    {
+        if ( params.size() != 5 )
+            throw runtime_error("nspv_mempool func(0 all, 1 address recv, 2 txid/vout spent, 3 txid inmempool) address isCC [txid vout]]]\n");
+        txid = Parseuint256((char *)params[3].get_str().c_str());
+        vout = atoi((char *)params[4].get_str().c_str());
+    }
+    return(NSPV_mempooltxids(coinaddr,CCflag,funcid,txid,vout));
+}
+
+UniValue nspv_listtransactions(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    int32_t skipcount = 0,CCflag = 0;
+    if ( fHelp || params.size() > 3 )
+        throw runtime_error("nspv_listtransactions [address [isCC [skipcount]]]\n");
+    if ( KOMODO_NSPV_FULLNODE )
+        throw runtime_error("-nSPV=1 must be set to use nspv\n");
+    if ( params.size() == 0 )
+    {
+        if ( NSPV_address.size() != 0 )
+            return(NSPV_addresstxids((char *)NSPV_address.c_str(),0,0,0));
+        else throw runtime_error("nspv_listtransactions [address [isCC [skipcount]]]\n");
+    }
+    if ( params.size() >= 1 )
+    {
+        if ( params.size() >= 2 )
+            CCflag = atoi((char *)params[1].get_str().c_str());
+        if ( params.size() == 3 )
+            skipcount = atoi((char *)params[2].get_str().c_str());
+        //fprintf(stderr,"call txids cc.%d skip.%d\n",CCflag,skipcount);
+        return(NSPV_addresstxids((char *)params[0].get_str().c_str(),CCflag,skipcount,0));
+    }
+    else throw runtime_error("nspv_listtransactions [address [isCC [skipcount]]]\n");
+}
+
+UniValue nspv_spentinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    uint256 txid; int32_t vout;
+    if ( fHelp || params.size() != 2 )
+        throw runtime_error("nspv_spentinfo txid vout\n");
+    if ( KOMODO_NSPV_FULLNODE )
+        throw runtime_error("-nSPV=1 must be set to use nspv\n");
+    txid = Parseuint256((char *)params[0].get_str().c_str());
+    vout = atoi((char *)params[1].get_str().c_str());
+    return(NSPV_spentinfo(txid,vout));
+}
+
+UniValue nspv_notarizations(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    int32_t height;
+    if ( fHelp || params.size() != 1 )
+        throw runtime_error("nspv_notarizations height\n");
+    if ( KOMODO_NSPV_FULLNODE )
+        throw runtime_error("-nSPV=1 must be set to use nspv\n");
+    height = atoi((char *)params[0].get_str().c_str());
+    return(NSPV_notarizations(height));
+}
+
+UniValue nspv_hdrsproof(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    int32_t prevheight,nextheight;
+    if ( fHelp || params.size() != 2 )
+        throw runtime_error("nspv_hdrsproof prevheight nextheight\n");
+    if ( KOMODO_NSPV_FULLNODE )
+        throw runtime_error("-nSPV=1 must be set to use nspv\n");
+    prevheight = atoi((char *)params[0].get_str().c_str());
+    nextheight = atoi((char *)params[1].get_str().c_str());
+    return(NSPV_hdrsproof(prevheight,nextheight));
+}
+
+UniValue nspv_txproof(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    uint256 txid; int32_t height;
+    if ( fHelp || params.size() != 2 )
+        throw runtime_error("nspv_txproof txid height\n");
+    if ( KOMODO_NSPV_FULLNODE )
+        throw runtime_error("-nSPV=1 must be set to use nspv\n");
+    txid = Parseuint256((char *)params[0].get_str().c_str());
+    height = atoi((char *)params[1].get_str().c_str());
+    return(NSPV_txproof(0,txid,height));
+}
+
+UniValue nspv_spend(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    uint64_t satoshis;
+    if ( fHelp || params.size() != 2 )
+        throw runtime_error("nspv_spend address amount\n");
+    if ( KOMODO_NSPV_FULLNODE )
+        throw runtime_error("-nSPV=1 must be set to use nspv\n");
+    if ( NSPV_address.size() == 0 )
+        throw runtime_error("to nspv_send you need an active nspv_login\n");
+    satoshis = atof(params[1].get_str().c_str())*COIN + 0.0000000049;
+    //fprintf(stderr,"satoshis.%lld from %.8f\n",(long long)satoshis,atof(params[1].get_str().c_str()));
+    if ( satoshis < 1000 )
+        throw runtime_error("amount too small\n");
+    return(NSPV_spend((char *)NSPV_address.c_str(),(char *)params[0].get_str().c_str(),satoshis));
+}
+
+UniValue nspv_broadcast(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    if ( fHelp || params.size() != 1 )
+        throw runtime_error("nspv_broadcast hex\n");
+    if ( KOMODO_NSPV_FULLNODE )
+        throw runtime_error("-nSPV=1 must be set to use nspv\n");
+    return(NSPV_broadcast((char *)params[0].get_str().c_str()));
+}
+
+UniValue nspv_listccmoduleunspent(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    int32_t skipcount = 0, CCflag = 0;
+    if (fHelp || params.size() != 5)
+        throw runtime_error("nspv_listccmoduleunspent address amount evalcode funcids txid\n\n" 
+        "returns utxos from the address, filtered by evalcode funcids and txid in opret.\n"
+        "if amount is 0 just returns no utxos and available total.\n"
+        "funcids is a string of funcid symbols. The first symbol is considered as the creation funcid, so the txid param will be compared to the creation tx id.\n"
+        "For the second+ funcids the txid param will be compared to txid in opreturn\n\n" );
+    if (KOMODO_NSPV_FULLNODE)
+        throw runtime_error("-nSPV=1 must be set to use nspv\n");
+
+    std::string address = params[0].get_str().c_str();
+    int64_t amount = atof(params[1].get_str().c_str());
+    uint8_t evalcode = atoi(params[2].get_str().c_str());
+    std::string funcids = params[3].get_str().c_str();
+    uint256 txid = Parseuint256( params[4].get_str().c_str() );
+    return(NSPV_ccmoduleutxos((char*)address.c_str(), amount, evalcode, funcids, txid));
+}
\ No newline at end of file
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index 6258c86e..4b502c77 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -54,6 +54,7 @@
 #include <stdint.h>
 
 #include <boost/assign/list_of.hpp>
+//#include <utf8.h>
 
 #include <univalue.h>
 
@@ -116,6 +117,24 @@ void EnsureWalletIsUnlocked()
         throw JSONRPCError(RPC_WALLET_UNLOCK_NEEDED, "Error: Please enter the wallet passphrase with walletpassphrase first.");
 }
 
+void Lock2NSPV(const CPubKey &pk)
+{
+    if (!pk.IsValid())
+    {
+        ENTER_CRITICAL_SECTION(cs_main);
+        ENTER_CRITICAL_SECTION(pwalletMain->cs_wallet);
+    }
+}
+
+void Unlock2NSPV(const CPubKey &pk)
+{
+    if (!pk.IsValid())
+    {
+        LEAVE_CRITICAL_SECTION(cs_main);
+        LEAVE_CRITICAL_SECTION(pwalletMain->cs_wallet);
+    }
+}
+
 uint64_t komodo_accrued_interest(int32_t *txheightp,uint32_t *locktimep,uint256 hash,int32_t n,int32_t checkheight,uint64_t checkvalue,int32_t tipheight);
 
 void WalletTxToJSON(const CWalletTx& wtx, UniValue& entry)
@@ -160,9 +179,11 @@ char *komodo_chainname()
      return(ASSETCHAINS_SYMBOL[0] == 0 ? (char *)"KMD" : ASSETCHAINS_SYMBOL);
 }
 
-UniValue getnewaddress(const UniValue& params, bool fHelp)
+void OS_randombytes(unsigned char *x,long xlen);
+
+UniValue getnewaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
-    if (!EnsureWalletIsAvailable(fHelp))
+    if ( KOMODO_NSPV_FULLNODE && !EnsureWalletIsAvailable(fHelp) )
         return NullUniValue;
 
     if (fHelp || params.size() > 1)
@@ -178,6 +199,23 @@ UniValue getnewaddress(const UniValue& params, bool fHelp)
             + HelpExampleRpc("getnewaddress", "")
         );
 
+    if ( KOMODO_NSPV_SUPERLITE )
+    {
+        UniValue result(UniValue::VOBJ); uint8_t priv32[32];
+#ifndef WIN32
+        OS_randombytes(priv32,sizeof(priv32));
+#else
+        randombytes_buf(priv32,sizeof(priv32));
+#endif
+        CKey key;
+        key.Set(&priv32[0],&priv32[32], true);
+        CPubKey pubkey = key.GetPubKey();
+        CKeyID vchAddress = pubkey.GetID();
+        result.push_back(Pair("wif",EncodeSecret(key)));
+        result.push_back(Pair("address",EncodeDestination(vchAddress)));
+        result.push_back(Pair("pubkey",HexStr(pubkey)));
+        return(result);
+    }
     LOCK2(cs_main, pwalletMain->cs_wallet);
 
     // Parse the account first so we don't generate a key if there's an error
@@ -237,7 +275,7 @@ CTxDestination GetAccountAddress(std::string strAccount, bool bForceNew=false)
     return account.vchPubKey.GetID();
 }
 
-UniValue getaccountaddress(const UniValue& params, bool fHelp)
+UniValue getaccountaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -269,7 +307,7 @@ UniValue getaccountaddress(const UniValue& params, bool fHelp)
 }
 
 
-UniValue getrawchangeaddress(const UniValue& params, bool fHelp)
+UniValue getrawchangeaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -304,7 +342,7 @@ UniValue getrawchangeaddress(const UniValue& params, bool fHelp)
 }
 
 
-UniValue setaccount(const UniValue& params, bool fHelp)
+UniValue setaccount(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -325,7 +363,7 @@ UniValue setaccount(const UniValue& params, bool fHelp)
 
     CTxDestination dest = DecodeDestination(params[0].get_str());
     if (!IsValidDestination(dest)) {
-        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Zcash address");
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Komodo address");
     }
 
     string strAccount;
@@ -350,7 +388,7 @@ UniValue setaccount(const UniValue& params, bool fHelp)
 }
 
 
-UniValue getaccount(const UniValue& params, bool fHelp)
+UniValue getaccount(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -372,7 +410,7 @@ UniValue getaccount(const UniValue& params, bool fHelp)
 
     CTxDestination dest = DecodeDestination(params[0].get_str());
     if (!IsValidDestination(dest)) {
-        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Zcash address");
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Komodo address");
     }
 
     std::string strAccount;
@@ -384,7 +422,7 @@ UniValue getaccount(const UniValue& params, bool fHelp)
 }
 
 
-UniValue getaddressesbyaccount(const UniValue& params, bool fHelp)
+UniValue getaddressesbyaccount(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -469,7 +507,7 @@ static void SendMoney(const CTxDestination &address, CAmount nValue, bool fSubtr
 }
 
 
-UniValue sendtoaddress(const UniValue& params, bool fHelp)
+UniValue sendtoaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -509,7 +547,7 @@ UniValue sendtoaddress(const UniValue& params, bool fHelp)
 
     CTxDestination dest = DecodeDestination(params[0].get_str());
     if (!IsValidDestination(dest)) {
-        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Zcash address");
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Komodo address");
     }
 
     // Amount
@@ -558,7 +596,7 @@ int32_t komodo_kvduration(uint32_t flags);
 uint256 komodo_kvprivkey(uint256 *pubkeyp,char *passphrase);
 int32_t komodo_kvsigverify(uint8_t *buf,int32_t len,uint256 _pubkey,uint256 sig);
 
-UniValue kvupdate(const UniValue& params, bool fHelp)
+UniValue kvupdate(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     static uint256 zeroes;
     CWalletTx wtx; UniValue ret(UniValue::VOBJ);
@@ -700,7 +738,7 @@ UniValue kvupdate(const UniValue& params, bool fHelp)
     return ret;
 }
 
-UniValue paxdeposit(const UniValue& params, bool fHelp)
+UniValue paxdeposit(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     uint64_t available,deposited,issued,withdrawn,approved,redeemed,seed,komodoshis = 0; int32_t height; char destaddr[64]; uint8_t i,pubkey37[33];
     bool fSubtractFeeFromAmount = false;
@@ -746,7 +784,7 @@ UniValue paxdeposit(const UniValue& params, bool fHelp)
     return wtx.GetHash().GetHex();
 }
 
-UniValue paxwithdraw(const UniValue& params, bool fHelp)
+UniValue paxwithdraw(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     CWalletTx wtx; std::string dest; int32_t kmdheight; uint64_t seed,komodoshis = 0; char destaddr[64]; uint8_t i,pubkey37[37]; bool fSubtractFeeFromAmount = false;
     if ( ASSETCHAINS_SYMBOL[0] == 0 )
@@ -781,7 +819,7 @@ UniValue paxwithdraw(const UniValue& params, bool fHelp)
     return wtx.GetHash().GetHex();
 }
 
-UniValue listaddressgroupings(const UniValue& params, bool fHelp)
+UniValue listaddressgroupings(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -832,7 +870,7 @@ UniValue listaddressgroupings(const UniValue& params, bool fHelp)
     return jsonGroupings;
 }
 
-UniValue signmessage(const UniValue& params, bool fHelp)
+UniValue signmessage(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -891,7 +929,7 @@ UniValue signmessage(const UniValue& params, bool fHelp)
     return EncodeBase64(&vchSig[0], vchSig.size());
 }
 
-UniValue getreceivedbyaddress(const UniValue& params, bool fHelp)
+UniValue getreceivedbyaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -921,7 +959,7 @@ UniValue getreceivedbyaddress(const UniValue& params, bool fHelp)
     // Bitcoin address
     CTxDestination dest = DecodeDestination(params[0].get_str());
     if (!IsValidDestination(dest)) {
-        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Zcash address");
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Komodo address");
     }
     CScript scriptPubKey = GetScriptForDestination(dest);
     if (!IsMine(*pwalletMain, scriptPubKey)) {
@@ -962,7 +1000,7 @@ UniValue getreceivedbyaddress(const UniValue& params, bool fHelp)
 }
 
 
-UniValue getreceivedbyaccount(const UniValue& params, bool fHelp)
+UniValue getreceivedbyaccount(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -1060,7 +1098,7 @@ CAmount GetAccountBalance(const string& strAccount, int nMinDepth, const isminef
     return GetAccountBalance(walletdb, strAccount, nMinDepth, filter);
 }
 
-UniValue cleanwallettransactions(const UniValue& params, bool fHelp)
+UniValue cleanwallettransactions(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -1163,7 +1201,7 @@ UniValue cleanwallettransactions(const UniValue& params, bool fHelp)
     return  (ret);
 }
 
-UniValue getbalance(const UniValue& params, bool fHelp)
+UniValue getbalance(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -1245,7 +1283,7 @@ UniValue getbalance(const UniValue& params, bool fHelp)
     return ValueFromAmount(nBalance);
 }
 
-UniValue getunconfirmedbalance(const UniValue &params, bool fHelp)
+UniValue getunconfirmedbalance(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -1261,7 +1299,7 @@ UniValue getunconfirmedbalance(const UniValue &params, bool fHelp)
 }
 
 
-UniValue movecmd(const UniValue& params, bool fHelp)
+UniValue movecmd(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -1336,7 +1374,7 @@ UniValue movecmd(const UniValue& params, bool fHelp)
 }
 
 
-UniValue sendfrom(const UniValue& params, bool fHelp)
+UniValue sendfrom(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -1375,7 +1413,7 @@ UniValue sendfrom(const UniValue& params, bool fHelp)
     std::string strAccount = AccountFromValue(params[0]);
     CTxDestination dest = DecodeDestination(params[1].get_str());
     if (!IsValidDestination(dest)) {
-        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Zcash address");
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Komodo address");
     }
     CAmount nAmount = AmountFromValue(params[2]);
     if (nAmount <= 0)
@@ -1404,7 +1442,7 @@ UniValue sendfrom(const UniValue& params, bool fHelp)
 }
 
 
-UniValue sendmany(const UniValue& params, bool fHelp)
+UniValue sendmany(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -1475,16 +1513,15 @@ UniValue sendmany(const UniValue& params, bool fHelp)
     for (const std::string& name_ : keys) {
         CTxDestination dest = DecodeDestination(name_);
         if (!IsValidDestination(dest)) {
-            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid Zcash address: ") + name_);
+            CScript tmpspk;
+            tmpspk << ParseHex(name_) << OP_CHECKSIG;
+            if ( !ExtractDestination(tmpspk, dest, true) )
+                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid Komodo address or pubkey: ") + name_);
         }
-
-        /*if (destinations.count(dest)) {
-            throw JSONRPCError(RPC_INVALID_PARAMETER, std::string("Invalid parameter, duplicated address: ") + name_);
-        }*/
-        destinations.insert(dest);
-
         CScript scriptPubKey = GetScriptForDestination(dest);
+        
         CAmount nAmount = AmountFromValue(sendTo[i]);
+        i++;
         if (nAmount <= 0)
             throw JSONRPCError(RPC_TYPE_ERROR, "Invalid amount for send");
         totalAmount += nAmount;
@@ -1498,7 +1535,6 @@ UniValue sendmany(const UniValue& params, bool fHelp)
 
         CRecipient recipient = {scriptPubKey, nAmount, fSubtractFeeFromAmount};
         vecSend.push_back(recipient);
-        i++;
     }
 
     EnsureWalletIsUnlocked();
@@ -1526,7 +1562,7 @@ UniValue sendmany(const UniValue& params, bool fHelp)
 // Defined in rpc/misc.cpp
 extern CScript _createmultisig_redeemScript(const UniValue& params);
 
-UniValue addmultisigaddress(const UniValue& params, bool fHelp)
+UniValue addmultisigaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -1720,7 +1756,7 @@ UniValue ListReceived(const UniValue& params, bool fByAccounts)
     return ret;
 }
 
-UniValue listreceivedbyaddress(const UniValue& params, bool fHelp)
+UniValue listreceivedbyaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -1757,7 +1793,7 @@ UniValue listreceivedbyaddress(const UniValue& params, bool fHelp)
     return ListReceived(params, false);
 }
 
-UniValue listreceivedbyaccount(const UniValue& params, bool fHelp)
+UniValue listreceivedbyaccount(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -1903,7 +1939,7 @@ void AcentryToJSON(const CAccountingEntry& acentry, const string& strAccount, Un
     }
 }
 
-UniValue listtransactions(const UniValue& params, bool fHelp)
+UniValue listtransactions(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -2029,7 +2065,7 @@ UniValue listtransactions(const UniValue& params, bool fHelp)
     return ret;
 }
 
-UniValue listaccounts(const UniValue& params, bool fHelp)
+UniValue listaccounts(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -2109,7 +2145,7 @@ UniValue listaccounts(const UniValue& params, bool fHelp)
     return ret;
 }
 
-UniValue listsinceblock(const UniValue& params, bool fHelp)
+UniValue listsinceblock(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -2200,7 +2236,7 @@ UniValue listsinceblock(const UniValue& params, bool fHelp)
     return ret;
 }
 
-UniValue gettransaction(const UniValue& params, bool fHelp)
+UniValue gettransaction(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -2289,7 +2325,7 @@ UniValue gettransaction(const UniValue& params, bool fHelp)
 }
 
 
-UniValue backupwallet(const UniValue& params, bool fHelp)
+UniValue backupwallet(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -2332,7 +2368,7 @@ UniValue backupwallet(const UniValue& params, bool fHelp)
 }
 
 
-UniValue keypoolrefill(const UniValue& params, bool fHelp)
+UniValue keypoolrefill(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -2376,7 +2412,7 @@ static void LockWallet(CWallet* pWallet)
     pWallet->Lock();
 }
 
-UniValue walletpassphrase(const UniValue& params, bool fHelp)
+UniValue walletpassphrase(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -2438,7 +2474,7 @@ UniValue walletpassphrase(const UniValue& params, bool fHelp)
 }
 
 
-UniValue walletpassphrasechange(const UniValue& params, bool fHelp)
+UniValue walletpassphrasechange(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -2484,7 +2520,7 @@ UniValue walletpassphrasechange(const UniValue& params, bool fHelp)
 }
 
 
-UniValue walletlock(const UniValue& params, bool fHelp)
+UniValue walletlock(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -2524,7 +2560,7 @@ UniValue walletlock(const UniValue& params, bool fHelp)
 
 int32_t komodo_acpublic(uint32_t tiptime);
 
-UniValue encryptwallet(const UniValue& params, bool fHelp)
+UniValue encryptwallet(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -2594,7 +2630,7 @@ UniValue encryptwallet(const UniValue& params, bool fHelp)
     return "wallet encrypted; Komodo server stopping, restart to run with encrypted wallet. The keypool has been flushed, you need to make a new backup.";
 }
 
-UniValue lockunspent(const UniValue& params, bool fHelp)
+UniValue lockunspent(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -2678,7 +2714,7 @@ UniValue lockunspent(const UniValue& params, bool fHelp)
     return true;
 }
 
-UniValue listlockunspent(const UniValue& params, bool fHelp)
+UniValue listlockunspent(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -2727,7 +2763,7 @@ UniValue listlockunspent(const UniValue& params, bool fHelp)
     return ret;
 }
 
-UniValue settxfee(const UniValue& params, bool fHelp)
+UniValue settxfee(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -2754,7 +2790,7 @@ UniValue settxfee(const UniValue& params, bool fHelp)
     return true;
 }
 
-UniValue getwalletinfo(const UniValue& params, bool fHelp)
+UniValue getwalletinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -2800,7 +2836,7 @@ UniValue getwalletinfo(const UniValue& params, bool fHelp)
     return obj;
 }
 
-UniValue resendwallettransactions(const UniValue& params, bool fHelp)
+UniValue resendwallettransactions(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -2827,7 +2863,7 @@ UniValue resendwallettransactions(const UniValue& params, bool fHelp)
 
 extern uint32_t komodo_segid32(char *coinaddr);
 
-UniValue listunspent(const UniValue& params, bool fHelp)
+UniValue listunspent(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -2854,7 +2890,7 @@ UniValue listunspent(const UniValue& params, bool fHelp)
             "    \"txid\" : \"txid\",          (string) the transaction id \n"
             "    \"vout\" : n,               (numeric) the vout value\n"
             "    \"generated\" : true|false  (boolean) true if txout is a coinbase transaction output\n"
-            "    \"address\" : \"address\",    (string) the Zcash address\n"
+            "    \"address\" : \"address\",    (string) the Komodo address\n"
             "    \"account\" : \"account\",    (string) DEPRECATED. The associated account, or \"\" for the default account\n"
             "    \"scriptPubKey\" : \"key\",   (string) the script key\n"
             "    \"amount\" : x.xxx,         (numeric) the transaction amount in " + CURRENCY_UNIT + "\n"
@@ -2888,7 +2924,7 @@ UniValue listunspent(const UniValue& params, bool fHelp)
             const UniValue& input = inputs[idx];
             CTxDestination dest = DecodeDestination(input.get_str());
             if (!IsValidDestination(dest)) {
-                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid Zcash address: ") + input.get_str());
+                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid Komodo address: ") + input.get_str());
             }
             if (!destinations.insert(dest).second) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER, std::string("Invalid parameter, duplicated address: ") + input.get_str());
@@ -2969,7 +3005,7 @@ UniValue listunspent(const UniValue& params, bool fHelp)
 uint64_t komodo_interestsum()
 {
 #ifdef ENABLE_WALLET
-    if ( ASSETCHAINS_SYMBOL[0] == 0 && GetBoolArg("-disablewallet", false) == 0 )
+    if ( ASSETCHAINS_SYMBOL[0] == 0 && GetBoolArg("-disablewallet", false) == 0 && KOMODO_NSPV_FULLNODE )
     {
         uint64_t interest,sum = 0; int32_t txheight; uint32_t locktime;
         vector<COutput> vecOutputs;
@@ -3000,7 +3036,7 @@ uint64_t komodo_interestsum()
 }
 
 
-UniValue z_listunspent(const UniValue& params, bool fHelp)
+UniValue z_listunspent(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -3184,8 +3220,7 @@ UniValue z_listunspent(const UniValue& params, bool fHelp)
     return results;
 }
 
-
-UniValue fundrawtransaction(const UniValue& params, bool fHelp)
+UniValue fundrawtransaction(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -3239,7 +3274,7 @@ UniValue fundrawtransaction(const UniValue& params, bool fHelp)
     return result;
 }
 
-UniValue zc_sample_joinsplit(const UniValue& params, bool fHelp)
+UniValue zc_sample_joinsplit(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp) {
         throw runtime_error(
@@ -3268,7 +3303,7 @@ UniValue zc_sample_joinsplit(const UniValue& params, bool fHelp)
     return HexStr(ss.begin(), ss.end());
 }
 
-UniValue zc_benchmark(const UniValue& params, bool fHelp)
+UniValue zc_benchmark(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp)) {
         return NullUniValue;
@@ -3394,7 +3429,7 @@ UniValue zc_benchmark(const UniValue& params, bool fHelp)
     return results;
 }
 
-UniValue zc_raw_receive(const UniValue& params, bool fHelp)
+UniValue zc_raw_receive(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp)) {
         return NullUniValue;
@@ -3481,7 +3516,7 @@ UniValue zc_raw_receive(const UniValue& params, bool fHelp)
 
 
 
-UniValue zc_raw_joinsplit(const UniValue& params, bool fHelp)
+UniValue zc_raw_joinsplit(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp)) {
         return NullUniValue;
@@ -3680,7 +3715,7 @@ UniValue zc_raw_joinsplit(const UniValue& params, bool fHelp)
     return result;
 }
 
-UniValue zc_raw_keygen(const UniValue& params, bool fHelp)
+UniValue zc_raw_keygen(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp)) {
         return NullUniValue;
@@ -3712,7 +3747,7 @@ UniValue zc_raw_keygen(const UniValue& params, bool fHelp)
 }
 
 
-UniValue z_getnewaddress(const UniValue& params, bool fHelp)
+UniValue z_getnewaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -3770,7 +3805,7 @@ UniValue z_getnewaddress(const UniValue& params, bool fHelp)
 }
 
 
-UniValue z_listaddresses(const UniValue& params, bool fHelp)
+UniValue z_listaddresses(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -3894,7 +3929,7 @@ CAmount getBalanceZaddr(std::string address, int minDepth = 1, bool ignoreUnspen
 }
 
 
-UniValue z_listreceivedbyaddress(const UniValue& params, bool fHelp)
+UniValue z_listreceivedbyaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -4004,7 +4039,7 @@ UniValue z_listreceivedbyaddress(const UniValue& params, bool fHelp)
     return result;
 }
 
-UniValue z_getbalance(const UniValue& params, bool fHelp)
+UniValue z_getbalance(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -4065,7 +4100,7 @@ UniValue z_getbalance(const UniValue& params, bool fHelp)
 }
 
 
-UniValue z_gettotalbalance(const UniValue& params, bool fHelp)
+UniValue z_gettotalbalance(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -4126,7 +4161,221 @@ UniValue z_gettotalbalance(const UniValue& params, bool fHelp)
     return result;
 }
 
-UniValue z_getoperationresult(const UniValue& params, bool fHelp)
+// got bored and copied str4d's work - thanks dude/dudette :)
+UniValue z_viewtransaction(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    if (!EnsureWalletIsAvailable(fHelp))
+        return NullUniValue;
+
+    if (fHelp || params.size() != 1)
+        throw runtime_error(
+            "z_viewtransaction \"txid\"\n"
+            "\nGet detailed shielded information about in-wallet transaction <txid>\n"
+            "\nArguments:\n"
+            "1. \"txid\" (string, required) The transaction id\n"
+            "\nResult:\n"
+            "{\n"
+            "  \"txid\" : \"transactionid\",   (string) The transaction id\n"
+            "  \"spends\" : [\n"
+            "    {\n"
+            "      \"type\" : \"sprout|sapling\",      (string) The type of address\n"
+            "      \"js\" : n,                       (numeric, sprout) the index of the JSDescription within vJoinSplit\n"
+            "      \"jsSpend\" : n,                  (numeric, sprout) the index of the spend within the JSDescription\n"
+            "      \"spend\" : n,                    (numeric, sapling) the index of the spend within vShieldedSpend\n"
+            "      \"txidPrev\" : \"transactionid\",   (string) The id for the transaction this note was created in\n"
+            "      \"jsPrev\" : n,                   (numeric, sprout) the index of the JSDescription within vJoinSplit\n"
+            "      \"jsOutputPrev\" : n,             (numeric, sprout) the index of the output within the JSDescription\n"
+            "      \"outputPrev\" : n,               (numeric, sapling) the index of the output within the vShieldedOutput\n"
+            "      \"address\" : \"zcashaddress\",     (string) The Zcash address involved in the transaction\n"
+            "      \"value\" : x.xxx                 (numeric) The amount in " + CURRENCY_UNIT + "\n"
+            "      \"valueZat\" : xxxx               (numeric) The amount in zatoshis\n"
+            "    }\n"
+            "    ,...\n"
+            "  ],\n"
+            "  \"outputs\" : [\n"
+            "    {\n"
+            "      \"type\" : \"sprout|sapling\",      (string) The type of address\n"
+            "      \"js\" : n,                       (numeric, sprout) the index of the JSDescription within vJoinSplit\n"
+            "      \"jsOutput\" : n,                 (numeric, sprout) the index of the output within the JSDescription\n"
+            "      \"output\" : n,                   (numeric, sapling) the index of the output within the vShieldedOutput\n"
+            "      \"address\" : \"zcashaddress\",     (string) The Zcash address involved in the transaction\n"
+            "      \"recovered\" : true|false        (boolean, sapling) True if the output is not for an address in the wallet\n"
+            "      \"value\" : x.xxx                 (numeric) The amount in " + CURRENCY_UNIT + "\n"
+            "      \"valueZat\" : xxxx               (numeric) The amount in zatoshis\n"
+            "      \"memo\" : \"hexmemo\",             (string) Hexademical string representation of the memo field\n"
+            "      \"memoStr\" : \"memo\",             (string) Only returned if memo contains valid UTF-8 text.\n"
+            "    }\n"
+            "    ,...\n"
+            "  ],\n"
+            "}\n"
+
+            "\nExamples:\n"
+            + HelpExampleCli("z_viewtransaction", "\"1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d\"")
+            + HelpExampleCli("z_viewtransaction", "\"1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d\" true")
+            + HelpExampleRpc("z_viewtransaction", "\"1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d\"")
+        );
+
+    LOCK2(cs_main, pwalletMain->cs_wallet);
+
+    uint256 hash;
+    hash.SetHex(params[0].get_str());
+
+    UniValue entry(UniValue::VOBJ);
+    if (!pwalletMain->mapWallet.count(hash))
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid or non-wallet transaction id");
+    const CWalletTx& wtx = pwalletMain->mapWallet[hash];
+
+    entry.push_back(Pair("txid", hash.GetHex()));
+
+    UniValue spends(UniValue::VARR);
+    UniValue outputs(UniValue::VARR);
+
+    // Sprout spends - retained for old sprout addresses and transactions
+    for (size_t i = 0; i < wtx.vjoinsplit.size(); ++i) {
+        for (size_t j = 0; j < wtx.vjoinsplit[i].nullifiers.size(); ++j) {
+            auto nullifier = wtx.vjoinsplit[i].nullifiers[j];
+
+            // Fetch the note that is being spent, if ours
+            auto res = pwalletMain->mapSproutNullifiersToNotes.find(nullifier);
+            if (res == pwalletMain->mapSproutNullifiersToNotes.end()) {
+                continue;
+            }
+            auto jsop = res->second;
+            auto wtxPrev = pwalletMain->mapWallet.at(jsop.hash);
+
+            auto decrypted = wtxPrev.DecryptSproutNote(jsop);
+            auto notePt = decrypted.first;
+            auto pa = decrypted.second;
+
+            UniValue entry(UniValue::VOBJ);
+            entry.push_back(Pair("type", ADDR_TYPE_SPROUT));
+            entry.push_back(Pair("js", (int)i));
+            entry.push_back(Pair("jsSpend", (int)j));
+            entry.push_back(Pair("txidPrev", jsop.hash.GetHex()));
+            entry.push_back(Pair("jsPrev", (int)jsop.js));
+            entry.push_back(Pair("jsOutputPrev", (int)jsop.n));
+            entry.push_back(Pair("address", EncodePaymentAddress(pa)));
+            entry.push_back(Pair("value", ValueFromAmount(notePt.value())));
+            entry.push_back(Pair("valueZat", notePt.value()));
+            outputs.push_back(entry);
+        }
+    }
+
+    // Sprout outputs
+    for (auto & pair : wtx.mapSproutNoteData) {
+        JSOutPoint jsop = pair.first;
+
+        auto decrypted = wtx.DecryptSproutNote(jsop);
+        auto notePt = decrypted.first;
+        auto pa = decrypted.second;
+        auto memo = notePt.memo();
+
+        UniValue entry(UniValue::VOBJ);
+        entry.push_back(Pair("type", ADDR_TYPE_SPROUT));
+        entry.push_back(Pair("js", (int)jsop.js));
+        entry.push_back(Pair("jsOutput", (int)jsop.n));
+        entry.push_back(Pair("address", EncodePaymentAddress(pa)));
+        entry.push_back(Pair("value", ValueFromAmount(notePt.value())));
+        entry.push_back(Pair("valueZat", notePt.value()));
+        entry.push_back(Pair("memo", HexStr(memo)));
+        if (memo[0] <= 0xf4) {
+            auto end = std::find_if(memo.rbegin(), memo.rend(), [](unsigned char v) { return v != 0; });
+            std::string memoStr(memo.begin(), end.base());
+            //if (utf8::is_valid(memoStr))
+            {
+                entry.push_back(Pair("memoStr", memoStr));
+            }
+        }
+        outputs.push_back(entry);
+    }
+
+    // Sapling spends
+    std::set<uint256> ovks;
+    for (size_t i = 0; i < wtx.vShieldedSpend.size(); ++i) {
+        auto spend = wtx.vShieldedSpend[i];
+
+        // Fetch teh note that is being spent
+        auto res = pwalletMain->mapSaplingNullifiersToNotes.find(spend.nullifier);
+        if (res == pwalletMain->mapSaplingNullifiersToNotes.end()) {
+            continue;
+        }
+        auto op = res->second;
+        auto wtxPrev = pwalletMain->mapWallet.at(op.hash);
+
+        auto decrypted = wtxPrev.DecryptSaplingNote(op).get();
+        auto notePt = decrypted.first;
+        auto pa = decrypted.second;
+
+        // Store the OutgoingViewingKey for recovering outputs
+        libzcash::SaplingFullViewingKey fvk;
+        assert(pwalletMain->GetSaplingFullViewingKey(wtxPrev.mapSaplingNoteData.at(op).ivk, fvk));
+        ovks.insert(fvk.ovk);
+
+        UniValue entry(UniValue::VOBJ);
+        entry.push_back(Pair("type", ADDR_TYPE_SAPLING));
+        entry.push_back(Pair("spend", (int)i));
+        entry.push_back(Pair("txidPrev", op.hash.GetHex()));
+        entry.push_back(Pair("outputPrev", (int)op.n));
+        entry.push_back(Pair("address", EncodePaymentAddress(pa)));
+        entry.push_back(Pair("value", ValueFromAmount(notePt.value())));
+        entry.push_back(Pair("valueZat", notePt.value()));
+        spends.push_back(entry);
+    }
+
+    // Sapling outputs
+    for (uint32_t i = 0; i < wtx.vShieldedOutput.size(); ++i) {
+        auto op = SaplingOutPoint(hash, i);
+
+        SaplingNotePlaintext notePt;
+        SaplingPaymentAddress pa;
+        bool isRecovered;
+
+        auto decrypted = wtx.DecryptSaplingNote(op);
+        if (decrypted) {
+            notePt = decrypted->first;
+            pa = decrypted->second;
+            isRecovered = false;
+        } else {
+            // Try recovering the output
+            auto recovered = wtx.RecoverSaplingNote(op, ovks);
+            if (recovered) {
+                notePt = recovered->first;
+                pa = recovered->second;
+                isRecovered = true;
+            } else {
+                // Unreadable
+                continue;
+            }
+        }
+        auto memo = notePt.memo();
+
+        UniValue entry(UniValue::VOBJ);
+        entry.push_back(Pair("type", ADDR_TYPE_SAPLING));
+        entry.push_back(Pair("output", (int)op.n));
+        entry.push_back(Pair("recovered", isRecovered));
+        entry.push_back(Pair("address", EncodePaymentAddress(pa)));
+        entry.push_back(Pair("value", ValueFromAmount(notePt.value())));
+        entry.push_back(Pair("valueZat", notePt.value()));
+        entry.push_back(Pair("memo", HexStr(memo)));
+        if (memo[0] <= 0xf4) {
+            auto end = std::find_if(memo.rbegin(), memo.rend(), [](unsigned char v) { return v != 0; });
+            std::string memoStr(memo.begin(), end.base());
+            //if (utf8::is_valid(memoStr))
+            {
+                entry.push_back(Pair("memoStr", memoStr));
+            }
+        }
+        outputs.push_back(entry);
+    }
+
+    entry.push_back(Pair("spends", spends));
+    entry.push_back(Pair("outputs", outputs));
+
+    return entry;
+}
+
+
+UniValue z_getoperationresult(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -4149,7 +4398,7 @@ UniValue z_getoperationresult(const UniValue& params, bool fHelp)
     return z_getoperationstatus_IMPL(params, true);
 }
 
-UniValue z_getoperationstatus(const UniValue& params, bool fHelp)
+UniValue z_getoperationstatus(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
    if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -4242,7 +4491,7 @@ UniValue z_getoperationstatus_IMPL(const UniValue& params, bool fRemoveFinishedO
 #define CTXIN_SPEND_DUST_SIZE   148
 #define CTXOUT_REGULAR_SIZE     34
 
-UniValue z_sendmany(const UniValue& params, bool fHelp)
+UniValue z_sendmany(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -4549,7 +4798,7 @@ When estimating the number of coinbase utxos we can shield in a single transacti
 
 #define SHIELD_COINBASE_DEFAULT_LIMIT 50
 
-UniValue z_shieldcoinbase(const UniValue& params, bool fHelp)
+UniValue z_shieldcoinbase(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -4780,7 +5029,7 @@ UniValue z_shieldcoinbase(const UniValue& params, bool fHelp)
 #define OUTPUTDESCRIPTION_SIZE GetSerializeSize(OutputDescription(), SER_NETWORK, PROTOCOL_VERSION)
 #define SPENDDESCRIPTION_SIZE GetSerializeSize(SpendDescription(), SER_NETWORK, PROTOCOL_VERSION)
 
-UniValue z_mergetoaddress(const UniValue& params, bool fHelp)
+UniValue z_mergetoaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -5209,7 +5458,7 @@ UniValue z_mergetoaddress(const UniValue& params, bool fHelp)
     return o;
 }
 
-UniValue z_listoperationids(const UniValue& params, bool fHelp)
+UniValue z_listoperationids(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (!EnsureWalletIsAvailable(fHelp))
         return NullUniValue;
@@ -5263,7 +5512,7 @@ extern std::string NOTARY_PUBKEY;
 
 int32_t komodo_notaryvin(CMutableTransaction &txNew,uint8_t *notarypub33, void *pTr)
 {
-    set<CBitcoinAddress> setAddress; uint8_t *script,utxosig[128]; uint256 utxotxid; uint64_t utxovalue; int32_t i,siglen=0,nMinDepth = 1,nMaxDepth = 9999999; vector<COutput> vecOutputs; uint32_t utxovout,eligible,earliest = 0; CScript best_scriptPubKey; bool fNegative,fOverflow;
+    set<CBitcoinAddress> setAddress; uint8_t *script,utxosig[128]; uint256 utxotxid; uint64_t utxovalue; int32_t i,siglen=0,nMinDepth = 0,nMaxDepth = 9999999; vector<COutput> vecOutputs; uint32_t utxovout,eligible,earliest = 0; CScript best_scriptPubKey; bool fNegative,fOverflow;
     bool signSuccess; SignatureData sigdata; uint64_t txfee; uint8_t *ptr;
     auto consensusBranchId = CurrentEpochBranchId(chainActive.Height() + 1, Params().GetConsensus());
     if (!EnsureWalletIsAvailable(0))
@@ -5367,6 +5616,7 @@ int32_t verus_staked(CBlock *pBlock, CMutableTransaction &txNew, uint32_t &nBits
 #include "../cc/CCHeir.h"
 #include "../cc/CCMarmara.h"
 #include "../cc/CCPayments.h"
+#include "../cc/CCPegs.h"
 
 int32_t ensure_CCrequirements(uint8_t evalcode)
 {
@@ -5410,6 +5660,7 @@ UniValue CCaddress(struct CCcontract_info *cp,char *name,std::vector<unsigned ch
         Myprivkey(priv); // it is assumed the CC's normal address'es -pubkey was used
         LogPrintf("fix mismatched CCaddr %s -> %s\n",cp->unspendableCCaddr,destaddr);
         strcpy(cp->unspendableCCaddr,destaddr);
+        memset(priv,0,32);
     }
     result.push_back(Pair("result", "success"));
     sprintf(str,"%sCCAddress",name);
@@ -5468,7 +5719,7 @@ UniValue CCaddress(struct CCcontract_info *cp,char *name,std::vector<unsigned ch
 
 bool pubkey2addr(char *destaddr,uint8_t *pubkey33);
 
-UniValue setpubkey(const UniValue& params, bool fHelp)
+UniValue setpubkey(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ);
     if ( fHelp || params.size() > 1 )
@@ -5544,7 +5795,7 @@ UniValue setpubkey(const UniValue& params, bool fHelp)
     return result;
 }
 
-UniValue setstakingsplit(const UniValue& params, bool fHelp)
+UniValue setstakingsplit(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ);
     if ( fHelp || params.size() > 1 )
@@ -5589,26 +5840,24 @@ UniValue setstakingsplit(const UniValue& params, bool fHelp)
     return result;
 }
 
-UniValue channelsaddress(const UniValue& params, bool fHelp)
+UniValue channelsaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); struct CCcontract_info *cp,C; std::vector<unsigned char> pubkey;
 
     cp = CCinit(&C,EVAL_CHANNELS);
     if ( fHelp || params.size() != 1 )
         throw runtime_error("channelsaddress pubkey\n");
-    if ( ensure_CCrequirements(0) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    if ( ensure_CCrequirements(cp->evalcode) < 0 )
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     pubkey = ParseHex(params[0].get_str().c_str());
     return(CCaddress(cp,(char *)"Channels",pubkey));
 }
 
-UniValue cclibaddress(const UniValue& params, bool fHelp)
+UniValue cclibaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     struct CCcontract_info *cp,C; std::vector<unsigned char> pubkey; uint8_t evalcode = EVAL_FIRSTUSER;
     if ( fHelp || params.size() > 2 )
         throw runtime_error("cclibaddress [evalcode] [pubkey]\n");
-    if ( ensure_CCrequirements(0) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
     if ( params.size() >= 1 )
     {
         evalcode = atoi(params[0].get_str().c_str());
@@ -5618,31 +5867,35 @@ UniValue cclibaddress(const UniValue& params, bool fHelp)
             pubkey = ParseHex(params[1].get_str().c_str());
     }
     cp = CCinit(&C,evalcode);
+    if ( ensure_CCrequirements(cp->evalcode) < 0 )
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     if ( cp == 0 )
         throw runtime_error("error creating *cp\n");
     return(CCaddress(cp,(char *)"CClib",pubkey));
 }
 
-UniValue cclibinfo(const UniValue& params, bool fHelp)
+UniValue cclibinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     struct CCcontract_info *cp,C; uint8_t evalcode = EVAL_FIRSTUSER;
     if ( fHelp || params.size() > 0 )
         throw runtime_error("cclibinfo\n");
     if ( ensure_CCrequirements(0) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     cp = CCinit(&C,evalcode);
     return(CClib_info(cp));
 }
 
-UniValue cclib(const UniValue& params, bool fHelp)
+UniValue cclib(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     struct CCcontract_info *cp,C; char *method,*jsonstr=0; uint8_t evalcode = EVAL_FIRSTUSER;
+    std::string vobjJsonSerialized;
+
     if ( fHelp || params.size() > 3 )
         throw runtime_error("cclib method [evalcode] [JSON params]\n");
     if ( ASSETCHAINS_CCLIB.size() == 0 )
         throw runtime_error("no -ac_cclib= specified\n");
     if ( ensure_CCrequirements(0) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     method = (char *)params[0].get_str().c_str();
@@ -5656,159 +5909,165 @@ UniValue cclib(const UniValue& params, bool fHelp)
         }
         if ( params.size() == 3 )
         {
-            jsonstr = (char *)params[2].get_str().c_str();
-            //LogPrintf("params.(%s %s %s)\n",params[0].get_str().c_str(),params[1].get_str().c_str(),jsonstr);
+            if (params[2].getType() == UniValue::VOBJ) {
+                vobjJsonSerialized = params[2].write(0, 0);
+                jsonstr = (char *)vobjJsonSerialized.c_str();
+            }
+            else  // VSTR assumed
+                jsonstr = (char *)params[2].get_str().c_str();
+            //fprintf(stderr,"params.(%s %s %s)\n",params[0].get_str().c_str(),params[1].get_str().c_str(),jsonstr);
         }
     }
     cp = CCinit(&C,evalcode);
     return(CClib(cp,method,jsonstr));
 }
 
-UniValue payments_release(const UniValue& params, bool fHelp)
+UniValue payments_release(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     struct CCcontract_info *cp,C;
     if ( fHelp || params.size() != 1 )
         throw runtime_error("paymentsrelease \"[%22createtxid%22,amount,(skipminimum)]\"\n");
     if ( ensure_CCrequirements(EVAL_PAYMENTS) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     cp = CCinit(&C,EVAL_PAYMENTS);
     return(PaymentsRelease(cp,(char *)params[0].get_str().c_str()));
 }
 
-UniValue payments_fund(const UniValue& params, bool fHelp)
+UniValue payments_fund(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     struct CCcontract_info *cp,C;
     if ( fHelp || params.size() != 1 )
         throw runtime_error("paymentsfund \"[%22createtxid%22,amount(,useopret)]\"\n");
     if ( ensure_CCrequirements(EVAL_PAYMENTS) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     cp = CCinit(&C,EVAL_PAYMENTS);
     return(PaymentsFund(cp,(char *)params[0].get_str().c_str()));
 }
 
-UniValue payments_merge(const UniValue& params, bool fHelp)
+UniValue payments_merge(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     struct CCcontract_info *cp,C;
     if ( fHelp || params.size() != 1 )
         throw runtime_error("paymentsmerge \"[%22createtxid%22]\"\n");
     if ( ensure_CCrequirements(EVAL_PAYMENTS) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     cp = CCinit(&C,EVAL_PAYMENTS);
     return(PaymentsMerge(cp,(char *)params[0].get_str().c_str()));
 }
 
-UniValue payments_txidopret(const UniValue& params, bool fHelp)
+UniValue payments_txidopret(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     struct CCcontract_info *cp,C;
     if ( fHelp || params.size() != 1 )
         throw runtime_error("paymentstxidopret \"[allocation,%22scriptPubKey%22(,%22destopret%22)]\"\n");
     if ( ensure_CCrequirements(EVAL_PAYMENTS) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     cp = CCinit(&C,EVAL_PAYMENTS);
     return(PaymentsTxidopret(cp,(char *)params[0].get_str().c_str()));
 }
 
-UniValue payments_create(const UniValue& params, bool fHelp)
+UniValue payments_create(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     struct CCcontract_info *cp,C;
     if ( fHelp || params.size() != 1 )
         throw runtime_error("paymentscreate \"[lockedblocks,minamount,%22paytxid0%22,...,%22paytxidN%22]\"\n");
     if ( ensure_CCrequirements(EVAL_PAYMENTS) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     cp = CCinit(&C,EVAL_PAYMENTS);
     return(PaymentsCreate(cp,(char *)params[0].get_str().c_str()));
 }
 
-UniValue payments_airdrop(const UniValue& params, bool fHelp)
+UniValue payments_airdrop(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     struct CCcontract_info *cp,C;
     if ( fHelp || params.size() != 1 )
         throw runtime_error("paymentsairdrop \"[lockedblocks,minamount,mintoaddress,top,bottom,fixedFlag,%22excludeAddress%22,...,%22excludeAddressN%22]\"\n");
     if ( ensure_CCrequirements(EVAL_PAYMENTS) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     cp = CCinit(&C,EVAL_PAYMENTS);
     return(PaymentsAirdrop(cp,(char *)params[0].get_str().c_str()));
 }
 
-UniValue payments_airdroptokens(const UniValue& params, bool fHelp)
+UniValue payments_airdroptokens(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     struct CCcontract_info *cp,C;
     if ( fHelp || params.size() != 1 )
         throw runtime_error("payments_airdroptokens \"[%22tokenid%22,lockedblocks,minamount,mintoaddress,top,bottom,fixedFlag,%22excludePubKey%22,...,%22excludePubKeyN%22]\"\n");
     if ( ensure_CCrequirements(EVAL_PAYMENTS) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     cp = CCinit(&C,EVAL_PAYMENTS);
     return(PaymentsAirdropTokens(cp,(char *)params[0].get_str().c_str()));
 }
 
-UniValue payments_info(const UniValue& params, bool fHelp)
+UniValue payments_info(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     struct CCcontract_info *cp,C;
     if ( fHelp || params.size() != 1 )
         throw runtime_error("paymentsinfo \"[%22createtxid%22]\"\n");
     if ( ensure_CCrequirements(EVAL_PAYMENTS) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     cp = CCinit(&C,EVAL_PAYMENTS);
     return(PaymentsInfo(cp,(char *)params[0].get_str().c_str()));
 }
 
-UniValue payments_list(const UniValue& params, bool fHelp)
+UniValue payments_list(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     struct CCcontract_info *cp,C;
     if ( fHelp || params.size() != 0 )
         throw runtime_error("paymentslist\n");
     if ( ensure_CCrequirements(EVAL_PAYMENTS) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     cp = CCinit(&C,EVAL_PAYMENTS);
     return(PaymentsList(cp,(char *)""));
 }
 
-UniValue oraclesaddress(const UniValue& params, bool fHelp)
+UniValue oraclesaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     struct CCcontract_info *cp,C; std::vector<unsigned char> pubkey;
     cp = CCinit(&C,EVAL_ORACLES);
     if ( fHelp || params.size() > 1 )
         throw runtime_error("oraclesaddress [pubkey]\n");
-    if ( ensure_CCrequirements(0) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    if ( ensure_CCrequirements(cp->evalcode) < 0 )
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     if ( params.size() == 1 )
         pubkey = ParseHex(params[0].get_str().c_str());
     return(CCaddress(cp,(char *)"Oracles",pubkey));
 }
 
-UniValue pricesaddress(const UniValue& params, bool fHelp)
+UniValue pricesaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
-    UniValue result(UniValue::VOBJ); struct CCcontract_info *cp,C,*assetscp,C2; std::vector<unsigned char> pubkey; CPubKey mypk,planpk,pricespk; char myaddr[64],houseaddr[64],exposureaddr[64];
+    UniValue result(UniValue::VOBJ); struct CCcontract_info *cp,C,*assetscp,C2; std::vector<unsigned char> pubkey; CPubKey pk,planpk,pricespk; char myaddr[64],houseaddr[64],exposureaddr[64];
     cp = CCinit(&C,EVAL_PRICES);
     assetscp = CCinit(&C2,EVAL_PRICES);
     if ( fHelp || params.size() > 1 )
         throw runtime_error("pricesaddress [pubkey]\n");
-    if ( ensure_CCrequirements(0) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    if ( ensure_CCrequirements(cp->evalcode) < 0 )
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     if ( params.size() == 1 )
         pubkey = ParseHex(params[0].get_str().c_str());
     result = CCaddress(cp,(char *)"Prices",pubkey);
-    mypk = pubkey2pk(Mypubkey());
+    if (mypk.IsValid()) pk=mypk;
+    else pk = pubkey2pk(Mypubkey());
     pricespk = GetUnspendable(cp,0);
-    GetCCaddress(assetscp,myaddr,mypk);
+    GetCCaddress(assetscp,myaddr,pk);
     GetCCaddress1of2(assetscp,houseaddr,pricespk,planpk);
     GetCCaddress1of2(assetscp,exposureaddr,pricespk,pricespk);
     result.push_back(Pair("myaddr",myaddr)); // for holding my asssets
@@ -5817,130 +6076,130 @@ UniValue pricesaddress(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue pegsaddress(const UniValue& params, bool fHelp)
+UniValue pegsaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     struct CCcontract_info *cp,C; std::vector<unsigned char> pubkey;
     cp = CCinit(&C,EVAL_PEGS);
     if ( fHelp || params.size() > 1 )
         throw runtime_error("pegssaddress [pubkey]\n");
-    if ( ensure_CCrequirements(0) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    if ( ensure_CCrequirements(cp->evalcode) < 0 )
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     if ( params.size() == 1 )
         pubkey = ParseHex(params[0].get_str().c_str());
     return(CCaddress(cp,(char *)"Pegs",pubkey));
 }
 
-UniValue marmaraaddress(const UniValue& params, bool fHelp)
+UniValue marmaraaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     struct CCcontract_info *cp,C; std::vector<unsigned char> pubkey;
     cp = CCinit(&C,EVAL_MARMARA);
     if ( fHelp || params.size() > 1 )
         throw runtime_error("Marmaraaddress [pubkey]\n");
-    if ( ensure_CCrequirements(0) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    if ( ensure_CCrequirements(cp->evalcode) < 0 )
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     if ( params.size() == 1 )
         pubkey = ParseHex(params[0].get_str().c_str());
     return(CCaddress(cp,(char *)"Marmara",pubkey));
 }
 
-UniValue paymentsaddress(const UniValue& params, bool fHelp)
+UniValue paymentsaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     struct CCcontract_info *cp,C; std::vector<unsigned char> pubkey;
     cp = CCinit(&C,EVAL_PAYMENTS);
     if ( fHelp || params.size() > 1 )
         throw runtime_error("paymentsaddress [pubkey]\n");
-    if ( ensure_CCrequirements(0) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    if ( ensure_CCrequirements(cp->evalcode) < 0 )
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     if ( params.size() == 1 )
         pubkey = ParseHex(params[0].get_str().c_str());
     return(CCaddress(cp,(char *)"Payments",pubkey));
 }
 
-UniValue gatewaysaddress(const UniValue& params, bool fHelp)
+UniValue gatewaysaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     struct CCcontract_info *cp,C; std::vector<unsigned char> pubkey;
     cp = CCinit(&C,EVAL_GATEWAYS);
     if ( fHelp || params.size() > 1 )
         throw runtime_error("gatewaysaddress [pubkey]\n");
-    if ( ensure_CCrequirements(0) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    if ( ensure_CCrequirements(cp->evalcode) < 0 )
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     if ( params.size() == 1 )
         pubkey = ParseHex(params[0].get_str().c_str());
     return(CCaddress(cp,(char *)"Gateways",pubkey));
 }
 
-UniValue heiraddress(const UniValue& params, bool fHelp)
+UniValue heiraddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
 	struct CCcontract_info *cp,C; std::vector<unsigned char> pubkey;
 	cp = CCinit(&C,EVAL_HEIR);
     if ( fHelp || params.size() > 1 )
         throw runtime_error("heiraddress pubkey\n");
-    if ( ensure_CCrequirements(0) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    if ( ensure_CCrequirements(cp->evalcode) < 0 )
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     pubkey = ParseHex(params[0].get_str().c_str());
 	return(CCaddress(cp,(char *)"Heir",pubkey));
 }
 
-UniValue lottoaddress(const UniValue& params, bool fHelp)
+UniValue lottoaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     struct CCcontract_info *cp,C; std::vector<unsigned char> pubkey;
     cp = CCinit(&C,EVAL_LOTTO);
     if ( fHelp || params.size() > 1 )
         throw runtime_error("lottoaddress [pubkey]\n");
-    if ( ensure_CCrequirements(0) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    if ( ensure_CCrequirements(cp->evalcode) < 0 )
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     if ( params.size() == 1 )
         pubkey = ParseHex(params[0].get_str().c_str());
     return(CCaddress(cp,(char *)"Lotto",pubkey));
 }
 
-UniValue FSMaddress(const UniValue& params, bool fHelp)
+UniValue FSMaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     struct CCcontract_info *cp,C; std::vector<unsigned char> pubkey;
     cp = CCinit(&C,EVAL_FSM);
     if ( fHelp || params.size() > 1 )
         throw runtime_error("FSMaddress [pubkey]\n");
-    if ( ensure_CCrequirements(0) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    if ( ensure_CCrequirements(cp->evalcode) < 0 )
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     if ( params.size() == 1 )
         pubkey = ParseHex(params[0].get_str().c_str());
     return(CCaddress(cp,(char *)"FSM",pubkey));
 }
 
-UniValue auctionaddress(const UniValue& params, bool fHelp)
+UniValue auctionaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     struct CCcontract_info *cp,C; std::vector<unsigned char> pubkey;
     cp = CCinit(&C,EVAL_AUCTION);
     if ( fHelp || params.size() > 1 )
         throw runtime_error("auctionaddress [pubkey]\n");
-    if ( ensure_CCrequirements(0) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    if ( ensure_CCrequirements(cp->evalcode) < 0 )
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     if ( params.size() == 1 )
         pubkey = ParseHex(params[0].get_str().c_str());
     return(CCaddress(cp,(char *)"Auction",pubkey));
 }
 
-UniValue diceaddress(const UniValue& params, bool fHelp)
+UniValue diceaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     struct CCcontract_info *cp,C; std::vector<unsigned char> pubkey;
     cp = CCinit(&C,EVAL_DICE);
     if ( fHelp || params.size() > 1 )
         throw runtime_error("diceaddress [pubkey]\n");
-    if ( ensure_CCrequirements(0) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    if ( ensure_CCrequirements(cp->evalcode) < 0 )
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     if ( params.size() == 1 )
         pubkey = ParseHex(params[0].get_str().c_str());
     return(CCaddress(cp,(char *)"Dice",pubkey));
 }
 
-UniValue faucetaddress(const UniValue& params, bool fHelp)
+UniValue faucetaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     struct CCcontract_info *cp,C; std::vector<unsigned char> pubkey;
     int error;
     cp = CCinit(&C,EVAL_FAUCET);
     if ( fHelp || params.size() > 1 )
         throw runtime_error("faucetaddress [pubkey]\n");
-    error = ensure_CCrequirements(0);
+    error = ensure_CCrequirements(cp->evalcode);
     if ( error < 0 )
         throw runtime_error(strprintf("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet. ERR=%d\n", error));
     if ( params.size() == 1 )
@@ -5948,59 +6207,59 @@ UniValue faucetaddress(const UniValue& params, bool fHelp)
     return(CCaddress(cp,(char *)"Faucet",pubkey));
 }
 
-UniValue rewardsaddress(const UniValue& params, bool fHelp)
+UniValue rewardsaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     struct CCcontract_info *cp,C; std::vector<unsigned char> pubkey;
     cp = CCinit(&C,EVAL_REWARDS);
     if ( fHelp || params.size() > 1 )
         throw runtime_error("rewardsaddress [pubkey]\n");
-    if ( ensure_CCrequirements(0) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    if ( ensure_CCrequirements(cp->evalcode) < 0 )
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     if ( params.size() == 1 )
         pubkey = ParseHex(params[0].get_str().c_str());
     return(CCaddress(cp,(char *)"Rewards",pubkey));
 }
 
-UniValue assetsaddress(const UniValue& params, bool fHelp)
+UniValue assetsaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
 	struct CCcontract_info *cp, C; std::vector<unsigned char> pubkey;
 	cp = CCinit(&C, EVAL_ASSETS);
 	if (fHelp || params.size() > 1)
 		throw runtime_error("assetsaddress [pubkey]\n");
-	if (ensure_CCrequirements(0) < 0)
-		throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+	if (ensure_CCrequirements(cp->evalcode) < 0)
+		throw runtime_error(CC_REQUIREMENTS_MSG);
 	if (params.size() == 1)
 		pubkey = ParseHex(params[0].get_str().c_str());
 	return(CCaddress(cp, (char *)"Assets", pubkey));
 }
 
-UniValue tokenaddress(const UniValue& params, bool fHelp)
+UniValue tokenaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     struct CCcontract_info *cp,C; std::vector<unsigned char> pubkey;
     cp = CCinit(&C,EVAL_TOKENS);
     if ( fHelp || params.size() > 1 )
         throw runtime_error("tokenaddress [pubkey]\n");
-    if ( ensure_CCrequirements(0) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    if ( ensure_CCrequirements(cp->evalcode) < 0 )
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     if ( params.size() == 1 )
         pubkey = ParseHex(params[0].get_str().c_str());
     return(CCaddress(cp,(char *)"Tokens", pubkey));
 }
 
-UniValue importgatewayaddress(const UniValue& params, bool fHelp)
+UniValue importgatewayaddress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     struct CCcontract_info *cp,C; std::vector<unsigned char> pubkey;
     cp = CCinit(&C,EVAL_IMPORTGATEWAY);
     if ( fHelp || params.size() > 1 )
         throw runtime_error("importgatewayddress [pubkey]\n");
-    if ( ensure_CCrequirements(0) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+    if ( ensure_CCrequirements(cp->evalcode) < 0 )
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     if ( params.size() == 1 )
         pubkey = ParseHex(params[0].get_str().c_str());
     return(CCaddress(cp,(char *)"ImportGateway", pubkey));
 }
 
-UniValue marmara_poolpayout(const UniValue& params, bool fHelp)
+UniValue marmara_poolpayout(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     int32_t firstheight; double perc; char *jsonstr;
     if ( fHelp || params.size() != 3 )
@@ -6010,7 +6269,7 @@ UniValue marmara_poolpayout(const UniValue& params, bool fHelp)
         throw runtime_error("marmarapoolpayout perc firstheight \"[[\\\"pubkey\\\":shares], ...]\"\n");
     }
     if ( ensure_CCrequirements(EVAL_MARMARA) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     perc = atof(params[0].get_str().c_str()) / 100.;
@@ -6019,7 +6278,7 @@ UniValue marmara_poolpayout(const UniValue& params, bool fHelp)
     return(MarmaraPoolPayout(0,firstheight,perc,jsonstr)); // [[pk0, shares0], [pk1, shares1], ...]
 }
 
-UniValue marmara_receive(const UniValue& params, bool fHelp)
+UniValue marmara_receive(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); uint256 batontxid; std::vector<uint8_t> senderpub; int64_t amount; int32_t matures; std::string currency;
     if ( fHelp || (params.size() != 5 && params.size() != 4) )
@@ -6030,7 +6289,7 @@ UniValue marmara_receive(const UniValue& params, bool fHelp)
         throw runtime_error("marmarareceive senderpk amount currency matures batontxid\n");
     }
     if ( ensure_CCrequirements(EVAL_MARMARA) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     memset(&batontxid,0,sizeof(batontxid));
@@ -6050,7 +6309,7 @@ UniValue marmara_receive(const UniValue& params, bool fHelp)
     return(MarmaraReceive(0,pubkey2pk(senderpub),amount,currency,matures,batontxid,true));
 }
 
-UniValue marmara_issue(const UniValue& params, bool fHelp)
+UniValue marmara_issue(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); uint256 approvaltxid; std::vector<uint8_t> receiverpub; int64_t amount; int32_t matures; std::string currency;
     if ( fHelp || params.size() != 5 )
@@ -6061,7 +6320,7 @@ UniValue marmara_issue(const UniValue& params, bool fHelp)
         throw runtime_error("marmaraissue receiverpk amount currency matures approvaltxid\n");
     }
     if ( ensure_CCrequirements(EVAL_MARMARA) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     receiverpub = ParseHex(params[0].get_str().c_str());
@@ -6077,7 +6336,7 @@ UniValue marmara_issue(const UniValue& params, bool fHelp)
     return(MarmaraIssue(0,'I',pubkey2pk(receiverpub),amount,currency,matures,approvaltxid,zeroid));
 }
 
-UniValue marmara_transfer(const UniValue& params, bool fHelp)
+UniValue marmara_transfer(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); uint256 approvaltxid,batontxid; std::vector<uint8_t> receiverpub; int64_t amount; int32_t matures; std::string currency; std::vector<uint256> creditloop;
     if ( fHelp || params.size() != 5 )
@@ -6086,7 +6345,7 @@ UniValue marmara_transfer(const UniValue& params, bool fHelp)
         throw runtime_error("marmaratransfer receiverpk amount currency matures approvaltxid\n");
     }
     if ( ensure_CCrequirements(EVAL_MARMARA) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     receiverpub = ParseHex(params[0].get_str().c_str());
     if (receiverpub.size()!= 33)
     {
@@ -6104,7 +6363,7 @@ UniValue marmara_transfer(const UniValue& params, bool fHelp)
     return(MarmaraIssue(0,'T',pubkey2pk(receiverpub),amount,currency,matures,approvaltxid,batontxid));
 }
 
-UniValue marmara_info(const UniValue& params, bool fHelp)
+UniValue marmara_info(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); CPubKey issuerpk; std::vector<uint8_t> issuerpub; int64_t minamount,maxamount; int32_t firstheight,lastheight; std::string currency;
     if ( fHelp || params.size() < 4 || params.size() > 6 )
@@ -6112,7 +6371,7 @@ UniValue marmara_info(const UniValue& params, bool fHelp)
         throw runtime_error("marmarainfo firstheight lastheight minamount maxamount [currency issuerpk]\n");
     }
     if ( ensure_CCrequirements(EVAL_MARMARA) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     firstheight = atol(params[0].get_str().c_str());
@@ -6135,7 +6394,7 @@ UniValue marmara_info(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue marmara_creditloop(const UniValue& params, bool fHelp)
+UniValue marmara_creditloop(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); uint256 txid;
     if ( fHelp || params.size() != 1 )
@@ -6144,7 +6403,7 @@ UniValue marmara_creditloop(const UniValue& params, bool fHelp)
         throw runtime_error("marmaracreditloop txid\n");
     }
     if ( ensure_CCrequirements(EVAL_MARMARA) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     txid = Parseuint256((char *)params[0].get_str().c_str());
@@ -6152,7 +6411,7 @@ UniValue marmara_creditloop(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue marmara_settlement(const UniValue& params, bool fHelp)
+UniValue marmara_settlement(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); uint256 batontxid;
     if ( fHelp || params.size() != 1 )
@@ -6162,7 +6421,7 @@ UniValue marmara_settlement(const UniValue& params, bool fHelp)
         throw runtime_error("marmarasettlement batontxid\n");
     }
     if ( ensure_CCrequirements(EVAL_MARMARA) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     batontxid = Parseuint256((char *)params[0].get_str().c_str());
@@ -6170,7 +6429,7 @@ UniValue marmara_settlement(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue marmara_lock(const UniValue& params, bool fHelp)
+UniValue marmara_lock(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); int64_t amount; int32_t height;
     if ( fHelp || params.size() > 2 || params.size() == 0 )
@@ -6186,157 +6445,125 @@ UniValue marmara_lock(const UniValue& params, bool fHelp)
     return(MarmaraLock(0,amount,height));
 }
 
-UniValue channelslist(const UniValue& params, bool fHelp)
+UniValue channelslist(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if ( fHelp || params.size() > 0 )
-        throw runtime_error("channelsinfo\n");
+        throw runtime_error("channelslist\n");
     if ( ensure_CCrequirements(EVAL_CHANNELS) < 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);
-    return(ChannelsList());
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+    return(ChannelsList(mypk));
 }
 
-UniValue channelsinfo(const UniValue& params, bool fHelp)
+UniValue channelsinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     uint256 opentxid;
     if ( fHelp || params.size() > 1 )
         throw runtime_error("channelsinfo [opentxid]\n");
     if ( ensure_CCrequirements(EVAL_CHANNELS) < 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);
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     opentxid=zeroid;
     if (params.size() > 0 && !params[0].isNull() && !params[0].get_str().empty())
         opentxid = Parseuint256((char *)params[0].get_str().c_str());
-    return(ChannelsInfo(opentxid));
+    return(ChannelsInfo(mypk,opentxid));
 }
 
-UniValue channelsopen(const UniValue& params, bool fHelp)
+UniValue channelsopen(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
-    UniValue result(UniValue::VOBJ); int32_t numpayments; int64_t payment; std::vector<unsigned char> destpub; struct CCcontract_info *cp,C; std::string hex;
+    UniValue result(UniValue::VOBJ); int32_t numpayments; int64_t payment; std::vector<unsigned char> destpub; struct CCcontract_info *cp,C;
     uint256 tokenid=zeroid;
 
     cp = CCinit(&C,EVAL_CHANNELS);
     if ( fHelp || params.size() < 3 || params.size() > 4)
-        throw runtime_error("channelsopen destpubkey numpayments payment\n");
+        throw runtime_error("channelsopen destpubkey numpayments payment [tokenid]\n");
     if ( ensure_CCrequirements(EVAL_CHANNELS) < 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);
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+    Lock2NSPV(mypk);
     destpub = ParseHex(params[0].get_str().c_str());
-    if (destpub.size()!= 33)
-    {
-        ERR_RESULT("invalid destination pubkey");
-        return result;
-    }
     numpayments = atoi(params[1].get_str().c_str());
-    if (numpayments <1)
-    {
-        ERR_RESULT("invalid number of payments, must be greater than 0");
-        return result;
-    }
     payment = atol(params[2].get_str().c_str());
-    if (payment <1)
-    {
-        ERR_RESULT("invalid payment amount, must be greater than 0");
-        return result;
-    }
     if (params.size()==4)
     {
         tokenid=Parseuint256((char *)params[3].get_str().c_str());
     }
-    hex = ChannelOpen(0,pubkey2pk(destpub),numpayments,payment,tokenid);
-    RETURN_IF_ERROR(CCerror);
-    if ( hex.size() > 0 )
+    result = ChannelOpen(mypk,0,pubkey2pk(destpub),numpayments,payment,tokenid);
+    if ( result[JSON_HEXTX].getValStr().size() > 0  )
     {
         result.push_back(Pair("result", "success"));
-        result.push_back(Pair("hex", hex));
-    } else ERR_RESULT("couldnt create channelsopen transaction");
+    }
+    Unlock2NSPV(mypk);    
     return(result);
 }
 
-UniValue channelspayment(const UniValue& params, bool fHelp)
+UniValue channelspayment(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
-    UniValue result(UniValue::VOBJ); struct CCcontract_info *cp,C; std::string hex; uint256 opentxid,secret=zeroid; int32_t n; int64_t amount;
+    UniValue result(UniValue::VOBJ); struct CCcontract_info *cp,C; uint256 opentxid,secret=zeroid; int32_t n; int64_t amount;
     cp = CCinit(&C,EVAL_CHANNELS);
     if ( fHelp || params.size() < 2 ||  params.size() >3 )
         throw runtime_error("channelspayment opentxid amount [secret]\n");
     if ( ensure_CCrequirements(EVAL_CHANNELS) < 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);
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+    Lock2NSPV(mypk);
     opentxid = Parseuint256((char *)params[0].get_str().c_str());
     amount = atoi((char *)params[1].get_str().c_str());
-    if (amount <1)
-    {
-        ERR_RESULT("invalid payment amount, must be greater than 0");
-        return result;
-    }
     if (params.size() > 2 && !params[2].isNull() && !params[2].get_str().empty())
     {
         secret = Parseuint256((char *)params[2].get_str().c_str());
     }
-    hex = ChannelPayment(0,opentxid,amount,secret);
-    RETURN_IF_ERROR(CCerror);
-    if ( hex.size() > 0 )
+    result = ChannelPayment(mypk,0,opentxid,amount,secret);
+    if ( result[JSON_HEXTX].getValStr().size() > 0  )
     {
         result.push_back(Pair("result", "success"));
-        result.push_back(Pair("hex", hex));
-    } else ERR_RESULT("couldnt create channelspayment transaction");
+    }
+    Unlock2NSPV(mypk);
     return(result);
 }
 
-UniValue channelsclose(const UniValue& params, bool fHelp)
+UniValue channelsclose(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
-    UniValue result(UniValue::VOBJ); struct CCcontract_info *cp,C; std::string hex; uint256 opentxid;
+    UniValue result(UniValue::VOBJ); struct CCcontract_info *cp,C; uint256 opentxid;
     cp = CCinit(&C,EVAL_CHANNELS);
     if ( fHelp || params.size() != 1 )
         throw runtime_error("channelsclose opentxid\n");
     if ( ensure_CCrequirements(EVAL_CHANNELS) < 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);
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+    Lock2NSPV(mypk);
     opentxid = Parseuint256((char *)params[0].get_str().c_str());
-    hex = ChannelClose(0,opentxid);
-    RETURN_IF_ERROR(CCerror);
-    if ( hex.size() > 0 )
+    result = ChannelClose(mypk,0,opentxid);
+    if ( result[JSON_HEXTX].getValStr().size() > 0  )
     {
         result.push_back(Pair("result", "success"));
-        result.push_back(Pair("hex", hex));
-    } else ERR_RESULT("couldnt create channelsclose transaction");
+    }
+    Unlock2NSPV(mypk);
     return(result);
 }
 
-UniValue channelsrefund(const UniValue& params, bool fHelp)
+UniValue channelsrefund(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
-    UniValue result(UniValue::VOBJ); struct CCcontract_info *cp,C; std::string hex; uint256 opentxid,closetxid;
+    UniValue result(UniValue::VOBJ); struct CCcontract_info *cp,C; uint256 opentxid,closetxid;
     cp = CCinit(&C,EVAL_CHANNELS);
     if ( fHelp || params.size() != 2 )
         throw runtime_error("channelsrefund opentxid closetxid\n");
     if ( ensure_CCrequirements(EVAL_CHANNELS) < 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);
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+    Lock2NSPV(mypk);
     opentxid = Parseuint256((char *)params[0].get_str().c_str());
     closetxid = Parseuint256((char *)params[1].get_str().c_str());
-    hex = ChannelRefund(0,opentxid,closetxid);
-    RETURN_IF_ERROR(CCerror);
-    if ( hex.size() > 0 )
+    result = ChannelRefund(mypk,0,opentxid,closetxid);
+    if ( result[JSON_HEXTX].getValStr().size() > 0  )
     {
         result.push_back(Pair("result", "success"));
-        result.push_back(Pair("hex", hex));
-    } else ERR_RESULT("couldnt create channelsrefund transaction");
+    }
+    Unlock2NSPV(mypk);
     return(result);
 }
 
-UniValue rewardscreatefunding(const UniValue& params, bool fHelp)
+UniValue rewardscreatefunding(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); char *name; int64_t funds,APR,minseconds,maxseconds,mindeposit; std::string hex;
     if ( fHelp || params.size() > 6 || params.size() < 2 )
         throw runtime_error("rewardscreatefunding name amount APR mindays maxdays mindeposit\n");
     if ( ensure_CCrequirements(EVAL_REWARDS) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
    // default to OOT params
@@ -6399,13 +6626,13 @@ UniValue rewardscreatefunding(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue rewardslock(const UniValue& params, bool fHelp)
+UniValue rewardslock(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); char *name; uint256 fundingtxid; int64_t amount; std::string hex;
     if ( fHelp || params.size() != 3 )
         throw runtime_error("rewardslock name fundingtxid amount\n");
     if ( ensure_CCrequirements(EVAL_REWARDS) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     name = (char *)params[0].get_str().c_str();
@@ -6429,13 +6656,13 @@ UniValue rewardslock(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue rewardsaddfunding(const UniValue& params, bool fHelp)
+UniValue rewardsaddfunding(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); char *name; uint256 fundingtxid; int64_t amount; std::string hex;
     if ( fHelp || params.size() != 3 )
         throw runtime_error("rewardsaddfunding name fundingtxid amount\n");
     if ( ensure_CCrequirements(EVAL_REWARDS) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     name = (char *)params[0].get_str().c_str();
@@ -6464,13 +6691,13 @@ UniValue rewardsaddfunding(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue rewardsunlock(const UniValue& params, bool fHelp)
+UniValue rewardsunlock(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); std::string hex; char *name; uint256 fundingtxid,txid;
     if ( fHelp || params.size() > 3 || params.size() < 2 )
         throw runtime_error("rewardsunlock name fundingtxid [txid]\n");
     if ( ensure_CCrequirements(EVAL_REWARDS) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     name = (char *)params[0].get_str().c_str();
@@ -6493,65 +6720,61 @@ UniValue rewardsunlock(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue rewardslist(const UniValue& params, bool fHelp)
+UniValue rewardslist(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if ( fHelp || params.size() > 0 )
         throw runtime_error("rewardslist\n");
     if ( ensure_CCrequirements(EVAL_REWARDS) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     return(RewardsList());
 }
 
-UniValue rewardsinfo(const UniValue& params, bool fHelp)
+UniValue rewardsinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     uint256 fundingtxid;
     if ( fHelp || params.size() != 1 )
         throw runtime_error("rewardsinfo fundingtxid\n");
     if ( ensure_CCrequirements(EVAL_REWARDS) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     fundingtxid = Parseuint256((char *)params[0].get_str().c_str());
     return(RewardsInfo(fundingtxid));
 }
 
-UniValue gatewayslist(const UniValue& params, bool fHelp)
+UniValue gatewayslist(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if ( fHelp || params.size() > 0 )
         throw runtime_error("gatewayslist\n");
     if ( ensure_CCrequirements(EVAL_GATEWAYS) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
-    LOCK2(cs_main, pwalletMain->cs_wallet);
     return(GatewaysList());
 }
 
-UniValue gatewaysexternaladdress(const UniValue& params, bool fHelp)
+UniValue gatewaysexternaladdress(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     uint256 bindtxid; CPubKey pubkey;
 
     if ( fHelp || params.size() != 2)
         throw runtime_error("gatewaysexternaladdress bindtxid pubkey\n");
     if ( ensure_CCrequirements(EVAL_GATEWAYS) < 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);
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     bindtxid = Parseuint256((char *)params[0].get_str().c_str());
     pubkey = ParseHex(params[1].get_str().c_str());
     return(GatewaysExternalAddress(bindtxid,pubkey));
 }
 
-UniValue gatewaysdumpprivkey(const UniValue& params, bool fHelp)
+UniValue gatewaysdumpprivkey(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     uint256 bindtxid;
 
     if ( fHelp || params.size() != 2)
         throw runtime_error("gatewaysdumpprivkey bindtxid address\n");
     if ( ensure_CCrequirements(EVAL_GATEWAYS) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
-    LOCK2(cs_main, pwalletMain->cs_wallet);
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     bindtxid = Parseuint256((char *)params[0].get_str().c_str());
     std::string strAddress = params[1].get_str();
     CTxDestination dest = DecodeDestination(strAddress);
@@ -6569,30 +6792,27 @@ UniValue gatewaysdumpprivkey(const UniValue& params, bool fHelp)
     return(GatewaysDumpPrivKey(bindtxid,vchSecret));
 }
 
-UniValue gatewaysinfo(const UniValue& params, bool fHelp)
+UniValue gatewaysinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     uint256 txid;
     if ( fHelp || params.size() != 1 )
         throw runtime_error("gatewaysinfo bindtxid\n");
     if ( ensure_CCrequirements(EVAL_GATEWAYS) < 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);
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     txid = Parseuint256((char *)params[0].get_str().c_str());
     return(GatewaysInfo(txid));
 }
 
-UniValue gatewaysbind(const UniValue& params, bool fHelp)
+UniValue gatewaysbind(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); uint256 tokenid,oracletxid; int32_t i; int64_t totalsupply; std::vector<CPubKey> pubkeys;
-    uint8_t M,N,p1,p2,p3,p4=0; std::string hex,coin; std::vector<unsigned char> pubkey;
+    uint8_t M,N,p1,p2,p3,p4=0; std::string coin; std::vector<unsigned char> pubkey;
 
     if ( fHelp || params.size() < 10 )
         throw runtime_error("gatewaysbind tokenid oracletxid coin tokensupply M N pubkey(s) pubtype p2shtype wiftype [taddr]\n");
     if ( ensure_CCrequirements(EVAL_GATEWAYS) < 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);
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+    Lock2NSPV(mypk);
     tokenid = Parseuint256((char *)params[0].get_str().c_str());
     oracletxid = Parseuint256((char *)params[1].get_str().c_str());
     coin = params[2].get_str();
@@ -6600,39 +6820,46 @@ UniValue gatewaysbind(const UniValue& params, bool fHelp)
     M = atoi((char *)params[4].get_str().c_str());
     N = atoi((char *)params[5].get_str().c_str());
     if ( M > N || N == 0 || N > 15 || totalsupply < COIN/100 || tokenid == zeroid )
+    {
+        Unlock2NSPV(mypk);
         throw runtime_error("illegal M or N > 15 or tokensupply or invalid tokenid\n");
+    }
     if ( params.size() < 6+N+3 )
+    {
+        Unlock2NSPV(mypk);
         throw runtime_error("not enough parameters for N pubkeys\n");
+    }
     for (i=0; i<N; i++)
     {       
         pubkey = ParseHex(params[6+i].get_str().c_str());
         if (pubkey.size()!= 33)
+        {
+            Unlock2NSPV(mypk);
             throw runtime_error("invalid destination pubkey");
+        }
         pubkeys.push_back(pubkey2pk(pubkey));
     }
     p1 = atoi((char *)params[6+N].get_str().c_str());
     p2 = atoi((char *)params[6+N+1].get_str().c_str());
     p3 = atoi((char *)params[6+N+2].get_str().c_str());
     if (params.size() == 9+N+1) p4 = atoi((char *)params[9+N].get_str().c_str());
-    hex = GatewaysBind(0,coin,tokenid,totalsupply,oracletxid,M,N,pubkeys,p1,p2,p3,p4);
-    RETURN_IF_ERROR(CCerror);
-    if ( hex.size() > 0 )
+    result = GatewaysBind(mypk,0,coin,tokenid,totalsupply,oracletxid,M,N,pubkeys,p1,p2,p3,p4);
+    if ( result[JSON_HEXTX].getValStr().size() > 0  )
     {
         result.push_back(Pair("result", "success"));
-        result.push_back(Pair("hex", hex));
-    } else ERR_RESULT("couldnt gatewaysbind");
+    }
+    Unlock2NSPV(mypk);
     return(result);
 }
 
-UniValue gatewaysdeposit(const UniValue& params, bool fHelp)
+UniValue gatewaysdeposit(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
-    UniValue result(UniValue::VOBJ); int32_t i,claimvout,height; int64_t amount; std::string hex,coin,deposithex; uint256 bindtxid,cointxid; std::vector<uint8_t>proof,destpub,pubkey;
+    UniValue result(UniValue::VOBJ); int32_t i,claimvout,height; int64_t amount; std::string coin,deposithex; uint256 bindtxid,cointxid; std::vector<uint8_t>proof,destpub,pubkey;
     if ( fHelp || params.size() != 9 )
         throw runtime_error("gatewaysdeposit bindtxid height coin cointxid claimvout deposithex proof destpub amount\n");
     if ( ensure_CCrequirements(EVAL_GATEWAYS) < 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);
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+    Lock2NSPV(mypk);
     bindtxid = Parseuint256((char *)params[0].get_str().c_str());
     height = atoi((char *)params[1].get_str().c_str());
     coin = params[2].get_str();
@@ -6643,348 +6870,321 @@ UniValue gatewaysdeposit(const UniValue& params, bool fHelp)
     destpub = ParseHex(params[7].get_str());
     amount = atof((char *)params[8].get_str().c_str()) * COIN + 0.00000000499999;
     if ( amount <= 0 || claimvout < 0 )
+    {
+        Unlock2NSPV(mypk);
         throw runtime_error("invalid param: amount, numpks or claimvout\n");
+    }
     if (destpub.size()!= 33)
+    {
+        Unlock2NSPV(mypk);
         throw runtime_error("invalid destination pubkey");
-    hex = GatewaysDeposit(0,bindtxid,height,coin,cointxid,claimvout,deposithex,proof,pubkey2pk(destpub),amount);
-
-    RETURN_IF_ERROR(CCerror);
-    if ( hex.size() > 0 )
+    }
+    result = GatewaysDeposit(mypk,0,bindtxid,height,coin,cointxid,claimvout,deposithex,proof,pubkey2pk(destpub),amount);
+    if ( result[JSON_HEXTX].getValStr().size() > 0  )
     {
         result.push_back(Pair("result", "success"));
-        result.push_back(Pair("hex", hex));
-    } else ERR_RESULT("couldnt gatewaysdeposit");
+    }
+    Unlock2NSPV(mypk);
     return(result);
 }
 
-UniValue gatewaysclaim(const UniValue& params, bool fHelp)
+UniValue gatewaysclaim(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
-    UniValue result(UniValue::VOBJ); std::string hex,coin; uint256 bindtxid,deposittxid; std::vector<uint8_t>destpub; int64_t amount;
+    UniValue result(UniValue::VOBJ); std::string coin; uint256 bindtxid,deposittxid; std::vector<uint8_t>destpub; int64_t amount;
     if ( fHelp || params.size() != 5 )
         throw runtime_error("gatewaysclaim bindtxid coin deposittxid destpub amount\n");
     if ( ensure_CCrequirements(EVAL_GATEWAYS) < 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);
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+    Lock2NSPV(mypk);
     bindtxid = Parseuint256((char *)params[0].get_str().c_str());
     coin = params[1].get_str();
     deposittxid = Parseuint256((char *)params[2].get_str().c_str());
     destpub = ParseHex(params[3].get_str());
     amount = atof((char *)params[4].get_str().c_str()) * COIN + 0.00000000499999;
     if (destpub.size()!= 33)
+    {
+        Unlock2NSPV(mypk);
         throw runtime_error("invalid destination pubkey");
-    hex = GatewaysClaim(0,bindtxid,coin,deposittxid,pubkey2pk(destpub),amount);
-    RETURN_IF_ERROR(CCerror);
-    if ( hex.size() > 0 )
+    }
+    result = GatewaysClaim(mypk,0,bindtxid,coin,deposittxid,pubkey2pk(destpub),amount);
+    if ( result[JSON_HEXTX].getValStr().size() > 0  )
     {
         result.push_back(Pair("result", "success"));
-        result.push_back(Pair("hex", hex));
-    } else ERR_RESULT("couldnt gatewaysclaim");
+    }
+    Unlock2NSPV(mypk);
     return(result);
 }
 
-UniValue gatewayswithdraw(const UniValue& params, bool fHelp)
+UniValue gatewayswithdraw(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
-    UniValue result(UniValue::VOBJ); uint256 bindtxid; int64_t amount; std::string hex,coin; std::vector<uint8_t> withdrawpub;
+    UniValue result(UniValue::VOBJ); uint256 bindtxid; int64_t amount; std::string coin; std::vector<uint8_t> withdrawpub;
     if ( fHelp || params.size() != 4 )
         throw runtime_error("gatewayswithdraw bindtxid coin withdrawpub amount\n");
     if ( ensure_CCrequirements(EVAL_GATEWAYS) < 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);
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+    Lock2NSPV(mypk);
     bindtxid = Parseuint256((char *)params[0].get_str().c_str());
     coin = params[1].get_str();
     withdrawpub = ParseHex(params[2].get_str());
     amount = atof((char *)params[3].get_str().c_str()) * COIN + 0.00000000499999;
     if (withdrawpub.size()!= 33)
+    {
+        Unlock2NSPV(mypk);
         throw runtime_error("invalid destination pubkey");
-    hex = GatewaysWithdraw(0,bindtxid,coin,pubkey2pk(withdrawpub),amount);
-    RETURN_IF_ERROR(CCerror);
-    if ( hex.size() > 0 )
+    }
+    result = GatewaysWithdraw(mypk,0,bindtxid,coin,pubkey2pk(withdrawpub),amount);
+    if ( result[JSON_HEXTX].getValStr().size() > 0  )
     {
         result.push_back(Pair("result", "success"));
-        result.push_back(Pair("hex", hex));
-    } else ERR_RESULT("couldnt gatewayswithdraw");
+    }
+    Lock2NSPV(mypk);
     return(result);
 }
 
-UniValue gatewayspartialsign(const UniValue& params, bool fHelp)
+UniValue gatewayspartialsign(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
-    UniValue result(UniValue::VOBJ); std::string coin,parthex,hex; uint256 txid;
+    UniValue result(UniValue::VOBJ); std::string coin,parthex; uint256 txid;
     if ( fHelp || params.size() != 3 )
         throw runtime_error("gatewayspartialsign txidaddr refcoin hex\n");
     if ( ensure_CCrequirements(EVAL_GATEWAYS) < 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);
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+    Lock2NSPV(mypk);
     txid = Parseuint256((char *)params[0].get_str().c_str());
     coin = params[1].get_str();
     parthex = params[2].get_str();
-    hex = GatewaysPartialSign(0,txid,coin,parthex);
-    RETURN_IF_ERROR(CCerror);
-    if ( hex.size() > 0 )
+    result = GatewaysPartialSign(mypk,0,txid,coin,parthex);
+    if ( result[JSON_HEXTX].getValStr().size() > 0  )
     {
         result.push_back(Pair("result", "success"));
-        result.push_back(Pair("hex",hex));
-    } else ERR_RESULT("couldnt gatewayspartialsign");
+    }
+    Unlock2NSPV(mypk);
     return(result);
 }
 
-UniValue gatewayscompletesigning(const UniValue& params, bool fHelp)
+UniValue gatewayscompletesigning(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
-    UniValue result(UniValue::VOBJ); uint256 withdrawtxid; std::string txhex,hex,coin;
+    UniValue result(UniValue::VOBJ); uint256 withdrawtxid; std::string txhex,coin;
     if ( fHelp || params.size() != 3 )
         throw runtime_error("gatewayscompletesigning withdrawtxid coin hex\n");
     if ( ensure_CCrequirements(EVAL_GATEWAYS) < 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);
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+    Lock2NSPV(mypk);
     withdrawtxid = Parseuint256((char *)params[0].get_str().c_str());
     coin = params[1].get_str();
     txhex = params[2].get_str();
-    hex = GatewaysCompleteSigning(0,withdrawtxid,coin,txhex);
-    RETURN_IF_ERROR(CCerror);
-    if ( hex.size() > 0 )
+    result = GatewaysCompleteSigning(mypk,0,withdrawtxid,coin,txhex);
+    if ( result[JSON_HEXTX].getValStr().size() > 0  )
     {
         result.push_back(Pair("result", "success"));
-        result.push_back(Pair("hex", hex));
-    } else ERR_RESULT("couldnt gatewayscompletesigning");
+    }
+    Unlock2NSPV(mypk);
     return(result);
 }
 
-UniValue gatewaysmarkdone(const UniValue& params, bool fHelp)
+UniValue gatewaysmarkdone(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
-    UniValue result(UniValue::VOBJ); uint256 completetxid; std::string hex,coin;
+    UniValue result(UniValue::VOBJ); uint256 completetxid; std::string coin;
     if ( fHelp || params.size() != 2 )
         throw runtime_error("gatewaysmarkdone completesigningtx coin\n");
     if ( ensure_CCrequirements(EVAL_GATEWAYS) < 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);
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+    Lock2NSPV(mypk);
     completetxid = Parseuint256((char *)params[0].get_str().c_str());
     coin = params[1].get_str();
-    hex = GatewaysMarkDone(0,completetxid,coin);
-    RETURN_IF_ERROR(CCerror);
-    if ( hex.size() > 0 )
+    result = GatewaysMarkDone(mypk,0,completetxid,coin);
+    if ( result[JSON_HEXTX].getValStr().size() > 0  )
     {
         result.push_back(Pair("result", "success"));
-        result.push_back(Pair("hex", hex));
-    } else ERR_RESULT("couldnt gatewaysmarkdone");
+    }
+    Unlock2NSPV(mypk);
     return(result);
 }
 
-UniValue gatewayspendingdeposits(const UniValue& params, bool fHelp)
+UniValue gatewayspendingdeposits(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     uint256 bindtxid; std::string coin;
     if ( fHelp || params.size() != 2 )
         throw runtime_error("gatewayspendingdeposits bindtxid coin\n");
     if ( ensure_CCrequirements(EVAL_GATEWAYS) < 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);
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     bindtxid = Parseuint256((char *)params[0].get_str().c_str());
     coin = params[1].get_str();
-    return(GatewaysPendingDeposits(bindtxid,coin));
+    return(GatewaysPendingDeposits(mypk,bindtxid,coin));
 }
 
-UniValue gatewayspendingwithdraws(const UniValue& params, bool fHelp)
+UniValue gatewayspendingwithdraws(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     uint256 bindtxid; std::string coin;
     if ( fHelp || params.size() != 2 )
         throw runtime_error("gatewayspendingwithdraws bindtxid coin\n");
     if ( ensure_CCrequirements(EVAL_GATEWAYS) < 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);
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     bindtxid = Parseuint256((char *)params[0].get_str().c_str());
     coin = params[1].get_str();
-    return(GatewaysPendingWithdraws(bindtxid,coin));
+    return(GatewaysPendingWithdraws(mypk,bindtxid,coin));
 }
 
-UniValue gatewaysprocessed(const UniValue& params, bool fHelp)
+UniValue gatewaysprocessed(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     uint256 bindtxid; std::string coin;
     if ( fHelp || params.size() != 2 )
         throw runtime_error("gatewaysprocessed bindtxid coin\n");
     if ( ensure_CCrequirements(EVAL_GATEWAYS) < 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);
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     bindtxid = Parseuint256((char *)params[0].get_str().c_str());
     coin = params[1].get_str();
-    return(GatewaysProcessedWithdraws(bindtxid,coin));
+    return(GatewaysProcessedWithdraws(mypk,bindtxid,coin));
 }
 
-UniValue oracleslist(const UniValue& params, bool fHelp)
+UniValue oracleslist(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if ( fHelp || params.size() > 0 )
         throw runtime_error("oracleslist\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);
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     return(OraclesList());
 }
 
-UniValue oraclesinfo(const UniValue& params, bool fHelp)
+UniValue oraclesinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     uint256 txid;
     if ( fHelp || params.size() != 1 )
         throw runtime_error("oraclesinfo 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);
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     txid = Parseuint256((char *)params[0].get_str().c_str());
     return(OracleInfo(txid));
 }
 
-UniValue oraclesfund(const UniValue& params, bool fHelp)
+UniValue oraclesfund(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
-    UniValue result(UniValue::VOBJ); uint256 txid; std::string hex;
+    UniValue result(UniValue::VOBJ); uint256 txid;
     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);
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+    Lock2NSPV(mypk);
     txid = Parseuint256((char *)params[0].get_str().c_str());
-    hex = OracleFund(0,txid);
-    RETURN_IF_ERROR(CCerror);
-    if ( hex.size() > 0 )
+    result = OracleFund(mypk,0,txid);
+    if ( result[JSON_HEXTX].getValStr().size() > 0  )
     {
         result.push_back(Pair("result", "success"));
-        result.push_back(Pair("hex", hex));
-    } else ERR_RESULT("couldnt fund with oracle txid");
+    }
+    Unlock2NSPV(mypk);
     return(result);
 }
 
-UniValue oraclesregister(const UniValue& params, bool fHelp)
+UniValue oraclesregister(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
-    UniValue result(UniValue::VOBJ); uint256 txid; int64_t datafee; std::string hex;
+    UniValue result(UniValue::VOBJ); uint256 txid; int64_t datafee;
     if ( fHelp || params.size() != 2 )
         throw runtime_error("oraclesregister oracletxid datafee\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);
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+    Lock2NSPV(mypk);
     txid = Parseuint256((char *)params[0].get_str().c_str());
     if ( (datafee= atol((char *)params[1].get_str().c_str())) == 0 )
         datafee = atof((char *)params[1].get_str().c_str()) * COIN + 0.00000000499999;
-    hex = OracleRegister(0,txid,datafee);
-    RETURN_IF_ERROR(CCerror);
-    if ( hex.size() > 0 )
+    result = OracleRegister(mypk,0,txid,datafee);
+    if ( result[JSON_HEXTX].getValStr().size() > 0  )
     {
         result.push_back(Pair("result", "success"));
-        result.push_back(Pair("hex", hex));
-    } else ERR_RESULT("couldnt register with oracle txid");
+    }
+    Unlock2NSPV(mypk);
     return(result);
 }
 
-UniValue oraclessubscribe(const UniValue& params, bool fHelp)
+UniValue oraclessubscribe(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
-    UniValue result(UniValue::VOBJ); uint256 txid; int64_t amount; std::string hex; std::vector<unsigned char> pubkey;
+    UniValue result(UniValue::VOBJ); uint256 txid; int64_t amount; std::vector<unsigned char> pubkey;
     if ( fHelp || params.size() != 3 )
         throw runtime_error("oraclessubscribe oracletxid publisher amount\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);
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+    Lock2NSPV(mypk);
     txid = Parseuint256((char *)params[0].get_str().c_str());
     pubkey = ParseHex(params[1].get_str().c_str());
     amount = atof((char *)params[2].get_str().c_str()) * COIN + 0.00000000499999;
-    hex = OracleSubscribe(0,txid,pubkey2pk(pubkey),amount);
-    RETURN_IF_ERROR(CCerror);
-    if ( hex.size() > 0 )
+    result = OracleSubscribe(mypk,0,txid,pubkey2pk(pubkey),amount);
+    if ( result[JSON_HEXTX].getValStr().size() > 0  )
     {
         result.push_back(Pair("result", "success"));
-        result.push_back(Pair("hex", hex));
-    } else ERR_RESULT("couldnt subscribe with oracle txid");
+    }
+    Unlock2NSPV(mypk);
     return(result);
 }
 
-UniValue oraclessamples(const UniValue& params, bool fHelp)
+UniValue oraclessample(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    UniValue result(UniValue::VOBJ); uint256 oracletxid,txid; int32_t num; char *batonaddr;
+    if ( fHelp || params.size() != 2 )
+        throw runtime_error("oraclessample oracletxid txid\n");
+    if ( ensure_CCrequirements(EVAL_ORACLES) < 0 )
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+    oracletxid = Parseuint256((char *)params[0].get_str().c_str());
+    txid = Parseuint256((char *)params[1].get_str().c_str());
+    return(OracleDataSample(oracletxid,txid));
+}
+
+UniValue oraclessamples(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); uint256 txid; int32_t num; char *batonaddr;
     if ( fHelp || params.size() != 3 )
         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);
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     txid = Parseuint256((char *)params[0].get_str().c_str());
     batonaddr = (char *)params[1].get_str().c_str();
     num = atoi((char *)params[2].get_str().c_str());
     return(OracleDataSamples(txid,batonaddr,num));
 }
 
-UniValue oraclesdata(const UniValue& params, bool fHelp)
+UniValue oraclesdata(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
-    UniValue result(UniValue::VOBJ); uint256 txid; std::vector<unsigned char> data; std::string hex;
+    UniValue result(UniValue::VOBJ); uint256 txid; std::vector<unsigned char> data;
     if ( fHelp || params.size() != 2 )
         throw runtime_error("oraclesdata oracletxid hexstr\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);
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+    Lock2NSPV(mypk);
     txid = Parseuint256((char *)params[0].get_str().c_str());
     data = ParseHex(params[1].get_str().c_str());
-    hex = OracleData(0,txid,data);
-
-    RETURN_IF_ERROR(CCerror);
-
-    if ( hex.size() > 0 )
+    result = OracleData(mypk,0,txid,data);
+    if ( result[JSON_HEXTX].getValStr().size() > 0  )
     {
         result.push_back(Pair("result", "success"));
-        result.push_back(Pair("hex", hex));
-    } else ERR_RESULT("couldnt publish data with oracle txid");
+    }
+    Unlock2NSPV(mypk);
     return(result);
 }
 
-UniValue oraclescreate(const UniValue& params, bool fHelp)
+UniValue oraclescreate(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
-    UniValue result(UniValue::VOBJ); std::string name,description,format,hex;
+    UniValue result(UniValue::VOBJ); std::string name,description,format;
     if ( fHelp || params.size() != 3 )
         throw runtime_error("oraclescreate name description format\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);
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+    Lock2NSPV(mypk);
     name = params[0].get_str();
-    if ( name.size() == 0 || name.size() > 32)
-    {
-        ERR_RESULT("oracles name must not be empty and up to 32 characters");
-        return(result);
-    }
     description = params[1].get_str();
-    if ( description.size() > 4096 )
-    {
-        ERR_RESULT("oracles description must be <= 4096 characters");
-        return(result);
-    }
     format = params[2].get_str();
-    if ( format.size() > 4096 )
-    {
-        ERR_RESULT("oracles format must be <= 4096 characters");
-        return(result);
-    }
-    hex = OracleCreate(0,name,description,format);
-    RETURN_IF_ERROR(CCerror);
-    if ( hex.size() > 0 )
+    result = OracleCreate(mypk,0,name,description,format);
+    if ( result[JSON_HEXTX].getValStr().size() > 0  )
     {
         result.push_back(Pair("result", "success"));
-        result.push_back(Pair("hex", hex));
-    } else ERR_RESULT("couldnt create oracle");
+    }
+    Unlock2NSPV(mypk);
     return(result);
 }
 
-UniValue FSMcreate(const UniValue& params, bool fHelp)
+UniValue FSMcreate(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); std::string name,states,hex;
     if ( fHelp || params.size() != 2 )
         throw runtime_error("FSMcreate name states\n");
     if ( ensure_CCrequirements(EVAL_FSM) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     name = params[0].get_str();
@@ -6998,71 +7198,115 @@ UniValue FSMcreate(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue FSMlist(const UniValue& params, bool fHelp)
+UniValue FSMlist(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     uint256 tokenid;
     if ( fHelp || params.size() > 0 )
         throw runtime_error("FSMlist\n");
     if ( ensure_CCrequirements(EVAL_FSM) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     return(FSMList());
 }
 
-UniValue FSMinfo(const UniValue& params, bool fHelp)
+UniValue FSMinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     uint256 FSMtxid;
     if ( fHelp || params.size() != 1 )
         throw runtime_error("FSMinfo fundingtxid\n");
     if ( ensure_CCrequirements(EVAL_FSM) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     FSMtxid = Parseuint256((char *)params[0].get_str().c_str());
     return(FSMInfo(FSMtxid));
 }
 
-UniValue faucetinfo(const UniValue& params, bool fHelp)
+UniValue faucetinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     uint256 fundingtxid;
     if ( fHelp || params.size() != 0 )
         throw runtime_error("faucetinfo\n");
     if ( ensure_CCrequirements(EVAL_FAUCET) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     return(FaucetInfo());
 }
 
-UniValue faucetfund(const UniValue& params, bool fHelp)
+UniValue faucetfund(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); int64_t funds; std::string hex;
-    if ( fHelp || params.size() > 1 )
+    if ( fHelp || params.size() != 1 )
         throw runtime_error("faucetfund amount\n");
-    if ( ensure_CCrequirements(EVAL_FAUCET) < 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);
     funds = atof(params[0].get_str().c_str()) * COIN + 0.00000000499999;
-    if (funds > 0) {
-        hex = FaucetFund(0,(uint64_t) funds);
-        if ( hex.size() > 0 )
+    if ( (0) && KOMODO_NSPV_SUPERLITE )
+    {
+        char coinaddr[64]; struct CCcontract_info *cp,C; CTxOut v;
+        cp = CCinit(&C,EVAL_FAUCET);
+        v = MakeCC1vout(EVAL_FAUCET,funds,GetUnspendable(cp,0));
+        Getscriptaddress(coinaddr,CScript() << ParseHex(HexStr(pubkey2pk(Mypubkey()))) << OP_CHECKSIG);
+        return(NSPV_spend(coinaddr,(char *)HexStr(v.scriptPubKey.begin()+1,v.scriptPubKey.end()-1).c_str(),funds));
+    }
+    if ( ensure_CCrequirements(EVAL_FAUCET) < 0 )
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+
+    //const CKeyStore& keystore = *pwalletMain;
+    //LOCK2(cs_main, pwalletMain->cs_wallet);
+
+    bool lockWallet = false;
+    if (!mypk.IsValid())   // if mypk is not set then it is a local call, use local wallet in AddNormalInputs
+        lockWallet = true;
+
+    if (funds > 0) 
+    {
+        if (lockWallet)
+        {
+            ENTER_CRITICAL_SECTION(cs_main);
+            ENTER_CRITICAL_SECTION(pwalletMain->cs_wallet);
+        }
+        result = FaucetFund(mypk, 0,(uint64_t) funds);
+        if (lockWallet)
+        {
+            LEAVE_CRITICAL_SECTION(pwalletMain->cs_wallet);
+            LEAVE_CRITICAL_SECTION(cs_main);
+        }
+
+        if ( result[JSON_HEXTX].getValStr().size() > 0 )
         {
             result.push_back(Pair("result", "success"));
-            result.push_back(Pair("hex", hex));
+            //result.push_back(Pair("hex", hex));
         } else ERR_RESULT("couldnt create faucet funding transaction");
     } else ERR_RESULT( "funding amount must be positive");
     return(result);
 }
 
-UniValue faucetget(const UniValue& params, bool fHelp)
+UniValue faucetget(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); std::string hex;
-    if ( fHelp || params.size() > 0 )
+    if ( fHelp || params.size() !=0 )
         throw runtime_error("faucetget\n");
     if ( ensure_CCrequirements(EVAL_FAUCET) < 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);
-    hex = FaucetGet(0);
-    if ( hex.size() > 0 ) {
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+
+    bool lockWallet = false;
+    if (!mypk.IsValid())   // if mypk is not set then it is a local call, use wallet in AddNormalInputs (see check for this there)
+        lockWallet = true;
+
+    //const CKeyStore& keystore = *pwalletMain;
+    //LOCK2(cs_main, pwalletMain->cs_wallet);
+
+    if (lockWallet)
+    {
+        // use this instead LOCK2 because we need conditional wallet lock
+        ENTER_CRITICAL_SECTION(cs_main);
+        ENTER_CRITICAL_SECTION(pwalletMain->cs_wallet);
+    }
+    result = FaucetGet(mypk, 0);
+    if (lockWallet)
+    {
+        LEAVE_CRITICAL_SECTION(pwalletMain->cs_wallet);
+        LEAVE_CRITICAL_SECTION(cs_main);
+    }
+
+    if (result[JSON_HEXTX].getValStr().size() > 0 ) {
         result.push_back(Pair("result", "success"));
-        result.push_back(Pair("hex", hex));
+        //result.push_back(Pair("hex", hex));
     } else ERR_RESULT("couldnt create faucet get transaction");
     return(result);
 }
@@ -7080,12 +7324,12 @@ uint32_t pricesGetParam(UniValue param) {
     return filter;
 }
 
-UniValue priceslist(const UniValue& params, bool fHelp)
+UniValue priceslist(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if ( fHelp || params.size() != 0 && params.size() != 1)
         throw runtime_error("priceslist [all|open|closed]\n");
     if ( ensure_CCrequirements(EVAL_PRICES) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     uint32_t filter = 0;
     if (params.size() == 1) 
         filter = pricesGetParam(params[0]);
@@ -7095,28 +7339,30 @@ UniValue priceslist(const UniValue& params, bool fHelp)
     return(PricesList(filter, emptypk));
 }
 
-UniValue mypriceslist(const UniValue& params, bool fHelp)
+UniValue mypriceslist(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if (fHelp || params.size() != 0 && params.size() != 1)
         throw runtime_error("mypriceslist [all|open|closed]\n");
     if (ensure_CCrequirements(EVAL_PRICES) < 0)
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
 
     uint32_t filter = 0;
     if (params.size() == 1)
         filter = pricesGetParam(params[0]);
-    CPubKey mypk = pubkey2pk(Mypubkey());
+    CPubKey pk;
+    if (mypk.IsValid()) pk=mypk;
+    else pk = pubkey2pk(Mypubkey());
 
-    return(PricesList(filter, mypk));
+    return(PricesList(filter, pk));
 }
 
-UniValue pricesinfo(const UniValue& params, bool fHelp)
+UniValue pricesinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     uint256 bettxid; int32_t height;
     if ( fHelp || params.size() != 1 && params.size() != 2)
         throw runtime_error("pricesinfo bettxid [height]\n");
     if ( ensure_CCrequirements(EVAL_PRICES) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     bettxid = Parseuint256((char *)params[0].get_str().c_str());
     height = 0;
     if (params.size() == 2)
@@ -7124,13 +7370,13 @@ UniValue pricesinfo(const UniValue& params, bool fHelp)
     return(PricesInfo(bettxid, height));
 }
 
-UniValue dicefund(const UniValue& params, bool fHelp)
+UniValue dicefund(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); int64_t funds,minbet,maxbet,maxodds,timeoutblocks; std::string hex; char *name;
     if ( fHelp || params.size() != 6 )
         throw runtime_error("dicefund name funds minbet maxbet maxodds timeoutblocks\n");
     if ( ensure_CCrequirements(EVAL_DICE) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     name = (char *)params[0].get_str().c_str();
@@ -7157,13 +7403,13 @@ UniValue dicefund(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue diceaddfunds(const UniValue& params, bool fHelp)
+UniValue diceaddfunds(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); char *name; uint256 fundingtxid; int64_t amount; std::string hex;
     if ( fHelp || params.size() != 3 )
         throw runtime_error("diceaddfunds name fundingtxid amount\n");
     if ( ensure_CCrequirements(EVAL_DICE) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     name = (char *)params[0].get_str().c_str();
@@ -7185,13 +7431,13 @@ UniValue diceaddfunds(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue dicebet(const UniValue& params, bool fHelp)
+UniValue dicebet(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); std::string hex,error; uint256 fundingtxid; int64_t amount,odds; char *name;
     if ( fHelp || params.size() != 4 )
         throw runtime_error("dicebet name fundingtxid amount odds\n");
     if ( ensure_CCrequirements(EVAL_DICE) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     name = (char *)params[0].get_str().c_str();
@@ -7217,13 +7463,13 @@ UniValue dicebet(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue dicefinish(const UniValue& params, bool fHelp)
+UniValue dicefinish(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); uint8_t funcid; char *name; uint256 entropyused,fundingtxid,bettxid; std::string hex; int32_t r,entropyvout;
     if ( fHelp || params.size() != 3 )
         throw runtime_error("dicefinish name fundingtxid bettxid\n");
     if ( ensure_CCrequirements(EVAL_DICE) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     name = (char *)params[0].get_str().c_str();
@@ -7252,13 +7498,13 @@ UniValue dicefinish(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue dicestatus(const UniValue& params, bool fHelp)
+UniValue dicestatus(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); char *name; uint256 fundingtxid,bettxid; std::string status,error; double winnings;
     if ( fHelp || (params.size() != 2 && params.size() != 3) )
         throw runtime_error("dicestatus name fundingtxid bettxid\n");
     if ( ensure_CCrequirements(EVAL_DICE) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     name = (char *)params[0].get_str().c_str();
@@ -7301,81 +7547,78 @@ UniValue dicestatus(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue dicelist(const UniValue& params, bool fHelp)
+UniValue dicelist(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     if ( fHelp || params.size() > 0 )
         throw runtime_error("dicelist\n");
     if ( ensure_CCrequirements(EVAL_DICE) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     return(DiceList());
 }
 
-UniValue diceinfo(const UniValue& params, bool fHelp)
+UniValue diceinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     uint256 fundingtxid;
     if ( fHelp || params.size() != 1 )
         throw runtime_error("diceinfo fundingtxid\n");
     if ( ensure_CCrequirements(EVAL_DICE) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     fundingtxid = Parseuint256((char *)params[0].get_str().c_str());
     return(DiceInfo(fundingtxid));
 }
 
-UniValue tokenlist(const UniValue& params, bool fHelp)
+UniValue tokenlist(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     uint256 tokenid;
     if ( fHelp || params.size() > 0 )
         throw runtime_error("tokenlist\n");
     if ( ensure_CCrequirements(EVAL_TOKENS) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     return(TokenList());
 }
 
-UniValue tokeninfo(const UniValue& params, bool fHelp)
+UniValue tokeninfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     uint256 tokenid;
     if ( fHelp || params.size() != 1 )
         throw runtime_error("tokeninfo tokenid\n");
     if ( ensure_CCrequirements(EVAL_TOKENS) < 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);
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     tokenid = Parseuint256((char *)params[0].get_str().c_str());
     return(TokenInfo(tokenid));
 }
 
-UniValue tokenorders(const UniValue& params, bool fHelp)
+UniValue tokenorders(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     uint256 tokenid;
     if ( fHelp || params.size() > 1 )
-        throw runtime_error("tokenorders tokenid\n");
+        throw runtime_error("tokenorders [tokenid]\n"
+                            "returns token orders for the tokenid or all available token orders if tokenid is not set\n"
+                            "(this rpc supports only fungible tokens)\n" "\n");
     if (ensure_CCrequirements(EVAL_ASSETS) < 0 || ensure_CCrequirements(EVAL_TOKENS) < 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);
+        throw runtime_error(CC_REQUIREMENTS_MSG);
 	if (params.size() == 1) {
 		tokenid = Parseuint256((char *)params[0].get_str().c_str());
 		if (tokenid == zeroid) 
 			throw runtime_error("incorrect tokenid\n");
+        return AssetOrders(tokenid, CPubKey(), 0);
 	}
     else {
-        // memset(&tokenid, 0, sizeof(tokenid));
-        throw runtime_error("no tokenid\n");
+        // throw runtime_error("no tokenid\n");
+        return AssetOrders(zeroid, CPubKey(), 0);
     }
-    return AssetOrders(tokenid, CPubKey(), 0);
 }
 
 
-UniValue mytokenorders(const UniValue& params, bool fHelp)
+UniValue mytokenorders(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     uint256 tokenid;
-    if (fHelp || params.size() > 2)
-        throw runtime_error("mytokenorders [evalcode]\n");
+    if (fHelp || params.size() > 1)
+        throw runtime_error("mytokenorders [evalcode]\n"
+                            "returns all the token orders for mypubkey\n"
+                            "if evalcode is set then returns mypubkey token orders for non-fungible tokens with this evalcode\n" "\n");
     if (ensure_CCrequirements(EVAL_ASSETS) < 0 || ensure_CCrequirements(EVAL_TOKENS) < 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);
-
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     uint8_t additionalEvalCode = 0;
     if (params.size() == 1)
         additionalEvalCode = strtol(params[0].get_str().c_str(), NULL, 0);  // supports also 0xEE-like values
@@ -7383,7 +7626,7 @@ UniValue mytokenorders(const UniValue& params, bool fHelp)
     return AssetOrders(zeroid, Mypubkey(), additionalEvalCode);
 }
 
-UniValue tokenbalance(const UniValue& params, bool fHelp)
+UniValue tokenbalance(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); uint256 tokenid; uint64_t balance; std::vector<unsigned char> pubkey; struct CCcontract_info *cp,C;
 	CCerror.clear();
@@ -7391,7 +7634,7 @@ UniValue tokenbalance(const UniValue& params, bool fHelp)
     if ( fHelp || params.size() > 2 )
         throw runtime_error("tokenbalance tokenid [pubkey]\n");
     if ( ensure_CCrequirements(EVAL_TOKENS) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     
 	LOCK(cs_main);
 
@@ -7421,7 +7664,7 @@ UniValue tokenbalance(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue tokencreate(const UniValue& params, bool fHelp)
+UniValue tokencreate(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ);
     std::string name, description, hextx; 
@@ -7433,7 +7676,7 @@ UniValue tokencreate(const UniValue& params, bool fHelp)
     if ( fHelp || params.size() > 4 || params.size() < 2 )
         throw runtime_error("tokencreate name supply [description][data]\n");
     if ( ensure_CCrequirements(EVAL_TOKENS) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
@@ -7480,7 +7723,7 @@ UniValue tokencreate(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue tokentransfer(const UniValue& params, bool fHelp)
+UniValue tokentransfer(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); 
     std::string hex; 
@@ -7492,7 +7735,7 @@ UniValue tokentransfer(const UniValue& params, bool fHelp)
     if ( fHelp || params.size() != 3)
         throw runtime_error("tokentransfer tokenid destpubkey amount\n");
     if ( ensure_CCrequirements(EVAL_TOKENS) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
@@ -7522,13 +7765,13 @@ UniValue tokentransfer(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue tokenconvert(const UniValue& params, bool fHelp)
+UniValue tokenconvert(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); std::string hex; int32_t evalcode; int64_t amount; uint256 tokenid;
     if ( fHelp || params.size() != 4 )
         throw runtime_error("tokenconvert evalcode tokenid pubkey amount\n");
     if ( ensure_CCrequirements(EVAL_ASSETS) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     evalcode = atoi(params[0].get_str().c_str());
@@ -7563,13 +7806,13 @@ UniValue tokenconvert(const UniValue& params, bool fHelp)
     return(result); */
 }
 
-UniValue tokenbid(const UniValue& params, bool fHelp)
+UniValue tokenbid(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); int64_t bidamount,numtokens; std::string hex; double price; uint256 tokenid;
     if ( fHelp || params.size() != 3 )
         throw runtime_error("tokenbid numtokens tokenid price\n");
     if (ensure_CCrequirements(EVAL_ASSETS) < 0 || ensure_CCrequirements(EVAL_TOKENS) < 0)
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     //numtokens = atoi(params[0].get_str().c_str());
@@ -7605,13 +7848,13 @@ UniValue tokenbid(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue tokencancelbid(const UniValue& params, bool fHelp)
+UniValue tokencancelbid(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); std::string hex; int32_t i; uint256 tokenid,bidtxid;
     if ( fHelp || params.size() != 2 )
         throw runtime_error("tokencancelbid tokenid bidtxid\n");
     if (ensure_CCrequirements(EVAL_ASSETS) < 0 || ensure_CCrequirements(EVAL_TOKENS) < 0)
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     tokenid = Parseuint256((char *)params[0].get_str().c_str());
@@ -7630,13 +7873,13 @@ UniValue tokencancelbid(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue tokenfillbid(const UniValue& params, bool fHelp)
+UniValue tokenfillbid(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); int64_t fillamount; std::string hex; uint256 tokenid,bidtxid;
     if ( fHelp || params.size() != 3 )
         throw runtime_error("tokenfillbid tokenid bidtxid fillamount\n");
     if (ensure_CCrequirements(EVAL_ASSETS) < 0 || ensure_CCrequirements(EVAL_TOKENS) < 0)
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     tokenid = Parseuint256((char *)params[0].get_str().c_str());
@@ -7662,13 +7905,13 @@ UniValue tokenfillbid(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue tokenask(const UniValue& params, bool fHelp)
+UniValue tokenask(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); int64_t askamount,numtokens; std::string hex; double price; uint256 tokenid;
     if ( fHelp || params.size() != 3 )
         throw runtime_error("tokenask numtokens tokenid price\n");
     if (ensure_CCrequirements(EVAL_ASSETS) < 0 || ensure_CCrequirements(EVAL_TOKENS) < 0)
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     //numtokens = atoi(params[0].get_str().c_str());
@@ -7695,14 +7938,14 @@ UniValue tokenask(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue tokenswapask(const UniValue& params, bool fHelp)
+UniValue tokenswapask(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     static uint256 zeroid;
     UniValue result(UniValue::VOBJ); int64_t askamount,numtokens; std::string hex; double price; uint256 tokenid,otherid;
     if ( fHelp || params.size() != 4 )
         throw runtime_error("tokenswapask numtokens tokenid otherid price\n");
     if ( ensure_CCrequirements(EVAL_ASSETS) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     //numtokens = atoi(params[0].get_str().c_str());
@@ -7724,13 +7967,13 @@ UniValue tokenswapask(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue tokencancelask(const UniValue& params, bool fHelp)
+UniValue tokencancelask(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); std::string hex; int32_t i; uint256 tokenid,asktxid;
     if ( fHelp || params.size() != 2 )
         throw runtime_error("tokencancelask tokenid asktxid\n");
     if (ensure_CCrequirements(EVAL_ASSETS) < 0 || ensure_CCrequirements(EVAL_TOKENS) < 0)
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     tokenid = Parseuint256((char *)params[0].get_str().c_str());
@@ -7749,13 +7992,13 @@ UniValue tokencancelask(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue tokenfillask(const UniValue& params, bool fHelp)
+UniValue tokenfillask(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     UniValue result(UniValue::VOBJ); int64_t fillunits; std::string hex; uint256 tokenid,asktxid;
     if ( fHelp || params.size() != 3 )
         throw runtime_error("tokenfillask tokenid asktxid fillunits\n");
     if (ensure_CCrequirements(EVAL_ASSETS) < 0 || ensure_CCrequirements(EVAL_TOKENS) < 0)
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     tokenid = Parseuint256((char *)params[0].get_str().c_str());
@@ -7788,14 +8031,14 @@ UniValue tokenfillask(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue tokenfillswap(const UniValue& params, bool fHelp)
+UniValue tokenfillswap(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     static uint256 zeroid;
     UniValue result(UniValue::VOBJ); int64_t fillunits; std::string hex; uint256 tokenid,otherid,asktxid;
     if ( fHelp || params.size() != 4 )
         throw runtime_error("tokenfillswap tokenid otherid asktxid fillunits\n");
     if ( ensure_CCrequirements(EVAL_ASSETS) < 0 )
-        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+        throw runtime_error(CC_REQUIREMENTS_MSG);
     const CKeyStore& keystore = *pwalletMain;
     LOCK2(cs_main, pwalletMain->cs_wallet);
     tokenid = Parseuint256((char *)params[0].get_str().c_str());
@@ -7815,7 +8058,7 @@ UniValue tokenfillswap(const UniValue& params, bool fHelp)
     return(result);
 }
 
-UniValue getbalance64(const UniValue& params, bool fHelp)
+UniValue getbalance64(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
     set<CBitcoinAddress> setAddress; vector<COutput> vecOutputs;
     UniValue ret(UniValue::VOBJ); UniValue a(UniValue::VARR),b(UniValue::VARR); CTxDestination address;
@@ -7859,11 +8102,10 @@ UniValue getbalance64(const UniValue& params, bool fHelp)
 
 
 // heir contract functions for coins and tokens
-UniValue heirfund(const UniValue& params, bool fHelp)
+UniValue heirfund(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
 	UniValue result(UniValue::VOBJ);
 	uint256 tokenid = zeroid;
-	int64_t txfee;
 	int64_t amount;
 	int64_t inactivitytime;
 	std::string hex;
@@ -7873,51 +8115,47 @@ UniValue heirfund(const UniValue& params, bool fHelp)
 	if (!EnsureWalletIsAvailable(fHelp))
 	    return NullUniValue;
 
-	if (fHelp || params.size() != 6 && params.size() != 7)
-		throw runtime_error("heirfund txfee funds heirname heirpubkey inactivitytime memo [tokenid]\n");
+	if (fHelp || params.size() != 5 && params.size() != 6)
+		throw runtime_error("heirfund funds heirname heirpubkey inactivitytime memo [tokenid]\n");
 	if (ensure_CCrequirements(EVAL_HEIR) < 0)
-		throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+		throw runtime_error(CC_REQUIREMENTS_MSG);
 
 	const CKeyStore& keystore = *pwalletMain;
 	LOCK2(cs_main, pwalletMain->cs_wallet);
 
-	txfee = atoll(params[0].get_str().c_str());
-	if (txfee < 0) {
-		result.push_back(Pair("result", "error"));
-		result.push_back(Pair("error", "incorrect txfee"));
-		return result;	
-	}
-
-	if(params.size() == 7)	// tokens in satoshis:
-		amount = atoll(params[1].get_str().c_str());
-	else	// coins:
-		amount = atof(params[1].get_str().c_str()) * COIN;
+	if (params.size() == 6)	// tokens in satoshis:
+		amount = atoll(params[0].get_str().c_str());
+    	else { // coins:
+        	amount = 0;   
+        	if (!ParseFixedPoint(params[0].get_str(), 8, &amount))  // using ParseFixedPoint instead atof to avoid small round errors
+            		amount = -1; // set error
+    	}
 	if (amount <= 0) {
 		result.push_back(Pair("result", "error"));
 		result.push_back(Pair("error", "incorrect amount"));
 		return result;
 	}
 
-	name = params[2].get_str();
+	name = params[1].get_str();
 
-	pubkey = ParseHex(params[3].get_str().c_str());
+	pubkey = ParseHex(params[2].get_str().c_str());
 	if (!pubkey2pk(pubkey).IsValid()) {
 		result.push_back(Pair("result", "error"));
 		result.push_back(Pair("error", "incorrect pubkey"));
 		return result;
 	}
 
-	inactivitytime = atoll(params[4].get_str().c_str());
+	inactivitytime = atoll(params[3].get_str().c_str());
 	if (inactivitytime <= 0) {
 		result.push_back(Pair("result", "error"));
 		result.push_back(Pair("error", "incorrect inactivity time"));
 		return result;
 	}
 
-	memo = params[5].get_str();
+	memo = params[4].get_str();
 
-	if (params.size() == 7) {
-		tokenid = Parseuint256((char*)params[6].get_str().c_str());
+	if (params.size() == 6) {
+		tokenid = Parseuint256((char*)params[5].get_str().c_str());
 		if (tokenid == zeroid) {
 			result.push_back(Pair("result", "error"));
 			result.push_back(Pair("error", "incorrect tokenid"));
@@ -7926,18 +8164,17 @@ UniValue heirfund(const UniValue& params, bool fHelp)
 	}
 
 	if( tokenid == zeroid )
-		result = HeirFundCoinCaller(txfee, amount, name, pubkey2pk(pubkey), inactivitytime, memo);
+		result = HeirFundCoinCaller(0, amount, name, pubkey2pk(pubkey), inactivitytime, memo);
 	else
-		result = HeirFundTokenCaller(txfee, amount, name, pubkey2pk(pubkey), inactivitytime, memo, tokenid);
+		result = HeirFundTokenCaller(0, amount, name, pubkey2pk(pubkey), inactivitytime, memo, tokenid);
 
 	return result;
 }
 
-UniValue heiradd(const UniValue& params, bool fHelp)
+UniValue heiradd(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
 	UniValue result; 
 	uint256 fundingtxid;
-	int64_t txfee;
 	int64_t amount;
 	int64_t inactivitytime;
 	std::string hex;
@@ -7947,103 +8184,262 @@ UniValue heiradd(const UniValue& params, bool fHelp)
 	if (!EnsureWalletIsAvailable(fHelp))
 	    return NullUniValue;
 
-	if (fHelp || params.size() != 3)
-		throw runtime_error("heiradd txfee funds fundingtxid\n");
+	if (fHelp || params.size() != 2)
+		throw runtime_error("heiradd funds fundingtxid\n");
 	if (ensure_CCrequirements(EVAL_HEIR) < 0)
-		throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+		throw runtime_error(CC_REQUIREMENTS_MSG);
 
 	const CKeyStore& keystore = *pwalletMain;
 	LOCK2(cs_main, pwalletMain->cs_wallet);
 
-	txfee = atoll(params[0].get_str().c_str());
-	if (txfee < 0) {
-		result.push_back(Pair("result", "error"));
-		result.push_back(Pair("error", "incorrect txfee"));
-		return result;
-	}
-
-	fundingtxid = Parseuint256((char*)params[2].get_str().c_str());
+	std::string strAmount = params[0].get_str();
+	fundingtxid = Parseuint256((char*)params[1].get_str().c_str());
 
-	result = HeirAddCaller(fundingtxid, txfee, params[1].get_str());
+	result = HeirAddCaller(fundingtxid, 0, strAmount);
 	return result;
 }
 
-UniValue heirclaim(const UniValue& params, bool fHelp)
+UniValue heirclaim(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
-	UniValue result;
-	uint256 fundingtxid;
-	int64_t txfee;
-	int64_t inactivitytime;
-	std::string hex;
-	std::vector<unsigned char> pubkey;
-	std::string name;
+	UniValue result; uint256 fundingtxid;
 
 	if (!EnsureWalletIsAvailable(fHelp))
 	    return NullUniValue;
-
-	if (fHelp || params.size() != 3)
-		throw runtime_error("heirclaim txfee funds fundingtxid\n");
+	if (fHelp || params.size() != 2)
+		throw runtime_error("heirclaim funds fundingtxid\n");
 	if (ensure_CCrequirements(EVAL_HEIR) < 0)
-		throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+		throw runtime_error(CC_REQUIREMENTS_MSG);
 
 	const CKeyStore& keystore = *pwalletMain;
 	LOCK2(cs_main, pwalletMain->cs_wallet);
 
-	txfee = atoll(params[0].get_str().c_str());
-	if (txfee < 0) {
-		result.push_back(Pair("result", "error"));
-		result.push_back(Pair("error", "incorrect txfee"));
-		return result;
-	}
-
-	fundingtxid = Parseuint256((char*)params[2].get_str().c_str());
-
-	result = HeirClaimCaller(fundingtxid, txfee, params[1].get_str());
+    	std::string strAmount = params[0].get_str();
+	fundingtxid = Parseuint256((char*)params[1].get_str().c_str());
+	result = HeirClaimCaller(fundingtxid, 0, strAmount);
 	return result;
 }
 
-UniValue heirinfo(const UniValue& params, bool fHelp)
+UniValue heirinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
 	uint256 fundingtxid;
 	if (fHelp || params.size() != 1) 
 		throw runtime_error("heirinfo fundingtxid\n");
-
-	//    if ( ensure_CCrequirements(EVAL_HEIR) < 0 )
-	//        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
-
+    if ( ensure_CCrequirements(EVAL_HEIR) < 0 )
+	    throw runtime_error(CC_REQUIREMENTS_MSG);
 	fundingtxid = Parseuint256((char*)params[0].get_str().c_str());
 	return (HeirInfo(fundingtxid));
 }
 
-UniValue heirlist(const UniValue& params, bool fHelp)
+UniValue heirlist(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
 	if (fHelp || params.size() != 0) 
 		throw runtime_error("heirlist\n");
+    if ( ensure_CCrequirements(EVAL_HEIR) < 0 )
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+	return (HeirList());
+}
 
-	//    if ( ensure_CCrequirements(EVAL_HEIR) < 0 )
-	//        throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
+UniValue pegscreate(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    UniValue result(UniValue::VOBJ); int32_t i; std::vector<uint256> txids;
+    uint8_t N; uint256 txid; int64_t amount;
 
-	return (HeirList());
+    if ( fHelp || params.size()<3)
+        throw runtime_error("pegscreate amount N bindtxid1 [bindtxid2 ...]\n");
+    if ( ensure_CCrequirements(EVAL_PEGS) < 0 )
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+    const CKeyStore& keystore = *pwalletMain;
+    Lock2NSPV(mypk);
+    amount = atof((char *)params[0].get_str().c_str()) * COIN + 0.00000000499999;
+    N = atoi((char *)params[1].get_str().c_str());
+    if ( params.size() < N+1 )
+    {
+        Unlock2NSPV(mypk);
+        throw runtime_error("not enough parameters for N pegscreate\n");
+    }
+    for (i=0; i<N; i++)
+    {       
+        txid = Parseuint256(params[i+2].get_str().c_str());
+        txids.push_back(txid);
+    }
+    result = PegsCreate(mypk,0,amount,txids);
+    if ( result[JSON_HEXTX].getValStr().size() > 0  )
+    {
+        result.push_back(Pair("result", "success"));
+    }
+    Unlock2NSPV(mypk);
+    return(result);
 }
 
+UniValue pegsfund(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    UniValue result(UniValue::VOBJ); uint256 pegstxid,tokenid; int64_t amount;
 
 
+    if ( fHelp || params.size()!=3)
+        throw runtime_error("pegsfund pegstxid tokenid amount\n");
+    if ( ensure_CCrequirements(EVAL_PEGS) < 0 )
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+    const CKeyStore& keystore = *pwalletMain;
+    Lock2NSPV(mypk);
+    pegstxid = Parseuint256(params[0].get_str().c_str());
+    tokenid = Parseuint256(params[1].get_str().c_str());
+    amount = atof((char *)params[2].get_str().c_str()) * COIN + 0.00000000499999;
+    result = PegsFund(mypk,0,pegstxid,tokenid,amount);
+    if ( result[JSON_HEXTX].getValStr().size() > 0  )
+    {
+        result.push_back(Pair("result", "success"));
+    }
+    Unlock2NSPV(mypk);
+    return(result);
+}
 
-extern UniValue dumpprivkey(const UniValue& params, bool fHelp); // in rpcdump.cpp
-extern UniValue convertpassphrase(const UniValue& params, bool fHelp);
-extern UniValue importprivkey(const UniValue& params, bool fHelp);
-extern UniValue importaddress(const UniValue& params, bool fHelp);
-extern UniValue dumpwallet(const UniValue& params, bool fHelp);
-extern UniValue importwallet(const UniValue& params, bool fHelp);
-extern UniValue z_exportkey(const UniValue& params, bool fHelp);
-extern UniValue z_importkey(const UniValue& params, bool fHelp);
-extern UniValue z_exportviewingkey(const UniValue& params, bool fHelp);
-extern UniValue z_importviewingkey(const UniValue& params, bool fHelp);
-extern UniValue z_exportwallet(const UniValue& params, bool fHelp);
-extern UniValue z_importwallet(const UniValue& params, bool fHelp);
+UniValue pegsget(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    UniValue result(UniValue::VOBJ); uint256 pegstxid,tokenid; int64_t amount;
 
-extern UniValue z_getpaymentdisclosure(const UniValue& params, bool fHelp); // in rpcdisclosure.cpp
-extern UniValue z_validatepaymentdisclosure(const UniValue &params, bool fHelp);
+    if ( fHelp || params.size()!=3)
+        throw runtime_error("pegsget pegstxid tokenid amount\n");
+    if ( ensure_CCrequirements(EVAL_PEGS) < 0 )
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+    Lock2NSPV(mypk);
+    pegstxid = Parseuint256(params[0].get_str().c_str());
+    tokenid = Parseuint256(params[1].get_str().c_str());
+    amount = atof((char *)params[2].get_str().c_str()) * COIN + 0.00000000499999;
+    result = PegsGet(mypk,0,pegstxid,tokenid,amount);
+    if ( result[JSON_HEXTX].getValStr().size() > 0  )
+    {
+        result.push_back(Pair("result", "success"));
+    }
+    Unlock2NSPV(mypk);
+    return(result);
+}
+
+UniValue pegsredeem(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    UniValue result(UniValue::VOBJ); uint256 pegstxid,tokenid; int64_t amount;
+
+    if ( fHelp || params.size()!=2)
+        throw runtime_error("pegsredeem pegstxid tokenid\n");
+    if ( ensure_CCrequirements(EVAL_PEGS) < 0 )
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+    Lock2NSPV(mypk);
+    pegstxid = Parseuint256(params[0].get_str().c_str());
+    tokenid = Parseuint256(params[1].get_str().c_str());
+    result = PegsRedeem(mypk,0,pegstxid,tokenid);
+    if ( result[JSON_HEXTX].getValStr().size() > 0  )
+    {
+        result.push_back(Pair("result", "success"));
+    }
+    Unlock2NSPV(mypk);
+    return(result);
+}
+
+UniValue pegsliquidate(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    UniValue result(UniValue::VOBJ); uint256 pegstxid,tokenid,accounttxid;
+
+    if ( fHelp || params.size()!=3)
+        throw runtime_error("pegsliquidate pegstxid tokenid accounttxid\n");
+    if ( ensure_CCrequirements(EVAL_PEGS) < 0 )
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+    Lock2NSPV(mypk);
+    pegstxid = Parseuint256(params[0].get_str().c_str());
+    tokenid = Parseuint256(params[1].get_str().c_str());
+    accounttxid = Parseuint256(params[2].get_str().c_str());
+    result = PegsLiquidate(mypk,0,pegstxid,tokenid,accounttxid);
+    if ( result[JSON_HEXTX].getValStr().size() > 0  )
+    {
+        result.push_back(Pair("result", "success"));
+    }
+    Unlock2NSPV(mypk);
+    return(result);
+}
+
+UniValue pegsexchange(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    UniValue result(UniValue::VOBJ); uint256 pegstxid,tokenid,accounttxid; int64_t amount;
+
+    if ( fHelp || params.size()!=3)
+        throw runtime_error("pegsexchange pegstxid tokenid amount\n");
+    if ( ensure_CCrequirements(EVAL_PEGS) < 0 )
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+    Lock2NSPV(mypk);
+    pegstxid = Parseuint256(params[0].get_str().c_str());
+    tokenid = Parseuint256(params[1].get_str().c_str());
+    amount = atof((char *)params[2].get_str().c_str()) * COIN + 0.00000000499999;
+    result = PegsExchange(mypk,0,pegstxid,tokenid,amount);
+    if ( result[JSON_HEXTX].getValStr().size() > 0  )
+    {
+        result.push_back(Pair("result", "success"));
+    }
+    Unlock2NSPV(mypk);
+    return(result);
+}
+
+UniValue pegsaccounthistory(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    uint256 pegstxid;
+
+    if ( fHelp || params.size() != 1 )
+        throw runtime_error("pegsaccounthistory pegstxid\n");
+    if ( ensure_CCrequirements(EVAL_GATEWAYS) < 0 )
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+    pegstxid = Parseuint256((char *)params[0].get_str().c_str());
+    return(PegsAccountHistory(mypk,pegstxid));
+}
+
+UniValue pegsaccountinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    uint256 pegstxid;
+
+    if ( fHelp || params.size() != 1 )
+        throw runtime_error("pegsaccountinfo pegstxid\n");
+    if ( ensure_CCrequirements(EVAL_GATEWAYS) < 0 )
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+    pegstxid = Parseuint256((char *)params[0].get_str().c_str());
+    return(PegsAccountInfo(mypk,pegstxid));
+}
+
+UniValue pegsworstaccounts(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    uint256 pegstxid;
+
+    if ( fHelp || params.size() != 1 )
+        throw runtime_error("pegsworstaccounts pegstxid\n");
+    if ( ensure_CCrequirements(EVAL_GATEWAYS) < 0 )
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+    pegstxid = Parseuint256((char *)params[0].get_str().c_str());
+    return(PegsWorstAccounts(pegstxid));
+}
+
+UniValue pegsinfo(const UniValue& params, bool fHelp, const CPubKey& mypk)
+{
+    uint256 pegstxid;
+
+    if ( fHelp || params.size() != 1 )
+        throw runtime_error("pegsinfo pegstxid\n");
+    if ( ensure_CCrequirements(EVAL_GATEWAYS) < 0 )
+        throw runtime_error(CC_REQUIREMENTS_MSG);
+    pegstxid = Parseuint256((char *)params[0].get_str().c_str());
+    return(PegsInfo(pegstxid));
+}
+
+extern UniValue dumpprivkey(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcdump.cpp
+extern UniValue convertpassphrase(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue importprivkey(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue importaddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue dumpwallet(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue importwallet(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue z_exportkey(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue z_importkey(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue z_exportviewingkey(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue z_importviewingkey(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue z_exportwallet(const UniValue& params, bool fHelp, const CPubKey& mypk);
+extern UniValue z_importwallet(const UniValue& params, bool fHelp, const CPubKey& mypk);
+
+extern UniValue z_getpaymentdisclosure(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcdisclosure.cpp
+extern UniValue z_validatepaymentdisclosure(const UniValue& params, bool fHelp, const CPubKey& mypk);
 
 static const CRPCCommand commands[] =
 { //  category              name                        actor (function)           okSafeMode
@@ -8113,6 +8509,7 @@ static const CRPCCommand commands[] =
     { "wallet",             "z_importviewingkey",       &z_importviewingkey,       true  },
     { "wallet",             "z_exportwallet",           &z_exportwallet,           true  },
     { "wallet",             "z_importwallet",           &z_importwallet,           true  },
+    { "wallet",             "z_viewtransaction",        &z_viewtransaction,        true  },
     // TODO: rearrange into another category
     { "disclosure",         "z_getpaymentdisclosure",   &z_getpaymentdisclosure,   true  },
     { "disclosure",         "z_validatepaymentdisclosure", &z_validatepaymentdisclosure, true }
@@ -8124,34 +8521,59 @@ void RegisterWalletRPCCommands(CRPCTable &tableRPC)
         tableRPC.appendCommand(commands[vcidx].name, &commands[vcidx]);
 }
 
-UniValue opreturn_burn(const UniValue& params, bool fHelp)
+UniValue opreturn_burn(const UniValue& params, bool fHelp, const CPubKey& mypk)
 {
-    std::vector<uint8_t> vHexStr; CScript opret; int32_t txfee = 10000;
-    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_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_ORACLES);
-	    
+    std::vector<uint8_t> vHexStr; CScript opret; int32_t txfee = 10000;CPubKey myPubkey;
+    if (fHelp || (params.size() < 2) || (params.size() > 4) )
+    {
+        throw runtime_error(
+        "opreturn_burn burn_amount hexstring ( txfee )\n"
+        "\nBurn the specified amount of coins via OP_RETURN. Returns unsigned transaction raw hex that must then be signed via signrawtransaction and broadcast via sendrawtransaction rpc\n"
+        "\nArguments:\n"
+        "1. \"burn_amount\"       (numeric, required) Amount of coins to burn.\n"
+        "2. \"hexstring\"         (string, required) Hex string to include in OP_RETURN data.\n"
+        "3. \"txfee\"             (numeric, optional, default=0.0001) Transaction fee.\n"
+        "\nResult:\n"
+        "  {\n"
+        "    \"hex\" : \"hexstring\",     (string) raw hex of transaction \n"
+        "  }\n"
+        "\nExamples:\n"
+        "\nBurn 10 coins with OP_RETURN data \"deadbeef\"\n"
+        + HelpExampleCli("opreturn_burn", "\"10\" \"deadbeef\"") 
+        + HelpExampleRpc("opreturn_burn", "\"10\", \"deadbeef\"") +
+        "\nBurn 10 coins with OP_RETURN data \"deadbeef\" with 0.00005 txfee\n"
+        + HelpExampleCli("opreturn_burn", "\"10\" \"deadbeef\" \"0.00005\"") 
+        + HelpExampleRpc("opreturn_burn", "\"10\", \"deadbeef\", 0.00005")
+      );
+    }
+    UniValue ret(UniValue::VOBJ);
+
 	CAmount nAmount = AmountFromValue(params[0]);
-    if (nAmount <= 10000)
-        throw JSONRPCError(RPC_TYPE_ERROR, "must burn at least 10000 sat");
     vHexStr = ParseHex(params[1].get_str());
     if ( vHexStr.size() == 0 )
         throw JSONRPCError(RPC_TYPE_ERROR, "hexstring is not valid.");
 
-	CPubKey myPubkey = pubkey2pk(Mypubkey());
+    if ( params.size() > 2 )
+        txfee = AmountFromValue(params[2]);
+
+    if (!EnsureWalletIsAvailable(fHelp))
+        throw JSONRPCError(RPC_TYPE_ERROR, "wallet is locked or unavailable.");
+    EnsureWalletIsUnlocked();
+    CReserveKey reservekey(pwalletMain);
+    if (!reservekey.GetReservedKey(myPubkey))
+    {
+        throw JSONRPCError(RPC_TYPE_ERROR, "keypool error.");
+    }
+
 	CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
 
-	int64_t normalInputs = AddNormalinputs(mtx, myPubkey, nAmount, 60);
+	int64_t normalInputs = AddNormalinputs(mtx, myPubkey, nAmount+txfee, 60);
 	if (normalInputs < nAmount)
-		throw runtime_error("not enough normals\n");
+		throw runtime_error("insufficient funds\n");
     
 	opret << OP_RETURN << E_MARSHAL(ss << vHexStr);
     
-    mtx.vout.push_back(CTxOut(txfee,CScript() << ParseHex(HexStr(myPubkey)) << OP_CHECKSIG));
     mtx.vout.push_back(CTxOut(nAmount,opret));
-    ret.push_back(Pair("hex",FinalizeCCTx(0, cp, mtx, myPubkey, txfee, CScript())));
+    ret.push_back(Pair("hex", EncodeHexTx(mtx)));
 	return(ret);
 }
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index 0be7d7ec..14a6d1d0 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -2498,6 +2498,107 @@ void CWalletTx::SetSaplingNoteData(mapSaplingNoteData_t &noteData)
     }
 }
 
+std::pair<SproutNotePlaintext, SproutPaymentAddress> CWalletTx::DecryptSproutNote(
+    JSOutPoint jsop) const
+{
+    LOCK(pwallet->cs_wallet);
+
+    auto nd = this->mapSproutNoteData.at(jsop);
+    SproutPaymentAddress pa = nd.address;
+
+    // Get cached decryptor
+    ZCNoteDecryption decryptor;
+    if (!pwallet->GetNoteDecryptor(pa, decryptor)) {
+        // Note decryptors are created when the wallet is loaded, so it should always exist
+        throw std::runtime_error(strprintf(
+            "Could not find note decryptor for payment address %s",
+            EncodePaymentAddress(pa)));
+    }
+
+    auto hSig = this->vjoinsplit[jsop.js].h_sig(*pzcashParams, this->joinSplitPubKey);
+    try {
+        SproutNotePlaintext plaintext = SproutNotePlaintext::decrypt(
+                decryptor,
+                this->vjoinsplit[jsop.js].ciphertexts[jsop.n],
+                this->vjoinsplit[jsop.js].ephemeralKey,
+                hSig,
+                (unsigned char) jsop.n);
+
+        return std::make_pair(plaintext, pa);
+    } catch (const note_decryption_failed &err) {
+        // Couldn't decrypt with this spending key
+        throw std::runtime_error(strprintf(
+            "Could not decrypt note for payment address %s",
+            EncodePaymentAddress(pa)));
+    } catch (const std::exception &exc) {
+        // Unexpected failure
+        throw std::runtime_error(strprintf(
+            "Error while decrypting note for payment address %s: %s",
+            EncodePaymentAddress(pa), exc.what()));
+    }
+}
+
+boost::optional<std::pair<
+    SaplingNotePlaintext,
+    SaplingPaymentAddress>> CWalletTx::DecryptSaplingNote(SaplingOutPoint op) const
+{
+    // Check whether we can decrypt this SaplingOutPoint
+    if (this->mapSaplingNoteData.count(op) == 0) {
+        return boost::none;
+    }
+
+    auto output = this->vShieldedOutput[op.n];
+    auto nd = this->mapSaplingNoteData.at(op);
+
+    auto maybe_pt = SaplingNotePlaintext::decrypt(
+        output.encCiphertext,
+        nd.ivk,
+        output.ephemeralKey,
+        output.cm);
+    assert(static_cast<bool>(maybe_pt));
+    auto notePt = maybe_pt.get();
+
+    auto maybe_pa = nd.ivk.address(notePt.d);
+    assert(static_cast<bool>(maybe_pa));
+    auto pa = maybe_pa.get();
+
+    return std::make_pair(notePt, pa);
+}
+
+boost::optional<std::pair<
+    SaplingNotePlaintext,
+    SaplingPaymentAddress>> CWalletTx::RecoverSaplingNote(
+        SaplingOutPoint op, std::set<uint256>& ovks) const
+{
+    auto output = this->vShieldedOutput[op.n];
+
+    for (auto ovk : ovks) {
+        auto outPt = SaplingOutgoingPlaintext::decrypt(
+            output.outCiphertext,
+            ovk,
+            output.cv,
+            output.cm,
+            output.ephemeralKey);
+        if (!outPt) {
+            continue;
+        }
+
+        auto maybe_pt = SaplingNotePlaintext::decrypt(
+            output.encCiphertext,
+            output.ephemeralKey,
+            outPt->esk,
+            outPt->pk_d,
+            output.cm);
+        assert(static_cast<bool>(maybe_pt));
+        auto notePt = maybe_pt.get();
+
+        return std::make_pair(notePt, SaplingPaymentAddress(notePt.d, outPt->pk_d));
+    }
+
+    // Couldn't recover with any of the provided OutgoingViewingKeys
+    return boost::none;
+}
+
 int64_t CWalletTx::GetTxTime() const
 {
     int64_t n = nTimeSmart;
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index 372c5ac2..af9c68f0 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -583,6 +583,16 @@ class CWalletTx : public CMerkleTx
     void SetSproutNoteData(mapSproutNoteData_t &noteData);
     void SetSaplingNoteData(mapSaplingNoteData_t &noteData);
 
+    std::pair<libzcash::SproutNotePlaintext, libzcash::SproutPaymentAddress> DecryptSproutNote(
+	JSOutPoint jsop) const;
+    boost::optional<std::pair<
+	libzcash::SaplingNotePlaintext,
+	libzcash::SaplingPaymentAddress>> DecryptSaplingNote(SaplingOutPoint op) const;
+    boost::optional<std::pair<
+	libzcash::SaplingNotePlaintext,
+	libzcash::SaplingPaymentAddress>> RecoverSaplingNote(
+            SaplingOutPoint op, std::set<uint256>& ovks) const;	
+
     //! filter decides which addresses will count towards the debit
     CAmount GetDebit(const isminefilter& filter) const;
     CAmount GetCredit(const isminefilter& filter) const;
diff --git a/src/zcbenchmarks.cpp b/src/zcbenchmarks.cpp
index 9244e280..22663ef1 100644
--- a/src/zcbenchmarks.cpp
+++ b/src/zcbenchmarks.cpp
@@ -438,20 +438,20 @@ double benchmark_connectblock_slow()
     return duration;
 }
 
-extern UniValue getnewaddress(const UniValue& params, bool fHelp); // in rpcwallet.cpp
-extern UniValue sendtoaddress(const UniValue& params, bool fHelp);
+extern UniValue getnewaddress(const UniValue& params, bool fHelp, const CPubKey& mypk); // in rpcwallet.cpp
+extern UniValue sendtoaddress(const UniValue& params, bool fHelp, const CPubKey& mypk);
 
 double benchmark_sendtoaddress(CAmount amount)
 {
     UniValue params(UniValue::VARR);
-    auto addr = getnewaddress(params, false);
+    auto addr = getnewaddress(params, false, CPubKey());
 
     params.push_back(addr);
     params.push_back(ValueFromAmount(amount));
 
     struct timeval tv_start;
     timer_start(tv_start);
-    auto txid = sendtoaddress(params, false);
+    auto txid = sendtoaddress(params, false, CPubKey());
     return timer_stop(tv_start);
 }
 
@@ -468,14 +468,14 @@ double benchmark_loadwallet()
     return res;
 }
 
-extern UniValue listunspent(const UniValue& params, bool fHelp);
+extern UniValue listunspent(const UniValue& params, bool fHelp, const CPubKey& mypk);
 
 double benchmark_listunspent()
 {
     UniValue params(UniValue::VARR);
     struct timeval tv_start;
     timer_start(tv_start);
-    auto unspent = listunspent(params, false);
+    auto unspent = listunspent(params, false, CPubKey());
     return timer_stop(tv_start);
 }