class CTransaction(object):
def __init__(self):
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.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]
def serialize(self):
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())
return self.sha256
-
+
def is_valid(self):
self.calc_sha256()
for tout in self.vout:
class CBlock(object):
def __init__(self):
- self.nVersion = 1
+ self.nVersion = 6
self.hashPrevBlock = 0
self.hashMerkleRoot = 0
self.nTime = 0
self.nNonce = 0
self.vtx = []
self.sha256 = None
+ self.signature = b""
def deserialize(self, f):
self.nVersion = struct.unpack("<i", f.read(4))[0]
self.hashPrevBlock = deser_uint256(f)
self.nBits = struct.unpack("<I", f.read(4))[0]
self.nNonce = struct.unpack("<I", f.read(4))[0]
self.vtx = deser_vector(f, CTransaction)
+ self.signature = deser_string(f)
def serialize(self):
r = []
r.append(struct.pack("<i", self.nVersion))
r.append(struct.pack("<I", self.nBits))
r.append(struct.pack("<I", self.nNonce))
r.append(ser_vector(self.vtx))
+ r.append(ser_string(self.signature))
return ''.join(r)
def calc_sha256(self):
if self.sha256 is None:
r.append(struct.pack("<I", self.nTime))
r.append(struct.pack("<I", self.nBits))
r.append(struct.pack("<I", self.nNonce))
- self.sha256 = uint256_from_str(SHA256.new(SHA256.new(''.join(r)).digest()).digest())
+ self.sha256 = uint256_from_str(scrypt(''.join(r)))
return self.sha256
def is_valid(self):
return False
tx.calc_sha256()
hashes.append(ser_uint256(tx.sha256))
-
+
while len(hashes) > 1:
newhashes = []
for i in xrange(0, len(hashes), 2):
i2 = min(i+1, len(hashes)-1)
newhashes.append(SHA256.new(SHA256.new(hashes[i] + hashes[i2]).digest()).digest())
hashes = newhashes
-
+
if uint256_from_str(hashes[0]) != self.hashMerkleRoot:
return False
return True
self.nNonce = random.getrandbits(64)
self.strSubVer = MY_SUBVERSION
self.nStartingHeight = 0
-
+
def deserialize(self, f):
self.nVersion = struct.unpack("<i", f.read(4))[0]
if self.nVersion == 10300:
return ""
def __repr__(self):
return "msg_alert()"
-
+
class BitcoinP2PProtocol(Protocol):
messagemap = {
"version": msg_version,
"ping": msg_ping,
"alert": msg_alert,
}
-
+
def connectionMade(self):
peer = self.transport.getPeer()
self.dstaddr = peer.host
self.dstport = peer.port
self.recvbuf = ""
self.last_sent = 0
-
+
t = msg_version()
t.nStartingHeight = getattr(self, 'nStartingHeight', 0)
t.addrTo.ip = self.dstaddr
t.addrFrom.port = 0
t.addrFrom.nTime = time.time()
self.send_message(t)
-
+
def dataReceived(self, data):
self.recvbuf += data
self.got_data()
-
+
def got_data(self):
while True:
if len(self.recvbuf) < 4:
self.got_message(t)
else:
print "UNKNOWN COMMAND", command, repr(msg)
-
- def prepare_message(self, message):
+
+ def prepare_message(self, message):
command = message.command
data = message.serialize()
tmsg = "\xf9\xbe\xb4\xd9"
tmsg += h[:4]
tmsg += data
return tmsg
-
+
def send_serialized_message(self, tmsg):
if not self.connected:
return
-
+
self.transport.write(tmsg)
- self.last_sent = time.time()
-
+ self.last_sent = time.time()
+
def send_message(self, message):
if not self.connected:
return
-
+
#print message.command
-
+
#print "send %s" % repr(message)
command = message.command
data = message.serialize()
h = SHA256.new(th).digest()
tmsg += h[:4]
tmsg += data
-
+
#print tmsg, len(tmsg)
self.transport.write(tmsg)
self.last_sent = time.time()
-
+
def got_message(self, message):
if self.last_sent + 30 * 60 < time.time():
self.send_message(msg_ping())
git://git.novaco.in / stratum-mining.git / blobdiff