def test_readserializable_fail(self):
# fails because input stream is too short
stream = BytesIO(b"\x04\x01\x02\x03")
reader = BinaryReader(stream)
test_object_list = reader.ReadSerializableArray(
'tests.test_io.TestObject')
self.assertEqual(len(test_object_list), 0)
def FromTrimmedData(byts):
"""
Deserialize a block from raw bytes.
Args:
byts:
Returns:
Block:
"""
block = Block()
block.__is_trimmed = True
ms = StreamManager.GetStream(byts)
reader = BinaryReader(ms)
block.DeserializeUnsigned(reader)
reader.ReadByte()
witness = Witness()
witness.Deserialize(reader)
block.Script = witness
bc = GetBlockchain()
tx_list = []
for tx_hash in reader.ReadHashes():
tx = bc.GetTransaction(tx_hash)[0]
if not tx:
raise Exception("Could not find transaction!\n Are you running code against a valid Blockchain instance?\n Tests that accesses transactions or size of a block but inherit from NeoTestCase instead of BlockchainFixtureTestCase will not work.")
tx_list.append(tx)
block.Transactions = tx_list
StreamManager.ReleaseStream(ms)
return block
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
ecdsa = ECDSA.secp256r1()
points = []
temp = binascii.unhexlify(contract.Script)
ms = MemoryStream(binascii.unhexlify(contract.Script))
reader = BinaryReader(ms)
numr = reader.ReadUInt8()
while reader.ReadUInt8() == 33:
ecpoint = ecdsa.ec.decode_from_hex(
binascii.hexlify(reader.ReadBytes(33)).decode())
points.append(ecpoint)
ms.close()
if pubkey 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:
pubkey = k.encode_point(True).decode()
if pubkey in item.Signatures:
if self.Add(contract, i,
item.Signatures[pubkey]) is None:
raise Exception("Invalid operation")
i += 1
item.Signatures = None
return True
else:
index = -1
if contract.ParameterList == '00':
contract.ParameterList = b'\x00'
length = len(contract.ParameterList)
for i in range(0, length):
if ContractParameterType(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(byts):
"""
Deserialize a block from raw bytes.
Args:
byts:
Returns:
Block:
"""
block = Block()
block.__is_trimmed = True
ms = StreamManager.GetStream(byts)
reader = BinaryReader(ms)
block.DeserializeUnsigned(reader)
reader.ReadByte()
witness = Witness()
witness.Deserialize(reader)
block.Script = witness
block.Transactions = reader.ReadHashes()
StreamManager.ReleaseStream(ms)
return block
def FromTrimmedData(byts, index=None, transaction_method=None):
"""
Deserialize a block from raw bytes.
Args:
byts:
index: UNUSED
transaction_method: UNUSED
Returns:
Block:
"""
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 FromTrimmedData(data, index):
"""
Deserialize into a Header object from the provided data.
Args:
data (bytes):
index: UNUSED
Returns:
Header:
"""
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 Deserialize(self, reader: BinaryReader):
"""
Deserialize full object.
Args:
reader (neocore.IO.BinaryReader):
"""
super(ValidatorState, self).Deserialize(reader)
self.PublicKey = ECDSA.Deserialize_Secp256r1(reader)
self.Registered = reader.ReadBool()
self.Votes = reader.ReadFixed8()
def test_write_serializable_array(self):
my_array = [TestObject(1), TestObject(2)]
stream = BytesIO()
bw = BinaryWriter.BinaryWriter(stream)
bw.WriteSerializableArray(my_array)
stream.seek(0)
reader = BinaryReader(stream)
test_object_list = reader.ReadSerializableArray('tests.test_io.TestObject')
self.assertEqual(0x1, test_object_list[0].test_value)
self.assertEqual(0x2, test_object_list[1].test_value)
def test_various(self):
self.assertEqual(self.br.unpack("c"), b"A")
b = self.br.ReadByte()
self.assertEqual(b, 1)
b = self.br.ReadByte(do_ord=False)
self.assertEqual(b, b"\x02")
bio0 = BytesIO(b"")
br0 = BinaryReader(bio0)
b = br0.ReadByte()
self.assertEqual(b, 0)
# print("===", b)
b = self.br.ReadBool()
self.assertEqual(b, True)
self.assertEqual(get_br(b"\x41").ReadChar(), b"A")
self.assertEqual(get_br(b"1234").ReadFloat(), 1.6688933612840628e-07)
self.assertEqual(
get_br(b"12345678").ReadDouble(), 6.821320051701325e-38)
self.assertEqual(get_br(b"12").ReadInt8(), 49)
self.assertEqual(get_br(b"12").ReadUInt8(), 49)
self.assertEqual(get_br(b"12").ReadInt16(), 12849)
self.assertEqual(get_br(b"12").ReadUInt16(), 12849)
self.assertEqual(get_br(b"\xff234").ReadInt32(), 875770623)
self.assertEqual(get_br(b"\xff234").ReadUInt32(), 875770623)
self.assertEqual(get_br(b"12345678").ReadInt64(), 4050765991979987505)
self.assertEqual(get_br(b"12345678").ReadUInt64(), 4050765991979987505)
self.assertEqual(get_br(b"\xfd1234abc").ReadVarBytes(), b"34abc")
self.assertEqual(get_br(b"\x03234").ReadString(), b"234")
self.assertEqual(get_br(b"\x03123").ReadVarString(), b"123")
self.assertEqual(get_br(b"abc").ReadFixedString(2), b"ab")
x = get_br(b"123871987392873918723981723987189").ReadUInt256()
self.assertEqual(
str(x),
"3831373839333237313839333237383139333738323933373839313738333231")
x = get_br(b"123871987392873918723981723987189").ReadUInt160()
self.assertEqual(str(x), "3237383139333738323933373839313738333231")
x = get_br(b"\x01\x02\x0345678").ReadFixed8()
self.assertEqual(str(x), "40507659919.768295")
self.assertEqual(
get_br(b"\x0212345567898765434567890987").ReadHashes(),
['3738393039383736353433343536373839383736353534333231', ''])
def FromByteArray(data):
stream = StreamManager.GetStream(data=data)
reader = BinaryReader(stream)
etype = reader.ReadVarString().decode('utf-8')
reader.stream.seek(0)
if etype == SmartContractEvent.RUNTIME_NOTIFY:
event = NotifyEvent(None, None, None, None, None)
else:
event = SmartContractEvent(None, None, None, None, None)
event.Deserialize(reader)
StreamManager.ReleaseStream(stream)
return event
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 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))
raise
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 AsSerializableWithType(buffer, class_name):
"""
Args:
buffer (BytesIO/bytes): stream to deserialize `class_name` to.
class_name (str): a full path to the class to be deserialized into. e.g. 'neo.Core.Block.Block'
Returns:
object: if deserialization is successful.
None: if deserialization failed.
"""
module = '.'.join(class_name.split('.')[:-1])
klassname = class_name.split('.')[-1]
klass = getattr(importlib.import_module(module), klassname)
mstream = StreamManager.GetStream(buffer)
reader = BinaryReader(mstream)
try:
serializable = klass()
serializable.Deserialize(reader)
return serializable
except Exception as e:
logger.error("Could not deserialize: %s %s" % (e, class_name))
finally:
StreamManager.ReleaseStream(mstream)
return None
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 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 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_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 __init__(self, engine=None, script=None, rvcount=0):
self.Script = script
self.__mstream = StreamManager.GetStream(self.Script)
self.__OpReader = BinaryReader(self.__mstream)
self._EvaluationStack = RandomAccessStack(name='Evaluation')
self._AltStack = RandomAccessStack(name='Alt')
self._RVCount = rvcount
self.crypto = engine.Crypto
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_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 Deserialize(self, reader: BinaryReader):
"""
Deserialize full object.
Args:
reader (neocore.IO.BinaryReader):
"""
self.Type = StateType(reader.ReadByte())
self.Key = reader.ReadVarBytes(max=100)
self.Field = reader.ReadVarString(max=32).decode('utf-8')
self.Value = reader.ReadVarBytes(max=65535)
if self.Type == StateType.Account:
self.CheckAccountState()
elif self.Type == StateType.Validator:
self.CheckValidatorState()
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 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)
self.assertEqual(
Fixed8.FromDecimal(settings.ALL_FEES['EnrollmentTransaction']),
tx.SystemFee())
def Runtime_Deserialize(self, engine: ExecutionEngine):
data = engine.CurrentContext.EvaluationStack.Pop().GetByteArray()
ms = StreamManager.GetStream(data=data)
reader = BinaryReader(ms)
try:
stack_item = StackItem.DeserializeStackItem(reader)
engine.CurrentContext.EvaluationStack.PushT(stack_item)
except Exception as e:
logger.error("Could not Deserialize stack item: %s " % e)
return False
return True
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 DeserializeTX(buffer):
"""
Deserialize the stream into a Transaction object.
Args:
buffer (BytesIO): stream to deserialize the Transaction from.
Returns:
neo.Core.TX.Transaction:
"""
mstream = MemoryStream(buffer)
reader = BinaryReader(mstream)
tx = Transaction.DeserializeFrom(reader)
return tx
def DeserializeFromDB(buffer):
"""
Deserialize full object.
Args:
buffer (bytes, bytearray, BytesIO): (Optional) data to create the stream from.
Returns:
StorageItem:
"""
m = StreamManager.GetStream(buffer)
reader = BinaryReader(m)
v = StorageItem()
v.Deserialize(reader)
StreamManager.ReleaseStream(m)
return v
