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