moved getwork checks to testcases

[p2pool.git] / p2pool / bitcoin / getwork.py

diff --git a/p2pool/bitcoin/getwork.py b/p2pool/bitcoin/getwork.py
index df4eb7c..721b8ba 100644 (file)
--- a/p2pool/bitcoin/getwork.py
+++ b/p2pool/bitcoin/getwork.py
@@ -6,6 +6,7 @@ from __future__ import division
 
 from . import data as bitcoin_data
 from . import sha256
+from p2pool.util import pack
 
 def _swap4(s):
     if len(s) % 4:
@@ -13,11 +14,11 @@ def _swap4(s):
     return ''.join(s[x:x+4][::-1] for x in xrange(0, len(s), 4))
 
 class BlockAttempt(object):
-    def __init__(self, version, previous_block, merkle_root, timestamp, block_target, share_target):
-        self.version, self.previous_block, self.merkle_root, self.timestamp, self.block_target, self.share_target = version, previous_block, merkle_root, timestamp, block_target, share_target
+    def __init__(self, version, previous_block, merkle_root, timestamp, bits, share_target):
+        self.version, self.previous_block, self.merkle_root, self.timestamp, self.bits, self.share_target = version, previous_block, merkle_root, timestamp, bits, share_target
     
     def __hash__(self):
-        return hash((self.version, self.previous_block, self.merkle_root, self.timestamp, self.block_target, self.share_target))
+        return hash((self.version, self.previous_block, self.merkle_root, self.timestamp, self.bits, self.share_target))
     
     def __eq__(self, other):
         if not isinstance(other, BlockAttempt):
@@ -30,7 +31,7 @@ class BlockAttempt(object):
     def __repr__(self):
         return 'BlockAttempt(%s)' % (', '.join('%s=%r' % (k, v) for k, v in self.__dict__.iteritems()),)
     
-    def getwork(self, _check=False, **extra):
+    def getwork(self, **extra):
         if 'data' in extra or 'hash1' in extra or 'target' in extra or 'midstate' in extra:
             raise ValueError()
         
@@ -39,49 +40,34 @@ class BlockAttempt(object):
             previous_block=self.previous_block,
             merkle_root=self.merkle_root,
             timestamp=self.timestamp,
-            target=self.block_target,
+            bits=self.bits,
             nonce=0,
         ))
         
         getwork = {
             'data': _swap4(block_data).encode('hex') + '000000800000000000000000000000000000000000000000000000000000000000000000000000000000000080020000',
             'hash1': '00000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000010000',
-            'target': bitcoin_data.HashType().pack(self.share_target).encode('hex'),
-            'midstate': _swap4(sha256.process(block_data[:64])).encode('hex'),
+            'target': pack.IntType(256).pack(self.share_target).encode('hex'),
+            'midstate': _swap4(sha256.process(sha256.initial_state, block_data[:64])).encode('hex'),
         }
         
-        if _check:
-            self_check = self.__class__.from_getwork(getwork, _check=False)
-            if self_check != self:
-                raise AssertionError('failed check - input invalid or implementation error')
-        
         getwork = dict(getwork)
         getwork.update(extra)
         
         return getwork
     
     @classmethod
-    def from_getwork(cls, getwork, _check=True):
+    def from_getwork(cls, getwork):
         attrs = decode_data(getwork['data'])
         
-        ba = cls(
+        return cls(
             version=attrs['version'],
             previous_block=attrs['previous_block'],
             merkle_root=attrs['merkle_root'],
             timestamp=attrs['timestamp'],
-            block_target=attrs['target'],
-            share_target=bitcoin_data.HashType().unpack(getwork['target'].decode('hex')),
+            bits=attrs['bits'],
+            share_target=pack.IntType(256).unpack(getwork['target'].decode('hex')),
         )
-        
-        if _check:
-            extra = dict(getwork)
-            del extra['data'], extra['hash1'], extra['target']
-            extra.pop('midstate', None)
-            getwork_check = ba.getwork(_check=False, **extra)
-            if getwork_check != getwork and dict((k, v) for k, v in getwork_check.iteritems() if k != 'midstate') != getwork:
-                raise AssertionError('failed check - input invalid or implementation error')
-        
-        return ba
     
     def update(self, **kwargs):
         d = self.__dict__.copy()