def OnAddHeader(self, header): hHash = header.Hash.ToBytes() if hHash not in self._header_index: self._header_index.append(hHash) while header.Index - 2000 >= self._stored_header_count: ms = StreamManager.GetStream() w = BinaryWriter(ms) headers_to_write = self._header_index[ self._stored_header_count:self._stored_header_count + 2000] w.Write2000256List(headers_to_write) out = ms.ToArray() StreamManager.ReleaseStream(ms) with self._db.write_batch() as wb: wb.put( DBPrefix.IX_HeaderHashList + self._stored_header_count.to_bytes(4, 'little'), out) self._stored_header_count += 2000 logger.debug("Trimming stored header index %s" % self._stored_header_count) with self._db.write_batch() as wb: wb.put(DBPrefix.DATA_Block + hHash, bytes(8) + header.ToArray()) wb.put(DBPrefix.SYS_CurrentHeader, hHash + header.Index.to_bytes(4, 'little'))
def Serialize(self, writer: BinaryWriter): """ Serialize full object. Args: writer (neo.IO.BinaryWriter): """ super(ValidatorState, self).Serialize(writer) self.PublicKey.Serialize(writer) writer.WriteBool(self.Registered) writer.WriteFixed8(self.Votes)
def test_serialize(self): data = b'abc' stream = BytesIO() u1 = UIntBase(3, bytearray(data)) u1.Serialize(BinaryWriter(stream)) self.assertEqual(stream.getvalue(), data) stream = BytesIO() u1 = UIntBase(3, data) u1.Serialize(BinaryWriter(stream)) self.assertEqual(stream.getvalue(), data)
def get_tx_data(tx): ms = MemoryStream() w = BinaryWriter(ms) tx.Serialize(w) ms.flush() tx_data = ms.ToArray().decode() return tx_data
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_2_serialize_notify_no_payload(self): sc = SmartContractEvent( SmartContractEvent.RUNTIME_NOTIFY, ContractParameter(ContractParameterType.Array, []), self.contract_hash, 99, self.event_tx, True, False) stream = StreamManager.GetStream() writer = BinaryWriter(stream) sc.Serialize(writer) out = bytes(stream.getvalue()) self.assertEqual( out, b'\x1cSmartContract.Runtime.Notify\x11\xc4\xd1\xf4\xfb\xa6\x19\xf2b\x88p\xd3n:\x97s\xe8tp[c\x00\x00\x00\x90\xe4\xf1\xbbb\x8e\xf1\x07\xde\xe9\xf0\xd2\x12\xd1w\xbco\x844\x07=\x1b\xa7\x1f\xa7\x94`\x0b\xb4\x88|K' ) StreamManager.ReleaseStream(stream) new_event = SmartContractEvent.FromByteArray(out) self.assertEqual(new_event.event_type, sc.event_type) self.assertEqual(new_event.contract_hash, sc.contract_hash) self.assertEqual(new_event.test_mode, sc.test_mode) self.assertEqual(new_event.tx_hash, sc.tx_hash) self.assertEqual(new_event.block_number, sc.block_number)
def test_4_serialize_full_transfer_notify_payload(self): payload = ContractParameter(ContractParameterType.Array, [ ContractParameter(ContractParameterType.String, b'transfer'), ContractParameter(ContractParameterType.ByteArray, self.addr_to), ContractParameter(ContractParameterType.ByteArray, self.addr_from), ContractParameter(ContractParameterType.Integer, 123000) ]) sc = NotifyEvent(SmartContractEvent.RUNTIME_NOTIFY, payload, self.contract_hash, 91349, self.event_tx, True, False) stream = StreamManager.GetStream() writer = BinaryWriter(stream) sc.Serialize(writer) out = bytes(stream.getvalue()) StreamManager.ReleaseStream(stream) new_event = SmartContractEvent.FromByteArray(out) self.assertEqual(new_event.event_type, sc.event_type) self.assertEqual(new_event.contract_hash, sc.contract_hash) self.assertEqual(new_event.test_mode, sc.test_mode) self.assertEqual(new_event.tx_hash, sc.tx_hash) self.assertEqual(new_event.block_number, sc.block_number) self.assertEqual(new_event.notify_type, b'transfer') self.assertEqual(new_event.AddressTo, 'ALb8FEhEmtSqv97fuNVuoLmcmrSKckffRf') self.assertEqual(new_event.AddressFrom, 'AKZmSGPD7ytJBbxpRPmobYGLNxdWH3Jiqs') self.assertEqual(new_event.Amount, 123000) self.assertEqual(new_event.is_standard_notify, True)
def test_6_serialize_full_approve_payload(self): sc = NotifyEvent( SmartContractEvent.RUNTIME_NOTIFY, [b'approve', self.addr_to, self.addr_from, b'x\xe0\x01'], self.contract_hash, 91349, self.event_tx, True, False) stream = StreamManager.GetStream() writer = BinaryWriter(stream) sc.Serialize(writer) out = bytes(stream.getvalue()) StreamManager.ReleaseStream(stream) new_event = SmartContractEvent.FromByteArray(out) self.assertEqual(new_event.event_type, sc.event_type) self.assertEqual(new_event.contract_hash, sc.contract_hash) self.assertEqual(new_event.test_mode, sc.test_mode) self.assertEqual(new_event.tx_hash, sc.tx_hash) self.assertEqual(new_event.block_number, sc.block_number) self.assertEqual(new_event.notify_type, b'approve') self.assertEqual(new_event.AddressFrom, 'AKZmSGPD7ytJBbxpRPmobYGLNxdWH3Jiqs') self.assertEqual(new_event.AddressTo, 'ALb8FEhEmtSqv97fuNVuoLmcmrSKckffRf') self.assertEqual(new_event.Amount, 123000) self.assertEqual(new_event.is_standard_notify, True) self.assertEqual(new_event.ShouldPersist, True)
def ToByteArray(self): stream = StreamManager.GetStream() writer = BinaryWriter(stream) self.Serialize(writer) out = stream.getvalue() StreamManager.ReleaseStream(stream) return out
def test_1_serialize_runtime_log(self): sc = SmartContractEvent(SmartContractEvent.RUNTIME_LOG, [], self.contract_hash, 99999, self.event_tx, True, False) stream = StreamManager.GetStream() writer = BinaryWriter(stream) sc.Serialize(writer) out = bytes(stream.getvalue()) self.assertEqual( out, b'\x19SmartContract.Runtime.Log\x11\xc4\xd1\xf4\xfb\xa6\x19\xf2b\x88p\xd3n:\x97s\xe8tp[\x9f\x86\x01\x00\x90\xe4\xf1\xbbb\x8e\xf1\x07\xde\xe9\xf0\xd2\x12\xd1w\xbco\x844\x07=\x1b\xa7\x1f\xa7\x94`\x0b\xb4\x88|K' ) StreamManager.ReleaseStream(stream) new_event = SmartContractEvent.FromByteArray(out) self.assertEqual(new_event.event_type, sc.event_type) self.assertEqual(new_event.contract_hash, sc.contract_hash) self.assertEqual(new_event.test_mode, sc.test_mode) self.assertEqual(new_event.tx_hash, sc.tx_hash) self.assertEqual(new_event.block_number, sc.block_number)
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_3_serialize_single_transfer_notify_payload(self): sc = NotifyEvent(SmartContractEvent.RUNTIME_NOTIFY, [b'transfer'], self.contract_hash, 99, self.event_tx, True, False) stream = StreamManager.GetStream() writer = BinaryWriter(stream) sc.Serialize(writer) out = bytes(stream.getvalue()) StreamManager.ReleaseStream(stream) new_event = SmartContractEvent.FromByteArray(out) self.assertEqual(new_event.event_type, sc.event_type) self.assertEqual(new_event.contract_hash, sc.contract_hash) self.assertEqual(new_event.test_mode, sc.test_mode) self.assertEqual(new_event.tx_hash, sc.tx_hash) self.assertEqual(new_event.block_number, sc.block_number) self.assertEqual(new_event.notify_type, b'transfer') self.assertEqual(new_event.AddressFrom, None) self.assertEqual(new_event.AddressTo, None) self.assertEqual(new_event.Amount, 0) self.assertEqual(new_event.is_standard_notify, False) self.assertEqual(new_event.ShouldPersist, False)
def Serialize(self, writer: BinaryWriter): """ Serialize full object. Args: writer (neo.IO.BinaryWriter): """ byt = None if self.Type == StateType.Account: byt = b'\x40' elif self.Type == StateType.Validator: byt = b'\x48' writer.WriteByte(byt) writer.WriteVarBytes(self.Key) writer.WriteVarString(self.Field) writer.WriteVarBytes(self.Value)
def test_5_serialize_full_refund_payload(self): sc = NotifyEvent(SmartContractEvent.RUNTIME_NOTIFY, [b'refund', self.addr_to, BigInteger(123000)], self.contract_hash, 91349, self.event_tx, True, False) stream = StreamManager.GetStream() writer = BinaryWriter(stream) sc.Serialize(writer) out = bytes(stream.getvalue()) StreamManager.ReleaseStream(stream) new_event = SmartContractEvent.FromByteArray(out) self.assertEqual(new_event.event_type, sc.event_type) self.assertEqual(new_event.contract_hash, sc.contract_hash) self.assertEqual(new_event.test_mode, sc.test_mode) self.assertEqual(new_event.tx_hash, sc.tx_hash) self.assertEqual(new_event.block_number, sc.block_number) self.assertEqual(new_event.notify_type, b'refund') self.assertEqual(new_event.AddressTo, 'AKZmSGPD7ytJBbxpRPmobYGLNxdWH3Jiqs') self.assertEqual(new_event.addr_from, sc.contract_hash) self.assertEqual(new_event.Amount, 123000) self.assertEqual(new_event.is_standard_notify, True)
def test_2_serialize_single_notify_payload(self): sc = NotifyEvent(SmartContractEvent.RUNTIME_NOTIFY, [b'hello'], self.contract_hash, 99, self.event_tx, True, False) stream = StreamManager.GetStream() writer = BinaryWriter(stream) sc.Serialize(writer) out = bytes(stream.getvalue()) self.assertEqual( out, b'\x1cSmartContract.Runtime.Notify\x11\xc4\xd1\xf4\xfb\xa6\x19\xf2b\x88p\xd3n:\x97s\xe8tp[c\x00\x00\x00\x90\xe4\xf1\xbbb\x8e\xf1\x07\xde\xe9\xf0\xd2\x12\xd1w\xbco\x844\x07=\x1b\xa7\x1f\xa7\x94`\x0b\xb4\x88|K\x05hello' ) StreamManager.ReleaseStream(stream) new_event = SmartContractEvent.FromByteArray(out) self.assertEqual(new_event.event_type, sc.event_type) self.assertEqual(new_event.contract_hash, sc.contract_hash) self.assertEqual(new_event.test_mode, sc.test_mode) self.assertEqual(new_event.tx_hash, sc.tx_hash) self.assertEqual(new_event.block_number, sc.block_number) self.assertEqual(new_event.notify_type, b'hello') self.assertEqual(new_event.AddressFrom, None) self.assertEqual(new_event.AddressTo, None) self.assertEqual(new_event.Amount, 0) self.assertEqual(new_event.is_standard_notify, False)
def get_tx_data(self): ms = MemoryStream() w = BinaryWriter(ms) self.SerializeUnsigned(w) ms.flush() tx_data = ms.ToArray().decode() return tx_data
def Serialize(self, writer: BinaryWriter): """ Serialize object. Args: writer (neo.IO.BinaryWriter): """ writer.WriteSerializableArray(self.Headers)
def Trim(self): """ Returns a byte array that contains only the block header and transaction hash. Returns: bytes: """ ms = StreamManager.GetStream() writer = BinaryWriter(ms) self.SerializeUnsigned(writer) writer.WriteByte(1) self.Script.Serialize(writer) writer.WriteHashes([tx.Hash.ToBytes() for tx in self.Transactions]) retVal = ms.ToArray() StreamManager.ReleaseStream(ms) return retVal
def deploy(from_addr, bytecode, contract_params, return_type, details): response = requests.post('http://127.0.0.1:20332', json={ 'jsonrpc': '2.0', 'id': 1, 'method': 'mw_construct_deploy_tx', 'params': [{ 'from_addr': from_addr, 'bin': bytecode, 'contract_params': contract_params, 'return_type': return_type, 'details': details, }] }).json() if 'error' in response: print(response['error']['message']) return context = response['result']['context'] binary_tx = response['result']['tx'] contract_hash = response['result']['hash'] tx = ContractTransaction.DeserializeFromBufer( binascii.unhexlify(binary_tx)) scripts = requests.post('http://127.0.0.1:5000/neo_sign/', json={ 'binary_tx': binary_tx }).json() tx.scripts = [ Witness( x['invocation'].encode(), x['verification'].encode(), ) for x in scripts ] ms = StreamManager.GetStream() writer = BinaryWriter(ms) tx.Serialize(writer) ms.flush() signed_tx = ms.ToArray() response = requests.post('http://127.0.0.1:20332', json={ 'jsonrpc': '2.0', 'id': 1, 'method': 'sendrawtransaction', 'params': [ signed_tx.decode(), ] }).json() print('contract hash:', contract_hash) print(response)
def test_token_serialize(self): wallet = self.GetWallet1(recreate=True) token = self.get_token(wallet) stream = StreamManager.GetStream() writer = BinaryWriter(stream) token.Serialize(writer) self.assertEqual(b'0f4e45582054656d706c617465205634044e58543408', stream.ToArray())
def send(addr_from, addr_to, asset, amount): response = requests.post('http://127.0.0.1:20332', json={ 'jsonrpc': '2.0', 'id': 1, 'method': 'mw_construct_send_tx', 'params': { 'from': addr_from, 'to': addr_to, 'asset': asset, 'amount': amount, } }).json() print(response) context = response['result']['context'] binary_tx = response['result']['tx'] tx = ContractTransaction.DeserializeFromBufer( binascii.unhexlify(binary_tx)) scripts = requests.post('http://127.0.0.1:5000/neo_sign/', json={ 'binary_tx': binary_tx, 'address': addr_from }).json() print('scripts', scripts) tx.scripts = [ Witness( x['invocation'].encode(), x['verification'].encode(), ) for x in scripts ] print(scripts) ms = StreamManager.GetStream() writer = BinaryWriter(ms) tx.Serialize(writer) ms.flush() signed_tx = ms.ToArray() print(tx.ToJson()) # print('does not send: return') ; return response = requests.post('http://127.0.0.1:20332', json={ 'jsonrpc': '2.0', 'id': 1, 'method': 'sendrawtransaction', 'params': [ signed_tx.decode(), ] }).json() print(response)
def GetHashData(self): """ Get the hashable data. Returns: bytes: """ ms = MemoryStream() w = BinaryWriter(ms) self.SerializeUnsigned(w) ms.flush() return ms.ToArray()
def test_token_serialize(self): wallet = self.GetWallet1(recreate=True) ImportToken(wallet, self.token_hash_str) token = self.get_token(wallet) stream = StreamManager.GetStream() writer = BinaryWriter(stream) token.Serialize(writer) self.assertEqual(b'0d4e455035205374616e64617264044e45503508', stream.ToArray())
def ToByteArray(self): """ Serialize self and get the byte stream. Returns: bytes: serialized object. """ ms = StreamManager.GetStream() writer = BinaryWriter(ms) self.Serialize(writer) retval = ms.ToArray() StreamManager.ReleaseStream(ms) return retval
def deploy(self, contract_params='0710', return_type='05'): self.compile() from_addr = NETWORKS[self.contract.network.name]['address'] bytecode = self.neo_contract_crowdsale.bytecode neo_int = NeoInt(self.contract.network.name) print('from address', from_addr) details = { 'name': 'WISH', 'description': 'NEO smart contract', 'email': '*****@*****.**', 'version': '1', 'author': 'MyWish' } param_list = { 'from_addr': from_addr, 'bin': bytecode, 'needs_storage': True, 'needs_dynamic_invoke': False, 'contract_params': contract_params, 'return_type': return_type, 'details': details, } response = neo_int.mw_construct_deploy_tx(param_list) print('construct response', response, flush=True) binary_tx = response['tx'] contract_hash = response['hash'] tx = ContractTransaction.DeserializeFromBufer( binascii.unhexlify(binary_tx)) tx = sign_neo_transaction(tx, binary_tx, from_addr) print('after sign', tx.ToJson()['txid'], flush=True) ms = StreamManager.GetStream() writer = BinaryWriter(ms) tx.Serialize(writer) ms.flush() signed_tx = ms.ToArray() print('full tx:', flush=True) print(signed_tx, flush=True) result = neo_int.sendrawtransaction(signed_tx.decode()) print(result, flush=True) if not result: raise TxFail() print('contract hash:', contract_hash) print('result of send raw transaction: ', result) self.neo_contract_crowdsale.address = contract_hash self.neo_contract_crowdsale.tx_hash = tx.ToJson()['txid'] self.neo_contract_crowdsale.save()
def Runtime_Serialize(self, engine): stack_item = engine.EvaluationStack.Pop() ms = StreamManager.GetStream() writer = BinaryWriter(ms) try: stack_item.Serialize(writer) except Exception as e: logger.error("Cannot serialize item %s: %s " % (stack_item, e)) return False ms.flush() retVal = ByteArray(ms.getvalue()) StreamManager.ReleaseStream(ms) engine.EvaluationStack.PushT(retVal) return True
def GetHashData(hashable): """ Get the data used for hashing. Args: hashable (neo.IO.Mixins.SerializableMixin): object extending SerializableMixin Returns: bytes: """ ms = StreamManager.GetStream() writer = BinaryWriter(ms) hashable.SerializeUnsigned(writer) ms.flush() retVal = ms.ToArray() StreamManager.ReleaseStream(ms) return retVal
def test_data_received(self, mock): node = NeoNode() node.endpoint = Endpoint('hello.com', 1234) node.host = node.endpoint.host node.port = node.endpoint.port payload = VersionPayload(10234, 1234, 'version') message = Message('version', payload=payload) stream = StreamManager.GetStream() writer = BinaryWriter(stream) message.Serialize(writer) out = stream.getvalue() node.dataReceived(out) mock.assert_called_once() self.assertEqual(node.Version.Nonce, payload.Nonce)
def ToJson(self): jsn = {} jsn['type'] = 'Neo.Core.ContractTransaction' # Verifiable.GetType().FullName ms = MemoryStream() w = BinaryWriter(ms) self.Verifiable.SerializeUnsigned(w) ms.flush() jsn['hex'] = ms.ToArray().decode() jsn['items'] = {} for key, value in self.ContextItems.items(): if type(key) == str: shkey = "0x{}".format(key) else: shkey = "0x{}".format(key.decode()) jsn['items'][shkey] = value.ToJson() return jsn
def ToArray(value): """ Serialize the given `value` to a an array of bytes. Args: value (neo.IO.Mixins.SerializableMixin): object extending SerializableMixin. Returns: bytes: """ ms = StreamManager.GetStream() writer = BinaryWriter(ms) value.Serialize(writer) retVal = ms.ToArray() StreamManager.ReleaseStream(ms) return retVal