def listactivechannels(): ac = [] chans = stub.ListChannels(ln.ListChannelsRequest()).channels for chan in chans: if chan.active: ac.append(chan) return ac
def get_channels(self): if self.channels is None: request = ln.ListChannelsRequest( active_only=True, ) self.channels = self.stub.ListChannels(request).channels return self.channels
def getActiveChannelList(): channel_request = ln.ListChannelsRequest( active_only=True, inactive_only=False, public_only=False, private_only=False, ) return stub.ListChannels(channel_request)
async def r_liquidity(*_): req = ln.ListChannelsRequest(public_only=True) channels = (await LND.stub.ListChannels(req)).channels return { "inbound": sum(x.remote_balance - x.remote_chan_reserve_sat for x in channels), "outbound": sum(x.local_balance - x.local_chan_reserve_sat for x in channels), }
def scan_channel(my_channel_id: int, scan_channel_id: int): # Grab some initial data and make sure everything came back OK node = init_node() my_channels = node.ListChannels(ln.ListChannelsRequest()).channels my_channel = [c for c in my_channels if c.chan_id == my_channel_id][0] channel = node.GetChanInfo(ln.ChanInfoRequest(chan_id=scan_channel_id)) if not my_channel: raise Exception(f'You have no channel with ID "{my_channel_id}"') if not channel: raise Exception(f'Unknown channel with ID "{scan_channel_id}"') # Determine the max we can scan, and who's the "receiver" maximum = min( int(channel.capacity), int(my_channel.local_balance), MAX_PAYMENT_SIZE, ) dest_pubkey = channel.node2_pub if my_channel.remote_pubkey == channel.node1_pub else channel.node2_pub # Loop send bogus payments until we find the balance low = 0 high = maximum print(f'Beginning scan of channel {scan_channel_id}, max scannable {maximum} satoshis...') while high - low > 1: test_amount = math.ceil((low + high) / 2) print(f'Probing with a {test_amount} sat payment...') res = node.SendPaymentSync(ln.SendRequest( dest_string=dest_pubkey, amt=test_amount, payment_hash_string=make_random_hash(), outgoing_chan_id=my_channel.chan_id, final_cltv_delta=144, )) err = res.payment_error # Depending on the error, raise or lower the amount. The route note having # enough capacity comes in many shapes and sizes of error, so we have to # check for a few types here. if 'UnknownPaymentHash' in err: print('Amount was too low, raising lower bound...') low = test_amount elif 'unable to find a path' in err or \ 'insufficient' in err or \ 'TemporaryChannelFailure' in err: print('Amount was too high, lowering upper bound...') high = test_amount else: raise Exception(f'Unknown error occured when trying to scan: {err}') print(f'Balance for channel ${scan_channel_id} is between {low} and {high} satoshis!') if high == maximum: print(f'NOTE: The balance exceeds the height we were able to scan, so it may be larger than {maximum} satoshis')
def _channel_with_remote(self, remote): self_id = self.id() remote_id = remote.id() channels = self.daemon.stub.ListChannels( lnrpc.ListChannelsRequest()).channels channel_by_remote = {c.remote_pubkey: c for c in channels} if remote_id not in channel_by_remote: self.logger.warning("Channel {} -> {} not found".format( self_id, remote_id)) return False return channel_by_remote[remote_id]
def get_header_line(): # header response = stub.GetInfo(ln.GetInfoRequest(), metadata=[('macaroon', macaroon)]) alias = response.alias chain = response.chains[0] version = response.version header = "%s (%s, lnd %s)" % (alias, chain, version) request = ln.ListChannelsRequest(active_only=True) response = stub.ListChannels(request, metadata=[('macaroon', macaroon)]) active_channels = response.channels request = ln.ListChannelsRequest(inactive_only=True) response = stub.ListChannels(request, metadata=[('macaroon', macaroon)]) inactive_channels = response.channels header += "\n" + ("%d active channels and %d inactive channels" % (len(active_channels), len(inactive_channels))) return header
def check_channel(self, remote): """ Make sure that we have an active channel with remote """ self_id = self.id() remote_id = remote.id() channels = self.rpc.stub.ListChannels(lnrpc.ListChannelsRequest()).channels channel_by_remote = {c.remote_pubkey: c for c in channels} if remote_id not in channel_by_remote: self.logger.warning("Channel {} -> {} not found".format(self_id, remote_id)) return False channel = channel_by_remote[remote_id] self.logger.debug("Channel {} -> {} state: {}".format(self_id, remote_id, channel)) return channel.active
async def open_channels(self, *_, active: bool = False, inactive: bool = False, public: bool = False, private: bool = False, peer: Optional[bytes] = None): req = ln.ListChannelsRequest( active_only=active, inactive_only=inactive, public_only=public, private_only=private, ) r = await LND.stub.ListChannels(req) return r.channels
def main(): request = ln.ListChannelsRequest( active_only=False, inactive_only=False, public_only=False, private_only=False, ) response = stub.ListChannels(request) if True: print('%35s' % 'chan_alias', '%18s' % 'chan_id', '%66s' % 'chan.remote_pubkey', '%5s' % 'active', '%3s' % 'htlcs', '%3s' % 'pri', '%9s' % 'remotebal', '%9s' % 'bal+myfee', '%7s' % 'myfee', '%10s' % 'usagerat', '%9s' % 'locbal', '%9s' % 'chancap', '%9s' % 'cap %') response.channels.sort(key=operator.attrgetter('initiator'), reverse=True) is_pending_htlcs = False for chan in response.channels: printOneChannel(chan, 'active') if (len(chan.pending_htlcs) > 0): is_pending_htlcs = True request_pending = ln.PendingChannelsRequest() response_pending = stub.PendingChannels(request_pending) #print(response_pending) for chan in response_pending.pending_open_channels: #print(chan) printOneChannel(chan, 'pending') print('total_limbo_balance=', response_pending.total_limbo_balance) msg = '' if (is_pending_htlcs): msg = 'note: balance may not reflect accurately if there are pending stuck HTLCs' tot_local_pct = round(100 * all_channel_val / all_channel_cap, 1) print('TOTAL (sat): ', all_channel_val, '/', all_channel_cap, '=', str(tot_local_pct), '%') print('TOTAL (BTC): ', all_channel_val / 100000000, 'BTC', '/', all_channel_cap / 100000000, 'BTC ' + msg)
def list_channels(self): try: response = self.client.ListChannels(ln.ListChannelsRequest()) return response except Exception as e: logger.exception(e)
def getCurrentChannels(stub, macaroon): responseChannels = stub.ListChannels(ln.ListChannelsRequest(), metadata=[('macaroon', macaroon)]) return responseChannels.channels
def peerpage(): try: rpc_connect = AuthServiceProxy("http://{}:{}@{}:{}".format(rpc_user,rpc_password,allowed_ip,rpc_port)) chain_type = rpc_connect.getblockchaininfo()['chain'] if chain_type == "test": chaintype_ln = "testnet" else: chaintype_ln = "mainnet" os.environ["GRPC_SSL_CIPHER_SUITES"] = 'HIGH+ECDSA' with open(os.path.expanduser(lnd_dir_location + 'data/chain/bitcoin/{}/admin.macaroon'.format(chaintype_ln)), 'rb') as f: macaroon_bytes = f.read() macaroon = codecs.encode(macaroon_bytes, 'hex') cert = open(os.path.expanduser(lnd_dir_location + 'tls.cert'), 'rb').read() creds = grpc.ssl_channel_credentials(cert) channel = grpc.secure_channel('localhost:10009', creds) stub = lnrpc.LightningStub(channel) pbks = stub.ListChannels(ln.ListChannelsRequest(), metadata=[('macaroon', macaroon)]) pubkey_list = [str(i.remote_pubkey) for i in pbks.channels] response = stub.ListPeers(ln.ListPeersRequest(), metadata=[('macaroon', macaroon)]) show_current_peers = response.peers show_current_peers_list = [] for peer in show_current_peers: if peer.pub_key in pubkey_list: show_current_peers_list.append((str(peer.pub_key), True)) else: show_current_peers_list.append((str(peer.pub_key), False)) conn = True length_of = len(show_current_peers_list) except: show_current_peers_list = ["Offline!"] length_of = 0 conn = False pubkey_list = ["Offline!"] if conn == True: if request.method == 'POST': if request.form['action'] == "connectbutton": if len(request.form['text']) > 10: response_uri = str(request.form['text']) result = response_uri.strip() def connect(host, port, node_id): addr = ln.LightningAddress(pubkey=node_id, host="{}:{}".format(host, port)) req = ln.ConnectPeerRequest(addr=addr, perm=True) stub.ConnectPeer(ln.ConnectPeerRequest(addr=addr,perm=False), metadata=[('macaroon',macaroon)]) try: nodeid, lnhost, lnport = result[:66], result[67:-5], result[-4:] connect(lnhost,lnport,nodeid) show_current_peers_list.append((nodeid, False)) length_of = len(show_current_peers_list) result = "Successfully connected!" return render_template('peerpage.html', len=len(show_current_peers_list), show_current_peers=show_current_peers_list, length_of=length_of, result="SuccessCon", conn=conn) except: return render_template('peerpage.html', len=len(show_current_peers_list), show_current_peers=show_current_peers_list, length_of=length_of, result="FalseCon", conn=conn) else: return render_template('peerpage.html', len=len(show_current_peers_list), show_current_peers=show_current_peers_list, length_of=length_of, result="FalseCon", conn=conn) else: if len(request.form['text']) > 10: response_uri = str(request.form['text']) result = response_uri.strip() def disconnect(pubkey): req = ln.DisconnectPeerRequest(pub_key=pubkey) stub.DisconnectPeer(ln.DisconnectPeerRequest(pub_key=pubkey), metadata=[('macaroon',macaroon)]) try: disconnect(result) del show_current_peers_list[-1] length_of = len(show_current_peers_list) return render_template('peerpage.html', len=len(show_current_peers_list), show_current_peers=show_current_peers_list, length_of=length_of, result="SuccessDis", conn=conn) except: return render_template('peerpage.html', len=len(show_current_peers_list), show_current_peers=show_current_peers_list, length_of=length_of, result="FalseDis", conn=conn) else: return render_template('peerpage.html', len=len(show_current_peers_list), show_current_peers=show_current_peers_list, length_of=length_of, result="FalseDis", conn=conn) return render_template('peerpage.html', len=len(show_current_peers_list), length_of=length_of, show_current_peers=show_current_peers_list, conn=conn)
import rpc_pb2 as ln, rpc_pb2_grpc as lnrpc import code import codecs, grpc, os import json # mac_path = '/root/.lnd/data/chain/bitcoin/mainnet/admin.macaroon' mac_path = '/root/.lnd/data/chain/litecoin/mainnet/admin.macaroon' macaroon = codecs.encode(open(mac_path, 'rb').read(), 'hex') os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA' cert = open('/root/.lnd/tls.cert', 'rb').read() ssl_creds = grpc.ssl_channel_credentials(cert) channel = grpc.secure_channel('localhost:10009', ssl_creds) stub = lnrpc.LightningStub(channel) request = ln.ListChannelsRequest() response = stub.ListChannels(request, metadata=[('macaroon', macaroon)]) for chan in response.channels: request = ln.NodeInfoRequest(pub_key=chan.remote_pubkey) r = stub.GetNodeInfo(request, metadata=[('macaroon', macaroon)]) chan_partner_alias = r.node.alias print("%s\t%s\t%f" % (chan_partner_alias, chan.remote_pubkey, (chan.local_balance / (chan.local_balance + chan.remote_balance)))) request = ln.InvoiceSubscription( add_index=0, settle_index=0, ) # Query routes for one direction
def channelpage(): try: rpc_connect = AuthServiceProxy("http://{}:{}@{}:{}".format(rpc_user,rpc_password,allowed_ip,rpc_port)) chain_type = rpc_connect.getblockchaininfo()['chain'] if chain_type == "test": chaintype_ln = "testnet" else: chaintype_ln = "mainnet" os.environ["GRPC_SSL_CIPHER_SUITES"] = 'HIGH+ECDSA' with open(os.path.expanduser(lnd_dir_location + 'data/chain/bitcoin/{}/admin.macaroon'.format(chaintype_ln)), 'rb') as f: macaroon_bytes = f.read() macaroon = codecs.encode(macaroon_bytes, 'hex') cert = open(os.path.expanduser(lnd_dir_location + 'tls.cert'), 'rb').read() creds = grpc.ssl_channel_credentials(cert) channel = grpc.secure_channel('localhost:10009', creds) stub = lnrpc.LightningStub(channel) response = stub.ListChannels(ln.ListChannelsRequest(), metadata=[('macaroon', macaroon)]) walbal = stub.WalletBalance(ln.WalletBalanceRequest(), metadata=[('macaroon', macaroon)]) availablefunds = walbal.confirmed_balance channellist = response.channels closedchannelidentifiers = [] channelidentifiers = [] pendingchannelidentifiers = [] pendingresponse = stub.PendingChannels(ln.PendingChannelsRequest(), metadata=[('macaroon', macaroon)]) pend = pendingresponse.pending_open_channels for i in pend: k = ((str(i.channel.remote_node_pub)), str(i.channel.channel_point), int(i.channel.capacity), int(i.channel.local_balance)) pendingchannelidentifiers.append(k) length_of_pending = len(pendingchannelidentifiers) closedresponse = stub.ClosedChannels(ln.ClosedChannelsRequest(), metadata=[('macaroon', macaroon)]) for i in closedresponse.channels: p = (str(i.remote_pubkey), str(i.channel_point), int(i.capacity), int(i.close_height), int(i.settled_balance)) closedchannelidentifiers.append(p) length_of_closed = len(closedchannelidentifiers) for i in channellist: if i.active == True: k = (str(i.remote_pubkey), int(i.capacity), int(i.local_balance), int(i.remote_balance), int(i.commit_fee), str(i.channel_point)) channelidentifiers.append(k) conn = True length_of = len(channelidentifiers) try: outcap = sum(zip(*channelidentifiers)[2]) incap = sum(zip(*channelidentifiers)[3]) except: outcap = incap = 0 length_of = 0 except: conn = False if conn == True: if request.method == "POST": if request.form['action'] == "openchan": try: pkstring = str(request.form['channelpubkey']) locfundamt = int(request.form['channelamt']) response = stub.OpenChannelSync(ln.OpenChannelRequest(node_pubkey_string=pkstring, local_funding_amount=locfundamt, push_sat=0), metadata=[('macaroon', macaroon)]) if response.funding_txid_bytes: return render_template('channels.html', availablefunds=availablefunds, channelidentifiers=channelidentifiers, closedchannelidentifiers=closedchannelidentifiers, outcap=outcap, incap=incap, conn=conn, opened="True", length_of=length_of, length_of_closed=length_of_closed, pendingchannelidentifiers=pendingchannelidentifiers, length_of_pending=length_of_pending) except: return render_template('channels.html', availablefunds=availablefunds, channelidentifiers=channelidentifiers, closedchannelidentifiers=closedchannelidentifiers, outcap=outcap, incap=incap, conn=conn, opened="True", length_of=length_of, length_of_closed=length_of_closed, pendingchannelidentifiers=pendingchannelidentifiers, length_of_pending=length_of_pending) elif request.form['action'] == "closechan": try: return ln.ChannelPoint(funding_txid_string=str(request.form['channelpubkey'])) stub.CloseChannel(ln.CloseChannelRequest(channel_point=channelpoint), metadata=[('macaroon', macaroon)]) return render_template('channels.html', availablefunds=availablefunds, channelidentifiers=channelidentifiers, closedchannelidentifiers=closedchannelidentifiers, outcap=outcap, incap=incap, conn=conn, closed="pendclose", length_of=length_of, length_of_closed=length_of_closed, pendingchannelidentifiers=pendingchannelidentifiers, length_of_pending=length_of_pending) except: return render_template('channels.html', availablefunds=availablefunds, channelidentifiers=channelidentifiers, closedchannelidentifiers=closedchannelidentifiers, outcap=outcap, incap=incap, conn=conn, closed="couldntclose", length_of=length_of, length_of_closed=length_of_closed, pendingchannelidentifiers=pendingchannelidentifiers, length_of_pending=length_of_pending) elif request.form['action'] == "fclosechan": try: return ln.ChannelPoint(funding_txid_string=str(request.form['channelpubkey'])) stub.CloseChannel(ln.CloseChannelRequest(channel_point=channelpoint, force=True), metadata=[('macaroon', macaroon)]) return render_template('channels.html', availablefunds=availablefunds, channelidentifiers=channelidentifiers, closedchannelidentifiers=closedchannelidentifiers, outcap=outcap, incap=incap, conn=conn, closed="pendclose", length_of=length_of, length_of_closed=length_of_closed, pendingchannelidentifiers=pendingchannelidentifiers, length_of_pending=length_of_pending) except: return render_template('channels.html', availablefunds=availablefunds, channelidentifiers=channelidentifiers, closedchannelidentifiers=closedchannelidentifiers, outcap=outcap, incap=incap, conn=conn, closed="couldntclose", length_of=length_of, length_of_closed=length_of_closed, pendingchannelidentifiers=pendingchannelidentifiers, length_of_pending=length_of_pending) else: return render_template('channels.html', conn=conn, length_of=length_of, channelidentifiers=channelidentifiers, closedchannelidentifiers=closedchannelidentifiers, incap=incap, outcap=outcap, availablefunds=availablefunds, length_of_closed=length_of_closed, pendingchannelidentifiers=pendingchannelidentifiers, length_of_pending=length_of_pending) return render_template('channels.html', conn=conn, length_of=0, channelidentifiers=0, closedchannelidentifiers=0, incap=0, outcap=0, availablefunds=0, length_of_closed=0, pendingchannelidentifiers=0, length_of_pending=0)
def metadata_callback(context, callback): mac_file = "~/.lnd/data/chain/bitcoin/mainnet/admin.macaroon" with open(os.path.expanduser(mac_file), "rb") as f: macaroon_bytes = f.read() macaroon = codecs.encode(macaroon_bytes, "hex") callback([("macaroon", macaroon)], None) cert = open(os.path.expanduser("~/.lnd/tls.cert"), "rb").read() cert_creds = grpc.ssl_channel_credentials(cert) auth_creds = grpc.metadata_call_credentials(metadata_callback) combined_creds = grpc.composite_channel_credentials(cert_creds, auth_creds) channel = grpc.secure_channel("localhost:10009", combined_creds) stub = lnrpc.LightningStub(channel) channel_info = stub.ListChannels(ln.ListChannelsRequest()).channels fields = [ "remote_pubkey", "chan_id", "active", "capacity", "local_balance", "remote_balance", "csv_delay", "private", ] chan_data = [[getattr(c, f) for f in fields] for c in channel_info] df_chan = pd.DataFrame(chan_data, columns=fields).set_index("chan_id") print(df_chan.sort_values(["active", "capacity", "private"], ascending=False)) print("\ncapital: {}".format(df_chan.local_balance.sum()))
def get_channels(active_only=True): # channels if active_only: request = ln.ListChannelsRequest(active_only=True) else: request = ln.ListChannelsRequest(inactive_only=True) response = stub.ListChannels(request, metadata=[('macaroon', macaroon)]) channels_ = response.channels channels = sorted(channels_, key=lambda c: int(c.chan_id), reverse=False) channel_number = 0 channels_with_names = {} request = ln.ForwardingHistoryRequest( start_time=int(time.time() - 24 * 60 * 60), end_time=int(time.time() + 24 * 60 * 60), #index_offset=<uint32>, #num_max_events=<uint32>, ) response = stub.ForwardingHistory(request, metadata=[('macaroon', macaroon)]) channel_events = {} for event in response.forwarding_events: if str(event.chan_id_in) in channel_events: channel_events[str(event.chan_id_in)]["in"] += 1 channel_events[str(event.chan_id_in)]["amt_in"] += event.amt_in #channel_events[str(event.chan_id_in)]["amt_out"] += event.amt_out channel_events[str(event.chan_id_in)]["fee"] += event.fee else: channel_events[str(event.chan_id_in)] = { "in": 1, "out": 0, "amt_in": event.amt_in, "amt_out": 0, #event.amt_out, "fee": event.fee } if str(event.chan_id_out) in channel_events: channel_events[str(event.chan_id_out)]["out"] += 1 #channel_events[str(event.chan_id_out)]["amt_in"] += event.amt_in channel_events[str(event.chan_id_out)]["amt_out"] += event.amt_out channel_events[str(event.chan_id_out)]["fee"] += event.fee else: channel_events[str(event.chan_id_out)] = { "in": 0, "out": 1, "amt_in": 0, #event.amt_in, "amt_out": event.amt_out, "fee": event.fee } #print "%d active channels" % (len(channels)) max_capacity = max([c.capacity for c in channels]) for channel in channels: channels_with_names[str(channel_number).rjust(2)] = { "channel": channel } capacity = channel.capacity local_balance = channel.local_balance chan_id = str(channel.chan_id) remote_pubkey = channel.remote_pubkey node_alias = get_node_alias(channel_graph, remote_pubkey).encode("utf8").decode( "ascii", "ignore") if len(node_alias) >= 15: node_alias = node_alias[:13] + "/" else: node_alias += " " * (15 - 1 - len(node_alias)) pass score = channel_score(capacity, local_balance) channels_with_names[str(channel_number).rjust(2)]["score"] = score if chan_id in channel_events.keys(): channel_transactions = " 24h: <- %d, -> %d" % ( channel_events[chan_id]["in"], channel_events[chan_id]["out"]) channel_transactions += " %d in, %d out, %d fees" % ( channel_events[chan_id]["amt_in"], channel_events[chan_id]["amt_out"], channel_events[chan_id]["fee"]) else: channel_transactions = " " yield (str(channel_number).rjust(2) + "/ " + chan_id + " " + node_alias + " " + channel_cursor(capacity, local_balance, max_capacity, score) #+ " " + remote_pubkey + channel_transactions) channel_number += 1
def get_channels(): request = ln.ListChannelsRequest(public_only=True) return stub.ListChannels(request, metadata=[('macaroon', macaroon)]).channels
def listchannels(): return stub.ListChannels(ln.ListChannelsRequest()).channels
def get_channels(self): request = ln.ListChannelsRequest( active_only=True, ) return self.stub.ListChannels(request).channels
def main(): #get currently connected channels (additional information) request_channels = ln.ListChannelsRequest( active_only=False, inactive_only=False, public_only=False, private_only=False, ) response_channels = stub.ListChannels(request_channels) request_graph = ln.ChannelGraphRequest(include_unannounced=False) response_graph = stub.DescribeGraph(request_graph) #print(response) dict_pubkey_chancount = {} current_node_pub_key = getCurrentNodePubKey() for edge in response_graph.edges: #print(edge) #check that capacity is above X if edge.capacity is not None and edge.capacity >= minCapacitySat: if areChannelFeesLow(edge.node1_policy): if (edge.node1_pub not in dict_pubkey_chancount): dict_pubkey_chancount[edge.node1_pub] = 1 else: current_count = dict_pubkey_chancount.get(edge.node1_pub) dict_pubkey_chancount[edge.node1_pub] = current_count + 1 #print(edge.node1_pub) if areChannelFeesLow(edge.node2_policy): if (edge.node2_pub not in dict_pubkey_chancount): dict_pubkey_chancount[edge.node2_pub] = 1 else: current_count = dict_pubkey_chancount.get(edge.node2_pub) dict_pubkey_chancount[edge.node2_pub] = current_count + 1 #print(edge.node2_pub) routesQueried = 0 #print sorted by channel count (value) for chanCount in sorted(set(dict_pubkey_chancount.values()), reverse=True): if chanCount >= minChanCount: for pubkey, count in dict_pubkey_chancount.items(): if (count == chanCount): #get info about remote node request_nodeinfo = ln.NodeInfoRequest(pub_key=pubkey, ) response_nodeinfo = stub.GetNodeInfo(request_nodeinfo) node_alias = response_nodeinfo.node.alias #check to see if we're connected connected = False for connectedChannel in response_channels.channels: if (pubkey == connectedChannel.remote_pubkey): connected = True if (connected): connectedText = '(connected)' elif (current_node_pub_key == pubkey): connectedText = '(self)' else: connectedText = '' route_fee = 'n/a' first_hop = 'n/a' hop_count = 0 if (count >= minChanCountToCalcRoutes): if (count <= maxChanCountToCalcRoutes): #query route to node (might be computationally expensive) request_route = ln.QueryRoutesRequest( pub_key=pubkey, amt=queryAmountSat, ) if (routesQueried < maxRoutesToQuery): routesQueried += 1 try: response_route = stub.QueryRoutes( request_route) route_fee = str(response_route.routes[0]. total_fees) + 'sat' first_hop = response_route.routes[0].hops[ 0].chan_id hop_count = len( response_route.routes[0].hops) time.sleep(pauseBetweenRouteQueriesSeconds) except (KeyboardInterrupt, SystemExit): raise except Exception as e: if (hasattr(e, 'details')): if ('unable to find a path to destination' in str(e.details)): route_fee = 'NO PATH!' else: route_fee = 'ERROR with details' print(e.details) print(str(e)) else: route_fee = 'UNKNOWN ERROR' print(str(e)) #print(dir(response_route)) else: route_fee = '(queries >)' else: route_fee = '(skip >)' else: route_fee = '(skip <)' print(pubkey, ":", '%5s' % count, '%8s' % route_fee, '%11s' % connectedText, '%35s' % node_alias.encode('ascii', 'ignore'), '%12s' % first_hop, '%2s' % hop_count)