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