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 )