def get_info(container): channel = get_channel(container) macaroon = codecs.encode(open(_macaroon(container), 'rb').read(), 'hex') stub = lnrpc.LightningStub(channel) request = ln.GetInfoRequest() response = stub.GetInfo(request, metadata=[('macaroon', macaroon)]) return response
def ping(self): try: self.client.GetInfo(ln.GetInfoRequest()) return True except Exception as e: logger.exception(e) return False
def get_info_dict(stub, macaroon): # Retrieve and display the wallet balance response = stub.GetInfo(ln.GetInfoRequest(), metadata=[('macaroon', macaroon)]) # responseWallet = stub.WalletBalance(ln.WalletBalanceRequest(),metadata = [('macaroon',macaroon)]) return response
def mainUI(self): self.screen.fill(background_color) self.add_qr_code() self.build_info_section("admin", get_ip(), (520, 120), False, True) # Tor is always going to be really long so not sure about this one ... :/ self.build_info_section( "tor", "r7cckasdfasfdargsnf4eoxaivgiykmrcglhg4zlwueknhuw66otiid.onion", (columns_x[0], rows_y[0]), pygame.freetype.Font(bold_font, 22)) stub = get_stub() metadata = [('macaroon', get_macaroon())] response = stub.GetInfo(ln.GetInfoRequest(), metadata=metadata) btcresponse = rpc_connection.getblockchaininfo() self.build_info_section("Max Send", "3M Sats", (columns_x[0], rows_y[1])) self.build_info_section("Max Recieve", "2M Sats", (columns_x[1], rows_y[1])) self.build_info_section("Active Channels", "16", (columns_x[2], rows_y[1])) self.build_info_section("24H Forwards", str(response.num_active_channels), (columns_x[0], rows_y[2])) self.build_info_section( "Sync progress", str(btcresponse["verificationprogress"] * 100) + "%", (columns_x[1], rows_y[2])) pygame.display.set_caption("UmbrUI") pygame.display.update() self.loaded = True
def main(): if not BOT_TOKEN: sys.stderr.write("Please specify BOT_TOKEN environment variable\n") return 1 # Open database global sessionmaker logger.info("Opening database {}".format(DB_PATH)) sessionmaker = db.open_database(DB_PATH) session = sessionmaker() logger.info("Counting {} users and {} transactions".format( db.count_users(session), db.count_transactions(session))) session.close() # Connect to lightning gRPC global stub logger.info("Reading TLS certificate {}".format(CERT_PATH)) cert = open(CERT_PATH, 'rb').read() creds = grpc.ssl_channel_credentials(cert) logger.info("Connecting to lnd at {}".format(LND_GRPC)) channel = grpc.secure_channel(LND_GRPC, creds) stub = lnrpc.LightningStub(channel) # Do a test call info = stub.GetInfo(ln.GetInfoRequest(), timeout=GRPC_TIMEOUT) logger.info(info) logger.info("Connected to lnd".format(info.alias)) if not info.testnet and TESTNET: logger.critical("lnd is running on mainnet, quitting") sys.exit(1) if not info.synced_to_chain: logger.critical("lnd is not synced") sys.exit(1) if not info.chains == ["bitcoin"]: logger.critical("Only bitcoin is supported at this time") sys.exit(1) # Create the telegram bot global updater updater = Updater(token=BOT_TOKEN) updater.dispatcher.add_handler(CommandHandler('start', command_start)) updater.dispatcher.add_handler(CommandHandler('balance', command_balance)) updater.dispatcher.add_handler( CommandHandler('invoice', command_invoice, pass_args=True)) updater.dispatcher.add_handler( CommandHandler('pay', command_pay, pass_args=True)) updater.dispatcher.add_handler(CommandHandler('help', help_handler)) updater.dispatcher.add_handler(MessageHandler(Filters.photo, photo_handler)) updater.dispatcher.add_handler(MessageHandler(Filters.text, text_handler)) updater.start_polling() # Payments listener in a new thread import thread thread.start_new_thread(payments_listener_thread, ()) logger.info("Bot started") # Wait until telegram poller stops or ^C updater.idle() return 0
def getInfo(stub, macaroon): # Retrieve and display the wallet balance response = stub.GetInfo(ln.GetInfoRequest(), metadata=[('macaroon', macaroon)]) response_wallet = stub.WalletBalance(ln.WalletBalanceRequest(), metadata=[('macaroon', macaroon)]) network = "[Mainnet]" if response.testnet: network = "[Testnet]" descriptionStr = term_print("Alias: ", bcolors.OKGREEN) + term_print( response.alias, bcolors.BOLD) + "\t\t" + term_print( "Pubkey: ", bcolors.OKGREEN) + str(response.identity_pubkey) + "\n" statusStr = term_print("Channels:", bcolors.OKGREEN) + str( response.num_active_channels ) + "(" + str(response.num_pending_channels) + ")\t" + term_print( "Peers:", bcolors.OKGREEN) + str(response.num_peers) + "\t" + term_print( "Height:", bcolors.OKGREEN) + str(response.block_height) + "\t" + term_print( "Balance:", bcolors.OKGREEN) + str( response_wallet.total_balance) + " (" + str( response_wallet.confirmed_balance) + ":" + str( response_wallet.unconfirmed_balance ) + ") SAT\t" + term_print(network, bcolors.OKGREEN) return descriptionStr + statusStr
def check_lnd(): try: stub = get_stub() metadata = [('macaroon',get_macaroon())] response = stub.GetInfo(ln.GetInfoRequest(),metadata=metadata) response.num_active_channels except grpc._channel._InactiveRpcError: sleep(2) check_lnd()
def get_uri(self): try: request = ln.GetInfoRequest() response = self.stub.GetInfo(request) logging.info(response) node_id = response.identity_pubkey return "%s@%s:%d" % (node_id, self.node_address, self.node_port) except grpc.RpcError as e: logging.error(e) return e.details()
def index(): try: rpc_connect = AuthServiceProxy("http://{}:{}@{}:{}".format(rpc_user,rpc_password,allowed_ip,rpc_port)) current_block_height = rpc_connect.getblockcount() onchain_peers = rpc_connect.getconnectioncount() onchain_balance = rpc_connect.getbalance() bitcoin_version = (rpc_connect.getnetworkinfo()['subversion'])[1:-1].replace("Satoshi:","") sync_prog = str(round(rpc_connect.getblockchaininfo()['verificationprogress']*100, 2)) + "%" chain_type = rpc_connect.getblockchaininfo()['chain'] if onchain_balance > 0 and chain_type == "main": onchain_balance = u"₿ " + str(onchain_balance) elif onchain_balance == 0: onchain_balance = u"₿ " + str(0) elif onchain_balance > 0 and chain_type == "test": onchain_balance = u"t₿ " + str(onchain_balance) else: onchain_balance = u"t₿ " + str(0) if chain_type == "test": chaintype_ln = "testnet" else: chaintype_ln = "mainnet" except: current_block_height = onchain_peers = onchain_balance = bitcoin_version = sync_prog = chain_type = "Offline!" try: 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.GetInfo(ln.GetInfoRequest(), metadata=[('macaroon', macaroon)]) satbalance = stub.ChannelBalance(ln.ChannelBalanceRequest(), metadata=[('macaroon', macaroon)]) lightning_channels_act = response.num_active_channels lightning_peers = response.num_peers offchain_balance = u"ş " + str(format(satbalance.balance,',')) lightning_version = response.version[:5] alias = response.alias except: lightning_channels_act = lightning_peers = offchain_balance = lightning_version = alias = "Offline!" return render_template('index.html', current_block_height=current_block_height, onchain_peers=onchain_peers, onchain_balance=onchain_balance, bitcoin_version=bitcoin_version, sync_prog=sync_prog, chain_type=chain_type, lightning_channels_act=lightning_channels_act, lightning_peers=lightning_peers, offchain_balance=offchain_balance, lightning_version=lightning_version, alias=alias)
def ping(self): """ Simple liveness test to see if the node is up and running Returns true if the node is reachable via RPC, false otherwise. """ try: self.rpc.stub.GetInfo(lnrpc.GetInfoRequest()) return True except Exception as e: print(e) return False
def __init__(self, cert, config): cert_creds = grpc.ssl_channel_credentials(cert) auth_creds = grpc.metadata_call_credentials(metadata_callback) creds = grpc.composite_channel_credentials(cert_creds, auth_creds) channel = grpc.secure_channel(config.LND_HOST, creds) self.stub = lnrpc.LightningStub(channel) self.DEFAULT_PRICE = config.DEFAULT_PRICE self.DEFAULT_EXPIRY = config.DEFAULT_EXPIRY try: request = ln.GetInfoRequest() response = self.stub.GetInfo(request) logging.info(response) except grpc.RpcError as e: logging.error(e)
def __init__(self, cert, config): creds = grpc.ssl_channel_credentials(cert) channel = grpc.secure_channel(config.LND_HOST, creds) self.stub = lnrpc.LightningStub(channel) self.DEFAULT_PRICE = config.DEFAULT_PRICE self.DEFAULT_EXPIRY = config.DEFAULT_EXPIRY try: request = ln.GetInfoRequest() response = self.stub.GetInfo(request) logging.info(response) except grpc.RpcError as e: logging.error(e) self.broadcast = Broadcaster._instance self.invoiceThread = threading.Thread(target = self.subscribe_invoices) self.invoiceThread.daemon = True LndWrapper._instance = self
async def initialize(self) -> None: """asynchronously init class and populate pubkey""" # TODO add wallet unlocking stub for wallet unlock # TODO max receive message length? = 1024^3 i = 1 while True: try: self.logger.info(f"Attempt ${i} to initialize lnd") self.stub = lnrpc.LightningStub(self._channel) req = ln.GetInfoRequest() info = await self.stub.GetInfo(req) self.id_pubkey = info.identity_pubkey assert self.id_pubkey self.logger.info("Success") break except (ConnectionRefusedError, gaierror) as error: i += 1 self.logger.info(f"Attempt failed: {error}") await asyncio.sleep(5)
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 get_info(): request = ln.GetInfoRequest() return stub.GetInfo(request, metadata=[('macaroon', macaroon)])
nodeinfo = stub.GetNodeInfo(ln.NodeInfoRequest(pub_key=pubkey)) if nodeinfo.node.addresses: return ".onion" in nodeinfo.node.addresses[0].addr else: return False channel_options = [ ("grpc.max_message_length", MESSAGE_SIZE_MB), ("grpc.max_receive_message_length", MESSAGE_SIZE_MB), ] channel = grpc.secure_channel("localhost:10009", get_creds(), channel_options) stub = lnrpc.LightningStub(channel) identity_pubkey = stub.GetInfo(ln.GetInfoRequest()).identity_pubkey lgraph = stub.DescribeGraph(ln.ChannelGraphRequest()) edges = lgraph.edges nodes = lgraph.nodes data = [(e.node1_pub, e.node2_pub, {"weight": e.capacity}) for e in edges] json.dump(data, open("lightning_graph.json", "w")) onions = [n.pub_key for n in nodes if is_onion(stub, n.pub_key)] print(len(onions)) json.dump(onions, open("onions.json", "w"))
def getCurrentNodePubKey(): request_getinfo = ln.GetInfoRequest() response_getinfo = stub.GetInfo(request_getinfo) return response_getinfo.identity_pubkey
async def r_info(*_) -> dict: request = ln.GetInfoRequest() return await LND.stub.GetInfo(request)
def get_info(self): if self.info is None: self.info = self.stub.GetInfo(ln.GetInfoRequest()) return self.info
def getInfo(self): request = ln.GetInfoRequest() response = self.stub.GetInfo(request) return response
def info(self): r = self.rpc.stub.GetInfo(lnrpc.GetInfoRequest()) return { 'id': r.identity_pubkey, 'blockheight': r.block_height, }
#illustrating for alice (port 10001) with open( os.path.expanduser( '~/snap/go/dev/alice/data/chain/bitcoin/simnet/admin.macaroon'), 'rb') as f: macaroon_bytes = f.read() macaroon = codecs.encode(macaroon_bytes, 'hex') def metadata_callback(context, callback): # for more info see grpc docs callback([('macaroon', macaroon)], None) # now build meta data credentials auth_creds = grpc.metadata_call_credentials(metadata_callback) # combine the cert credentials and the macaroon auth credentials # such that every call is properly encrypted and authenticated combined_creds = grpc.composite_channel_credentials(cert_creds, auth_creds) # finally pass in the combined credentials when creating a channel channel = grpc.secure_channel( 'localhost:10001', combined_creds) #example uses 10009, but my user ports are 10001-3 #create the stub (some frameworks just call this the "client") stub = lnrpc.LightningStub(channel) print(stub.GetInfo(ln.GetInfoRequest()))
def getinfo(): return stub.GetInfo(ln.GetInfoRequest())
def GetInfo(self): response = stub.GetInfo(ln.GetInfoRequest()) return response
from collections import defaultdict macaroon = codecs.encode(open('/home/joao/.lnd/data/chain/bitcoin/mainnet/admin.macaroon', 'rb').read(), 'hex') os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA' cert = open('/home/joao/.lnd/tls.cert', 'rb').read() ssl_creds = grpc.ssl_channel_credentials(cert) channel = grpc.secure_channel('localhost:10009', ssl_creds, options=[ ('grpc.max_send_message_length', 50 * 1024 * 1024), ('grpc.max_receive_message_length', 50 * 1024 * 1024) ]) # Creating a stub and requesting the client for the latest network graph and graph info stub = lnrpc.LightningStub(channel) graphRequest = ln.ChannelGraphRequest(include_unannounced=True) networkInfoRequest = ln.NetworkInfoRequest() infoRequest = ln.request = ln.GetInfoRequest() graphResponse = stub.DescribeGraph(graphRequest, metadata=[('macaroon', macaroon)]) networkInfoResponse = stub.GetNetworkInfo(networkInfoRequest, metadata=[('macaroon', macaroon)]) infoResponse = stub.GetInfo(infoRequest, metadata=[('macaroon', macaroon)]) # GetNetworkInfo returns some basic stats about the known channel graph from the point of view of the node. print("Network Info: \n\n" + str(networkInfoResponse)) # GetInfo returns general information concerning the lightning node including # it's identity pubkey, alias, the chains it is connected to, and information concerning the number of open+pending channels. print("Info: \n\n" + str(infoResponse)) # Treat the response and build a multi line adjancency list from it # https://networkx.github.io/documentation/stable/reference/readwrite/multiline_adjlist.html adjListDic = defaultdict(list)
#if p==1: #pass #else: #print('There is a variable. It is "',master[i],'"') ans=calculate(master,0) print("The result of the above equation is",ans,"\n") the_end = process.memory_info().rss mem_tot = the_end - beginning print("End", the_end, "bytes", mem_tot, "bytes", psutil.cpu_freq(), "MHz") satoshi_amt = round(mem_tot*0.0000845) print("The cost is", satoshi_amt, "sats") response = stub.WalletBalance(ln.WalletBalanceRequest(), metadata=[('macaroon', macaroon)]) print(response.total_balance, "Satoshis") response_two = stub.GetInfo(ln.GetInfoRequest(), metadata=[('macaroon', macaroon)]) print(response_two)
def getinfo(self): try: response = self.client.GetInfo(ln.GetInfoRequest()) return response except Exception as e: logger.exception(e)
def get_info(self): return self.stub.GetInfo(ln.GetInfoRequest())
def metadata_callback(context, callback): # for more info see grpc docs callback([('macaroon', macaroon)], None) # Due to updated ECDSA generated tls.cert we need to let gprc know that # we need to use that cipher suite otherwise there will be a handhsake # error when we communicate with the lnd rpc server. os.environ["GRPC_SSL_CIPHER_SUITES"] = 'HIGH+ECDSA' # Lnd cert is at ~/.lnd/tls.cert on Linux and # ~/Library/Application Support/Lnd/tls.cert on Mac cert = open(os.path.expanduser('~/.lnd/tls.cert'), 'rb').read() # build ssl credentials using the cert the same as before cert_creds = grpc.ssl_channel_credentials(cert) # now build meta data credentials auth_creds = grpc.metadata_call_credentials(metadata_callback) # combine the cert credentials and the macaroon auth credentials # such that every call is properly encrypted and authenticated combined_creds = grpc.composite_channel_credentials(cert_creds, auth_creds) # finally pass in the combined credentials when creating a channel channel = grpc.secure_channel('localhost:10009', combined_creds) stub = lnrpc.LightningStub(channel) # now every call will be made with the macaroon already included stub.GetInfo(ln.GetInfoRequest())