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