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_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_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_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_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_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_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_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 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 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_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_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 GetTransaction(self, hash): if type(hash) is str: hash = hash.encode('utf-8') elif type(hash) is UInt256: hash = hash.ToBytes() out = self._db.get(DBPrefix.DATA_Transaction + hash) if out is not None: out = bytearray(out) height = int.from_bytes(out[:4], 'little') out = out[4:] outhex = binascii.unhexlify(out) return Transaction.DeserializeFromBufer(outhex, 0), height return None, -1
def GetTransaction(self, hash): if not type(hash) is bytes: hash = hash.encode('utf-8') out = self._db.get(DBPrefix.DATA_Transaction + hash) if out is not None: out = bytearray(out) height = int.from_bytes(out[:4], 'little') out = out[4:] outhex = binascii.unhexlify(out) return Transaction.DeserializeFromBufer(outhex, 0), height raise Exception("Colud not find transaction for hash %s " % hash)
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 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 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_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 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_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 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_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() 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_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 json_rpc_method_handler(self, method, params): if method == "getaccountstate": acct = Blockchain.Default().GetAccountState(params[0]) if acct is None: try: acct = AccountState( script_hash=Helper.AddrStrToScriptHash(params[0])) except Exception as e: raise JsonRpcError( -2146233033, "One of the identified items was in an invalid format." ) return acct.ToJson() elif method == "getassetstate": asset_id = UInt256.ParseString(params[0]) asset = Blockchain.Default().GetAssetState(asset_id.ToBytes()) if asset: return asset.ToJson() raise JsonRpcError(-100, "Unknown asset") elif method == "getbestblockhash": return '0x%s' % Blockchain.Default().CurrentHeaderHash.decode( 'utf-8') elif method == "getblock": # this should work for either str or int block = Blockchain.Default().GetBlock(params[0]) if not block: raise JsonRpcError(-100, "Unknown block") return self.get_block_output(block, params) elif method == "getblockcount": return Blockchain.Default().Height + 1 elif method == "getblockhash": height = params[0] if height >= 0 and height <= Blockchain.Default().Height: return '0x%s' % Blockchain.Default().GetBlockHash( height).decode('utf-8') else: raise JsonRpcError(-100, "Invalid Height") elif method == "getblocksysfee": height = params[0] if height >= 0 and height <= Blockchain.Default().Height: return Blockchain.Default().GetSysFeeAmountByHeight(height) else: raise JsonRpcError(-100, "Invalid Height") elif method == "getconnectioncount": return len(NodeLeader.Instance().Peers) elif method == "getcontractstate": script_hash = UInt160.ParseString(params[0]) contract = Blockchain.Default().GetContract(script_hash.ToBytes()) if contract is None: raise JsonRpcError(-100, "Unknown contract") return contract.ToJson() elif method == "getrawmempool": return list( map(lambda hash: "0x%s" % hash.decode('utf-8'), NodeLeader.Instance().MemPool.keys())) elif method == "getversion": return { "port": self.port, "nonce": NodeLeader.Instance().NodeId, "useragent": settings.VERSION_NAME } elif method == "getrawtransaction": tx_id = UInt256.ParseString(params[0]) tx, height = Blockchain.Default().GetTransaction(tx_id) if not tx: raise JsonRpcError(-100, "Unknown Transaction") return self.get_tx_output(tx, height, params) elif method == "getstorage": script_hash = UInt160.ParseString(params[0]) key = binascii.unhexlify(params[1].encode('utf-8')) storage_key = StorageKey(script_hash=script_hash, key=key) storage_item = Blockchain.Default().GetStorageItem(storage_key) if storage_item: return storage_item.Value.hex() return None elif method == "gettxout": hash = params[0].encode('utf-8') index = params[1] utxo = Blockchain.Default().GetUnspent(hash, index) if utxo: return utxo.ToJson(index) else: return None elif method == "invoke": shash = UInt160.ParseString(params[0]) contract_parameters = [ ContractParameter.FromJson(p) for p in params[1] ] sb = ScriptBuilder() sb.EmitAppCallWithJsonArgs(shash, contract_parameters) return self.get_invoke_result(sb.ToArray()) elif method == "invokefunction": contract_parameters = [] if len(params) > 2: contract_parameters = [ ContractParameter.FromJson(p).ToVM() for p in params[2] ] sb = ScriptBuilder() sb.EmitAppCallWithOperationAndArgs(UInt160.ParseString(params[0]), params[1], contract_parameters) return self.get_invoke_result(sb.ToArray()) elif method == "invokescript": script = params[0].encode('utf-8') return self.get_invoke_result(script) elif method == "sendrawtransaction": tx_script = binascii.unhexlify(params[0].encode('utf-8')) transaction = Transaction.DeserializeFromBufer(tx_script) result = NodeLeader.Instance().Relay(transaction) return result elif method == "validateaddress": return self.validateaddress(params) elif method == "getpeers": return self.get_peers() elif method == "getbalance": if self.wallet: return self.get_balance(params) else: raise JsonRpcError(-400, "Access denied.") elif method == "getwalletheight": if self.wallet: return self.wallet.WalletHeight else: raise JsonRpcError(-400, "Access denied.") elif method == "listaddress": if self.wallet: return self.list_address() else: raise JsonRpcError(-400, "Access denied.") elif method == "getnewaddress": if self.wallet: keys = self.wallet.CreateKey() account = Account.get( PublicKeyHash=keys.PublicKeyHash.ToBytes()) return account.contract_set[0].Address.ToString() else: raise JsonRpcError(-400, "Access denied.") raise JsonRpcError.methodNotFound()
def json_rpc_method_handler(self, method, params): if method == "getaccountstate": acct = Blockchain.Default().GetAccountState(params[0]) if acct is None: try: acct = AccountState(script_hash=Helper.AddrStrToScriptHash(params[0])) except Exception as e: raise JsonRpcError(-2146233033, "One of the identified items was in an invalid format.") return acct.ToJson() elif method == "getassetstate": asset_id = UInt256.ParseString(params[0]) asset = Blockchain.Default().GetAssetState(asset_id.ToBytes()) if asset: return asset.ToJson() raise JsonRpcError(-100, "Unknown asset") elif method == "getbestblockhash": return '0x%s' % Blockchain.Default().CurrentHeaderHash.decode('utf-8') elif method == "getblock": # this should work for either str or int block = Blockchain.Default().GetBlock(params[0]) if not block: raise JsonRpcError(-100, "Unknown block") return self.get_block_output(block, params) elif method == "getblockcount": return Blockchain.Default().Height + 1 elif method == "getblockhash": height = params[0] if height >= 0 and height <= Blockchain.Default().Height: return '0x%s' % Blockchain.Default().GetBlockHash(height).decode('utf-8') else: raise JsonRpcError(-100, "Invalid Height") elif method == "getblocksysfee": height = params[0] if height >= 0 and height <= Blockchain.Default().Height: return Blockchain.Default().GetSysFeeAmountByHeight(height) else: raise JsonRpcError(-100, "Invalid Height") elif method == "getconnectioncount": return len(NodeLeader.Instance().Peers) elif method == "getcontractstate": script_hash = UInt160.ParseString(params[0]) contract = Blockchain.Default().GetContract(script_hash.ToBytes()) if contract is None: raise JsonRpcError(-100, "Unknown contract") return contract.ToJson() elif method == "getrawmempool": return list(map(lambda hash: "0x%s" % hash.decode('utf-8'), NodeLeader.Instance().MemPool.keys())) elif method == "getversion": return { "port": self.port, "nonce": NodeLeader.Instance().NodeId, "useragent": settings.VERSION_NAME } elif method == "getrawtransaction": tx_id = UInt256.ParseString(params[0]) tx, height = Blockchain.Default().GetTransaction(tx_id) if not tx: raise JsonRpcError(-100, "Unknown Transaction") return self.get_tx_output(tx, height, params) elif method == "getstorage": script_hash = UInt160.ParseString(params[0]) key = binascii.unhexlify(params[1].encode('utf-8')) storage_key = StorageKey(script_hash=script_hash, key=key) storage_item = Blockchain.Default().GetStorageItem(storage_key) if storage_item: return storage_item.Value.hex() return None elif method == "gettxout": hash = params[0].encode('utf-8') index = params[1] utxo = Blockchain.Default().GetUnspent(hash, index) if utxo: return utxo.ToJson(index) else: return None elif method == "invoke": shash = UInt160.ParseString(params[0]) contract_parameters = [ContractParameter.FromJson(p) for p in params[1]] sb = ScriptBuilder() sb.EmitAppCallWithJsonArgs(shash, contract_parameters) return self.get_invoke_result(sb.ToArray()) elif method == "invokefunction": contract_parameters = [] if len(params) > 2: contract_parameters = [ContractParameter.FromJson(p).ToVM() for p in params[2]] sb = ScriptBuilder() sb.EmitAppCallWithOperationAndArgs(UInt160.ParseString(params[0]), params[1], contract_parameters) return self.get_invoke_result(sb.ToArray()) elif method == "invokescript": script = params[0].encode('utf-8') return self.get_invoke_result(script) elif method == "sendrawtransaction": tx_script = binascii.unhexlify(params[0].encode('utf-8')) transaction = Transaction.DeserializeFromBufer(tx_script) result = NodeLeader.Instance().Relay(transaction) return result elif method == "mw_construct_send_tx": return MyWishMethods.construct_send_tx(self.wallet, params) elif method == "mw_construct_deploy_tx": return MyWishMethods.construct_deploy_tx(self.wallet, params) elif method == "mw_construct_invoke_tx": return MyWishMethods.construct_invoke_tx(self.wallet, params) elif method == "getapplicationlog": assert(all([x in '1234567890abcdefABCDEFxX' for x in params[0]])) # prevent traversal try: with open('/home/neo/neo-python/notis/' + params[0]) as f: res = [json.loads(x) for x in f.read().split('\n') if x] return [{'name': x['notify_type'], 'contract': x['contract'], 'args': x['payload']} for x in res] except FileNotFoundError: return ([]) elif method == "submitblock": raise NotImplementedError() elif method == "validateaddress": return self.validateaddress(params) elif method == "getpeers": return self.get_peers() raise JsonRpcError.methodNotFound()
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