def main(): # Use PrivateNet settings.setup_privnet() # Setup the blockchain blockchain = LevelDBBlockchain(settings.chain_leveldb_path) Blockchain.RegisterBlockchain(blockchain) dbloop = task.LoopingCall(Blockchain.Default().PersistBlocks) dbloop.start(.1) NodeLeader.Instance().Start() # Disable smart contract events for external smart contracts settings.set_log_smart_contract_events(False) # Start a thread with custom code d = threading.Thread(target=custom_background_code) d.setDaemon( True ) # daemonizing the thread will kill it when the main thread is quit d.start() # Run all the things (blocking call) logger.info("Everything setup and running. Waiting for events...") reactor.run() logger.info("Shutting down.")
def get_peers(self): """Get all known nodes and their "state" In the current implementation of NodeLeader there is no way to know which nodes are bad. """ node = NodeLeader.Instance() result = {"connected": [], "unconnected": [], "bad": []} connected_peers = [] for peer in node.Peers: result['connected'].append({ "address": peer.host, "port": peer.port }) connected_peers.append("{}:{}".format(peer.host, peer.port)) # "UnconnectedPeers" is never used. So a check is needed to # verify that a given address:port does not belong to a connected peer for peer in node.ADDRS: addr, port = peer.split(':') if peer not in connected_peers: result['unconnected'].append({ "address": addr, "port": int(port) }) return result
def main(): # Setup the blockchain blockchain = LevelDBBlockchain(settings.LEVELDB_PATH) Blockchain.RegisterBlockchain(blockchain) dbloop = task.LoopingCall(Blockchain.Default().PersistBlocks) dbloop.start(.1) NodeLeader.Instance().Start() # Disable smart contract events for external smart contracts settings.set_log_smart_contract_events(False) # Start a thread with custom code d = threading.Thread(target=custom_background_code) d.setDaemon(True) # daemonizing the thread will kill it when the main thread is quit d.start() # Hook up Klein API to Twisted reactor endpoint_description = "tcp:port=%s:interface=localhost" % API_PORT endpoint = endpoints.serverFromString(reactor, endpoint_description) endpoint.listen(Site(app.resource())) # Run all the things (blocking call) logger.info("Everything setup and running. Waiting for events...") reactor.run() logger.info("Shutting down.")
def run(self): dbloop = task.LoopingCall(Blockchain.Default().PersistBlocks) dbloop.start(0.1) NodeLeader.Instance().Start() reactor.suggestThreadPoolSize(15) # reactor.callInThread(self.prompt) reactor.run(installSignalHandlers=False)
def __init__(self, incoming_client=False): """ Create an instance. The NeoNode class is the equivalent of the C# RemoteNode.cs class. It represents a single Node connected to the client. Args: incoming_client (bool): True if node is an incoming client and the handshake should be initiated. """ from neo.Network.NodeLeader import NodeLeader self.leader = NodeLeader.Instance() self.nodeid = self.leader.NodeId self.remote_nodeid = random.randint(1294967200, 4294967200) self.endpoint = '' self.buffer_in = bytearray() self.myblockrequests = set() self.bytes_in = 0 self.bytes_out = 0 self.host = None self.port = None self.identifier = self.leader.NodeCount self.leader.NodeCount += 1 self.incoming_client = incoming_client self.expect_verack_next = False self.Log("New Node created %s " % self.identifier)
def start_neo(): # Use TestNet settings.setup_testnet() # Setup the blockchain blockchain = LevelDBBlockchain(settings.chain_leveldb_path) Blockchain.RegisterBlockchain(blockchain) dbloop = task.LoopingCall(Blockchain.Default().PersistBlocks) dbloop.start(.1) NodeLeader.Instance().Start() wallet = UserWallet.Open(path, to_aes_key(password)) # wallet.Rebuild() _walletdb_loop = task.LoopingCall(wallet.ProcessBlocks()) _walletdb_loop.start(.1) print("Opened wallet at %s" % path) # Start a thread with custom code d = threading.Thread(target=custom_background_code) d.setDaemon( True ) # daemonizing the thread will kill it when the main thread is quit d.start() # Run all the things (blocking call) reactor.run() logger.info("Shutting down.")
def main(): conn = psycopg2.connect(connection_str) cursor = conn.cursor() ip_dict = getIpAddressMap(cursor) cursor.close() conn.close() # Use Custom config settings.setup("./config.json") settings.set_max_peers(500) # Setup the blockchain blockchain = LevelDBBlockchain(settings.chain_leveldb_path) Blockchain.RegisterBlockchain(blockchain) dbloop = task.LoopingCall(Blockchain.Default().PersistBlocks) dbloop.start(.1) NodeLeader.Instance().Start() # Start a thread with custom code d = threading.Thread(target=custom_background_code, args=( connection_str, ip_dict, )) d.setDaemon( True ) # daemonizing the thread will kill it when the main thread is quit d.start() # Run all the things (blocking call) reactor.run() logger.info("Shutting down.")
def get_peers(self): """Get all known nodes and their 'state' """ node = NodeLeader.Instance() result = {"connected": [], "unconnected": [], "bad": []} connected_peers = [] for peer in node.Peers: result['connected'].append({ "address": peer.host, "port": peer.port }) connected_peers.append("{}:{}".format(peer.host, peer.port)) for addr in node.DEAD_ADDRS: host, port = addr.rsplit(':', 1) result['bad'].append({"address": host, "port": port}) # "UnconnectedPeers" is never used. So a check is needed to # verify that a given address:port does not belong to a connected peer for addr in node.KNOWN_ADDRS: host, port = addr.rsplit(':', 1) if addr not in connected_peers: result['unconnected'].append({ "address": host, "port": int(port) }) return result
def main(): parser = argparse.ArgumentParser() parser.add_argument("-c", "--config", action="store", help="Config file (default. %s)" % PROTOCOL_CONFIG, default=PROTOCOL_CONFIG) args = parser.parse_args() settings.setup(args.config) logger.info("Starting api.py") logger.info("Config: %s", args.config) logger.info("Network: %s", settings.net_name) # Setup the blockchain blockchain = LevelDBBlockchain(settings.LEVELDB_PATH) Blockchain.RegisterBlockchain(blockchain) dbloop = task.LoopingCall(Blockchain.Default().PersistBlocks) dbloop.start(.1) NodeLeader.Instance().Start() # Disable smart contract events for external smart contracts settings.set_log_smart_contract_events(False) # Start a thread with custom code d = threading.Thread(target=custom_background_code) d.setDaemon(True) # daemonizing the thread will kill it when the main thread is quit d.start() # Run all the things (blocking call) logger.info("Everything setup and running. Waiting for events...") reactor.run() logger.info("Shutting down.")
def main(): settings.setup('protocol.coz.json') # Setup the blockchain blockchain = LevelDBBlockchain(settings.LEVELDB_PATH) Blockchain.RegisterBlockchain(blockchain) dbloop = task.LoopingCall(Blockchain.Default().PersistBlocks) dbloop.start(.1) NodeLeader.Instance().Start() # Disable smart contract events for external smart contracts settings.set_log_smart_contract_events(False) global Wallet Wallet = UserWallet.Open(path="infinitewallet", password="******") logger.info("Created the Wallet") logger.info(Wallet.AddressVersion) walletdb_loop = task.LoopingCall(Wallet.ProcessBlocks) walletdb_loop.start(1) #Wallet.CreateKey(KeyPair.PrivateKeyFromWIF(wif)) # Start a thread with custom code d = threading.Thread(target=custom_background_code) d.setDaemon(True) # daemonizing the thread will kill it when the main thread is quit d.start() # Run all the things (blocking call) logger.info("Everything setup and running. Waiting for events...") reactor.run() logger.info("Shutting down.")
def main(): # Use TestNet settings.setup_testnet() # Setup the blockchain blockchain = LevelDBBlockchain(settings.chain_leveldb_path) Blockchain.RegisterBlockchain(blockchain) dbloop = task.LoopingCall(Blockchain.Default().PersistBlocks) dbloop.start(.1) NodeLeader.Instance().Start() # Start a thread with custom code d = threading.Thread(target=custom_background_code) d.setDaemon( True ) # daemonizing the thread will kill it when the main thread is quit d.start() # Start a thread with custom code t = threading.Thread(target=custom_background_stateinfo) t.setDaemon( True ) # daemonizing the thread will kill it when the main thread is quit t.start() # Run all the things (blocking call) reactor.run() logger.info("Shutting down.")
def do_send_created_tx(self): passwd = self._gathered_passwords[0] tx = self._wallet_send_tx self._wallet_send_tx = None self._gathered_passwords = None self._gather_password_action = None if not self.Wallet.ValidatePassword(passwd): print("incorrect password") return try: context = ContractParametersContext(tx) self.Wallet.Sign(context) if context.Completed: tx.scripts = context.GetScripts() self.Wallet.SaveTransaction(tx) relayed = NodeLeader.Instance().Relay(tx) if relayed: print("Relayed Tx: %s " % tx.Hash.ToString()) else: print("Could not relay tx %s " % tx.Hash.ToString()) except Exception as e: print("could not sign %s " % e) traceback.print_stack() traceback.print_exc()
def InvokeWithTokenVerificationScript(wallet, tx, token, fee=Fixed8.Zero(), invoke_attrs=None): wallet_tx = wallet.MakeTransaction(tx=tx, fee=fee, use_standard=True) if wallet_tx: token_contract_state = Blockchain.Default().GetContract( token.ScriptHash.ToString()) print("token contract %s " % token_contract_state) tx.Attributes = [ TransactionAttribute(usage=TransactionAttributeUsage.Script, data=token.ScriptHash.Data) ] if invoke_attrs: tx.Attributes += invoke_attrs reedeem_script = token_contract_state.Code.Script.hex() # there has to be at least 1 param, and the first # one needs to be a signature param param_list = bytearray(b'\x00\x00') verification_contract = Contract.Create( reedeem_script, param_list, wallet.GetDefaultContract().PublicKeyHash) context = ContractParametersContext(wallet_tx) wallet.Sign(context) context.Add(verification_contract, 0, 0) if context.Completed: wallet_tx.scripts = context.GetScripts() relayed = NodeLeader.Instance().Relay(wallet_tx) if relayed: print("Relayed Tx: %s " % wallet_tx.Hash.ToString()) # if it was relayed, we save tx wallet.SaveTransaction(wallet_tx) return wallet_tx else: print("Could not relay tx %s " % wallet_tx.Hash.ToString()) else: print("Incomplete signature") else: print("Insufficient funds") return False
def quit(self): print('Commands completed.') self.running = False NodeLeader.Instance().Shutdown() Blockchain.Default().Dispose() NotificationDB.close() reactor.stop()
def process_transaction(self, contract_tx, fee=None, address_from=None, change_addr=None): standard_contract = self.wallet.GetStandardAddress() signer_contract = self.wallet.GetContract(standard_contract) try: tx = self.wallet.MakeTransaction(tx=contract_tx, change_address=change_addr, fee=fee, from_addr=address_from) except ValueError: # if not enough unspents while fully synced raise JsonRpcError(-300, "Insufficient funds") except TXFeeError as e: raise JsonRpcError(-300, e) if tx is None: # if not enough unspents while not being fully synced raise JsonRpcError(-300, "Insufficient funds") data = standard_contract.Data tx.Attributes = [ TransactionAttribute(usage=TransactionAttributeUsage.Script, data=data) ] context = ContractParametersContext( tx, isMultiSig=signer_contract.IsMultiSigContract ) self.wallet.Sign(context) if context.Completed: tx.scripts = context.GetScripts() self.wallet.SaveTransaction(tx) NodeLeader.Instance().Relay(tx) return tx.ToJson() else: return context.ToJson()
def test_relay(self): leader = NodeLeader.Instance() def mock_call_later(delay, method, *args): method(*args) def mock_connect_tcp(host, port, factory): node = NeoNode() node.endpoint = Endpoint(host, port) leader.AddConnectedPeer(node) return node def mock_send_msg(node, message): return True with patch('twisted.internet.reactor.connectTCP', mock_connect_tcp): with patch('twisted.internet.reactor.callLater', mock_call_later): with patch('neo.Network.NeoNode.NeoNode.SendSerializedMessage', mock_send_msg): leader.Start() miner = MinerTransaction() res = leader.Relay(miner) self.assertFalse(res) tx = self._generate_tx() res = leader.Relay(tx) self.assertEqual(res, True) self.assertTrue(tx.Hash.ToBytes() in leader.MemPool.keys()) res2 = leader.Relay(tx) self.assertFalse(res2)
def quit(self): print('Shutting down. This may take a bit...') self.go_on = False PromptData.close_wallet() Blockchain.Default().Dispose() NodeLeader.Instance().Shutdown() reactor.stop()
def main(): # Setup the blockchain settings.setup('protocol.faucet.json') blockchain = LevelDBBlockchain(settings.LEVELDB_PATH) Blockchain.RegisterBlockchain(blockchain) dbloop = task.LoopingCall(Blockchain.Default().PersistBlocks) dbloop.start(.1) NodeLeader.Instance().Start() # Start a thread with custom code # d = threading.Thread(target=custom_background_code) # d.setDaemon(True) # daemonizing the thread will kill it when the main thread is quit # d.start() # Run all the things (blocking call) #reactor.run() port = os.environ.get('FAUCET_PORT', 8080) host = os.environ.get('FAUCET_HOST', 'localhost') store = ItemStore() store.app.run(host, int(port)) logger.info("Shutting down.")
def InvokeContract(wallet, tx, fee=Fixed8.Zero()): wallet_tx = wallet.MakeTransaction(tx=tx, fee=fee) if wallet_tx: context = ContractParametersContext(wallet_tx) wallet.Sign(context) if context.Completed: wallet_tx.scripts = context.GetScripts() wallet.SaveTransaction(wallet_tx) relayed = NodeLeader.Instance().Relay(wallet_tx) if relayed: print("Relayed Tx: %s " % tx.Hash.ToString()) return True else: print("Could not relay tx %s " % tx.Hash.ToString()) else: print("Incomplete signature") else: print("Insufficient funds") return False
def sign_and_finish(self, wallet, jsn): context = ContractParametersContext.FromJson(jsn) if context is None: print("Failed to parse JSON") return None wallet.Sign(context) if context.Completed: print("Signature complete, relaying...") tx = context.Verifiable tx.scripts = context.GetScripts() wallet.SaveTransaction(tx) print("will send tx: %s " % json.dumps(tx.ToJson(), indent=4)) relayed = NodeLeader.Instance().Relay(tx) if relayed: print("Relayed Tx: %s " % tx.Hash.ToString()) self.wait_for_tx(tx) return('success') else: print("Could not relay tx %s " % tx.Hash.ToString()) return('fail') else: print("Transaction signed, but the signature is still incomplete") return(json.dumps(context.ToJson(), separators=(',', ':')))
def InvokeWithTokenVerificationScript(wallet, tx, token, fee=Fixed8.Zero()): wallet_tx = wallet.MakeTransaction(tx=tx, fee=fee, use_standard=True) if wallet_tx: token_contract_state = Blockchain.Default().GetContract(token.ScriptHash.ToString()) print("token contract %s " % token_contract_state) tx.Attributes = [ TransactionAttribute(usage=TransactionAttributeUsage.Script, data=token.ScriptHash.Data) ] reedeem_script = token_contract_state.Code.Script.hex() # there has to be at least 1 param, and the first # one needs to be a signature param param_list = bytearray(b'\x00\x00') verification_contract = Contract.Create(reedeem_script, param_list, wallet.GetDefaultContract().PublicKeyHash) context = ContractParametersContext(wallet_tx) wallet.Sign(context) context.Add(verification_contract, 0, 0) if context.Completed: wallet_tx.scripts = context.GetScripts() relayed = False # print("full wallet tx: %s " % json.dumps(wallet_tx.ToJson(), indent=4)) # toarray = Helper.ToArray(wallet_tx) # print("to arary %s " % toarray) # check if we can save the tx first save_tx = wallet.SaveTransaction(wallet_tx) if save_tx: relayed = NodeLeader.Instance().Relay(wallet_tx) else: print("Could not save tx to wallet, will not send tx") if relayed: print("Relayed Tx: %s " % wallet_tx.Hash.ToString()) return wallet_tx else: print("Could not relay tx %s " % wallet_tx.Hash.ToString()) else: print("Incomplete signature") else: print("Insufficient funds") return False
def InvokeWithdrawTx(wallet, tx, contract_hash): # print("withdraw tx 1 %s " % json.dumps(tx.ToJson(), indent=4)) requestor_contract = wallet.GetDefaultContract() tx.Attributes = [ TransactionAttribute(usage=TransactionAttributeUsage.Script, data=Crypto.ToScriptHash( requestor_contract.Script).Data) ] withdraw_contract_state = Blockchain.Default().GetContract( contract_hash.encode('utf-8')) withdraw_verification = None if withdraw_contract_state is not None: reedeem_script = withdraw_contract_state.Code.Script.hex() # there has to be at least 1 param, and the first # one needs to be a signature param param_list = bytearray(b'\x00') # if there's more than one param # we set the first parameter to be the signature param if len(withdraw_contract_state.Code.ParameterList) > 1: param_list = bytearray(withdraw_contract_state.Code.ParameterList) param_list[0] = 0 verification_contract = Contract.Create( reedeem_script, param_list, requestor_contract.PublicKeyHash) address = verification_contract.Address withdraw_verification = verification_contract context = ContractParametersContext(tx) wallet.Sign(context) context.Add(withdraw_verification, 0, 0) if context.Completed: tx.scripts = context.GetScripts() print("withdraw tx %s " % json.dumps(tx.ToJson(), indent=4)) wallet.SaveTransaction(tx) relayed = NodeLeader.Instance().Relay(tx) if relayed: print("Relayed Withdrawal Tx: %s " % tx.Hash.ToString()) return True else: print("Could not relay witdrawal tx %s " % tx.Hash.ToString()) else: print("Incomplete signature")
def execute(self, arguments): if len(arguments) in [1, 2]: if len(arguments) == 2: try: return NodeLeader.Instance().setBlockReqSizeAndMax( int(arguments[0]), int(arguments[1])) except ValueError: print( "Invalid values. Please specify a block request part and max size for each node, like 30 and 1000" ) return False elif len(arguments) == 1: return NodeLeader.Instance().setBlockReqSizeByName( arguments[0]) else: print("Please specify the required parameter") return False
def test_get_transaction(self): # delete any tx in the mempool self._clear_mempool() # generate a new tx tx = self._generate_tx(Fixed8.TryParse(5)) # try to get it res = NodeLeader.Instance().GetTransaction(tx.Hash.ToBytes()) self.assertIsNone(res) # now add it to the mempool NodeLeader.Instance().MemPool[tx.Hash.ToBytes()] = tx # and try to get it res = NodeLeader.Instance().GetTransaction(tx.Hash.ToBytes()) self.assertTrue(res is tx)
def quit(self): print('Shutting down. This may take a bit...') self.go_on = False NotificationDB.close() Blockchain.Default().Dispose() #reactor.stop() # >>> commented out reactor NodeLeader.Instance().Shutdown() sys.exit() # >>> close all widgets
def custom_background_code(): """ Custom code run in a background thread. Prints the current block height. This function is run in a daemonized thread, which means it can be instantly killed at any moment, whenever the main thread quits. If you need more safety, don't use a daemonized thread and handle exiting this thread in another way (eg. with signals and events). Raises an exception every 5 minutes the block count is blocked and restarts the node """ if settings.is_mainnet: network = 'Mainnet' elif settings.is_testnet: network = 'Testnet' else: network = 'Privnet' counter = 0 previous_block_count = 0 while True: try: logger.info( f"Block {str(Blockchain.Default().Height)} / {str(Blockchain.Default().HeaderHeight)}" ) logger.info( f"Connected to {len(NodeLeader.Instance().Peers)} peers.") for peer in NodeLeader.Instance().Peers: logger.info(peer.Address) logger.info("\n") if previous_block_count == Blockchain.Default().Height: counter += 1 if counter % 5 == 0: error = '{} Node is blocking'.format(network) message = 'Node is blocking at block: {}. Connected peers: {}. Attempting restart.' message = message.format(Blockchain.Default().Height, len(NodeLeader.Instance().Peers)) raise NodeBlockingException(error, message) else: previous_block_count = Blockchain.Default().Height counter = 0 except Exception as e: logger.warning(e) NodeLeader.Instance().Shutdown() NodeLeader.Instance().Start() counter = 0 sleep(15)
def InvokeContract(wallet, tx, fee=Fixed8.Zero(), from_addr=None, owners=None): if from_addr is not None: from_addr = PromptUtils.lookup_addr_str(wallet, from_addr) try: wallet_tx = wallet.MakeTransaction(tx=tx, fee=fee, use_standard=True, from_addr=from_addr) except ValueError: print("Insufficient funds") return False except TXFeeError as e: print(e) return False if wallet_tx: if owners: for owner in list(owners): wallet_tx.Attributes.append( TransactionAttribute( usage=TransactionAttributeUsage.Script, data=owner)) wallet_tx.Attributes = make_unique_script_attr(tx.Attributes) context = ContractParametersContext(wallet_tx) wallet.Sign(context) if owners: gather_signatures(context, wallet_tx, list(owners)) if context.Completed: wallet_tx.scripts = context.GetScripts() relayed = False # print("SENDING TX: %s " % json.dumps(wallet_tx.ToJson(), indent=4)) relayed = NodeLeader.Instance().Relay(wallet_tx) if relayed: print("Relayed Tx: %s " % wallet_tx.Hash.ToString()) wallet.SaveTransaction(wallet_tx) return wallet_tx else: print("Could not relay tx %s " % wallet_tx.Hash.ToString()) else: print("Incomplete signature") else: print("Insufficient funds") return False
def SplitUnspentCoin(wallet, args, prompt_passwd=True): """ example ``wallet split Ab8RGQEWetkhVqXjPHeGN9LJdbhaFLyUXz neo 1 100`` this would split the second unspent neo vin into 100 vouts :param wallet: :param args (list): A list of arguments as [Address, asset type, unspent index, divisions] :return: bool """ try: addr = wallet.ToScriptHash(args[0]) asset = get_asset_id(wallet, args[1]) index = int(args[2]) divisions = int(args[3]) except Exception as e: logger.info("Invalid arguments specified: %s " % e) return None try: unspentItem = wallet.FindUnspentCoinsByAsset(asset, from_addr=addr)[index] except Exception as e: logger.info( "Could not find unspent item for asset with index %s %s : %s" % (asset, index, e)) return None outputs = split_to_vouts(asset, addr, unspentItem.Output.Value, divisions) contract_tx = ContractTransaction(outputs=outputs, inputs=[unspentItem.Reference]) ctx = ContractParametersContext(contract_tx) wallet.Sign(ctx) print("Splitting: %s " % json.dumps(contract_tx.ToJson(), indent=4)) if prompt_passwd: passwd = prompt("[Password]> ", is_password=True) if not wallet.ValidatePassword(passwd): print("incorrect password") return None if ctx.Completed: contract_tx.scripts = ctx.GetScripts() relayed = NodeLeader.Instance().Relay(contract_tx) if relayed: wallet.SaveTransaction(contract_tx) print("Relayed Tx: %s " % contract_tx.Hash.ToString()) return contract_tx else: print("Could not relay tx %s " % contract_tx.Hash.ToString()) return None
def main(): parser = argparse.ArgumentParser() parser.add_argument("-m", "--mainnet", action="store_true", default=False, help="Use MainNet instead of the default TestNet") parser.add_argument("-p", "--privnet", action="store_true", default=False, help="Use PrivNet instead of the default TestNet") parser.add_argument("-c", "--config", action="store", help="Use a specific config file") parser.add_argument("-t", "--set-default-theme", dest="theme", choices=["dark", "light"], help="Set the default theme to be loaded from the config file. Default: 'dark'") parser.add_argument('--version', action='version', version='neo-python v{version}'.format(version=__version__)) parser.add_argument("-e", "--exec_command", action="store", help="Use a specific commands") args = parser.parse_args() if args.config and (args.mainnet or args.privnet): print("Cannot use both --config and --mainnet/--privnet arguments, please use only one.") exit(1) if args.mainnet and args.privnet: print("Cannot use both --mainnet and --privnet arguments") exit(1) # Setup depending on command line arguments. By default, the testnet settings are already loaded. if args.config: settings.setup(args.config) elif args.mainnet: settings.setup_mainnet() elif args.privnet: settings.setup_privnet() mycoms = [] mycoms2 = [] if args.exec_command: mycoms = args.exec_command.split(',') #print("exec:"+args.exec_command) for k in mycoms: mycoms2.append( codecs.decode(k, "hex").decode() ) if args.theme: preferences.set_theme(args.theme) # Instantiate the blockchain and subscribe to notifications blockchain = LevelDBBlockchain(settings.LEVELDB_PATH) Blockchain.RegisterBlockchain(blockchain) # Start the prompt interface cli = PromptInterface() cli.mycommands = mycoms2 #['oi', 'oi2'] # Run reactor.suggestThreadPoolSize(15) reactor.callInThread(cli.run) NodeLeader.Instance().Start() reactor.run()
def test_mempool_check_loop(self): # delete any tx in the mempool self._clear_mempool() # add a tx which is already confirmed self._add_existing_tx() # and add a tx which is not confirmed tx = self._generate_tx(Fixed8.TryParse(20)) NodeLeader.Instance().MemPool[tx.Hash.ToBytes()] = tx # now remove the confirmed tx NodeLeader.Instance().MempoolCheck() self.assertEqual( len( list( map(lambda hash: "0x%s" % hash.decode('utf-8'), NodeLeader.Instance().MemPool.keys()))), 1)