def test_state_tx(self):
ms = MemoryStream(binascii.unhexlify(self.sttx))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
# the net_fee calculation in short is : net_fee = inputs - outputs -system fee.
# For this test to be able to grab the input values we need to make the TX that it references available for this test
ms2 = MemoryStream(binascii.unhexlify(
b'80000001def3ab1c73a13e80fea34ca751c79fe8dcf68d93d91d4956818baf0b99d95818010002e72d286979ee6cb1b7e65dfddfb2e384100b8d148e7758de42e4168b71792c6000e8764817000000faaa0f339e0fb33f91697cbf5aac41d17921222ae72d286979ee6cb1b7e65dfddfb2e384100b8d148e7758de42e4168b71792c60008997b2270000002d9a070d388aa24d9f639bc8ddf985dc473c75d70141401a07d186fdfe3f9862c873d7cd9bdcb9cc8b3f5edcf853af31addcc4476d7d4fe89385cc955a4f604c667110332c14cb2fd8f62a29569b01a572774c7f7136572321026aeca2aed2094e9622a44cf584c694554f10cdb84d4f8eeab3e28ead4e87c168ac'))
reader2 = BinaryReader(ms2)
vout_tx = Transaction.DeserializeFrom(reader2)
self.assertEqual(tx.ToArray(), self.sttx)
self.assertEqual(tx.Hash.ToBytes(), self.sttx_id)
with patch('neo.Core.Blockchain.Blockchain.GetTransaction', return_value=(vout_tx, 0)):
json = tx.ToJson()
self.assertEqual(json['size'], 191)
self.assertEqual(json['type'], "StateTransaction")
self.assertEqual(json['version'], 0)
self.assertEqual(len(json['attributes']), 0)
self.assertEqual(len(json['vout']), 0)
self.assertEqual(len(json['vin']), 1)
self.assertEqual(json['sys_fee'], "1000")
self.assertEqual(json['net_fee'], "0")
descriptors = json['descriptors'][0]
self.assertEqual(descriptors['type'], "Validator")
self.assertEqual(descriptors['key'], "025bdf3f181f53e9696227843950deb72dcd374ded17c057159513c3d0abe20b64")
self.assertEqual(descriptors['field'], "Registered")
self.assertEqual(descriptors['value'], "01")
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(
'neo.Core.tests.test_io.TestObject')
self.assertEqual(len(test_object_list), 0)
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 (neo.Core.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(
'neo.Core.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, b'\x01')
b = self.br.ReadByte()
self.assertEqual(b, b"\x02")
bio0 = BytesIO(b"")
br0 = BinaryReader(bio0)
with self.assertRaises(ValueError):
br0.ReadByte()
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"\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.76829529")
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 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_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 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 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_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 __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_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_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_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 (neo.Core.IO.BinaryReader):
"""
self.Type = StateType(ord(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 test_GetScriptHashesForVerifying_neo_gas(self):
# test a raw tx using neo
ms = MemoryStream(binascii.unhexlify(self.ntx))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
tx.raw_tx = True
res = tx.GetScriptHashesForVerifying()
self.assertTrue(type(res), list)
# test a raw tx using gas
ms = MemoryStream(binascii.unhexlify(self.gtx))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
tx.raw_tx = True
res = tx.GetScriptHashesForVerifying()
self.assertTrue(type(res), list)
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 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)
if len(tx_list) < 1:
raise Exception(
"Invalid block, no transactions found for block %s " %
block.Index)
block.Transactions = tx_list
StreamManager.ReleaseStream(ms)
return block
def test_GetScriptHashesForVerifying_invalid_operation(self):
# test a normal tx with a bad assetId
ms = MemoryStream(binascii.unhexlify(self.rtx))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
with self.assertRaises(Exception) as e:
tx.GetScriptHashesForVerifying()
self.assertTrue("Invalid operation" in str(e.exception))
# test a raw tx with a bad assetId
ms = MemoryStream(binascii.unhexlify(self.rtx))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
tx.raw_tx = True
with self.assertRaises(Exception) as e:
tx.GetScriptHashesForVerifying()
self.assertTrue("Invalid operation" in str(e.exception))
def test_contract_tx_deserialize(self):
ms = MemoryStream(binascii.unhexlify(self.ctx_raw))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(tx.ToArray(), self.ctx_raw)
self.assertEqual(tx.Hash.ToBytes(), self.ctx_id)
json = tx.ToJson()
self.assertEqual(json['size'], 605)
self.assertEqual(json['type'], 'ContractTransaction')
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)
json = tx.ToJson()
self.assertEqual(json['size'], 402)
self.assertEqual(json['type'], 'PublishTransaction')
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 ValueError as e:
# can't deserialize type
logger.error("%s " % e)
return False
return True
def TryGetInternal(self, key):
data = self.db.get(self.prefix + key)
if data is None:
return data
data = binascii.unhexlify(data)
stream = StreamManager.GetStream(data)
br = BinaryReader(stream)
obj = self.ClassRef()
obj.Deserialize(br)
StreamManager.ReleaseStream(stream)
return obj
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_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'], b'[{"lang":"zh-CN","name":"TestCoin"}]')
self.assertEqual(asset['precision'], 8)
self.assertEqual(Fixed8.FromDecimal(settings.ALL_FEES['RegisterTransaction']), tx.SystemFee())
self.assertEqual(json['size'], 302)
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
