Update flo-data text when for mined tx

user nonexistance error

.gitignore

@@ -2,3 +2,4 @@
 conf/config.py
 *.log
 LOG
+*.bak

.travis.yml

@@ -0,0 +1,9 @@
+language: python
+python:
+  - "2.6"
+  - "2.7"
+  - "3.2"
+  - "3.3"
+# command to install dependencies
+install:
+  - "pip install -r requirements.txt"

README.md

@@ -1,5 +1,4 @@
-[ ![Codeship Status for ahmedbodi/php-mpos](https://www.codeship.io/projects/b3003a70-61a3-0131-231e-26f75a0c690d/status?branch=master)](https://www.codeship.io/projects/12274)
-#Description
+# Description
 Stratum-mining is a pooled mining protocol. It is a replacement for *getwork* based pooling servers by allowing clients to generate work. The stratum protocol is described [here](http://mining.bitcoin.cz/stratum-mining) in full detail.
 
 This is a implementation of stratum-mining for scrypt based coins. It is compatible with *MPOS* as it complies with the standards of *pushpool*. The end goal is to build on these standards to come up with a more stable solution.
@@ -8,7 +7,7 @@ The goal is to make a reliable stratum mining server for a wide range of coins u
 
 **NOTE:** This fork is still in development. Many features may be broken. Please report any broken features or issues.
 
-#Features
+# Features
 
 * Stratum Mining Pool 
 * Solved Block Confirmation
@@ -24,25 +23,14 @@ The goal is to make a reliable stratum mining server for a wide range of coins u
 * Proof Of Work and Proof of Stake Coin Support
 * Transaction Messaging Support
 
-#Donations 
-* BTC:  18Xg4qP6RUvpeajanKPt5PDvvcqvU2pP6d
-* BTE:  8UJLskr8eDYATvYzmaCBw3vbRmeNweT3rW
-* DGC:  DSBb5KmGWYKMJjxk3rETtvpk9sPqgCCYAw
-* LTC:  Lg4kXMqPsmMHrGr81LLe8oHpbsMiWiuMSB
-* WDC:  WeVFgZQsKSKXGak7NJPp9SrcUexghzTPGJ
-* Doge: DLtBRYtNCzfiZfcpUeEr8KPvy5k1aR7jca
-* SRC:  sMP2wHN5H2ik7FQDPjhSzFZUWux75BYZGe
-* ARG:  AQvXPWVqGzcpH2j2XSRG7X5R9nA3y9D9aQ
-* Cryptsy Trade Key: ec13d183e304326ebd41258d6ae7188e303866fe
 
-
-#Requirements
+# Requirements
 *stratum-mining* is built in python. I have been testing it with 2.7.3, but it should work with other versions. The requirements for running the software are below.
 * Python 2.7+
 * python-twisted
 * stratum
 * MySQL Server 
-* SHA256 or Scrypt CoinDaemon
+* CoinD's
 
 Other coins have been known to work with this implementation. I have tested with the following coins, but there may be many others that work. 
 
@@ -62,23 +50,17 @@ Other coins have been known to work with this implementation. I have tested with
 * Quark
 * Securecoin
 
-#Installation
+# Installation
 
 The installation of this *stratum-mining* can be found in the Repo Wiki. 
 
-#Contact
-I am available in the #MPOS, #crypto-expert, #digitalcoin, and #worldcoin channels on freenode. 
-Although i am willing to provide support through IRC please file issues on the repo.
-Issues as a direct result of stratum will be helped with as much as possible
-However issues related to a coin daemon's setup and other non stratum issues, 
-Please research and attempt to debug first.
-
-#Credits
+# Credits
 
 * Original version by Slush0 and ArtForz (original stratum code)
 * More Features added by GeneralFault, Wadee Womersley, Viperaus, TheSeven and Moopless
 * Multi Algo, Vardiff, DB and MPOS support done by Ahmed_Bodi, penner42 and Obigal
+* Riecoin support implemented by gatra
 
-#License
-This software is provides AS-IS without any warranties of any kind. Please use at your own risk. 
+# License
+This software is provided AS-IS without any warranties of any kind. Please use at your own risk. 
 

conf/config_sample.py

@@ -9,32 +9,33 @@ You NEED to set the parameters in BASIC SETTINGS
 # ******************** BASIC SETTINGS ***************
 # These are the MUST BE SET parameters!
 
-CENTRAL_WALLET = 'set_valid_addresss_in_config!'    # local coin address where money goes
+CENTRAL_WALLET = 'set_valid_addresss_in_config!'                # Local coin address where money goes
 
 COINDAEMON_TRUSTED_HOST = 'localhost'
-COINDAEMON_TRUSTED_PORT = 8332
+COINDAEMON_TRUSTED_PORT = 28332
 COINDAEMON_TRUSTED_USER = 'user'
 COINDAEMON_TRUSTED_PASSWORD = 'somepassword'
 
-# Coin Algorithm is the option used to determine the algortithm used by stratum
+# Coin algorithm is the option used to determine the algorithm used by stratum
 # This currently works with POW and POS coins
 # The available options are:
-# scrypt, sha256d, scrypt-jane and quark
+# scrypt, sha256d, scrypt-jane, skeinhash, quark and riecoin
 # If the option does not meet either of these criteria stratum defaults to scrypt
 # For Coins which support TX Messages please enter yes in the TX selection
-COINDAEMON_ALGO = 'scrypt'
+COINDAEMON_ALGO = 'riecoin'
 COINDAEMON_TX = 'no'
+
 # ******************** BASIC SETTINGS ***************
 # Backup Coin Daemon address's (consider having at least 1 backup)
 # You can have up to 99
 
 #COINDAEMON_TRUSTED_HOST_1 = 'localhost'
-#COINDAEMON_TRUSTED_PORT_1 = 8332
+#COINDAEMON_TRUSTED_PORT_1 = 28332
 #COINDAEMON_TRUSTED_USER_1 = 'user'
 #COINDAEMON_TRUSTED_PASSWORD_1 = 'somepassword'
 
 #COINDAEMON_TRUSTED_HOST_2 = 'localhost'
-#COINDAEMON_TRUSTED_PORT_2 = 8332
+#COINDAEMON_TRUSTED_PORT_2 = 28332
 #COINDAEMON_TRUSTED_USER_2 = 'user'
 #COINDAEMON_TRUSTED_PASSWORD_2 = 'somepassword'
 
@@ -54,7 +55,7 @@ LOGFILE = None      # eg. 'stratum.log'
 LOGLEVEL = 'DEBUG'
 # Logging Rotation can be enabled with the following settings
 # It if not enabled here, you can set up logrotate to rotate the files. 
-# For built in log rotation set LOG_ROTATION = True and configrue the variables
+# For built in log rotation set LOG_ROTATION = True and configure the variables
 LOG_ROTATION = True
 LOG_SIZE = 10485760 # Rotate every 10M
 LOG_RETENTION = 10 # Keep 10 Logs
@@ -65,7 +66,6 @@ LOG_RETENTION = 10 # Keep 10 Logs
 THREAD_POOL_SIZE = 300
 
 # ******************** TRANSPORTS *********************
-
 # Hostname or external IP to expose
 HOSTNAME = 'localhost'
 
@@ -87,9 +87,8 @@ LISTEN_WSS_TRANSPORT = None
 PASSWORD_SALT = 'some_crazy_string'
 
 # ******************** Database  *********************
-
-DATABASE_DRIVER = 'mysql'        # Options: none, sqlite, postgresql or mysql
-DATABASE_EXTEND = False          # SQLite and PGSQL Only!
+DATABASE_DRIVER = 'mysql'       # Options: none, sqlite, postgresql or mysql
+DATABASE_EXTEND = False         # SQLite and PGSQL Only!
 
 # SQLite
 DB_SQLITE_FILE = 'pooldb.sqlite'
@@ -104,7 +103,7 @@ DB_MYSQL_HOST = 'localhost'
 DB_MYSQL_DBNAME = 'pooldb'
 DB_MYSQL_USER = 'pooldb'
 DB_MYSQL_PASS = '**empty**'
-DB_MYSQL_PORT = 3306        # Default port for MySQL
+DB_MYSQL_PORT = 3306            # Default port for MySQL
 
 # ******************** Adv. DB Settings *********************
 #  Don't change these unless you know what you are doing
@@ -120,7 +119,7 @@ DB_USERCACHE_TIME = 600         # How long the usercache is good for before we r
 # ******************** Pool Settings *********************
 
 # User Auth Options
-USERS_AUTOADD = False           # Automatically add users to db when they connect.
+USERS_AUTOADD = False           # Automatically add users to database when they connect.
                                 # This basically disables User Auth for the pool.
 USERS_CHECK_PASSWORD = False    # Check the workers password? (Many pools don't)
 
@@ -129,70 +128,69 @@ COINBASE_EXTRAS = '/stratumPool/'           # Extra Descriptive String to incorp
 ALLOW_NONLOCAL_WALLET = False               # Allow valid, but NON-Local wallet's
 
 # Coin Daemon communication polling settings (In Seconds)
-PREVHASH_REFRESH_INTERVAL = 5       # How often to check for new Blocks
-                                    #   If using the blocknotify script (recommended) set = to MERKLE_REFRESH_INTERVAL
-                                    #   (No reason to poll if we're getting pushed notifications)
-MERKLE_REFRESH_INTERVAL = 60        # How often check memorypool
-                                    #   This effectively resets the template and incorporates new transactions.
-                                    #   This should be "slow"
+PREVHASH_REFRESH_INTERVAL = 5   # How often to check for new Blocks
+                                #   If using the blocknotify script (recommended) set = to MERKLE_REFRESH_INTERVAL
+                                #   (No reason to poll if we're getting pushed notifications)
+MERKLE_REFRESH_INTERVAL = 60    # How often check memorypool
+                                #   This effectively resets the template and incorporates new transactions.
+                                #   This should be "slow"
 
-INSTANCE_ID = 31                    # Used for extranonce and needs to be 0-31
+INSTANCE_ID = 31                # Used for extranonce and needs to be 0-31
 
 # ******************** Pool Difficulty Settings *********************
-VDIFF_X2_TYPE = True  # powers of 2 e.g. 2,4,8,16,32,64,128,256,512,1024
-VDIFF_FLOAT = False    # Use float difficulty
+VDIFF_X2_TYPE = True            # Powers of 2 e.g. 2,4,8,16,32,64,128,256,512,1024
+VDIFF_FLOAT = False             # Use float difficulty
 
 # Pool Target (Base Difficulty)
-POOL_TARGET = 32                        # Pool-wide difficulty target int >= 1
+POOL_TARGET = 4                 # Pool-wide difficulty target int >= 1
 
 # Variable Difficulty Enable
-VARIABLE_DIFF = True                # Master variable difficulty enable
+VARIABLE_DIFF = True            # Master variable difficulty enable
 
 # Variable diff tuning variables
-#VARDIFF will start at the POOL_TARGET. It can go as low as the VDIFF_MIN and as high as min(VDIFF_MAX or Liteconin's difficulty)
-USE_COINDAEMON_DIFF = False   # Set the maximum difficulty to the litecoin difficulty. 
-DIFF_UPDATE_FREQUENCY = 86400 # Update the litecoin difficulty once a day for the VARDIFF maximum
-VDIFF_MIN_TARGET = 16                #  Minimum Target difficulty 
-VDIFF_MAX_TARGET = 1024                # Maximum Target difficulty 
-VDIFF_TARGET_TIME = 15                # Target time per share (i.e. try to get 1 share per this many seconds)
-VDIFF_RETARGET_TIME = 120                # Check to see if we should retarget this often
-VDIFF_VARIANCE_PERCENT = 30        # Allow average time to very this % from target without retarget
+#VARDIFF will start at the POOL_TARGET. It can go as low as the VDIFF_MIN and as high as min(VDIFF_MAX or coindaemons difficulty)
+USE_COINDAEMON_DIFF = False     # Set the maximum difficulty to the coindaemon difficulty. 
+DIFF_UPDATE_FREQUENCY = 86400   # Update the coindaemon difficulty once a day for the VARDIFF maximum
+VDIFF_MIN_TARGET = 16           # Minimum target difficulty 
+VDIFF_MAX_TARGET = 1024         # Maximum target difficulty 
+VDIFF_TARGET_TIME = 15          # Target time per share (i.e. try to get 1 share per this many seconds)
+VDIFF_RETARGET_TIME = 120       # Check to see if we should retarget this often
+VDIFF_VARIANCE_PERCENT = 30     # Allow average time to very this % from target without retarget
 
 # Allow external setting of worker difficulty, checks pool_worker table datarow[6] position for target difficulty
 # if present or else defaults to pool target, over rides all other difficulty settings, no checks are made
-#for min or max limits this sould be done by your front end software
+# for min or max limits this should be done by your front end software
 ALLOW_EXTERNAL_DIFFICULTY = False 
 
 #### Advanced Option ##### 
 # For backwards compatibility, we send the scrypt hash to the solutions column in the shares table 
 # For block confirmation, we have an option to send the block hash in 
 # Please make sure your front end is compatible with the block hash in the solutions table. 
-# For People using the MPOS frontend enabling this is recommended. It allows the frontend to compare the block hash to the coin daemon reducing the liklihood of missing share error's for blocks
-SOLUTION_BLOCK_HASH = True # If enabled, enter the block hash. If false enter the scrypt/sha hash into the shares table 
+# For People using the MPOS frontend enabling this is recommended. It allows the frontend to compare the block hash to the coin daemon reducing the likelihood of missing share error's for blocks
+SOLUTION_BLOCK_HASH = True      # If enabled, enter the block hash. If false enter the scrypt/sha hash into the shares table 
 
 #Pass scrypt hash to submit block check.
-#Use if submit block is returning errors and marking submitted blocks invaild upstream, but the submitted blocks are being a accepted by the coin daemon into the block chain.
+#Use if submit block is returning errors and marking submitted blocks invalid upstream, but the submitted blocks are being a accepted by the coin daemon into the block chain.
 BLOCK_CHECK_SCRYPT_HASH = False
 
 # ******************** Worker Ban Options *********************
-ENABLE_WORKER_BANNING = True # enable/disable temporary worker banning 
-WORKER_CACHE_TIME = 600    # How long the worker stats cache is good before we check and refresh
-WORKER_BAN_TIME = 300    # How long we temporarily ban worker
-INVALID_SHARES_PERCENT = 50    # Allow average invalid shares vary this % before we ban
+ENABLE_WORKER_BANNING = True    # Enable/disable temporary worker banning 
+WORKER_CACHE_TIME = 600         # How long the worker stats cache is good before we check and refresh
+WORKER_BAN_TIME = 300           # How long we temporarily ban worker
+INVALID_SHARES_PERCENT = 50     # Allow average invalid shares vary this % before we ban
 
 # ******************** E-Mail Notification Settings *********************
-NOTIFY_EMAIL_TO = ''    # Where to send Start/Found block notifications
-NOTIFY_EMAIL_TO_DEADMINER = ''  # Where to send dead miner notifications
-NOTIFY_EMAIL_FROM = 'root@localhost'  # Sender address
-NOTIFY_EMAIL_SERVER = 'localhost'  # E-Mail Sender
-NOTIFY_EMAIL_USERNAME = ''    # E-Mail server SMTP Logon
+NOTIFY_EMAIL_TO = ''                                            # Where to send Start/Found block notifications
+NOTIFY_EMAIL_TO_DEADMINER = ''                                  # Where to send dead miner notifications
+NOTIFY_EMAIL_FROM = 'root@localhost'                            # Sender address
+NOTIFY_EMAIL_SERVER = 'localhost'                               # E-Mail sender
+NOTIFY_EMAIL_USERNAME = ''                                      # E-Mail server SMTP logon
 NOTIFY_EMAIL_PASSWORD = ''
 NOTIFY_EMAIL_USETLS = True
 
-#### Memcache ####
+# ******************** Memcache Settings *********************
 # Memcahce is a requirement. Enter the settings below
-MEMCACHE_HOST = "localhost" # hostname or IP that runs memcached
-MEMCACHE_PORT = 11211 # Port
-MEMCACHE_TIMEOUT = 900 # Key timeout
-MEMCACHE_PREFIX = "stratum_" # Prefix for keys
-
+MEMCACHE_HOST = "localhost"     # Hostname or IP that runs memcached
+MEMCACHE_PORT = 11211           # Port
+MEMCACHE_TIMEOUT = 900          # Key timeout
+MEMCACHE_PREFIX = "stratum_"    # Prefix for keys

launcher.tac

@@ -3,7 +3,7 @@
 # Add conf directory to python path.
 # Configuration file is standard python module.
 import os, sys
-sys.path = [os.path.join(os.getcwd(), 'conf'),os.path.join(os.getcwd(), 'externals', 'stratum-mining-proxy'),] + sys.path
+sys.path = [os.path.join(os.getcwd(), 'conf'),os.path.join(os.getcwd(), '.'),os.path.join(os.getcwd(), 'externals', 'stratum-mining-proxy'),] + sys.path
 
 from twisted.internet import defer
 from twisted.application.service import Application, IProcess

lib/bitcoin_rpc.py

@@ -141,12 +141,16 @@ class BitcoinRPC(object):
                                                   
     @defer.inlineCallbacks
     def prevhash(self):
-        resp = (yield self._call('getwork', []))
         try:
-            defer.returnValue(json.loads(resp)['result']['data'][8:72])
+            resp = (yield self._call('getblocktemplate', [{}]))
+            defer.returnValue(json.loads(resp)['result']['previousblockhash'])
         except Exception as e:
-            log.exception("Cannot decode prevhash %s" % str(e))
-            raise
+            if (str(e) == "500 Internal Server Error"):
+                resp = (yield self._call('getblocktemplate', []))
+                defer.returnValue(json.loads(resp)['result']['previousblockhash'])
+            else:
+                log.exception("Cannot decode prevhash %s" % str(e))
+                raise
         
     @defer.inlineCallbacks
     def validateaddress(self, address):

lib/block_template.py

@@ -69,6 +69,7 @@ class BlockTemplate(halfnode.CBlock):
         self.nVersion = data['version']
         self.hashPrevBlock = int(data['previousblockhash'], 16)
         self.nBits = int(data['bits'], 16)
+
         self.hashMerkleRoot = 0
         self.nTime = 0
         self.nNonce = 0
@@ -139,8 +140,12 @@ class BlockTemplate(halfnode.CBlock):
         r  = struct.pack(">i", self.nVersion)
         r += self.prevhash_bin
         r += util.ser_uint256_be(merkle_root_int)
-        r += ntime_bin
-        r += struct.pack(">I", self.nBits)
+        if settings.COINDAEMON_ALGO == 'riecoin':
+            r += struct.pack(">I", self.nBits)
+            r += ntime_bin
+        else:
+            r += ntime_bin
+            r += struct.pack(">I", self.nBits)
         r += nonce_bin    
         return r       
 

lib/coinbasetx.py

@@ -40,7 +40,7 @@ class CoinbaseTransactionPOW(halfnode.CTransaction):
         tx_out.scriptPubKey = coinbaser.get_script_pubkey()
 
         if settings.COINDAEMON_TX == 'yes':
-            self.strTxComment = "http://github.com/ahmedbodi/stratum-mining"
+            self.strTxComment = "RanchiMall mining"
         self.vin.append(tx_in)
         self.vout.append(tx_out)
         
@@ -88,7 +88,7 @@ class CoinbaseTransactionPOS(halfnode.CTransaction):
        
         self.nTime = ntime 
         if settings.COINDAEMON_SHA256_TX == 'yes':
-            self.strTxComment = "http://github.com/ahmedbodi/stratum-mining"
+            self.strTxComment = "RanchiMall mining"
         self.vin.append(tx_in)
         self.vout.append(tx_out)
         

lib/config_default.py

@@ -109,7 +109,7 @@ COINDAEMON_TRUSTED_PASSWORD = '***somepassword***'
 # Until AutoReward Selecting Code has been implemented the below options are us$
 # For Reward type there is POW and POS. please ensure you choose the currect ty$
 # For SHA256 PoS Coins which support TX Messages please enter yes in the TX sel$
-COINDAEMON_ALGO = 'scrypt'
+COINDAEMON_ALGO = 'riecoin'
 COINDAEMON_Reward = 'POW'
 COINDAEMON_SHA256_TX = 'yes'
 

lib/halfnode.py

@@ -239,6 +239,8 @@ class CBlock(object):
             self.scrypt = None
         elif settings.COINDAEMON_ALGO == 'quark':
             self.quark = None
+        elif settings.COINDAEMON_ALGO == 'riecoin':
+            self.riecoin = None
         else: pass
         if settings.COINDAEMON_Reward == 'POS':
             self.signature = b""
@@ -248,9 +250,14 @@ class CBlock(object):
         self.nVersion = struct.unpack("<i", f.read(4))[0]
         self.hashPrevBlock = deser_uint256(f)
         self.hashMerkleRoot = deser_uint256(f)
-        self.nTime = struct.unpack("<I", f.read(4))[0]
-        self.nBits = struct.unpack("<I", f.read(4))[0]
-        self.nNonce = struct.unpack("<I", f.read(4))[0]
+        if settings.COINDAEMON_ALGO == 'riecoin':
+            self.nBits = struct.unpack("<I", f.read(4))[0]
+            self.nTime = struct.unpack("<II", f.read(8))[0]
+            self.nNonce = struct.unpack("<IIIIIIII", f.read(32))[0]
+        else:
+            self.nTime = struct.unpack("<I", f.read(4))[0]
+            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)
@@ -261,9 +268,14 @@ class CBlock(object):
         r.append(struct.pack("<i", self.nVersion))
         r.append(ser_uint256(self.hashPrevBlock))
         r.append(ser_uint256(self.hashMerkleRoot))
-        r.append(struct.pack("<I", self.nTime))
-        r.append(struct.pack("<I", self.nBits))
-        r.append(struct.pack("<I", self.nNonce))
+        if settings.COINDAEMON_ALGO == 'riecoin':
+            r.append(struct.pack("<I", self.nBits))
+            r.append(struct.pack("<Q", self.nTime))
+            r.append(ser_uint256(self.nNonce))
+        else:
+            r.append(struct.pack("<I", self.nTime))
+            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))
@@ -294,6 +306,18 @@ class CBlock(object):
                 r.append(struct.pack("<I", self.nNonce))
                 self.quark = uint256_from_str(quark_hash.getPoWHash(''.join(r)))
              return self.quark
+    elif settings.COINDAEMON_ALGO == 'riecoin':
+         def calc_riecoin(self):
+             if self.riecoin is None:
+                r = []
+                r.append(struct.pack("<i", self.nVersion))
+                r.append(ser_uint256(self.hashPrevBlock))
+                r.append(ser_uint256(self.hashMerkleRoot))
+                r.append(struct.pack("<I", self.nBits))
+                r.append(struct.pack("<Q", self.nTime))
+                sha256 = uint256_from_str(SHA256.new(SHA256.new(''.join(r)).digest()).digest())
+                self.riecoin = riecoinPoW( sha256, uint256_from_compact(self.nBits), self.nNonce )
+             return self.riecoin
     else:
        def calc_sha256(self):
            if self.sha256 is None:
@@ -309,15 +333,23 @@ class CBlock(object):
 
 
     def is_valid(self):
-        if settings.COINDAEMON_ALGO == 'scrypt':
+        if settings.COINDAEMON_ALGO == 'riecoin':
+            self.calc_riecoin()
+        elif settings.COINDAEMON_ALGO == 'scrypt':
             self.calc_scrypt()
         elif settings.COINDAEMON_ALGO == 'quark':
             self.calc_quark()
         else:
             self.calc_sha256()
 
-        target = uint256_from_compact(self.nBits)
+        if settings.COINDAEMON_ALGO == 'riecoin':
+            target = settings.POOL_TARGET
+        else:
+            target = uint256_from_compact(self.nBits)
 
+        if settings.COINDAEMON_ALGO == 'riecoin':
+            if self.riecoin < target:
+                return False
         if settings.COINDAEMON_ALGO == 'scrypt':
             if self.scrypt > target:
                 return False

lib/skein.py

@@ -0,0 +1,206 @@
+# /usr/bin/env python
+# coding=utf-8
+
+#  Copyright 2010 Jonathan Bowman
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+#  implied. See the License for the specific language governing
+#  permissions and limitations under the License.
+
+"""Pure Python implementation of the Skein 512-bit hashing algorithm"""
+
+import array
+import binascii
+import os
+import struct
+
+from threefish import (add64, bigint, bytes2words, Threefish512, words,
+                        words2bytes, words_format, xrange,
+                        zero_bytes, zero_words)
+
+# An empty bytestring that behaves itself whether in Python 2 or 3
+empty_bytes = array.array('B').tostring()
+
+class Skein512(object):
+    """Skein 512-bit hashing algorithm
+
+    The message to be hashed may be set as `msg` when initialized, or
+    passed in later using the ``update`` method.
+
+    Use `key` (a bytestring with arbitrary length) for MAC
+    functionality.
+
+    `block_type` will typically be "msg", but may also be one of:
+    "key", "nonce", "cfg_final", or "out_final". These will affect the
+    tweak value passed to the underlying Threefish block cipher. Again,
+    if you don't know which one to choose, "msg" is probably what you
+    want.
+
+    Example:
+
+    >>> Skein512("Hello, world!").hexdigest()
+    '8449f597f1764274f8bf4a03ead22e0404ea2dc63c8737629e6e282303aebfd5dd96f07e21ae2e7a8b2bdfadd445bd1d71dfdd9745c95b0eb05dc01f289ad765'
+
+    """
+    block_size = 64
+    block_bits = 512
+    block_type = {'key':       0,
+                  'nonce':     0x5400000000000000,
+                  'msg':       0x7000000000000000,
+                  'cfg_final': 0xc400000000000000,
+                  'out_final': 0xff00000000000000}
+
+    def __init__(self, msg='', digest_bits=512, key=None,
+                 block_type='msg'):
+        self.tf = Threefish512()
+        if key:
+            self.digest_bits = 512
+            self._start_new_type('key')
+            self.update(key)
+            self.tf.key = bytes2words(self.final(False))
+        self.digest_bits = digest_bits
+        self.digest_size = (digest_bits + 7) >> 3
+        self._start_new_type('cfg_final')
+        b = words2bytes((0x133414853,digest_bits,0,0,0,0,0,0))
+        self._process_block(b,32)
+        self._start_new_type(block_type)
+        if msg:
+            self.update(msg)
+
+    def _start_new_type(self, block_type):
+        """Setup new tweak values and internal buffer.
+
+        Primarily for internal use.
+
+        """
+        self.buf = empty_bytes
+        self.tf.tweak = words([0, self.block_type[block_type]])
+
+    def _process_block(self, block, byte_count_add):
+        """Encrypt internal state using Threefish.
+
+        Primarily for internal use.
+
+        """
+        block_len = len(block)
+        for i in xrange(0,block_len,64):
+            w = bytes2words(block[i:i+64])
+            self.tf.tweak[0] = add64(self.tf.tweak[0], byte_count_add)
+            self.tf.prepare_tweak()
+            self.tf.prepare_key()
+            self.tf.key = self.tf.encrypt_block(w)
+            self.tf._feed_forward(self.tf.key, w)
+            # set second tweak value to ~SKEIN_T1_FLAG_FIRST:
+            self.tf.tweak[1] &= bigint(0xbfffffffffffffff)
+
+    def update(self, msg):
+        """Update internal state with new data to be hashed.
+
+        `msg` is a bytestring, and should be a bytes object in Python 3
+        and up, or simply a string in Python 2.5 and 2.6.
+
+        """
+        self.buf += msg
+        buflen = len(self.buf)
+        if buflen > 64:
+            end = -(buflen % 64) or (buflen-64)
+            data = self.buf[0:end]
+            self.buf = self.buf[end:]
+            try:
+                self._process_block(data, 64)
+            except:
+                print(len(data))
+                print(binascii.b2a_hex(data))
+
+    def final(self, output=True):
+        """Return hashed data as bytestring.
+
+        `output` is primarily for internal use. It should only be False
+        if you have a clear reason for doing so.
+
+        This function can be called as either ``final`` or ``digest``.
+
+        """
+        self.tf.tweak[1] |= bigint(0x8000000000000000) # SKEIN_T1_FLAG_FINAL
+        buflen = len(self.buf)
+        self.buf += zero_bytes[:64-buflen]
+
+        self._process_block(self.buf, buflen)
+
+        if not output:
+            hash_val = words2bytes(self.tf.key)
+        else:
+            hash_val = empty_bytes
+            self.buf = zero_bytes[:]
+            key = self.tf.key[:] # temporary copy
+            i=0
+            while i*64 < self.digest_size:
+                self.buf = words_format[1].pack(i) + self.buf[8:]
+                self.tf.tweak = [0, self.block_type['out_final']]
+                self._process_block(self.buf, 8)
+                n = self.digest_size - i*64
+                if n >= 64:
+                    n = 64
+                hash_val += words2bytes(self.tf.key)[0:n]
+                self.tf.key = key
+                i+=1
+        return hash_val
+
+    digest = final
+
+    def hexdigest(self):
+        """Return a hexadecimal representation of the hashed data"""
+        return binascii.b2a_hex(self.digest())
+
+class Skein512Random(Skein512):
+    """A Skein-based pseudo-random bytestring generator.
+
+    If `seed` is unspecified, ``os.urandom`` will be used to provide the
+    seed.
+
+    In case you are using this as an iterator, rather than generating
+    new data at each iteration, a pool of length `queue_size` is
+    generated periodically.
+
+    """
+    def __init__(self, seed=None, queue_size=512):
+        Skein512.__init__(self, block_type='nonce')
+        self.queue = []
+        self.queue_size = queue_size
+        self.tf.key = zero_words[:]
+        if not seed:
+          seed = os.urandom(100)
+        self.reseed(seed)
+
+    def reseed(self, seed):
+        """(Re)seed the generator."""
+        self.digest_size = 64
+        self.update(words2bytes(self.tf.key) + seed)
+        self.tf.key = bytes2words(self.final())
+
+    def getbytes(self, request_bytes):
+        """Return random bytestring of length `request_bytes`."""
+        self.digest_size = 64 + request_bytes
+        self.update(words2bytes(self.tf.key))
+        output = self.final()
+        self.tf.key = bytes2words(output[0:64])
+        return output[64:]
+
+    def __iter__(self):
+      return self
+
+    def next(self):
+      if not self.queue:
+        self.queue = array.array('B', self.getbytes(self.queue_size))
+      return self.queue.pop()
+
+if __name__ == '__main__':
+    print Skein512('123').hexdigest()

lib/skeinhash.py

@@ -0,0 +1,20 @@
+import hashlib
+import struct
+import skein
+
+def skeinhash(msg):
+    return hashlib.sha256(skein.Skein512(msg[:80]).digest()).digest()
+
+def skeinhashmid(msg):
+    s = skein.Skein512(msg[:64] + '\x00') # hack to force Skein512.update()
+    return struct.pack('<8Q', *s.tf.key.tolist())
+
+if __name__ == '__main__':
+    mesg = "dissociative1234dissociative4567dissociative1234dissociative4567dissociative1234"
+    h = skeinhashmid(mesg)
+    print h.encode('hex')
+    print 'ad0d423b18b47f57724e519c42c9d5623308feac3df37aca964f2aa869f170bdf23e97f644e81511df49c59c5962887d17e277e7e8513345137638334c8e59a4' == h.encode('hex')
+
+    h = skeinhash(mesg)
+    print h.encode('hex')
+    print '764da2e768811e91c6c0c649b052b7109a9bc786bce136a59c8d5a0547cddc54' == h.encode('hex')

lib/template_registry.py

@@ -9,6 +9,8 @@ elif settings.COINDAEMON_ALGO  == 'scrypt-jane':
     import yac_scrypt
 elif settings.COINDAEMON_ALGO == 'quark':
     import quark_hash
+elif settings.COINDAEMON_ALGO == 'skeinhash':
+    import skeinhash
 else: pass
 from twisted.internet import defer
 from lib.exceptions import SubmitException
@@ -63,7 +65,7 @@ class TemplateRegistry(object):
     def get_new_extranonce1(self):
         '''Generates unique extranonce1 (e.g. for newly
         subscribed connection.'''
-        log.debug("Getting Unique Extronance")
+        log.debug("Getting Unique Extranonce")
         return self.extranonce_counter.get_new_bin()
     
     def get_last_broadcast_args(self):
@@ -148,10 +150,14 @@ class TemplateRegistry(object):
     
     def diff_to_target(self, difficulty):
         '''Converts difficulty to target'''
-        if settings.COINDAEMON_ALGO == 'scrypt' or 'scrypt-jane':
+        if settings.COINDAEMON_ALGO == 'scrypt':
+            diff1 = 0x0000ffff00000000000000000000000000000000000000000000000000000000
+        elif settings.COINDAEMON_ALGO == 'scrypt-jane':
             diff1 = 0x0000ffff00000000000000000000000000000000000000000000000000000000
         elif settings.COINDAEMON_ALGO == 'quark':
             diff1 = 0x000000ffff000000000000000000000000000000000000000000000000000000
+        elif settings.COINDAEMON_ALGO == 'riecoin':
+            return difficulty
         else:
             diff1 = 0x00000000ffff0000000000000000000000000000000000000000000000000000
 
@@ -200,15 +206,23 @@ class TemplateRegistry(object):
             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 settings.COINDAEMON_ALGO == 'riecoin':
+            if len(ntime) != 16:
+                raise SubmitException("Incorrect size of ntime. Expected 16 chars")
+        else:
+            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")
+        if settings.COINDAEMON_ALGO == 'riecoin':
+            if len(nonce) != 64:
+                 raise SubmitException("Incorrect size of nonce. Expected 64 chars")
+        else:
+            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):
@@ -223,6 +237,9 @@ class TemplateRegistry(object):
         extranonce2_bin = binascii.unhexlify(extranonce2)
         ntime_bin = binascii.unhexlify(ntime)
         nonce_bin = binascii.unhexlify(nonce)
+        if settings.COINDAEMON_ALGO == 'riecoin':
+            ntime_bin = (''.join([ ntime_bin[(1-i)*4:(1-i)*4+4] for i in range(0, 2) ]))
+            nonce_bin = (''.join([ nonce_bin[(7-i)*4:(7-i)*4+4] for i in range(0, 8) ]))
                 
         # 1. Build coinbase
         coinbase_bin = job.serialize_coinbase(extranonce1_bin, extranonce2_bin)
@@ -242,45 +259,65 @@ class TemplateRegistry(object):
             hash_bin = yac_scrypt.getPoWHash(''.join([ header_bin[i*4:i*4+4][::-1] for i in range(0, 20) ]), int(ntime, 16))
         elif settings.COINDAEMON_ALGO == 'quark':
             hash_bin = quark_hash.getPoWHash(''.join([ header_bin[i*4:i*4+4][::-1] for i in range(0, 20) ]))
+	elif settings.COINDAEMON_ALGO == 'skeinhash':
+            hash_bin = skeinhash.skeinhash(''.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
+
+        if settings.COINDAEMON_ALGO == 'riecoin':
+            # this is kind of an ugly hack: we use hash_int to store the number of primes
+            hash_int = util.riecoinPoW( hash_int, job.target, int(nonce, 16) )
+
         header_hex = binascii.hexlify(header_bin)
         if settings.COINDAEMON_ALGO == 'scrypt' or settings.COINDAEMON_ALGO == 'scrypt-jane':
             header_hex = header_hex+"000000800000000000000000000000000000000000000000000000000000000000000000000000000000000080020000"
         elif settings.COINDAEMON_ALGO == 'quark':
             header_hex = header_hex+"000000800000000000000000000000000000000000000000000000000000000000000000000000000000000080020000"
+        elif settings.COINDAEMON_ALGO == 'riecoin':
+            header_hex = header_hex+"00000080000000000000000080030000"
         else: pass
                  
         target_user = self.diff_to_target(difficulty)
-        if hash_int > target_user:
-            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")
+        if settings.COINDAEMON_ALGO == 'riecoin':
+	    if hash_int < target_user:
+                raise SubmitException("Share does not meet target")
+        else:
+	    if hash_int > target_user:
+                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:
+        isBlockCandidate = False
+        if settings.COINDAEMON_ALGO == 'riecoin':
+            if hash_int == 6:
+                isBlockCandidate = True
+        else:
+            if hash_int <= job.target:
+                isBlockCandidate = True
+
+        if isBlockCandidate == True:
             # 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) 
-            #if settings.COINDAEMON_ALGO == 'scrypt' or settings.COINDAEMON_ALGO == 'sha256d':
-            #   if settings.COINDAEMON_Reward == 'POW':
-            block_hash_bin = util.doublesha(''.join([ header_bin[i*4:i*4+4][::-1] for i in range(0, 20) ]))
+            if settings.COINDAEMON_ALGO == 'riecoin':
+            	block_hash_bin = util.doublesha(''.join([ header_bin[i*4:i*4+4][::-1] for i in range(0, 28) ]))
+            else:
+            	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')
-            #else:   block_hash_hex = hash_bin[::-1].encode('hex_codec')
-            #else:  block_hash_hex = 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.exception("FINAL JOB VALIDATION FAILED!(Try enabling/disabling tx messages)")
@@ -298,7 +335,10 @@ class TemplateRegistry(object):
         
         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) ]))
+            if settings.COINDAEMON_ALGO == 'riecoin':
+                block_hash_bin = util.doublesha(''.join([ header_bin[i*4:i*4+4][::-1] for i in range(0, 28) ]))
+            else:
+	        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:

lib/threefish.py

@@ -0,0 +1,147 @@
+# /usr/bin/env python
+# coding=utf-8
+
+#  Copyright 2010 Jonathan Bowman
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+#  implied. See the License for the specific language governing
+#  permissions and limitations under the License.
+
+"""Pure Python implementation of the Threefish block cipher
+
+The core of the Skein 512-bit hashing algorithm
+
+"""
+from util_numpy import add64, bigint, bytelist, bytes2words, imap, izip, sub64, \
+    SKEIN_KS_PARITY, words, words2bytes, words_format, xrange, zero_bytes, zero_words, RotL_64, RotR_64, xor
+
+from itertools import cycle
+
+ROT = bytelist((46, 36, 19, 37,
+                33, 27, 14, 42,
+                17, 49, 36, 39,
+                44,  9, 54, 56,
+                39, 30, 34, 24,
+                13, 50, 10, 17,
+                25, 29, 39, 43,
+                 8, 35, 56, 22))
+
+PERM = bytelist(((0,1),(2,3),(4,5),(6,7),
+                 (2,1),(4,7),(6,5),(0,3),
+                 (4,1),(6,3),(0,5),(2,7),
+                 (6,1),(0,7),(2,5),(4,3)))
+
+class Threefish512(object):
+    """The Threefish 512-bit block cipher.
+
+    The key and tweak may be set when initialized (as
+    bytestrings) or after initialization using the ``tweak`` or
+    ``key`` properties. When choosing the latter, be sure to call
+    the ``prepare_key`` and ``prepare_tweak`` methods.
+
+    """
+    def __init__(self, key=None, tweak=None):
+        """Set key and tweak.
+
+        The key and the tweak will be lists of 8 64-bit words
+        converted from `key` and `tweak` bytestrings, or all
+        zeroes if not specified.
+
+        """
+        if key:
+            self.key = bytes2words(key)
+            self.prepare_key()
+        else:
+            self.key = words(zero_words[:] + [0])
+        if tweak:
+            self.tweak = bytes2words(tweak, 2)
+            self.prepare_tweak()
+        else:
+            self.tweak = zero_words[:3]
+
+    def prepare_key(self):
+        """Compute key."""
+        final = reduce(xor, self.key[:8]) ^ SKEIN_KS_PARITY
+        try:
+            self.key[8] = final
+        except IndexError:
+            #self.key.append(final)
+            self.key = words(list(self.key) + [final])
+
+    def prepare_tweak(self):
+        """Compute tweak."""
+        final =  self.tweak[0] ^ self.tweak[1]
+        try:
+            self.tweak[2] = final
+        except IndexError:
+            #self.tweak.append(final)
+            self.tweak = words(list(self.tweak) + [final])
+
+    def encrypt_block(self, plaintext):
+        """Return 8-word ciphertext, encrypted from plaintext.
+
+        `plaintext` must be a list of 8 64-bit words.
+
+        """
+        key = self.key
+        tweak = self.tweak
+        state = words(list(imap(add64, plaintext, key[:8])))
+        state[5] = add64(state[5], tweak[0])
+        state[6] = add64(state[6], tweak[1])
+
+        for r,s in izip(xrange(1,19),cycle((0,16))):
+            for i in xrange(16):
+                m,n = PERM[i]
+                state[m] = add64(state[m], state[n])
+                state[n] = RotL_64(state[n], ROT[i+s])
+                state[n] = state[n] ^ state[m]
+            for y in xrange(8):
+                     state[y] = add64(state[y], key[(r+y) % 9])
+            state[5] = add64(state[5], tweak[r % 3])
+            state[6] = add64(state[6], tweak[(r+1) % 3])
+            state[7] = add64(state[7], r)
+
+        return state
+
+    def _feed_forward(self, state, plaintext):
+        """Compute additional step required when hashing.
+
+        Primarily for internal use.
+
+        """
+        state[:] = list(imap(xor, state, plaintext))
+
+    def decrypt_block(self, ciphertext):
+        """Return 8-word plaintext, decrypted from plaintext.
+
+        `ciphertext` must be a list of 8 64-bit words.
+
+        """
+        key = self.key
+        tweak = self.tweak
+        state = ciphertext[:]
+
+        for r,s in izip(xrange(18,0,-1),cycle((16,0))):
+            for y in xrange(8):
+                 state[y] = sub64(state[y], key[(r+y) % 9])
+            state[5] = sub64(state[5], tweak[r % 3])
+            state[6] = sub64(state[6], tweak[(r+1) % 3])
+            state[7] = sub64(state[7], r)
+
+            for i in xrange(15,-1,-1):
+                m,n = PERM[i]
+                state[n] = RotR_64(state[m] ^ state[n], ROT[i+s])
+                state[m] = sub64(state[m], state[n])
+
+        result = list(imap(sub64, state, key))
+        result[5] = sub64(result[5], tweak[0])
+        result[6] = sub64(result[6], tweak[1])
+        return result

lib/util.py

@@ -56,7 +56,10 @@ def uint256_from_str_be(s):
 
 def uint256_from_compact(c):
     nbytes = (c >> 24) & 0xFF
-    v = (c & 0xFFFFFFL) << (8 * (nbytes - 3))
+    if nbytes <= 3:
+        v = (c & 0xFFFFFFL) >> (8 * (3 - nbytes))
+    else:
+        v = (c & 0xFFFFFFL) << (8 * (nbytes - 3))
     return v
 
 def deser_vector(f, c):
@@ -211,6 +214,54 @@ def ser_number(n):
     s.append(n)
     return bytes(s)
 
+
+def isPrime( n ):
+    if pow( 2, n-1, n ) == 1:
+        return True
+    return False
+
+def riecoinPoW( hash_int, diff, nNonce ):
+    base = 1 << 8
+    for i in range(256):
+        base = base << 1
+        base = base | (hash_int & 1)
+        hash_int = hash_int >> 1
+    trailingZeros = diff - 1 - 8 - 256
+    if trailingZeros < 16 or trailingZeros > 20000:
+        return 0
+    base = base << trailingZeros
+    
+    base += nNonce
+    
+    if (base % 210) != 97:
+        return 0
+    
+    if not isPrime( base ):
+        return 0
+    primes = 1
+    
+    base += 4
+    if isPrime( base ):
+        primes+=1
+    
+    base += 2
+    if isPrime( base ):
+        primes+=1
+    
+    base += 4
+    if isPrime( base ):
+        primes+=1
+    
+    base += 2
+    if isPrime( base ):
+        primes+=1
+    
+    base += 4
+    if isPrime( base ):
+        primes+=1
+      
+    return primes
+
 #if settings.COINDAEMON_Reward == 'POW':
 def script_to_address(addr):
     d = address_to_pubkeyhash(addr)

lib/util_numpy.py

@@ -0,0 +1,100 @@
+# /usr/bin/env python
+# coding=utf-8
+
+#  Copyright 2010 Jonathan Bowman
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+#  implied. See the License for the specific language governing
+#  permissions and limitations under the License.
+
+"""Various helper functions for handling arrays, etc. using numpy"""
+
+import struct
+from operator import xor, add as add64, sub as sub64
+import numpy as np
+
+words = np.uint64
+bytelist = np.uint8
+bigint = np.uint64
+
+# working out some differences between Python 2 and 3
+try:
+    from itertools import imap, izip
+except ImportError:
+    imap = map
+    izip = zip
+try:
+    xrange = xrange
+except:
+    xrange = range
+
+SKEIN_KS_PARITY = np.uint64(0x1BD11BDAA9FC1A22)
+
+# zeroed out byte string and list for convenience and performance
+zero_bytes = struct.pack('64B', *[0] * 64)
+zero_words = np.zeros(8, dtype=np.uint64)
+
+# Build structs for conversion appropriate to this system, favoring
+# native formats if possible for slight performance benefit
+words_format_tpl = "%dQ"
+if struct.pack('2B', 0, 1) == struct.pack('=H', 1): # big endian?
+    words_format_tpl = "<" + words_format_tpl # force little endian
+else:
+    try: # is 64-bit integer native?
+        struct.unpack(words_format_tpl % 2, zero_bytes[:16])
+    except(struct.error): # Use standard instead of native
+        words_format_tpl = "=" + words_format_tpl
+
+# build structs for one-, two- and eight-word sequences
+words_format = dict(
+    (i,struct.Struct(words_format_tpl % i)) for i in (1,2,8))
+
+def bytes2words(data, length=8):
+    """Return a list of `length` 64-bit words from `data`.
+
+    `data` must consist of `length` * 8 bytes.
+    `length` must be 1, 2, or 8.
+
+    """
+    return(np.fromstring(data, dtype=np.uint64))
+
+def words2bytes(data, length=8):
+    """Return a `length` * 8 byte string from `data`.
+
+
+    `data` must be a list of `length` 64-bit words
+    `length` must be 1, 2, or 8.
+
+    """
+    try:
+        return(data.tostring())
+    except AttributeError:
+        return(np.uint64(data).tostring())
+
+def RotL_64(x, N):
+    """Return `x` rotated left by `N`."""
+    #return (x << np.uint64(N & 63)) | (x >> np.uint64((64-N) & 63))
+    return(np.left_shift(x, (N & 63), dtype=np.uint64) |
+           np.right_shift(x, ((64-N) & 63), dtype=np.uint64))
+
+def RotR_64(x, N):
+    """Return `x` rotated right by `N`."""
+    return(np.right_shift(x, (N & 63), dtype=np.uint64) |
+           np.left_shift(x, ((64-N) & 63), dtype=np.uint64))
+
+def add64(a,b):
+    """Return a 64-bit integer sum of `a` and `b`."""
+    return(np.add(a, b, dtype=np.uint64))
+
+def sub64(a,b):
+    """Return a 64-bit integer difference of `a` and `b`."""
+    return(np.subtract(a, b, dtype=np.uint64))
+

mining/DBInterface.py

@@ -179,6 +179,13 @@ class DBInterface():
                 self.dbi.insert_worker(uid, username, password)
                 self.cache.set(username, password)
                 return True
+            else:
+                self.dbi.insert_user(username, password)
+                if self.dbi.get_uid(username) != False:
+                    uid = self.dbi.get_uid(username)
+                    self.dbi.insert_worker(uid, username, password)
+                    self.cache.set(username, password)
+                    return True
         
         log.info("Authentication for %s failed" % username)
         return False
@@ -187,7 +194,10 @@ class DBInterface():
         return self.dbi.list_users()
     
     def get_user(self, id):
-        return self.dbi.get_user(id)
+        if self.cache.get(id) is None:
+            self.cache.set(id,self.dbi.get_user(id))
+        return self.cache.get(id)
+ 
 
     def user_exists(self, username):
         if self.cache.get(username) is not None:

mining/DB_Mysql.py

@@ -125,7 +125,7 @@ class DB_Mysql():
 
         shareid = self.dbc.fetchone()
 
-        if shareid and shareid[0] > 0:
+        if shareid[0] > 0:
             # Note: difficulty = -1 here
             self.execute(
                 """
@@ -342,28 +342,13 @@ class DB_Mysql():
             }
             
         return ret
-    def get_uid(self, id_or_username):
-        log.debug("Finding user id of %s", id_or_username)
-        uname = id_or_username.split(".", 1)[0]
-        self.execute("SELECT `id` FROM `accounts` where username = %s", (uname))
-        row = self.dbc.fetchone()
-        
-       
-        if row is None:
-            return False
-        else:
-            uid = row[0]
-            return uid
-    
-    
+
     def insert_worker(self, account_id, username, password):
         log.debug("Adding new worker %s", username)
         query = "INSERT INTO pool_worker"
         self.execute(query + '(account_id, username, password) VALUES (%s, %s, %s);', (account_id, username, password))
         self.dbh.commit()
         return str(username)
-        
-
 
     def close(self):
         self.dbh.close()

mining/DB_Mysql_Vardiff.py

@@ -83,7 +83,7 @@ class DB_Mysql_Vardiff(DB_Mysql.DB_Mysql):
 
         shareid = self.dbc.fetchone()
 
-        if shareid and shareid[0] > 0:
+        if shareid[0] > 0:
             # Note: difficulty = -1 here
             self.execute(
                 """
@@ -113,15 +113,16 @@ class DB_Mysql_Vardiff(DB_Mysql.DB_Mysql):
                   %(lres)s, %(result)s, %(reason)s, %(solution)s)
                 """,
                 {
-                    "time": data[4],
-                    "host": data[6],
-                    "uname": data[0],
-                    "lres": data[5],
-                    "result": data[5],
-                    "reason": data[9],
-                    "solution": data[2]
+                    "time": v[4], 
+                    "host": v[6], 
+                    "uname": v[0], 
+                    "lres": v[5], 
+                    "result": v[5], 
+                    "reason": v[9],
+                    "solution": v[2]
                 }
             )
+
             self.dbh.commit()
 
 

mining/service.py

@@ -87,7 +87,7 @@ class MiningService(GenericService):
             else:
                 session['difficulty'] = settings.POOL_TARGET
             # worker_log = (valid, invalid, is_banned, diff, is_ext_diff, timestamp)
-            Interfaces.worker_manager.worker_log['authorized'][worker_name] = (0, 0, False, session['difficulty'], is_ext_diff, Interfaces.timestamper.time())            
+            Interfaces.worker_manager.worker_log['authorized'][worker_name] = (0, 0, False, session['difficulty'], is_ext_diff, Interfaces.timestamper.time())
             return True
         else:
             ip = self.connection_ref()._get_ip()

requirements.txt

@@ -1,48 +1,34 @@
-# This File is used to create a list of requirements needed for testing stratum-mining or to create a clone install
 BeautifulSoup==3.2.1
-#Brlapi==0.5.7
-#GnuPGInterface==0.3.2
-MySQL-python==1.2.3
-#PAM==0.4.2
-#Pyste==0.9.10
-#SOAPpy==0.12.0
-Twisted==12.0.0
-#Twisted-Conch==12.0.0
-#Twisted-Core==12.0.0
-#Twisted-Lore==12.0.0
-#Twisted-Mail==12.0.0
-#Twisted-Names==12.0.0
-#Twisted-News==12.0.0
-#Twisted-Runner==12.0.0
-#Twisted-Web==12.0.0
-#Twisted-Words==12.0.0
-#apt-xapian-index==0.45
+Jinja2==2.7.2
+Magic-file-extensions==0.2
+MarkupSafe==0.18
+MySQL-python==1.2.5
+PyYAML==3.10
+Twisted==13.2.0
+ansible==1.4.5
 argparse==1.2.1
-autobahn==0.6.5
-#chardet==2.0.1
+autobahn==0.8.4-3
+cffi==0.8.2
+cryptography==0.2.2
 defer==1.0.6
-distribute==0.6.28
 ecdsa==0.10
-feedparser==5.1.2
+feedparser==5.1.3
 fpconst==0.7.2
-httplib2==0.7.4
-#louis==2.4.1
-#ltc-scrypt==1.0
-#numpy==1.6.2
-pyOpenSSL==0.13
-pyasn1==0.1.3
-pycrypto==2.6
-#pycurl==7.19.0
-pyserial==2.5
-#python-apt==0.8.8.2
-#python-debian==0.1.21
-#python-debianbts==1.11
-python-memcached==1.48
-pyxdg==0.19
-#reportbug==6.4.4
-simplejson==2.5.2
-#stratum==0.2.13
-#uTidylib==0.2
-#unattended-upgrades==0.1
-#wsgiref==0.1.2
-zope.interface==3.6.1
+httplib2==0.8
+numpy==1.7.1
+paramiko==1.12.1
+pyOpenSSL==0.14
+pyasn1==0.1.7
+pycparser==2.10
+pycrypto==2.6.1
+pylibmc==1.2.3
+pyserial==2.7
+python-dateutil==2.1
+python-memcached==1.53
+pyxdg==0.25
+requests==2.2.0
+simplejson==3.3.3
+six==1.4.1
+wsgiref==0.1.2
+zope.interface==4.1.0
+stratum==0.2.15

sql/base_structure.sql

@@ -0,0 +1,260 @@
+SET SQL_MODE = "NO_AUTO_VALUE_ON_ZERO";
+SET time_zone = "+00:00";
+
+/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
+/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
+/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
+/*!40101 SET NAMES utf8 */;
+
+
+CREATE TABLE IF NOT EXISTS `accounts` (
+  `id` int(255) NOT NULL AUTO_INCREMENT,
+  `is_admin` tinyint(1) NOT NULL DEFAULT '0',
+  `is_anonymous` tinyint(1) NOT NULL DEFAULT '0',
+  `no_fees` tinyint(1) NOT NULL DEFAULT '0',
+  `username` varchar(40) NOT NULL,
+  `pass` varchar(255) NOT NULL,
+  `email` varchar(255) DEFAULT NULL COMMENT 'Assocaited email: used for validating users, and re-setting passwords',
+  `timezone` varchar(35) NOT NULL DEFAULT '415',
+  `notify_email` VARCHAR( 255 ) NULL DEFAULT NULL,
+  `loggedIp` varchar(255) DEFAULT NULL,
+  `is_locked` tinyint(1) NOT NULL DEFAULT '0',
+  `failed_logins` int(5) unsigned DEFAULT '0',
+  `failed_pins` int(5) unsigned DEFAULT '0',
+  `signup_timestamp` int(10) DEFAULT '0',
+  `last_login` int(10) DEFAULT NULL,
+  `pin` varchar(255) NOT NULL COMMENT 'four digit pin to allow account changes',
+  `api_key` varchar(255) DEFAULT NULL,
+  `token` varchar(65) DEFAULT NULL,
+  `donate_percent` float DEFAULT '0',
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `username` (`username`),
+  UNIQUE KEY `email` (`email`)
+) ENGINE=InnoDB  DEFAULT CHARSET=utf8;
+
+CREATE TABLE IF NOT EXISTS `blocks` (
+  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
+  `height` int(10) unsigned NOT NULL,
+  `blockhash` char(65) NOT NULL,
+  `confirmations` int(10) NOT NULL,
+  `amount` double NOT NULL,
+  `difficulty` double NOT NULL,
+  `time` int(11) NOT NULL,
+  `accounted` tinyint(1) NOT NULL DEFAULT '0',
+  `account_id` int(255) unsigned DEFAULT NULL,
+  `worker_name` varchar(50) DEFAULT 'unknown',
+  `shares` double unsigned DEFAULT NULL,
+  `share_id` bigint(30) DEFAULT NULL,
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `height` (`height`,`blockhash`),
+  KEY `time` (`time`)
+) ENGINE=InnoDB  DEFAULT CHARSET=utf8 COMMENT='Discovered blocks persisted from Litecoin Service';
+
+CREATE TABLE IF NOT EXISTS `coin_addresses` (
+  `id` int(11) NOT NULL AUTO_INCREMENT,
+  `account_id` int(11) NOT NULL,
+  `currency` varchar(5) NOT NULL,
+  `coin_address` varchar(255) NOT NULL,
+  `ap_threshold` float DEFAULT '0',
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `coin_address` (`coin_address`),
+  KEY `account_id` (`account_id`)
+) ENGINE=InnoDB  DEFAULT CHARSET=utf8;
+
+CREATE TABLE IF NOT EXISTS `invitations` (
+  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
+  `account_id` int(11) unsigned NOT NULL,
+  `email` varchar(50) NOT NULL,
+  `token_id` int(11) NOT NULL,
+  `is_activated` tinyint(1) NOT NULL DEFAULT '0',
+  `time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB  DEFAULT CHARSET=utf8;
+
+CREATE TABLE IF NOT EXISTS `monitoring` (
+  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
+  `name` varchar(30) NOT NULL,
+  `type` varchar(15) NOT NULL,
+  `value` varchar(255) NOT NULL,
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `name` (`name`)
+) ENGINE=InnoDB  DEFAULT CHARSET=utf8 COMMENT='Monitoring events from cronjobs';
+
+CREATE TABLE IF NOT EXISTS `news` (
+  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
+  `account_id` int(10) unsigned NOT NULL,
+  `header` varchar(255) NOT NULL,
+  `content` text NOT NULL,
+  `time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  `active` tinyint(1) NOT NULL DEFAULT '0',
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB  DEFAULT CHARSET=utf8;
+
+CREATE TABLE IF NOT EXISTS `notifications` (
+  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
+  `type` varchar(25) NOT NULL,
+  `data` varchar(255) NOT NULL,
+  `active` tinyint(1) NOT NULL DEFAULT '1',
+  `time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  `account_id` int(10) unsigned DEFAULT NULL,
+  PRIMARY KEY (`id`),
+  KEY `active` (`active`),
+  KEY `data` (`data`),
+  KEY `account_id` (`account_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+CREATE TABLE IF NOT EXISTS `notification_settings` (
+  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
+  `type` varchar(15) NOT NULL,
+  `account_id` int(11) NOT NULL,
+  `active` tinyint(1) NOT NULL DEFAULT '0',
+  PRIMARY KEY (`id`),
+  KEY `account_id` (`account_id`),
+  UNIQUE KEY `account_id_type` (`account_id`,`type`)
+) ENGINE=InnoDB  DEFAULT CHARSET=utf8;
+
+CREATE TABLE IF NOT EXISTS `payouts` (
+  `id` int(11) NOT NULL AUTO_INCREMENT,
+  `account_id` int(11) NOT NULL,
+  `time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  `completed` tinyint(1) NOT NULL DEFAULT '0',
+  PRIMARY KEY (`id`),
+  KEY `account_id` (`account_id`,`completed`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+CREATE TABLE IF NOT EXISTS `pool_worker` (
+  `id` int(255) NOT NULL AUTO_INCREMENT,
+  `account_id` int(255) NOT NULL,
+  `username` char(50) DEFAULT NULL,
+  `password` char(255) DEFAULT NULL,
+  `difficulty` float NOT NULL DEFAULT '0',
+  `monitor` tinyint(1) NOT NULL DEFAULT '0',
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `username` (`username`),
+  KEY `account_id` (`account_id`),
+  KEY `pool_worker_username` (`username`(10))
+) ENGINE=InnoDB  DEFAULT CHARSET=utf8;
+
+CREATE TABLE IF NOT EXISTS `settings` (
+  `name` varchar(255) NOT NULL,
+  `value` text DEFAULT NULL,
+  PRIMARY KEY (`name`),
+  UNIQUE KEY `setting` (`name`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+INSERT INTO `settings` (`name`, `value`) VALUES ('DB_VERSION', '1.0.3');
+
+CREATE TABLE IF NOT EXISTS `shares` (
+  `id` bigint(30) NOT NULL AUTO_INCREMENT,
+  `rem_host` varchar(255) NOT NULL,
+  `username` varchar(120) NOT NULL,
+  `our_result` enum('Y','N') NOT NULL,
+  `upstream_result` enum('Y','N') DEFAULT NULL,
+  `reason` varchar(50) DEFAULT NULL,
+  `solution` varchar(257) NOT NULL,
+  `difficulty` float NOT NULL DEFAULT '0',
+  `time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  PRIMARY KEY (`id`),
+  KEY `time` (`time`),
+  KEY `upstream_result` (`upstream_result`),
+  KEY `our_result` (`our_result`),
+  KEY `username` (`username`),
+  KEY `shares_username` (`username`(10))
+) ENGINE=InnoDB  DEFAULT CHARSET=utf8;
+
+CREATE TABLE IF NOT EXISTS `shares_archive` (
+  `id` bigint(30) unsigned NOT NULL AUTO_INCREMENT,
+  `share_id` bigint(30) unsigned NOT NULL,
+  `username` varchar(120) NOT NULL,
+  `our_result` enum('Y','N') DEFAULT NULL,
+  `upstream_result` enum('Y','N') DEFAULT NULL,
+  `block_id` int(10) unsigned NOT NULL,
+  `difficulty` float NOT NULL DEFAULT '0',
+  `time` datetime NOT NULL,
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `share_id` (`share_id`),
+  KEY `time` (`time`),
+  KEY `our_result` (`our_result`),
+  KEY `username` (`username`)
+) ENGINE=InnoDB  DEFAULT CHARSET=utf8 COMMENT='Archive shares for potential later debugging purposes';
+
+CREATE TABLE IF NOT EXISTS `statistics_shares` (
+  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
+  `account_id` int(10) unsigned NOT NULL,
+  `block_id` int(10) unsigned NOT NULL,
+  `valid` float unsigned NOT NULL DEFAULT '0',
+  `invalid` float unsigned NOT NULL DEFAULT '0',
+  `pplns_valid` float unsigned NOT NULL DEFAULT '0',
+  `pplns_invalid` float unsigned NOT NULL DEFAULT '0',
+  PRIMARY KEY (`id`),
+  KEY `account_id` (`account_id`),
+  KEY `block_id` (`block_id`)
+) ENGINE=InnoDB  DEFAULT CHARSET=utf8;
+
+CREATE TABLE IF NOT EXISTS `tokens` (
+  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
+  `account_id` int(11) NOT NULL,
+  `token` varchar(65) NOT NULL,
+  `type` tinyint(4) NOT NULL,
+  `time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `token` (`token`),
+  KEY `account_id` (`account_id`)
+) ENGINE=InnoDB  DEFAULT CHARSET=utf8;
+
+CREATE TABLE IF NOT EXISTS `token_types` (
+  `id` tinyint(4) unsigned NOT NULL AUTO_INCREMENT,
+  `name` varchar(25) NOT NULL,
+  `expiration` INT NULL DEFAULT  '0',
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `name` (`name`)
+) ENGINE=InnoDB  DEFAULT CHARSET=utf8;
+
+INSERT INTO `token_types` (`id`, `name`, `expiration`) VALUES
+(1, 'password_reset', 3600),
+(2, 'confirm_email', 0),
+(3, 'invitation', 0),
+(4, 'account_unlock', 0),
+(5, 'account_edit', 3600),
+(6, 'change_pw', 3600),
+(7, 'withdraw_funds', 3600);
+
+CREATE TABLE IF NOT EXISTS `transactions` (
+  `id` int(255) NOT NULL AUTO_INCREMENT,
+  `account_id` int(255) unsigned NOT NULL,
+  `type` varchar(25) DEFAULT NULL,
+  `coin_address` varchar(255) DEFAULT NULL,
+  `amount` decimal(50,30) DEFAULT '0',
+  `block_id` int(255) DEFAULT NULL,
+  `timestamp` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  `txid` varchar(256) DEFAULT NULL,
+  `archived` tinyint(1) NOT NULL DEFAULT '0',
+  PRIMARY KEY (`id`),
+  KEY `block_id` (`block_id`),
+  KEY `account_id` (`account_id`),
+  KEY `type` (`type`),
+  KEY `archived` (`archived`),
+  KEY `account_id_archived` (`account_id`,`archived`)
+) ENGINE=InnoDB  DEFAULT CHARSET=utf8;
+
+CREATE TABLE `statistics_users` (
+  `id` int(11) NOT NULL AUTO_INCREMENT,
+  `account_id` int(11) NOT NULL,
+  `hashrate` bigint(20) unsigned NOT NULL,
+  `workers` int(11) NOT NULL,
+  `sharerate` float NOT NULL,
+  `timestamp` int(11) NOT NULL,
+  PRIMARY KEY (`id`),
+  KEY `account_id_timestamp` (`account_id`,`timestamp`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+CREATE TABLE IF NOT EXISTS `user_settings` (
+  `account_id` int(11) NOT NULL,
+  `name` varchar(50) NOT NULL,
+  `value` text DEFAULT NULL,
+  PRIMARY KEY (`account_id`,`name`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT;
+
+/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
+/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
+/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;