def FromJson(jsn, isMultiSig=True):
try:
parsed = json.loads(jsn)
if parsed['type'] == 'Neo.Core.ContractTransaction':
verifiable = ContractTransaction()
ms = StreamManager.GetStream(binascii.unhexlify(parsed['hex']))
r = BinaryReader(ms)
verifiable.DeserializeUnsigned(r)
StreamManager.ReleaseStream(ms)
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_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_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 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 DeserializeFromBufer(buffer, offset=0):
mstream = StreamManager.GetStream(buffer)
reader = BinaryReader(mstream)
tx = Transaction.DeserializeFrom(reader)
StreamManager.ReleaseStream(mstream)
return tx
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 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_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 test_1_serialize_runtime_log(self):
print("%s", self.contract_hash)
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_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 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 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 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 DeserializeFromDB(buffer):
m = StreamManager.GetStream(buffer)
reader = BinaryReader(m)
v = StorageItem()
v.Deserialize(reader)
StreamManager.ReleaseStream(m)
return v
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 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
with self._db.write_batch() as wb:
if self._db.get(DBPrefix.DATA_Block + hHash) is None:
wb.put(DBPrefix.DATA_Block + hHash,
bytes(8) + header.ToArray())
wb.put(DBPrefix.SYS_CurrentHeader,
hHash + header.Index.to_bytes(4, 'little'))
def ToByteArray(self):
stream = StreamManager.GetStream()
writer = BinaryWriter(stream)
self.Serialize(writer)
out = stream.getvalue()
StreamManager.ReleaseStream(stream)
return out
def UpdateInternal(self, key, value):
if self.batch:
stream = StreamManager.GetStream()
bw = BinaryWriter(stream)
value.Serialize(bw)
self.batch.put(self.prefix + key, stream.ToArray())
StreamManager.ReleaseStream(stream)
def GetHashData(hashable):
ms = StreamManager.GetStream()
writer = BinaryWriter(ms)
hashable.SerializeUnsigned(writer)
ms.flush()
retVal = ms.ToArray()
StreamManager.ReleaseStream(ms)
return retVal
def ToByteArray(self):
ms = StreamManager.GetStream()
writer = BinaryWriter(ms)
self.Serialize(writer)
retval = ms.ToArray()
StreamManager.ReleaseStream(ms)
return retval
def DeserializeFromDB(buffer):
m = StreamManager.GetStream(buffer)
reader = BinaryReader(m)
spentcoin = SpentCoinState()
spentcoin.Deserialize(reader)
StreamManager.ReleaseStream(m)
return spentcoin
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 Trim(self):
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 ToArray( value ):
ms = StreamManager.GetStream()
writer = BinaryWriter(ms)
value.Serialize(writer)
retVal = ms.ToArray()
StreamManager.ReleaseStream(ms)
return retVal
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 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
return False
finally:
StreamManager.ReleaseStream(ms)
return True
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 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 show_mem(self):
process = psutil.Process(os.getpid())
total = process.memory_info().rss
totalmb = total / (1024 * 1024)
out = "Total: %s MB\n" % totalmb
out += "Total buffers: %s\n" % StreamManager.TotalBuffers()
print_tokens([(Token.Number, out)], self.token_style)
