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 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_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 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 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 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 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 Deserialize(self, reader):
super(Block,self).Deserialize(reader)
self.Transactions = []
byt = reader.ReadVarInt()
transaction_length = byt
if transaction_length < 1:
raise Exception('Invalid format')
for i in range(0, transaction_length):
tx = Transaction.DeserializeFrom(reader)
self.Transactions.append(tx)
if MerkleTree.ComputeRoot( [tx.Hash for tx in self.Transactions]) != self.MerkleRoot:
raise Exception("Merkle Root Mismatch")
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 test_verify_claim_tx_high_priority(self):
ms = MemoryStream(binascii.unhexlify(self.cltx))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(tx.ToArray(), self.cltx)
self.assertEqual(tx.Hash.ToBytes(), self.cltx_id)
snapshot = GetBlockchain()._db.createSnapshot()
with patch("neo.Core.TX.Transaction.Transaction.Size", return_value=(settings.MAX_FREE_TX_SIZE + 1)):
with patch('neo.SmartContract.Helper.Helper.VerifyWitnesses', return_value=True): # we are not testing VerifyScripts
with patch('neo.Core.Blockchain.Blockchain.CalculateBonusIgnoreClaimed', return_value=Fixed8.FromDecimal(0.30551243)):
res = tx.Verify(snapshot, [tx])
self.assertTrue(res)
tx_size = tx.Size()
self.assertGreater(tx_size, settings.MAX_FREE_TX_SIZE)
def test_verify_exceeds_max_tx_size(self):
ms = MemoryStream(binascii.unhexlify(self.vvtx))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
tx._network_fee = Fixed8.FromDecimal(0.001)
self.assertEqual(tx.ToArray(), self.vvtx)
self.assertEqual(tx.Hash.ToBytes(), self.vvtx_id)
snapshot = GetBlockchain()._db.createSnapshot()
with patch("neo.Core.TX.Transaction.Transaction.Size", return_value=(Transaction.MAX_TX_SIZE + 1)):
res = tx.Verify(snapshot, [tx])
self.assertFalse(res)
tx_size = tx.Size()
self.assertGreater(tx_size, Transaction.MAX_TX_SIZE)
def test_GetScriptHashesForVerifying_DutyFlag(self):
# test a raw tx
ms = MemoryStream(binascii.unhexlify(self.rtx))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
tx.raw_tx = True
# create the mocked asset
mock_asset = AssetState()
mock_asset.AssetType = 0x80
snapshot = GetBlockchain()._db.createSnapshot()
with patch("neo.Core.Helper.Helper.StaticAssetState", return_value=mock_asset):
res = tx.GetScriptHashesForVerifying(snapshot)
self.assertTrue(type(res), list)
self.assertEqual(res[0], Helper.AddrStrToScriptHash("AJQ6FoaSXDFzA6wLnyZ1nFN7SGSN2oNTc3"))
def DeserializeForImport(self, reader):
"""
Deserialize full object.
Args:
reader (neo.IO.BinaryReader):
"""
super(Block, self).Deserialize(reader)
self.Transactions = []
transaction_length = reader.ReadVarInt()
for i in range(0, transaction_length):
tx = Transaction.DeserializeFrom(reader)
self.Transactions.append(tx)
if len(self.Transactions) < 1:
raise Exception('Invalid format %s ' % self.Index)
def test_invocation_txn_size(self):
""" For more information about the following test read here
https://github.com/neo-project/neo/issues/652
"""
raw_tx = b"d1015904802b530b14d5a682e81b8a840cc44b3b360cbd0f1ee6f50efd14235a717ed7ed18a43de47499c3d05b8d4a4bcf3a53c1087472616e7366657267fb1c540417067c270dee32f21023aa8b9b71abcef166fc47646b02d3f92300000000000000000120235a717ed7ed18a43de47499c3d05b8d4a4bcf3a0000014140b9234cad658c4d512bca453908a0df1c2beda49c544ec735bb492b81b4d0974ac8d66046061b3d0ce823e27c71fef1ee6a8f2fa369198ac74acedd045901d7222321030ab39b99d8675cd9bd90aaec37cba964297cc817078d33e508ab11f1d245c068ac"
raw_tx_id = b"c4bb9b638da2e5f4a88ffcc4cb1d4f6693e7f19b7f78d242068254a6c77721f9" # see https://neoscan.io/transaction/C4BB9B638DA2E5F4A88FFCC4CB1D4F6693E7F19B7F78D242068254A6C77721F9
mstream = StreamManager.GetStream(binascii.unhexlify(raw_tx))
reader = BinaryReader(mstream)
tx = Transaction.DeserializeFrom(reader)
mstream.Cleanup()
self.assertEqual(tx.ToArray(), raw_tx)
self.assertEqual(tx.Hash.ToBytes(), raw_tx_id)
txjson = tx.ToJson()
self.assertEqual(227, txjson['size'])
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 test_claim_tx(self):
ms = MemoryStream(binascii.unhexlify(self.cltx))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(tx.ToArray(), self.cltx)
self.assertEqual(tx.Hash.ToBytes(), self.cltx_id)
json = tx.ToJson()
self.assertEqual(json['size'], 577)
self.assertEqual(json['type'], "ClaimTransaction")
self.assertEqual(json['version'], 0)
self.assertEqual(len(json['attributes']), 0)
self.assertEqual(len(json['vout']), 1)
self.assertEqual(len(json['vin']), 0)
self.assertEqual(json['sys_fee'], "0")
self.assertEqual(json['net_fee'], "0")
self.assertEqual(len(json['claims']), 12)
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()
self.assertEqual(json['size'], 613)
self.assertEqual(json['type'], 'PublishTransaction')
contract = json['contract']
self.assertEqual(contract['author'], 'Erik Zhang')
self.assertEqual(contract['description'], 'Lock your assets until a timestamp.')
self.assertEqual(contract['code']['hash'], '0xffbd1a7ad1e2348b6b3822426f364bfb4bcce3b9')
self.assertEqual(contract['code']['returntype'], "Boolean")
self.assertEqual(contract['code']['parameters'], ['Integer', 'ByteArray', 'Signature'])
self.assertEqual(Fixed8.FromDecimal(settings.ALL_FEES['PublishTransaction']), tx.SystemFee())
def test_verify_exceeds_free_tx_size_less_low_priority_threshhold(self):
ms = MemoryStream(binascii.unhexlify(self.vtx))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(tx.ToArray(), self.vtx)
self.assertEqual(tx.Hash.ToBytes(), self.vtx_id)
snapshot = GetBlockchain()._db.createSnapshot()
res = tx.Verify(snapshot, [tx])
self.assertFalse(res)
tx_size = tx.Size()
self.assertGreater(tx_size, settings.MAX_FREE_TX_SIZE)
req_fee = Fixed8.FromDecimal(settings.FEE_PER_EXTRA_BYTE * (tx_size - settings.MAX_FREE_TX_SIZE))
self.assertLess(req_fee, settings.LOW_PRIORITY_THRESHOLD)
n_fee = tx.NetworkFee()
self.assertEqual(n_fee.ToString(), '0')
self.assertLess(n_fee, req_fee)
def test_issue_tx(self):
ms = MemoryStream(binascii.unhexlify(self.ii))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(self.ii_id, tx.Hash.ToBytes())
json = tx.ToJson()
self.assertEqual(json['size'], 69)
self.assertEqual(json['type'], "IssueTransaction")
self.assertEqual(json['version'], 0)
self.assertEqual(len(json['attributes']), 0)
jsn_vout = json['vout'][0]
self.assertEqual(jsn_vout['asset'], "0xc56f33fc6ecfcd0c225c4ab356fee59390af8560be0e930faebe74a6daff7c9b")
self.assertEqual(jsn_vout['value'], "100000000")
self.assertEqual(jsn_vout['address'], "AQVh2pG732YvtNaxEGkQUei3YA4cvo7d2i")
self.assertEqual(len(json['vin']), 0)
self.assertEqual(json['sys_fee'], "0")
self.assertEqual(json['net_fee'], "0")
self.assertEqual(json['scripts'][0]['invocation'], "")
self.assertEqual(json['scripts'][0]['verification'], "51")
def Deserialize(self, reader):
super(TransactionState, self).Deserialize(reader)
self.BlockIndex = reader.ReadUInt32()
self.Transaction = Transaction.DeserializeFrom(reader)
def OnMessageReceived(self, message):
self.__log.debug("ON MESSAGE RECEIVED:::::::::: %s " % message.Command)
if message.Command == "addr":
self.OnAddrMessageReceived(
IOHelper.AsSerializableWithType(
message.Payload,
'neo.Network.Payloads.AddrPayload.AddrPayload'))
elif message.Command == "block":
self.OnInventoryReceived(
IOHelper.AsSerializableWithType(message.Payload,
'neo.Core.Block.Block'))
elif message.Command == 'consensus':
self.OnInventoryReceived(
IOHelper.AsSerializableWithType(
message.Payload,
'neo.Network.Payloads.ConsensusPayload.ConsensusPayload'))
elif message.Command == 'filteradd':
pass
elif message.Command == 'filterclear':
pass
elif message.Command == 'filterload':
pass
elif message.Command == 'getaddr':
self.OnGetAddrMessageReceived()
elif message.Command == 'getblocks':
self.OnGetBlocksMessageReceived(
IOHelper.AsSerializableWithType(
message.Payload,
'neo.Network.Payloads.GetBlocksPayload.GetBlocksPayload'))
elif message.Command == 'getdata':
self.OnGetDataMessageReceived(
IOHelper.AsSerializableWithType(
message.Payload,
'neo.Network.Payloads.InvPayload.InvPayload'))
elif message.Command == 'getheaders':
self.OnGetHeadersMessageReceived(
IOHelper.AsSerializableWithType(
message.Payload,
'neo.Network.Payloads.GetBlocksPayload.GetBlocksPayload'))
elif message.Command == 'headers':
self.OnHeadersMessageReceived(
IOHelper.AsSerializableWithType(
message.Payload,
'neo.Network.Payloads.HeadersPayload.HeadersPayload'))
elif message.Command == 'inv':
self.OnInvMessageReceived(
IOHelper.AsSerializableWithType(
message.Payload,
'neo.Network.Payloads.InvPayload.InvPayload'))
elif message.Command == 'mempool':
self.OnMemPoolMessageReceived()
elif message.Command == 'tx':
if len(message.Payload) < 1024 * 1024:
self.OnInventoryReceived(
Transaction.DeserializeFrom(message.Payload))
elif message.Command in [
'verack',
'version',
]:
self.Disconnect(True)
elif message.Command in [
"alert",
"merkleblock",
"notfound",
"ping",
"pong",
"reject",
]:
pass
