def OnAddHeader(self, header):
hHash = header.Hash.ToBytes()
if not hHash in self._header_index:
self._header_index.append(hHash)
while header.Index - 2000 >= self._stored_header_count:
ms = StreamManager.GetStream()
w = BinaryWriter(ms)
headers_to_write = self._header_index[self._stored_header_count:self._stored_header_count+2000]
w.Write2000256List(headers_to_write)
out = ms.ToArray()
StreamManager.ReleaseStream(ms)
with self._db.write_batch() as wb:
wb.put( DBPrefix.IX_HeaderHashList + self._stored_header_count.to_bytes(4, 'little'), out)
self._stored_header_count += 2000
self.__log.debug("Trimming stored header index!!!!! %s" % self._stored_header_count)
with self._db.write_batch() as wb:
wb.put( DBPrefix.DATA_Block + hHash, bytes(8) + header.ToArray())
wb.put( DBPrefix.SYS_CurrentHeader, hHash + header.Index.to_bytes( 4, 'little'))
def Trim(self):
ms = MemoryStream()
writer = BinaryWriter(ms)
self.SerializeUnsigned(writer)
writer.WriteByte(1)
self.Script.serialize(writer)
writer.WriteSerializableArray([tx.Hash() for tx in self.Transactions])
ms.flush()
return ms.ToArray()
def Trim(self):
ms = StreamManager.GetStream()
writer = BinaryWriter(ms)
self.SerializeUnsigned(writer)
writer.WriteByte(1)
self.Script.Serialize(writer)
writer.WriteHashes([tx.Hash.ToBytes() for tx in self.Transactions])
retVal = ms.ToArray()
StreamManager.ReleaseStream(ms)
return retVal
def test_serialize(self):
data = b'abc'
stream = BytesIO()
u1 = UIntBase(3, bytearray(data))
u1.Serialize(BinaryWriter(stream))
self.assertEqual(stream.getvalue(), data)
stream = BytesIO()
u1 = UIntBase(3, data)
u1.Serialize(BinaryWriter(stream))
self.assertEqual(stream.getvalue(), data)
def test_network_addrtime(self):
addr = "55.15.69.104"
port = 10333
ts = int(datetime.now().timestamp())
services = 0
nawt = NetworkAddressWithTime(addr, port, services, ts)
ms = StreamManager.GetStream()
writer = BinaryWriter(ms)
nawt.Serialize(writer)
arr = ms.ToArray()
arhex = binascii.unhexlify(arr)
StreamManager.ReleaseStream(ms)
ms = StreamManager.GetStream(arhex)
reader = BinaryReader(ms)
nawt2 = NetworkAddressWithTime()
nawt2.Deserialize(reader)
StreamManager.ReleaseStream(ms)
# self.assertEqual(nawt.Address, nawt2.Address)
self.assertEqual(nawt.Services, nawt2.Services)
self.assertEqual(nawt.Port, nawt2.Port)
self.assertEqual(nawt.Timestamp, nawt2.Timestamp)
def test_tx_deserialize(self):
ms = MemoryStream(self.tx_raw_hex)
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(type(tx), MinerTransaction)
self.assertEqual(tx.Hash.ToBytes(), self.tx_id)
self.assertEqual(tx.Nonce, self.tx_nonce)
self.assertEqual(tx.inputs, [])
self.assertEqual(tx.outputs, [])
self.assertEqual(tx.scripts, [])
ms = MemoryStream()
writer = BinaryWriter(ms)
tx.Serialize(writer)
out = ms.ToArray()
self.assertEqual(out, self.tx_raw)
json = tx.ToJson()
self.assertEqual(json['nonce'], self.tx_nonce)
def GetHashData(hashable):
ms = StreamManager.GetStream()
writer = BinaryWriter(ms)
hashable.SerializeUnsigned(writer)
ms.flush()
retVal = ms.ToArray()
StreamManager.ReleaseStream(ms)
return retVal
def ToArray( value ):
ms = MemoryStream()
writer = BinaryWriter(ms)
value.Serialize(writer)
ms.flush()
return ms.ToArray()
def ToByteArray(self):
ms = StreamManager.GetStream()
writer = BinaryWriter(ms)
self.Serialize(writer)
retval = ms.ToArray()
StreamManager.ReleaseStream(ms)
return retval
def ToArray( value ):
ms = StreamManager.GetStream()
writer = BinaryWriter(ms)
value.Serialize(writer)
retVal = ms.ToArray()
StreamManager.ReleaseStream(ms)
return retVal
def ToJson(self):
jsn = {}
jsn['type'] = 'Neo.Core.ContractTransaction' # Verifiable.GetType().FullName
ms = MemoryStream()
w = BinaryWriter(ms)
self.Verifiable.SerializeUnsigned(w)
ms.flush()
jsn['hex'] = ms.ToArray().decode()
jsn['items'] = {}
for key, value in self.ContextItems.items():
if type(key) == str:
shkey = "0x{}".format(key)
else:
shkey = "0x{}".format(key.decode())
jsn['items'][shkey] = value.ToJson()
return jsn
def test_message_serialization(self):
message = Message('version', payload=self.payload)
self.assertEqual(message.Command, 'version')
ms = StreamManager.GetStream()
writer = BinaryWriter(ms)
message.Serialize(writer)
result = binascii.unhexlify( ms.ToArray())
StreamManager.ReleaseStream(ms)
ms = StreamManager.GetStream(result)
reader = BinaryReader(ms)
deserialized_message = Message()
deserialized_message.Deserialize( reader )
StreamManager.ReleaseStream(ms)
dm = deserialized_message
self.assertEqual(dm.Command, 'version')
self.assertEqual(dm.Magic, Settings.MAGIC)
checksum = Message.GetChecksum(dm.Payload)
self.assertEqual(checksum, dm.Checksum)
deserialized_version = IOHelper.AsSerializableWithType(dm.Payload, 'neo.Network.Payloads.VersionPayload.VersionPayload')
self.assertEqual(deserialized_version.Port, self.port)
self.assertEqual(deserialized_version.UserAgent, self.ua)
self.assertEqual(deserialized_version.Timestamp, self.payload.Timestamp)
def test_account_state(self):
hash = UInt160(data=self.shash)
account = AccountState(script_hash=hash)
addr = account.Address
self.assertEqual(addr, self.saddr)
input = binascii.unhexlify(self.assset)
asset = AssetState.DeserializeFromDB(input)
account.AddToBalance(asset.AssetId, Fixed8(2440000000))
self.assertEqual(account.BalanceFor(asset.AssetId), Fixed8(2440000000))
account.SubtractFromBalance(asset.AssetId, Fixed8(1220000000))
self.assertEqual(account.BalanceFor(asset.AssetId), Fixed8(1220000000))
self.assertEqual(account.HasBalance(asset.AssetId), True)
sshare_hash = Blockchain.SystemShare().Hash
account.SubtractFromBalance(sshare_hash, Fixed8(800000000))
self.assertFalse(account.AllBalancesZeroOrLess())
acct_json = account.ToJson()
stream = StreamManager.GetStream()
writer = BinaryWriter(stream)
account.Serialize(writer)
out = stream.ToArray()
StreamManager.ReleaseStream(stream)
input = binascii.unhexlify(out)
newaccount = AccountState.DeserializeFromDB(input)
self.assertEqual(acct_json, newaccount.ToJson())
def GetHashData(hashable):
ms = MemoryStream()
writer = BinaryWriter(ms)
hashable.SerializeUnsigned(writer)
ms.flush()
return ms.ToArray()
def GetHashData(self):
ms = MemoryStream()
w = BinaryWriter(ms)
self.SerializeUnsigned(w)
ms.flush()
return ms.ToArray()