diff --git a/lib/bitcoin_rpc_manager.py b/lib/bitcoin_rpc_manager.py
index 06b6c8e..9977e87 100644
--- a/lib/bitcoin_rpc_manager.py
+++ b/lib/bitcoin_rpc_manager.py
@@ -124,7 +124,6 @@ class BitcoinRPCManager(object):
 	    except:
 		self.next_connection()
 	
-
     def getdifficulty(self):
 	while True:
 	    try:
diff --git a/lib/block_template.py b/lib/block_template.py
index e04ee53..e30bcf9 100644
--- a/lib/block_template.py
+++ b/lib/block_template.py
@@ -19,6 +19,7 @@ class BlockTemplate(halfnode.CBlock):
     coinbase_transaction_class = CoinbaseTransaction
     
     def __init__(self, timestamper, coinbaser, job_id):
+   	print("Hit Block_template.py")
         super(BlockTemplate, self).__init__()
         
         self.job_id = job_id 
@@ -46,10 +47,13 @@ class BlockTemplate(halfnode.CBlock):
         #txhashes = [None] + [ binascii.unhexlify(t['hash']) for t in data['transactions'] ]
         txhashes = [None] + [ util.ser_uint256(int(t['hash'], 16)) for t in data['transactions'] ]
         mt = merkletree.MerkleTree(txhashes)
+	if settings.COINDAEMON_Reward == 'POW':
+           coinbase = self.coinbase_transaction_class(self.timestamper, self.coinbaser, data['coinbasevalue'], data['coinbaseaux']['flags'], data['height'], 
+			settings.COINBASE_EXTRAS)
+	else:
+	    coinbase = self.coinbase_transaction_class(self.timestamper, self.coinbaser, data['coinbasevalue'], data['coinbaseaux']['flags'], data['height'],
+                        settings.COINBASE_EXTRAS, data['curtime'])
 
-        coinbase = self.coinbase_transaction_class(self.timestamper, self.coinbaser, data['coinbasevalue'],
-                        data['coinbaseaux']['flags'], data['height'], settings.COINBASE_EXTRAS)
-        
         self.height = data['height']
         self.nVersion = data['version']
         self.hashPrevBlock = int(data['previousblockhash'], 16)
diff --git a/lib/coinbaser.py b/lib/coinbaser.py
index 97f3c88..932bdf8 100644
--- a/lib/coinbaser.py
+++ b/lib/coinbaser.py
@@ -9,59 +9,71 @@ log = lib.logger.get_logger('coinbaser')
 # TODO: Add on_* hooks in the app
     
 class SimpleCoinbaser(object):
-    '''This very simple coinbaser uses a constant coin address
+    '''This very simple coinbaser uses constant bitcoin address
     for all generated blocks.'''
     
     def __init__(self, bitcoin_rpc, address):
-        # Fire callback when coinbaser is ready
-        self.on_load = defer.Deferred()
-        
+	print("hit the coinbaser")
+	# Fire Callback when the coinbaser is ready
+	self.on_load = defer.Deferred()
+
         self.address = address
-        self.is_valid = False # We need to check if pool can use this address
-        
-        self.bitcoin_rpc = bitcoin_rpc
-        self._validate()
+	self.is_valid = False
+
+	self.bitcoin_rpc = bitcoin_rpc
+	self._validate()
 
     def _validate(self):
-        d = self.bitcoin_rpc.validateaddress(self.address)
-        d.addCallback(self._address_check)
-        d.addErrback(self._failure)
-        
-    def _address_check(self, result):
-        if result['isvalid'] and result['ismine']:
-            self.is_valid = True
-            log.info("Coinbase address '%s' is valid" % self.address)
-            
-            if not self.on_load.called:
-                self.on_load.callback(True)
-	
-	elif result['isvalid'] and settings.ALLOW_NONLOCAL_WALLET == True :
-            self.is_valid = True
-            log.warning("!!! Coinbase address '%s' is valid BUT it is not local" % self.address)
-            
-            if not self.on_load.called:
-                self.on_load.callback(True)
+	d = self.bitcoin_rpc.validateaddress(self.address)
+	if settings.COINDAEMON_Reward == 'POW':
+        	d.addCallback(self._POW_address_check)
+	else:   d.addCallback(self._POS_address_check)
+	d.addErrback(self._failure)
+
+    def _POW_address_check(self, result):
+       	if result['isvalid'] and result['ismine']:
+           self.is_valid = True
+      	   log.info("Coinbase address '%s' is valid" % self.address)
+       
+      	   if not self.on_load.called:
+              	self.on_load.callback(True)
+     
+      	elif result['isvalid'] and settings.ALLOW_NONLOCAL_WALLET == True :
+      	   self.is_valid = True
+      	   log.warning("!!! Coinbase address '%s' is valid BUT it is not local" % self.address)
+     
+       	   if not self.on_load.called:
+              self.on_load.callback(True)
                 
-        else:
-            self.is_valid = False
-            log.error("Coinbase address '%s' is NOT valid!" % self.address)
+      	else:
+      	   self.is_valid = False
+      	   log.error("Coinbase address '%s' is NOT valid!" % self.address)
         
-    def _failure(self, failure):
-        log.error("Cannot validate Bitcoin address '%s'" % self.address)
-        raise
+    def _POS_address_check(self, result):
+	   print(result)
+	   print(result['pubkey'])
+	   self.pubkey = result['pubkey']
+ 	   print("You're PUBKEY is : ", self.pubkey)
+           # Fire callback when coinbaser is ready
+           self.on_load.callback(True)
     
     #def on_new_block(self):
     #    pass
     
     #def on_new_template(self):
     #    pass
+    def _failure(self, failure):
+           log.error("Cannot validate Bitcoin address '%s'" % self.address)
+           raise
     
     def get_script_pubkey(self):
-        if not self.is_valid:
-            # Try again, maybe the coind was down?
-            self._validate()
-            raise Exception("Coinbase address is not validated!")
-        return util.script_to_address(self.address)    
+	if settings.COINDAEMON_Reward == 'POW':
+	   if not self.is_valid:
+		self._validate()
+		raise Exception("Wallet Address is Wrong")
+	   return util.script_to_address(self.address)
+ 	else:
+ 	       return util.script_to_pubkey(self.pubkey)    
                    
     def get_coinbase_data(self):
         return ''
diff --git a/lib/coinbasetx.py b/lib/coinbasetx.py
index 11c7e36..e2d5743 100644
--- a/lib/coinbasetx.py
+++ b/lib/coinbasetx.py
@@ -2,8 +2,9 @@ import binascii
 import halfnode
 import struct
 import util
-
-class CoinbaseTransaction(halfnode.CTransaction):
+import settings
+if settings.COINDAEMON_Reward == 'POW':
+  class CoinbaseTransaction(halfnode.CTransaction):
     '''Construct special transaction used for coinbase tx.
     It also implements quick serialization using pre-cached
     scriptSig template.'''
@@ -46,4 +47,50 @@ class CoinbaseTransaction(halfnode.CTransaction):
             raise Exception("Incorrect extranonce size")
         
         (part1, part2) = self.vin[0]._scriptSig_template
-        self.vin[0].scriptSig = part1 + extranonce + part2
\ No newline at end of file
+        self.vin[0].scriptSig = part1 + extranonce + part2
+else:
+   class CoinbaseTransaction(halfnode.CTransaction):
+    '''Construct special transaction used for coinbase tx.
+    It also implements quick serialization using pre-cached
+    scriptSig template.'''
+    
+    extranonce_type = '>Q'
+    extranonce_placeholder = struct.pack(extranonce_type, int('f000000ff111111f', 16))
+    extranonce_size = struct.calcsize(extranonce_type)
+
+    def __init__(self, timestamper, coinbaser, value, flags, height, data, ntime):
+        super(CoinbaseTransaction, self).__init__()
+        
+        #self.extranonce = 0
+        
+        if len(self.extranonce_placeholder) != self.extranonce_size:
+            raise Exception("Extranonce placeholder don't match expected length!")
+
+        tx_in = halfnode.CTxIn()
+        tx_in.prevout.hash = 0L
+        tx_in.prevout.n = 2**32-1
+        tx_in._scriptSig_template = (
+            util.ser_number(height) + binascii.unhexlify(flags) + util.ser_number(int(timestamper.time())) + \
+            chr(self.extranonce_size),
+            util.ser_string(coinbaser.get_coinbase_data() + data)
+        )
+                
+        tx_in.scriptSig = tx_in._scriptSig_template[0] + self.extranonce_placeholder + tx_in._scriptSig_template[1]
+    
+        tx_out = halfnode.CTxOut()
+        tx_out.nValue = value
+        tx_out.scriptPubKey = coinbaser.get_script_pubkey()
+       
+	self.nTime = ntime 
+        self.vin.append(tx_in)
+        self.vout.append(tx_out)
+        
+        # Two parts of serialized coinbase, just put part1 + extranonce + part2 to have final serialized tx
+        self._serialized = super(CoinbaseTransaction, self).serialize().split(self.extranonce_placeholder)
+
+    def set_extranonce(self, extranonce):
+        if len(extranonce) != self.extranonce_size:
+            raise Exception("Incorrect extranonce size")
+        
+        (part1, part2) = self.vin[0]._scriptSig_template
+        self.vin[0].scriptSig = part1 + extranonce + part2
diff --git a/lib/halfnode.py b/lib/halfnode.py
index 576ea8b..b03a6f5 100644
--- a/lib/halfnode.py
+++ b/lib/halfnode.py
@@ -138,25 +138,49 @@ class CTxOut(object):
 
 class CTransaction(object):
     def __init__(self):
-        self.nVersion = 1
-        self.vin = []
-        self.vout = []
-        self.nLockTime = 0
-        self.sha256 = None
+	if settings.COINDAEMON_Reward == 'POW':
+        	self.nVersion = 1
+        	self.vin = []
+        	self.vout = []
+        	self.nLockTime = 0
+        	self.sha256 = None
+	else: 
+		self.nVersion = 1
+ 		self.nTime = 0
+    		self.vin = []
+         	self.vout = []
+          	self.nLockTime = 0
+          	self.sha256 = None
     def deserialize(self, f):
-        self.nVersion = struct.unpack("<i", f.read(4))[0]
-        self.vin = deser_vector(f, CTxIn)
-        self.vout = deser_vector(f, CTxOut)
-        self.nLockTime = struct.unpack("<I", f.read(4))[0]
-        self.sha256 = None
+        if settings.COINDAEMON_Reward == 'POW':
+	        self.nVersion = struct.unpack("<i", f.read(4))[0]
+	        self.vin = deser_vector(f, CTxIn)
+	        self.vout = deser_vector(f, CTxOut)
+	        self.nLockTime = struct.unpack("<I", f.read(4))[0]
+	        self.sha256 = None
+    	else:
+		self.nVersion = struct.unpack("<i", f.read(4))[0]
+	        self.nTime = struct.unpack("<i", f.read(4))[0]
+	        self.vin = deser_vector(f, CTxIn)
+	        self.vout = deser_vector(f, CTxOut)
+	        self.nLockTime = struct.unpack("<I", f.read(4))[0]
+	        self.sha256 = None
     def serialize(self):
-        r = ""
-        r += struct.pack("<i", self.nVersion)
-        r += ser_vector(self.vin)
-        r += ser_vector(self.vout)
-        r += struct.pack("<I", self.nLockTime)
-        return r
-    
+        if settings.COINDAEMON_Reward == 'POW':
+		r = ""
+	        r += struct.pack("<i", self.nVersion)
+	        r += ser_vector(self.vin)
+	        r += ser_vector(self.vout)
+	        r += struct.pack("<I", self.nLockTime)
+        	return r
+	else:
+		r = ""
+	        r += struct.pack("<i", self.nVersion)
+	        r += struct.pack("<i", self.nTime)
+	        r += ser_vector(self.vin)
+	        r += ser_vector(self.vout)
+	        r += struct.pack("<I", self.nLockTime)
+	        return r    
     def calc_sha256(self):
         if self.sha256 is None:
             self.sha256 = uint256_from_str(SHA256.new(SHA256.new(self.serialize()).digest()).digest())
@@ -184,6 +208,10 @@ class CBlock(object):
 	if settings.COINDAEMON_ALGO == 'scrypt':
 	        self.scrypt = None
 	else: pass
+	if settings.COINDAEMON_Reward == 'POS':
+		self.signature = b""
+	else: pass
+
     def deserialize(self, f):
         self.nVersion = struct.unpack("<i", f.read(4))[0]
         self.hashPrevBlock = deser_uint256(f)
@@ -192,6 +220,9 @@ class CBlock(object):
         self.nBits = struct.unpack("<I", f.read(4))[0]
         self.nNonce = struct.unpack("<I", f.read(4))[0]
         self.vtx = deser_vector(f, CTransaction)
+	if settings.COINDAEMON_Reward == 'POS':
+		self.signature = deser_string(f)
+	else: pass
     def serialize(self):
         r = []
         r.append(struct.pack("<i", self.nVersion))
@@ -201,6 +232,9 @@ class CBlock(object):
         r.append(struct.pack("<I", self.nBits))
         r.append(struct.pack("<I", self.nNonce))
         r.append(ser_vector(self.vtx))
+	if settings.COINDAEMON_Reward == 'POS':
+		r.append(ser_string(self.signature))
+	else: pass
         return ''.join(r)
 
     if settings.COINDAEMON_ALGO == 'scrypt':
diff --git a/lib/template_registry.py b/lib/template_registry.py
index 34f6d7c..3d00660 100644
--- a/lib/template_registry.py
+++ b/lib/template_registry.py
@@ -131,7 +131,8 @@ class TemplateRegistry(object):
         start = Interfaces.timestamper.time()
                 
         template = self.block_template_class(Interfaces.timestamper, self.coinbaser, JobIdGenerator.get_new_id())
-        template.fill_from_rpc(data)
+	print("hit template registry")
+	log.info(template.fill_from_rpc(data))
         self.add_template(template,data['height'])
 
         log.info("Update finished, %.03f sec, %d txes" % \
diff --git a/lib/template_registry.py.save b/lib/template_registry.py.save
new file mode 100644
index 0000000..0a4cac7
--- /dev/null
+++ b/lib/template_registry.py.save
@@ -0,0 +1,288 @@
+import weakref
+import binascii
+import util
+import StringIO
+import settings
+if settings.COINDAEMON_ALGO == 'scrypt':
+	import ltc_scrypt
+else: pass
+from twisted.internet import defer
+from lib.exceptions import SubmitException
+
+import lib.logger
+log = lib.logger.get_logger('template_registry')
+
+from mining.interfaces import Interfaces
+from extranonce_counter import ExtranonceCounter
+import lib.settings as settings
+
+
+class JobIdGenerator(object):
+    '''Generate pseudo-unique job_id. It does not need to be absolutely unique,
+    because pool sends "clean_jobs" flag to clients and they should drop all previous jobs.'''
+    counter = 0
+    
+    @classmethod
+    def get_new_id(cls):
+        cls.counter += 1
+        if cls.counter % 0xffff == 0:
+            cls.counter = 1
+        return "%x" % cls.counter
+                
+class TemplateRegistry(object):
+    '''Implements the main logic of the pool. Keep track
+    on valid block templates, provide internal interface for stratum
+    service and implements block validation and submits.'''
+    
+    def __init__(self, block_template_class, coinbaser, bitcoin_rpc, instance_id,
+                 on_template_callback, on_block_callback):
+        self.prevhashes = {}
+        self.jobs = weakref.WeakValueDictionary()
+        
+        self.extranonce_counter = ExtranonceCounter(instance_id)
+        self.extranonce2_size = block_template_class.coinbase_transaction_class.extranonce_size \
+                - self.extranonce_counter.get_size()
+                 
+        self.coinbaser = coinbaser
+        self.block_template_class = block_template_class
+        self.bitcoin_rpc = bitcoin_rpc
+        self.on_block_callback = on_block_callback
+        self.on_template_callback = on_template_callback
+        
+        self.last_block = None
+        self.update_in_progress = False
+        self.last_update = None
+        
+        # Create first block template on startup
+        self.update_block()
+        
+    def get_new_extranonce1(self):
+        '''Generates unique extranonce1 (e.g. for newly
+        subscribed connection.'''
+        return self.extranonce_counter.get_new_bin()
+    
+    def get_last_broadcast_args(self):
+        '''Returns arguments for mining.notify
+        from last known template.'''
+        return self.last_block.broadcast_args
+        
+    def add_template(self, block,block_height):
+        '''Adds new template to the registry.
+        It also clean up templates which should
+        not be used anymore.'''
+        
+        prevhash = block.prevhash_hex
+
+        if prevhash in self.prevhashes.keys():
+            new_block = False
+        else:
+            new_block = True
+            self.prevhashes[prevhash] = []
+               
+        # Blocks sorted by prevhash, so it's easy to drop
+        # them on blockchain update
+        self.prevhashes[prevhash].append(block)
+        
+        # Weak reference for fast lookup using job_id
+        self.jobs[block.job_id] = block
+        
+        # Use this template for every new request
+        self.last_block = block
+        
+        # Drop templates of obsolete blocks
+        for ph in self.prevhashes.keys():
+            if ph != prevhash:
+                del self.prevhashes[ph]
+                
+        log.info("New template for %s" % prevhash)
+
+        if new_block:
+            # Tell the system about new block
+            # It is mostly important for share manager
+            self.on_block_callback(prevhash, block_height)
+
+        # Everything is ready, let's broadcast jobs!
+        self.on_template_callback(new_block)
+        
+
+        #from twisted.internet import reactor
+        #reactor.callLater(10, self.on_block_callback, new_block) 
+              
+    def update_block(self):
+        '''Registry calls the getblocktemplate() RPC
+        and build new block template.'''
+        
+        if self.update_in_progress:
+            # Block has been already detected
+            return
+        
+        self.update_in_progress = True
+        self.last_update = Interfaces.timestamper.time()
+        
+        d = self.bitcoin_rpc.getblocktemplate()
+        d.addCallback(self._update_block)
+        d.addErrback(self._update_block_failed)
+        
+    def _update_block_failed(self, failure):
+        log.error(str(failure))
+        self.update_in_progress = False
+        
+    def _update_block(self, data):
+        start = Interfaces.timestamper.time()
+                
+        template = self.block_template_class(Interfaces.timestamper, self.coinbaser, JobIdGenerator.get_new_id())
+	print("hit template registry")
+ template.fill_from_rpc(data)	template.fill_from_rpc(data)
+        self.add_template(template,data['height'])
+
+        log.info("Update finished, %.03f sec, %d txes" % \
+                    (Interfaces.timestamper.time() - start, len(template.vtx)))
+        
+        self.update_in_progress = False        
+        return data
+    
+    def diff_to_target(self, difficulty):
+        '''Converts difficulty to target'''
+	if settings.COINDAEMON_ALGO == 'scrypt':
+	       	diff1 = 0x0000ffff00000000000000000000000000000000000000000000000000000000
+        else:   diff1 = 0x00000000ffff0000000000000000000000000000000000000000000000000000
+	return diff1 / difficulty
+    
+    def get_job(self, job_id):
+        '''For given job_id returns BlockTemplate instance or None'''
+        try:
+            j = self.jobs[job_id]
+        except:
+            log.info("Job id '%s' not found" % job_id)
+            return None
+        
+        # Now we have to check if job is still valid.
+        # Unfortunately weak references are not bulletproof and
+        # old reference can be found until next run of garbage collector.
+        if j.prevhash_hex not in self.prevhashes:
+            log.info("Prevhash of job '%s' is unknown" % job_id)
+            return None
+        
+        if j not in self.prevhashes[j.prevhash_hex]:
+            log.info("Job %s is unknown" % job_id)
+            return None
+        
+        return j
+        
+    def submit_share(self, job_id, worker_name, session, extranonce1_bin, extranonce2, ntime, nonce,
+                     difficulty):
+        '''Check parameters and finalize block template. If it leads
+           to valid block candidate, asynchronously submits the block
+           back to the bitcoin network.
+        
+            - extranonce1_bin is binary. No checks performed, it should be from session data
+            - job_id, extranonce2, ntime, nonce - in hex form sent by the client
+            - difficulty - decimal number from session, again no checks performed
+            - submitblock_callback - reference to method which receive result of submitblock()
+        '''
+        
+        # Check if extranonce2 looks correctly. extranonce2 is in hex form...
+        if len(extranonce2) != self.extranonce2_size * 2:
+            raise SubmitException("Incorrect size of extranonce2. Expected %d chars" % (self.extranonce2_size*2))
+        
+        # Check for job
+        job = self.get_job(job_id)
+        if job == None:
+            raise SubmitException("Job '%s' not found" % job_id)
+                
+        # Check if ntime looks correct
+        if len(ntime) != 8:
+            raise SubmitException("Incorrect size of ntime. Expected 8 chars")
+
+        if not job.check_ntime(int(ntime, 16)):
+            raise SubmitException("Ntime out of range")
+        
+        # Check nonce        
+        if len(nonce) != 8:
+            raise SubmitException("Incorrect size of nonce. Expected 8 chars")
+        
+        # Check for duplicated submit
+        if not job.register_submit(extranonce1_bin, extranonce2, ntime, nonce):
+            log.info("Duplicate from %s, (%s %s %s %s)" % \
+                    (worker_name, binascii.hexlify(extranonce1_bin), extranonce2, ntime, nonce))
+            raise SubmitException("Duplicate share")
+        
+        # Now let's do the hard work!
+        # ---------------------------
+        
+        # 0. Some sugar
+        extranonce2_bin = binascii.unhexlify(extranonce2)
+        ntime_bin = binascii.unhexlify(ntime)
+        nonce_bin = binascii.unhexlify(nonce)
+                
+        # 1. Build coinbase
+        coinbase_bin = job.serialize_coinbase(extranonce1_bin, extranonce2_bin)
+        coinbase_hash = util.doublesha(coinbase_bin)
+        
+        # 2. Calculate merkle root
+        merkle_root_bin = job.merkletree.withFirst(coinbase_hash)
+        merkle_root_int = util.uint256_from_str(merkle_root_bin)
+                
+        # 3. Serialize header with given merkle, ntime and nonce
+        header_bin = job.serialize_header(merkle_root_int, ntime_bin, nonce_bin)
+    
+        # 4. Reverse header and compare it with target of the user
+	if settings.COINDAEMON_ALGO == 'scrypt':
+		hash_bin = ltc_scrypt.getPoWHash(''.join([ header_bin[i*4:i*4+4][::-1] for i in range(0, 20) ]))
+        else: 	hash_bin = util.doublesha(''.join([ header_bin[i*4:i*4+4][::-1] for i in range(0, 20) ]))
+        hash_int = util.uint256_from_str(hash_bin)
+        scrypt_hash_hex = "%064x" % hash_int
+        header_hex = binascii.hexlify(header_bin)
+	if settings.COINDAEMON_ALGO == 'scrypt':
+	      	header_hex = header_hex+"000000800000000000000000000000000000000000000000000000000000000000000000000000000000000080020000"
+        else: pass        
+                 
+        target_user = self.diff_to_target(difficulty)        
+        if hash_int > target_user and \
+		( 'prev_jobid' not in session or session['prev_jobid'] < job_id \
+		or 'prev_diff' not in session or hash_int > self.diff_to_target(session['prev_diff']) ):
+            raise SubmitException("Share is above target")
+
+        # Mostly for debugging purposes
+        target_info = self.diff_to_target(100000)
+        if hash_int <= target_info:
+            log.info("Yay, share with diff above 100000")
+
+        # Algebra tells us the diff_to_target is the same as hash_to_diff
+        share_diff = int(self.diff_to_target(hash_int))
+
+
+   # 5. Compare hash with target of the network        
+        if hash_int <= job.target:
+            # Yay! It is block candidate! 
+            log.info("We found a block candidate! %s" % scrypt_hash_hex)
+
+            # Reverse the header and get the potential block hash (for scrypt only) 
+            block_hash_bin = util.doublesha(''.join([ header_bin[i*4:i*4+4][::-1] for i in range(0, 20) ]))
+            block_hash_hex = block_hash_bin[::-1].encode('hex_codec')
+           
+            # 6. Finalize and serialize block object 
+            job.finalize(merkle_root_int, extranonce1_bin, extranonce2_bin, int(ntime, 16), int(nonce, 16))
+            
+            if not job.is_valid():
+                # Should not happen
+                log.error("Final job validation failed!")
+                            
+            # 7. Submit block to the network
+            serialized = binascii.hexlify(job.serialize())
+            on_submit = self.bitcoin_rpc.submitblock(serialized, block_hash_hex)
+            if on_submit:
+                self.update_block()
+
+            if settings.SOLUTION_BLOCK_HASH:
+                return (header_hex, block_hash_hex, share_diff, on_submit)
+            else:
+                return (header_hex, scrypt_hash_hex, share_diff, on_submit)
+        
+        if settings.SOLUTION_BLOCK_HASH:
+        # Reverse the header and get the potential block hash (for scrypt only) only do this if we want to send in the block hash to the shares table
+            block_hash_bin = util.doublesha(''.join([ header_bin[i*4:i*4+4][::-1] for i in range(0, 20) ]))
+            block_hash_hex = block_hash_bin[::-1].encode('hex_codec')
+            return (header_hex, block_hash_hex, share_diff, None)
+        else:
+            return (header_hex, scrypt_hash_hex, share_diff, None)
diff --git a/lib/util.py b/lib/util.py
index 050876c..1b41659 100644
--- a/lib/util.py
+++ b/lib/util.py
@@ -3,6 +3,8 @@
 import struct
 import StringIO
 import binascii
+import settings
+import bitcoin_rpc
 from hashlib import sha256
 
 def deser_string(f):
@@ -171,7 +173,7 @@ def address_to_pubkeyhash(addr):
         addr = b58decode(addr, 25)
     except:
         return None
-    
+	    
     if addr is None:
         return None
     
@@ -209,9 +211,15 @@ def ser_number(n):
     s.append(n)
     return bytes(s)
 
-def script_to_address(addr):
-    d = address_to_pubkeyhash(addr)
-    if not d:
-        raise ValueError('invalid address')
-    (ver, pubkeyhash) = d
-    return b'\x76\xa9\x14' + pubkeyhash + b'\x88\xac'
+if settings.COINDAEMON_Reward == 'POW':
+   def script_to_address(addr):
+      d = address_to_pubkeyhash(addr)
+      if not d:
+         raise ValueError('invalid address')
+      (ver, pubkeyhash) = d
+      return b'\x76\xa9\x14' + pubkeyhash + b'\x88\xac'
+else:
+   def script_to_pubkey(key):
+      if len(key) == 66: key = binascii.unhexlify(key)
+      if len(key) != 33: raise Exception('invalid pubkey passed to script_to_pubkey')
+      return b'\x21' + key + b'\xac'
diff --git a/mining/basic_share_limiter.py b/mining/basic_share_limiter.py
index adc04c2..73450c2 100644
--- a/mining/basic_share_limiter.py
+++ b/mining/basic_share_limiter.py
@@ -125,7 +125,7 @@ class BasicShareLimiter(object):
                 ddiff = 1
             # Don't go above LITECOIN or VDIFF_MAX_TARGET
             self.update_litecoin_difficulty()
-            if settings.USE_LITECOIN_DIFF:
+            if settings.USE_COINDAEMON_DIFF:
                 diff_max = min([settings.VDIFF_MAX_TARGET, self.litecoin_diff])
             else:
                 diff_max = settings.VDIFF_MAX_TARGET