def AddSignature(self, contract, pubkey, signature):
if contract.Type == ContractType.MultiSigContract:
item = self.CreateItem(contract)
if item is None:
return False
for p in item.ContractParameters:
if p.Value is not None:
return False
if item.Signatures is None:
item.Signatures = {}
elif pubkey.encode_point(True) in item.Signatures:
return False
points = []
temp = binascii.unhexlify(contract.Script)
ms = MemoryStream(binascii.unhexlify(contract.Script))
reader = BinaryReader(ms)
numr = reader.ReadUInt8()
while reader.ReadUInt8() == 33:
points.append(binascii.hexlify(reader.ReadBytes(33)))
ms.close()
if pubkey.encode_point(True) not in points:
return False
item.Signatures[pubkey.encode_point(
True).decode()] = binascii.hexlify(signature)
if len(item.Signatures) == len(contract.ParameterList):
i = 0
points.sort(reverse=True)
for k in points:
if k.decode() in item.Signatures:
if self.Add(contract, i,
item.Signatures[k.decode()]) is None:
raise Exception("Invalid operation")
i += 1
item.Signatures = None
return True
else:
index = -1
length = len(contract.ParameterList)
for i in range(0, length):
if contract.ParameterList[
i] == ContractParameterType.Signature:
if index >= 0:
raise Exception("Signature must be first")
else:
index = i
return self.Add(contract, index, signature)
def FromTrimmedData(bytes, index, transaction_method):
block = Block()
ms = MemoryStream()
reader = BinaryReader(ms)
block.DeserializeUnsigned(reader)
reader.ReadByte()
block.Script = reader.ReadSerializableArray('neo.Core.Witness.Witness')
block.Transactions = []
for i in range(0, reader.ReadVarInt()):
tx = Transaction.DeserializeFrom(reader)
block.Transactions.append(tx)
return block
def __init__(self, engine=None, script=None, push_only=False, break_points=set()):
self._Engine = engine
self.Script = script
self.PushOnly = push_only
self.__Breakpoints = break_points
self.__mstream = StreamManager.GetStream(self.Script)
self.__OpReader = BinaryReader(self.__mstream)
def DeserializeFromBufer(buffer, offset=0):
mstream = StreamManager.GetStream(buffer)
reader = BinaryReader(mstream)
tx = Transaction.DeserializeFrom(reader)
StreamManager.ReleaseStream(mstream)
return tx
def FromTrimmedData(data, index):
header = Header()
ms = MemoryStream(data)
reader = BinaryReader(ms)
header.DeserializeUnsigned(reader)
reader.ReadByte()
witness = Witness()
witness.Deserialize(reader)
header.Script = witness
return header
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 FromJson(jsn, isMultiSig=True):
try:
parsed = json.loads(jsn)
if parsed['type'] == 'Neo.Core.ContractTransaction':
verifiable = ContractTransaction()
ms = MemoryStream(binascii.unhexlify(parsed['hex']))
r = BinaryReader(ms)
verifiable.DeserializeUnsigned(r)
context = ContractParametersContext(verifiable,
isMultiSig=isMultiSig)
for key, value in parsed['items'].items():
if "0x" in key:
key = key[2:]
key = key.encode()
parameterbytes = []
for pt in value['parameters']:
if pt['type'] == 'Signature':
parameterbytes.append(0)
contract = Contract.Create(value['script'], parameterbytes,
key)
context.ContextItems[key] = ContextItem(contract)
if 'signatures' in value:
context.ContextItems[key].Signatures = value[
'signatures']
return context
else:
raise ("Unsupported transaction type in JSON")
except Exception as e:
logger.error(
"Failed to import ContractParametersContext from JSON: {}".
format(e))
def DeserializeFromDB(buffer):
m = StreamManager.GetStream(buffer)
reader = BinaryReader(m)
v = StorageItem()
v.Deserialize(reader)
StreamManager.ReleaseStream(m)
return v
def test_deserialize(self):
u1 = UIntBase(2)
self.assertEqual(hash(u1), 0)
# deserialize from stream now. hash should equal hash of b'ab',
# because size was set to 2.
u1.Deserialize(BinaryReader(BytesIO(b'abc')))
self.assertEqual(hash(u1), 25185)
def test_yet_another_tx(self):
ms = MemoryStream(binascii.unhexlify(self.yatx))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(tx.ToArray(), self.yatx)
self.assertEqual(tx.Hash.ToBytes(), self.yatx_id)
def FromTrimmedData(data, index):
header = Header()
ms = StreamManager.GetStream(data)
reader = BinaryReader(ms)
header.DeserializeUnsigned(reader)
reader.ReadByte()
witness = Witness()
witness.Deserialize(reader)
header.Script = witness
StreamManager.ReleaseStream(ms)
return header
def FromTrimmedData(byts, index, transaction_method=None):
block = Block()
block.__is_trimmed = True
ms = StreamManager.GetStream(byts)
reader = BinaryReader(ms)
block.DeserializeUnsigned(reader)
reader.ReadByte()
witness = Witness()
witness.Deserialize(reader)
block.witness = witness
block.Transactions = reader.ReadHashes()
StreamManager.ReleaseStream(ms)
return block
def DeserializeFromDB(buffer):
m = StreamManager.GetStream(buffer)
reader = BinaryReader(m)
c = ContractState()
c.Deserialize(reader)
StreamManager.ReleaseStream(m)
return c
def DeserializeFromDB(buffer):
m = StreamManager.GetStream(buffer)
reader = BinaryReader(m)
account = AssetState()
account.Deserialize(reader)
StreamManager.ReleaseStream(m)
return account
def test_contract_tx_again(self):
ms = MemoryStream(binascii.unhexlify(self.cr))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(tx.ToArray(), self.cr)
self.assertEqual(tx.Hash.ToBytes(), self.crid)
def test_miner_tx(self):
ms = MemoryStream(binascii.unhexlify(self.mr))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(tx.Nonce, self.mrn)
self.assertEqual(tx.ToArray(), self.mr)
self.assertEqual(tx.Hash.ToBytes(), self.mrh)
def DeserializeFromDB(buffer):
m = StreamManager.GetStream(buffer)
reader = BinaryReader(m)
spentcoin = SpentCoinState()
spentcoin.Deserialize(reader)
StreamManager.ReleaseStream(m)
return spentcoin
def test_invocation_transaction(self):
ms = MemoryStream(binascii.unhexlify(self.ir))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(tx.ToArray(), self.ir)
self.assertEqual(tx.Hash.ToBytes(), self.ir_id)
def test_enrollment_tx(self):
ms = MemoryStream(binascii.unhexlify(self.eraw))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(tx.ToArray(), self.eraw)
self.assertEqual(tx.Hash.ToBytes(), self.eid)
def test_pub_two(self):
ms = MemoryStream(binascii.unhexlify(self.p2))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(tx.ToArray(), self.p2)
self.assertEqual(tx.Hash.ToBytes(), self.p2id)
def CheckDataReceived(self):
if len(self.buffer_in) >= 24:
mstart = self.buffer_in[:24]
ms = StreamManager.GetStream(mstart)
reader = BinaryReader(ms)
try:
m = Message()
m.Magic = reader.ReadUInt32()
m.Command = reader.ReadFixedString(12).decode('utf-8')
m.Length = reader.ReadUInt32()
m.Checksum = reader.ReadUInt32()
self.pm = m
except Exception as e:
self.Log('could not read initial bytes %s ' % e)
finally:
StreamManager.ReleaseStream(ms)
del reader
try:
#make this threadsafe
# reactor.callFromThread(self.CheckMessageData)
self.CheckMessageData()
except RecursionError:
self.Log("Recursion error!!!")
self.Disconnect()
def test_register_tx(self):
ms = MemoryStream(binascii.unhexlify(self.rr))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(self.rrid, tx.Hash.ToBytes())
json = tx.ToJson()
asset = json['asset']
self.assertEqual(asset['admin'], 'ARFe4mTKRTETerRoMsyzBXoPt2EKBvBXFX')
self.assertEqual(asset['name'], '[{"lang":"zh-CN","name":"TestCoin"}]')
self.assertEqual(asset['precision'], 8)
def test_tx_big_remark(self):
path = '%s/fixtures/bigtx.txt' % os.getcwd()
with open(path, 'rb') as f:
blockraw = f.read().strip()
unhex = binascii.unhexlify(blockraw)
mstream = StreamManager.GetStream(unhex)
reader = BinaryReader(mstream)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(tx.Hash.ToString(), self.giant_tx_hash)
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_publish_tx_deserialize(self):
ms = MemoryStream(binascii.unhexlify(self.pb_raw))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(tx.ToArray(), self.pb_raw)
self.assertEqual(tx.Hash.ToBytes(), self.pb_hash)
json = tx.ToJson()
contract = json['contract']
self.assertEqual(contract['author'], 'Erik Zhang')
self.assertEqual(contract['description'], 'Lock your assets until a timestamp.')
self.assertEqual(contract['code']['hash'], 'ffbd1a7ad1e2348b6b3822426f364bfb4bcce3b9')
self.assertEqual(contract['code']['returntype'], 1)
self.assertEqual(contract['code']['parameters'], '020500')
def CheckMessageData(self):
if not self.pm: return
currentlength = len(self.buffer_in)
messageExpectedLength = 24 + self.pm.Length
# percentcomplete = int(100 * (currentlength / messageExpectedLength))
# self.Log("Receiving %s data: %s percent complete" % (self.pm.Command, percentcomplete))
if currentlength >= messageExpectedLength:
mdata = self.buffer_in[:messageExpectedLength]
stream = StreamManager.GetStream(mdata)
reader = BinaryReader(stream)
message = Message()
message.Deserialize(reader)
StreamManager.ReleaseStream(stream)
self.buffer_in = self.buffer_in[messageExpectedLength:]
self.pm = None
self.MessageReceived(message)
self.reset_counter = False
while len(self.buffer_in) > 24 and not self.reset_counter:
self.CheckDataReceived()
else:
self.reset_counter = True
def DeserializeFromAsyncSocket(socket, cancellation_token):
buffer = bytearray(24)
try:
socket.recv_into(buffer, 24)
ms = MemoryStream(buffer)
reader = BinaryReader(ms)
message = Message()
message.Magic = reader.ReadUInt32()
message.Command = reader.ReadFixedString(12).decode('utf-8')
length = reader.ReadUInt32()
if length > Message.PayloadMaxSizeInt:
raise Exception("format too big")
message.Checksum = reader.ReadUInt32()
message.Payload = bytearray(length)
if length > 0:
message.Payload = Message.FillBufferAsyncStream(
socket, length, None)
checksum = Message.GetChecksum(message.Payload)
if checksum != message.Checksum:
print("Message command :%s " % message.Command)
print("Checksum mismatch: %s " % message.Checksum)
print("message payload: %s " % message.Payload)
raise Exception("invalid checksum")
return message
except Exception as e:
print("could not receive buffer from socket: %s " % e)
def DeserializeFromBufer(buffer, offset=0):
mstream = MemoryStream(buffer, offset)
reader = BinaryReader(mstream)
return Transaction.DeserializeFrom(reader)
def __init__(self, path):
super(LevelDBBlockchain,self).__init__()
self._path = path
self._header_index = []
self._header_index.append(Blockchain.GenesisBlock().Header.Hash.ToBytes())
try:
self._db = plyvel.DB(self._path, create_if_missing=True)
except Exception as e:
self.__log.debug("leveldb unavailable, you may already be running this process: %s " % e)
raise Exception('Leveldb Unavailable')
version = self._db.get(DBPrefix.SYS_Version)
if version == self._sysversion: #or in the future, if version doesn't equal the current version...
ba=bytearray(self._db.get(DBPrefix.SYS_CurrentBlock, 0))
self._current_block_height = int.from_bytes( ba[-4:], 'little')
ba = bytearray(self._db.get(DBPrefix.SYS_CurrentHeader, 0))
current_header_height = int.from_bytes(ba[-4:], 'little')
current_header_hash = bytes(ba[:64].decode('utf-8'), encoding='utf-8')
self.__log.debug("current header hash!! %s " % current_header_hash)
self.__log.debug("current header height, hashes %s %s %s" %(self._current_block_height, self._header_index, current_header_height) )
hashes = []
try:
for key, value in self._db.iterator(prefix=DBPrefix.IX_HeaderHashList):
ms = StreamManager.GetStream(value)
reader = BinaryReader(ms)
hlist = reader.Read2000256List()
key =int.from_bytes(key[-4:], 'little')
hashes.append({'k':key, 'v':hlist})
StreamManager.ReleaseStream(ms)
# hashes.append({'index':int.from_bytes(key, 'little'), 'hash':value})
except Exception as e:
self.__log.debug("Coludnt get stored header hash list: %s " % e)
if len(hashes):
hashes.sort(key=lambda x:x['k'])
genstr = Blockchain.GenesisBlock().Hash.ToBytes()
for hlist in hashes:
for hash in hlist['v']:
if hash != genstr:
self._header_index.append(hash)
self._stored_header_count += 1
if self._stored_header_count == 0:
headers = []
for key, value in self._db.iterator(prefix=DBPrefix.DATA_Block):
dbhash = bytearray(value)[4:]
headers.append( Header.FromTrimmedData(binascii.unhexlify(dbhash), 0))
headers.sort(key=lambda h: h.Index)
for h in headers:
if h.Index > 0:
self._header_index.append(h.Hash.ToBytes())
else:
with self._db.write_batch() as wb:
for key,value in self._db.iterator():
wb.delete(key)
self.Persist(Blockchain.GenesisBlock())
self._db.put(DBPrefix.SYS_Version, self._sysversion )
