mirror of
https://github.com/curly60e/pyblock.git
synced 2026-08-13 12:33:15 +02:00
389f6f3497
Automated fixes applied by KCode Audit Engine: - pybitblock/SPV/apisnd.py | 2 ++ - pybitblock/SPV/nodeconnection.py | 4 ++++ - pybitblock/ppi.py | 2 ++ Signed-off-by: Astrolexis.space — Kulvex Code
2118 lines
86 KiB
Python
2118 lines
86 KiB
Python
#Developer: Curly60e
|
||
#Tester: __B__T__C__
|
||
#ℙ𝕪𝔹𝕃𝕆ℂ𝕂 𝕚𝕥𝕤 𝕒 𝔹𝕚𝕥𝕔𝕠𝕚𝕟 𝔻𝕒𝕤𝕙𝕓𝕠𝕒𝕣𝕕 𝕨𝕚𝕥𝕙 ℂ𝕪𝕡𝕙𝕖𝕣𝕡𝕦𝕟𝕜 𝕒𝕖𝕤𝕥𝕙𝕖𝕥𝕚𝕔.
|
||
|
||
|
||
import base64, codecs, requests
|
||
import logging
|
||
import subprocess
|
||
import os
|
||
import os.path
|
||
import qrcode
|
||
import xmltodict
|
||
import time as t
|
||
try:
|
||
import simplejson as json
|
||
except ImportError:
|
||
import json
|
||
from cfonts import render, say
|
||
from pblogo import blogo
|
||
from logos import logoB
|
||
#from lnpay_py.wallet import LNPayWallet
|
||
from pycoingecko import CoinGeckoAPI
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
# Allowed fiat currency codes for rate.sx
|
||
_VALID_FIAT_CODES = {
|
||
'AUD', 'BRL', 'CAD', 'CHF', 'CLP', 'CNY', 'CZK', 'DKK', 'EUR', 'GBP',
|
||
'HKD', 'HUF', 'IDR', 'ILS', 'INR', 'JPY', 'KRW', 'MXN', 'MYR', 'NOK',
|
||
'NZD', 'PHP', 'PKR', 'PLN', 'RUB', 'SEK', 'SGD', 'THB', 'TRY', 'TWD',
|
||
'USD',
|
||
}
|
||
|
||
def clear(): # clear the screen
|
||
subprocess.run(['clear'] if os.name != 'nt' else ['cls'], shell=(os.name == 'nt')) # noqa: S603 - hardcoded safe commands only
|
||
|
||
def closed():
|
||
print("<<< Back Control + C.\n\n")
|
||
|
||
def opreturnOnchainONLY():
|
||
qr = qrcode.QRCode(
|
||
version=1,
|
||
error_correction=qrcode.constants.ERROR_CORRECT_L,
|
||
box_size=10,
|
||
border=4,
|
||
)
|
||
try:
|
||
clear()
|
||
blogo()
|
||
output = render(
|
||
"OP_RETURN Message", colors=['yellow'], align='left', font='tiny'
|
||
)
|
||
|
||
print(output)
|
||
message = input("Message: ")
|
||
|
||
while len(message) > 70:
|
||
clear()
|
||
blogo()
|
||
print("Error! Only 80 characters allowed!")
|
||
message = input("\nMessage: ")
|
||
resp = requests.post('https://opreturnbot.com/api/create', json={'message': message + '...PyBLOCK'}, timeout=10)
|
||
b = resp.text
|
||
clear()
|
||
blogo()
|
||
print("\033[1;30;47m")
|
||
qr.add_data(b)
|
||
qr.print_ascii()
|
||
print("\033[0;37;40m")
|
||
print(f'LND Invoice: {b}')
|
||
qr.clear()
|
||
input("\nContinue...")
|
||
if lndconnectload['ln']:
|
||
invoiceN = b
|
||
invoice = invoiceN.lower()
|
||
lsd = subprocess.run([lndconnectload["ln"], "decodepayreq", invoice], capture_output=True, text=True).stdout
|
||
lsd0 = str(lsd)
|
||
d = json.loads(lsd0)
|
||
url = f"https://opreturnbot.com/api/status/{d['payment_hash']}"
|
||
else:
|
||
cert_path = lndconnectload["tls"]
|
||
with open(lndconnectload["macaroon"], 'rb') as f:
|
||
macaroon = codecs.encode(f.read(), 'hex')
|
||
headers = {'Grpc-Metadata-macaroon': macaroon}
|
||
url = f'https://{lndconnectload["ip_port"]}/v1/payreq/{b}'
|
||
r = requests.get(url, headers=headers, verify=cert_path, timeout=10)
|
||
s = r.json()
|
||
url = f"https://opreturnbot.com/api/status/{s['payment_hash']}"
|
||
response = requests.get(url, timeout=10)
|
||
responseB = str(response.text)
|
||
responseC = responseB
|
||
clear()
|
||
blogo()
|
||
print("\nTransaction ID: " + responseC)
|
||
input("\nContinue...")
|
||
except (requests.RequestException, json.JSONDecodeError, KeyError, subprocess.SubprocessError, OSError) as e:
|
||
logger.debug("opreturnOnchainONLY error: %s", e)
|
||
|
||
def opreturn():
|
||
qr = qrcode.QRCode(
|
||
version=1,
|
||
error_correction=qrcode.constants.ERROR_CORRECT_L,
|
||
box_size=10,
|
||
border=4,
|
||
)
|
||
try:
|
||
lndconnectload = {"ip_port":"", "tls":"", "macaroon":"", "ln":""}
|
||
if os.path.isfile('blndconnect.conf'): # Check if the file 'bclock.conf' is in the same folder
|
||
with open("blndconnect.conf", "r") as f:
|
||
lndconnectData = json.load(f) # Load the file 'bclock.conf'
|
||
lndconnectload = lndconnectData # Copy the variable pathv to 'path'
|
||
else:
|
||
clear()
|
||
blogo()
|
||
print("\n\tIf you are going to use your local node leave IP:PORT/CERT/MACAROONS in blank.\n")
|
||
lndconnectload["ip_port"] = input("Insert IP:PORT to your node: ") # path to the bitcoin-cli
|
||
lndconnectload["tls"] = input("Insert the path to tls.cert file: ")
|
||
lndconnectload["macaroon"] = input("Insert the path to admin.macaroon: ")
|
||
print("\n\tLocal Lightning Node connection.\n")
|
||
lndconnectload["ln"] = input("Insert the path to lncli: ")
|
||
with open("blndconnect.conf", "w") as f:
|
||
json.dump(lndconnectload, f) # Save the file 'bclock.conf'
|
||
|
||
path = {"ip_port":"", "rpcuser":"", "rpcpass":"", "bitcoincli":""}
|
||
if os.path.isfile('bclock.conf') or os.path.isfile('blnclock.conf'): # Check if the file 'bclock.conf' is in the same folder
|
||
with open("bclock.conf", "r") as f:
|
||
pathv = json.load(f) # Load the file 'bclock.conf'
|
||
path = pathv # Copy the variable pathv to 'path'
|
||
else:
|
||
blogo()
|
||
print("Welcome to \033[1;31;40mPyBLOCK\033[0;37;40m\n\n")
|
||
print("\n\tIf you are going to use your local node leave IP:PORT/USER/PASSWORD in blank.\n")
|
||
path[
|
||
'ip_port'
|
||
] = f'http://{input("Insert IP:PORT to access your remote Bitcoin-Cli node: ")}'
|
||
|
||
path['rpcuser'] = input("RPC User: ")
|
||
path['rpcpass'] = input("RPC Password: ")
|
||
print("\n\tLocal Bitcoin Core Node connection.\n")
|
||
path['bitcoincli']= input("Insert the Path to Bitcoin-Cli: ")
|
||
with open("bclock.conf", "w") as f:
|
||
json.dump(path, f)
|
||
clear()
|
||
blogo()
|
||
output = render(
|
||
"OP_RETURN Message", colors=['yellow'], align='left', font='tiny'
|
||
)
|
||
|
||
print(output)
|
||
message = input("Message: ")
|
||
|
||
while len(message) > 70:
|
||
clear()
|
||
blogo()
|
||
print("Error! Only 80 characters allowed!")
|
||
message = input("\nMessage: ")
|
||
resp = requests.post('https://opreturnbot.com/api/create', json={'message': message + '...PyBLOCK'}, timeout=10)
|
||
b = resp.text
|
||
node_not = input("\nDo you want to pay this invoice with your node? Y/n: ")
|
||
if node_not in ["Y", "y"]:
|
||
lndconnectload = {"ip_port":"", "tls":"", "macaroon":"", "ln":""}
|
||
with open("blndconnect.conf", "r") as f:
|
||
lndconnectData = json.load(f) # Load the file 'bclock.conf'
|
||
lndconnectload = lndconnectData # Copy the variable pathv to 'path'
|
||
if lndconnectload['ip_port']:
|
||
print("\nInvoice: " + b + "\n")
|
||
payinvoice()
|
||
cert_path = lndconnectload["tls"]
|
||
with open(lndconnectload["macaroon"], 'rb') as f:
|
||
macaroon = codecs.encode(f.read(), 'hex')
|
||
headers = {'Grpc-Metadata-macaroon': macaroon}
|
||
url = f'https://{lndconnectload["ip_port"]}/v1/payreq/{b}'
|
||
r = requests.get(url, headers=headers, verify=cert_path, timeout=10)
|
||
s = r.json()
|
||
url = f"https://opreturnbot.com/api/status/{s['payment_hash']}"
|
||
response = requests.get(url, timeout=10)
|
||
responseB = str(response.text)
|
||
responseC = responseB
|
||
clear()
|
||
blogo()
|
||
print("\nTransaction ID: " + responseC)
|
||
input("\nContinue...")
|
||
elif lndconnectload['ln']:
|
||
print("\nInvoice: " + b + "\n")
|
||
localpayinvoice()
|
||
invoiceN = b
|
||
invoice = invoiceN.lower()
|
||
lsd = subprocess.run([lndconnectload["ln"], "decodepayreq", invoice], capture_output=True, text=True).stdout
|
||
lsd0 = str(lsd)
|
||
d = json.loads(lsd0)
|
||
url = f"https://opreturnbot.com/api/status/{d['payment_hash']}"
|
||
response = requests.get(url, timeout=10)
|
||
responseB = str(response.text)
|
||
responseC = responseB
|
||
clear()
|
||
blogo()
|
||
print("\nTransaction ID: " + responseC)
|
||
input("\nContinue...")
|
||
else:
|
||
clear()
|
||
blogo()
|
||
print("\033[1;30;47m")
|
||
qr.add_data(b)
|
||
qr.print_ascii()
|
||
print("\033[0;37;40m")
|
||
print(f'LND Invoice: {b}')
|
||
qr.clear()
|
||
input("\nContinue...")
|
||
if lndconnectload['ln']:
|
||
invoiceN = b
|
||
invoice = invoiceN.lower()
|
||
lsd = subprocess.run([lndconnectload["ln"], "decodepayreq", invoice], capture_output=True, text=True).stdout
|
||
lsd0 = str(lsd)
|
||
d = json.loads(lsd0)
|
||
url = f"https://opreturnbot.com/api/status/{d['payment_hash']}"
|
||
else:
|
||
cert_path = lndconnectload["tls"]
|
||
with open(lndconnectload["macaroon"], 'rb') as f:
|
||
macaroon = codecs.encode(f.read(), 'hex')
|
||
headers = {'Grpc-Metadata-macaroon': macaroon}
|
||
url = f'https://{lndconnectload["ip_port"]}/v1/payreq/{b}'
|
||
r = requests.get(url, headers=headers, verify=cert_path, timeout=10)
|
||
s = r.json()
|
||
url = f"https://opreturnbot.com/api/status/{s['payment_hash']}"
|
||
response = requests.get(url, timeout=10)
|
||
responseB = str(response.text)
|
||
responseC = responseB
|
||
clear()
|
||
blogo()
|
||
print("\nTransaction ID: " + responseC)
|
||
input("\nContinue...")
|
||
except (requests.RequestException, json.JSONDecodeError, KeyError, subprocess.SubprocessError, OSError) as e:
|
||
logger.debug("opreturn error: %s", e)
|
||
|
||
def opreturn_view():
|
||
try:
|
||
clear()
|
||
blogo()
|
||
output = render(
|
||
"OP_RETURN Message", colors=['yellow'], align='left', font='tiny'
|
||
)
|
||
|
||
print(output)
|
||
responseC = input("TX ID: ")
|
||
url2 = f'https://opreturnbot.com/api/view/{responseC}'
|
||
r = requests.get(url2, timeout=10)
|
||
r2 = str(r.text)
|
||
r3 = r2
|
||
clear()
|
||
blogo()
|
||
print("\nTransaction ID: " + responseC)
|
||
print(f'OP_RETURN Message: {r3}')
|
||
input("\nContinue...")
|
||
except (requests.RequestException, KeyError) as e:
|
||
logger.debug("opreturn_view error: %s", e)
|
||
|
||
def opretminer():
|
||
try:
|
||
resp = requests.get('https://bitcointicker.co/latestblocks/', timeout=15)
|
||
raw_html = resp.text
|
||
# Use html2text subprocess (safe: no user input)
|
||
proc = subprocess.run(
|
||
["html2text"],
|
||
input=raw_html, capture_output=True, text=True
|
||
)
|
||
lines = proc.stdout.splitlines()
|
||
filtered = []
|
||
capture = False
|
||
capture_count = 0
|
||
for line in lines:
|
||
stripped = line.replace('|', '')
|
||
if "Coinbase" in line:
|
||
capture = True
|
||
capture_count = 0
|
||
continue
|
||
if capture:
|
||
capture_count += 1
|
||
if capture_count > 70:
|
||
capture = False
|
||
elif '6.25' in stripped:
|
||
filtered.append(stripped)
|
||
a = '\n'.join(filtered)
|
||
clear()
|
||
blogo()
|
||
closed()
|
||
output = render(
|
||
"decoded coinbase", colors=['yellow'], align='left', font='tiny'
|
||
)
|
||
|
||
print(output)
|
||
print(a)
|
||
input("")
|
||
except (requests.RequestException, subprocess.SubprocessError, OSError) as e:
|
||
logger.debug("opretminer error: %s", e)
|
||
|
||
#-----------------------------GAMES--------------------------------
|
||
#------------------------------------------------------------------
|
||
|
||
def gameroom():
|
||
try:
|
||
clear()
|
||
blogo()
|
||
print("""
|
||
--------------------------------------
|
||
|
||
INITIATE ARCADE?
|
||
|
||
--------------------------------------
|
||
""".format(closed()))
|
||
input("\a\nContinue...")
|
||
subprocess.run(["ssh", "gameroom@bitreich.org"])
|
||
except (subprocess.SubprocessError, OSError) as e:
|
||
logger.debug("gameroom error: %s", e)
|
||
#----------------------------------------------------------------------
|
||
|
||
#-----------------------------Stats--------------------------------
|
||
|
||
def statsConn():
|
||
try:
|
||
resp = requests.get('https://www.bitcoinblockhalf.com/', timeout=15)
|
||
proc = subprocess.run(
|
||
["html2text"],
|
||
input=resp.text, capture_output=True, text=True
|
||
)
|
||
lines = proc.stdout.splitlines()
|
||
filtered = []
|
||
capture = False
|
||
capture_count = 0
|
||
for line in lines:
|
||
cleaned = line.replace('*', '').replace('"', '')
|
||
if "Total" in line:
|
||
capture = True
|
||
capture_count = 0
|
||
if capture:
|
||
capture_count += 1
|
||
if capture_count > 11:
|
||
capture = False
|
||
elif '--' not in cleaned:
|
||
filtered.append(cleaned)
|
||
a = '\n'.join(filtered)
|
||
clear()
|
||
blogo()
|
||
closed()
|
||
output = render("stats", colors=['yellow'], align='left', font='tiny')
|
||
print(output)
|
||
print(a)
|
||
input("\a\nContinue...")
|
||
except (requests.RequestException, subprocess.SubprocessError, OSError) as e:
|
||
logger.debug("statsConn error: %s", e)
|
||
|
||
#-----------------------------END Stats--------------------------------
|
||
|
||
#-----------------------------PGP--------------------------------
|
||
|
||
def pgpConn():
|
||
try:
|
||
resp = requests.get('https://web.archive.org/web/20110228054007/http://www.bitcoin.org/Satoshi_Nakamoto.asc', timeout=15)
|
||
a = resp.text
|
||
clear()
|
||
blogo()
|
||
closed()
|
||
output = render(
|
||
"pgp", colors=['yellow'], align='left', font='tiny'
|
||
)
|
||
|
||
print(output)
|
||
print(a)
|
||
input("\a\nContinue...")
|
||
except requests.RequestException as e:
|
||
logger.debug("pgpConn error: %s", e)
|
||
|
||
#-----------------------------END PGP--------------------------------
|
||
|
||
#-----------------------------MoscowT--------------------------------
|
||
def mtConn(): # here we convert the result of the command 'getblockcount' on a random art design
|
||
while True:
|
||
try:
|
||
resp = requests.get('https://blockchain.info/tobtc', params={'currency': 'USD', 'value': '1'}, timeout=10)
|
||
a = resp.text.strip()
|
||
sats = a.lstrip('0.')
|
||
clear()
|
||
blogo()
|
||
closed()
|
||
output = render("Moscow Time", colors=['yellow'], align='left', font='tiny')
|
||
outputT = render(f"{sats[:4]} sats", colors=['green'], align='left', font='tiny')
|
||
print(output)
|
||
print(outputT)
|
||
input("\a\nContinue...")
|
||
except (requests.RequestException, ValueError, KeyboardInterrupt):
|
||
break
|
||
|
||
def mtclock():
|
||
try:
|
||
resp = requests.get('https://blockchain.info/tobtc', params={'currency': 'USD', 'value': '1'}, timeout=10)
|
||
a = resp.text.strip()
|
||
clear()
|
||
blogo()
|
||
closed()
|
||
output = render("Moscow Time", colors=['yellow'], align='left', font='tiny')
|
||
outputT = render(f"{a} sats", colors=['green'], align='left', font='tiny')
|
||
print(output)
|
||
print(outputT)
|
||
input("\a\nContinue...")
|
||
except requests.RequestException as e:
|
||
logger.debug("mtclock error: %s", e)
|
||
|
||
#-----------------------------END MT--------------------------------
|
||
|
||
#-----------------------------Satoshi--------------------------------
|
||
|
||
def satoshiConn():
|
||
try:
|
||
resp = requests.get('https://www.metzdowd.com/pipermail/cryptography/2009-January/014994.html', timeout=15)
|
||
proc = subprocess.run(
|
||
["html2text"],
|
||
input=resp.text, capture_output=True, text=True
|
||
)
|
||
lines = proc.stdout.splitlines()
|
||
# Take last 82 lines, filter out navigation text
|
||
tail_lines = lines[-82:] if len(lines) >= 82 else lines
|
||
exclude = ["Unsubscribe", "Next message", "Previous message", "Messages sorted", "More information", "list]"]
|
||
filtered = [l for l in tail_lines if not any(ex in l for ex in exclude)]
|
||
a = '\n'.join(filtered)
|
||
clear()
|
||
blogo()
|
||
closed()
|
||
output = render(
|
||
"𝐒𝐚𝐭𝐨𝐬𝐡𝐢 𝐍𝐚𝐤𝐚𝐦𝐨𝐭𝐨. 𝟎𝐱𝟏𝟖𝐂𝟎𝟗𝐄𝟖𝟔𝟓𝐄𝐂𝟗𝟒𝟖𝐀𝟏. 𝐃𝐄𝟒𝐄 𝐅𝐂𝐀𝟑 𝐄𝟏𝐀𝐁 𝟗𝐄𝟒𝟏 𝐂𝐄𝟗𝟔 𝐂𝐄𝐂𝐁 𝟏𝟖𝐂𝟎 𝟗𝐄𝟖𝟔 𝟓𝐄𝐂𝟗 𝟒𝟖𝐀𝟏.", colors=['green'], align='left', font='console'
|
||
)
|
||
|
||
print(output)
|
||
print(a)
|
||
input("\a\nContinue...")
|
||
except (requests.RequestException, subprocess.SubprocessError, OSError) as e:
|
||
logger.debug("satoshiConn error: %s", e)
|
||
|
||
#-----------------------------END Satoshi--------------------------------
|
||
|
||
#-----------------------------Whale Alert--------------------------------
|
||
|
||
def whalalConn():
|
||
try:
|
||
api_key = os.environ.get("WHALE_ALERT_API_KEY", "")
|
||
if not api_key:
|
||
print("\n\033[1;31;40mSet WHALE_ALERT_API_KEY environment variable to use Whale Alert.\033[0;37;40m")
|
||
input("\nContinue...")
|
||
return
|
||
url = "https://api.whale-alert.io/v1/transactions"
|
||
params = {"api_key": api_key, "limit": 7, "min_value": 5000000, "currency": "btc"}
|
||
response = requests.get(url, params=params, timeout=10)
|
||
data = response.json()
|
||
clear()
|
||
blogo()
|
||
closed()
|
||
output = render("whale alert", colors=['yellow'], align='left', font='tiny')
|
||
print(output)
|
||
for tx in data.get("transactions", []):
|
||
blockchain = tx.get("blockchain", "unknown")
|
||
amount = tx.get("amount", 0)
|
||
amount_usd = tx.get("amount_usd", 0)
|
||
print(f" WHALE ALERT ₿ {amount} =${amount_usd:.0f}")
|
||
input("\a\nContinue...")
|
||
except (requests.RequestException, json.JSONDecodeError, KeyError) as e:
|
||
logger.debug("whalalConn error: %s", e)
|
||
|
||
#-----------------------------END Whale Alert--------------------------------
|
||
#-----------------------------bwt.dev--------------------------------
|
||
|
||
def bwtConn():
|
||
try:
|
||
resp = requests.get('https://bwt.dev/banner.txt', timeout=10)
|
||
a = resp.text
|
||
clear()
|
||
blogo()
|
||
closed()
|
||
print(a)
|
||
input("\a\nContinue...")
|
||
except requests.RequestException as e:
|
||
logger.debug("bwtConn error: %s", e)
|
||
|
||
#-----------------------------END bwt.dev--------------------------------
|
||
#-----------------------------Dates--------------------------------
|
||
|
||
def datesConn():
|
||
try:
|
||
resp = requests.get('https://bitcoinexplorer.org/fun', timeout=15)
|
||
proc = subprocess.run(
|
||
["html2text"],
|
||
input=resp.text, capture_output=True, text=True
|
||
)
|
||
lines = proc.stdout.splitlines()
|
||
filtered = []
|
||
for line in lines:
|
||
if '20' in line and 'https' not in line and ' ' in line:
|
||
cleaned = line.replace('[', '').replace(',', '')
|
||
filtered.append(cleaned)
|
||
if len(filtered) >= 46:
|
||
break
|
||
a = '\n'.join(filtered)
|
||
clear()
|
||
blogo()
|
||
closed()
|
||
output = render("dates", colors=['yellow'], align='left', font='tiny')
|
||
print(output)
|
||
print(a)
|
||
input("\a\nContinue...")
|
||
except (requests.RequestException, subprocess.SubprocessError, OSError) as e:
|
||
logger.debug("datesConn error: %s", e)
|
||
|
||
#-----------------------------END Dates--------------------------------
|
||
#-----------------------------Quotes--------------------------------
|
||
|
||
def quotesConn():
|
||
try:
|
||
resp = requests.get('https://bitcoinexplorer.org/api/quotes/all', timeout=10)
|
||
data = resp.json()
|
||
clear()
|
||
blogo()
|
||
closed()
|
||
output = render("quotes", colors=['yellow'], align='left', font='tiny')
|
||
print(output)
|
||
for quote in data:
|
||
text = quote.get('text', '')
|
||
speaker = quote.get('speaker', '')
|
||
url = quote.get('url', '')
|
||
date = quote.get('date', '')
|
||
if 'conQuote' not in text:
|
||
print(f' Quote: {text}')
|
||
print(f' By: {speaker}')
|
||
if url:
|
||
print(f' Link: {url}')
|
||
if date:
|
||
print(f' Date: {date}')
|
||
print()
|
||
input("\a\nContinue...")
|
||
except (requests.RequestException, json.JSONDecodeError, KeyError) as e:
|
||
logger.debug("quotesConn error: %s", e)
|
||
|
||
#-----------------------------END Quotes--------------------------------
|
||
#-----------------------------Hashrate--------------------------------
|
||
|
||
def miningConn():
|
||
try:
|
||
resp = requests.get('https://bitcoinexplorer.org/api/mining/hashrate', timeout=10)
|
||
data = resp.json()
|
||
clear()
|
||
blogo()
|
||
closed()
|
||
output = render("hashrate", colors=['yellow'], align='left', font='tiny')
|
||
print(output)
|
||
for key, value in data.items():
|
||
if isinstance(value, dict):
|
||
for k, v in value.items():
|
||
print(f' {k}: {v}')
|
||
else:
|
||
print(f' {key}: {value}')
|
||
input("\a\nContinue...")
|
||
except (requests.RequestException, json.JSONDecodeError, KeyError) as e:
|
||
logger.debug("miningConn error: %s", e)
|
||
|
||
#-----------------------------END Hashrate--------------------------------
|
||
#-----------------------------StatsLN--------------------------------
|
||
|
||
def stalnConn():
|
||
try:
|
||
resp = requests.get('https://1ml.com', timeout=15)
|
||
proc = subprocess.run(
|
||
["html2text"],
|
||
input=resp.text, capture_output=True, text=True
|
||
)
|
||
lines = proc.stdout.splitlines()
|
||
filtered = []
|
||
capture = False
|
||
capture_count = 0
|
||
for line in lines:
|
||
stripped = ' '.join(line.split())
|
||
if "Number" in line:
|
||
capture = True
|
||
capture_count = 0
|
||
if capture:
|
||
filtered.append(stripped)
|
||
capture_count += 1
|
||
if capture_count > 8:
|
||
capture = False
|
||
a = '\n'.join(filtered)
|
||
clear()
|
||
blogo()
|
||
closed()
|
||
output = render(
|
||
"lightning stats", colors=['yellow'], align='left', font='tiny'
|
||
)
|
||
|
||
print(output)
|
||
print(a)
|
||
input("\a\nContinue...")
|
||
except (requests.RequestException, subprocess.SubprocessError, OSError) as e:
|
||
logger.debug("stalnConn error: %s", e)
|
||
|
||
#-----------------------------END StatsLN--------------------------------
|
||
#-----------------------------StatRanking--------------------------------
|
||
def ranConn():
|
||
try:
|
||
resp = requests.get('https://1ml.com/node?order=capacity&json=true', timeout=15)
|
||
data = resp.json()
|
||
clear()
|
||
blogo()
|
||
closed()
|
||
output = render("ranking", colors=['yellow'], align='left', font='tiny')
|
||
print(output)
|
||
exclude_keys = {'last_update', 'color', 'noderank', 'addresses'}
|
||
for node in data:
|
||
if isinstance(node, dict):
|
||
for k, v in node.items():
|
||
if k not in exclude_keys:
|
||
label = 'Node' if k == 'alias' else ('RANK' if k == 'capacity' else k)
|
||
print(f' {label}: {v}')
|
||
print()
|
||
input("\a\nContinue...")
|
||
except (requests.RequestException, json.JSONDecodeError, KeyError, ValueError) as e:
|
||
logger.debug("ranConn error: %s", e)
|
||
#-----------------------------END Ranking--------------------------------
|
||
|
||
def trustednode():
|
||
try:
|
||
clear()
|
||
blogo()
|
||
closed()
|
||
addv = """
|
||
---------------------------------------------------------------
|
||
|
||
REMEMBER TO INITIALIZE \033[1;35;40mTOR\033[0;37;40m ON THE SHELL
|
||
|
||
$ source torsocks on
|
||
|
||
---------------------------------------------------------------
|
||
|
||
"""
|
||
print(addv)
|
||
input("\a\nContinue...")
|
||
conn = ["telnet", "cut45oarvxfvfydrjery6slyeca4zpal7tljygdt5bji7l3jsrrgwkad.onion", "6023"]
|
||
subprocess.run(conn)
|
||
except (subprocess.SubprocessError, OSError) as e:
|
||
logger.debug("trustednode error: %s", e)
|
||
#-----------------------------END GAMES--------------------------------
|
||
|
||
#-----------------------------Node Miner--------------------------------
|
||
|
||
def CoreMiner():
|
||
try:
|
||
clear()
|
||
blogo()
|
||
output = render("Core Miner", colors=['yellow'], align='left', font='tiny')
|
||
print(output)
|
||
input("\a\n...Mining...")
|
||
subprocess.run([path['bitcoincli'], "-generate", "1", "2147483647"])
|
||
input("\a\nContinue...")
|
||
except (subprocess.SubprocessError, OSError, KeyError) as e:
|
||
logger.debug("CoreMiner error: %s", e)
|
||
|
||
def OwnNodeMinerComputer():
|
||
try:
|
||
clear()
|
||
blogo()
|
||
output = render(
|
||
"Own Node Miner", colors=['yellow'], align='left', font='tiny'
|
||
)
|
||
if os.path.isdir ('OwnNodeMiner'):
|
||
print("...Follow the steps...")
|
||
else: # Check if the file 'bclock.conf' is in the same folder
|
||
os.makedirs("OwnNodeMiner", exist_ok=True)
|
||
subprocess.run(["wget", "https://github.com/pooler/cpuminer/releases/download/v2.5.1/pooler-cpuminer-2.5.1-linux-x86_64.tar.gz"], cwd="OwnNodeMiner")
|
||
# SECURITY: Validate user-controlled args before passing to subprocess
|
||
# Sanitize: strip shell metacharacters, validate expected format
|
||
subprocess.run(["tar", "-xf", "pooler-cpuminer-2.5.1-linux-x86_64.tar.gz"], cwd="OwnNodeMiner")
|
||
clear()
|
||
blogo()
|
||
print(output)
|
||
responseC = input("Your RPC User: ")
|
||
responseD = input("Your RPC Pass: ")
|
||
responseE = input("Your Bitcoin Address: ")
|
||
responseF = input("Select Your Threads, 2, 4, 6, 8, 10, ..: ")
|
||
subprocess.run(["./minerd", "-a", "sha256d", "-O", f"{responseC}:{responseD}", "-o", "http://127.0.0.1:8332", f"--coinbase-addr={responseE}", "-t", responseF], cwd="OwnNodeMiner")
|
||
input("\a\nContinue...")
|
||
except (subprocess.SubprocessError, OSError) as e:
|
||
logger.debug("OwnNodeMinerComputer error: %s", e)
|
||
|
||
def OwnNodeMinerRaspberry():
|
||
try:
|
||
clear()
|
||
blogo()
|
||
output = render(
|
||
"Own Node Miner", colors=['yellow'], align='left', font='tiny'
|
||
)
|
||
if os.path.isdir ('OwnNodeMiner'):
|
||
print("...Follow the steps...")
|
||
else: # Check if the file 'bclock.conf' is in the same folder
|
||
os.makedirs("OwnNodeMiner", exist_ok=True)
|
||
subprocess.run(["git", "clone", "https://github.com/jojapoppa/cpuminer-multi-arm.git"], cwd="OwnNodeMiner")
|
||
clear()
|
||
blogo()
|
||
print(output)
|
||
responseC = input("Your RPC User: ")
|
||
responseD = input("Your RPC Pass: ")
|
||
responseE = input("Your Bitcoin Address: ")
|
||
responseF = input("Select Your Threads, 2, 4, 6, 8, 10, ..: ")
|
||
subprocess.run(["./cpuminer", "-a", "sha256d", "-O", f"{responseC}:{responseD}", "-o", "http://127.0.0.1:8332", f"--coinbase-addr={responseE}", "-t", responseF], cwd="OwnNodeMiner/cpuminer-multi-arm")
|
||
input("\a\nContinue...")
|
||
except (subprocess.SubprocessError, OSError) as e:
|
||
logger.debug("OwnNodeMinerRaspberry error: %s", e)
|
||
#-----------------------------Node Miner--------------------------------
|
||
|
||
#-----------------------------wttr.in--------------------------------
|
||
def wttrDataV1():
|
||
try:
|
||
clear()
|
||
blogo()
|
||
weatherList = """
|
||
------------------------------------------------------------------------------------
|
||
|
||
|
||
|
||
\033[1;31;40m*\033[0;37;40m uruguay # city name
|
||
\033[1;31;40m*\033[0;37;40m ~Giza+pyramid # any location (+ for spaces)
|
||
\033[1;31;40m*\033[0;37;40m Москва # Unicode name of any location in any language
|
||
\033[1;31;40m*\033[0;37;40m muc # airport code (3 letters)
|
||
\033[1;31;40m*\033[0;37;40m @lightninghood.com # domain name
|
||
\033[1;31;40m*\033[0;37;40m 94107 # area codes
|
||
\033[1;31;40m*\033[0;37;40m -78.46,106.79 # GPS coordinates
|
||
\033[1;31;40m*\033[0;37;40m moon # Moon phase (add ,+US or ,+France for these cities)
|
||
\033[1;31;40m*\033[0;37;40m moon@2009-01-03 # Moon phase for the date (@2016-10-25)
|
||
|
||
PRESS \033[1;32;40mM\033[0;37;40m TO INSERT MORE DATA
|
||
|
||
------------------------------------------------------------------------------------
|
||
|
||
"""
|
||
print(weatherList)
|
||
selectData = input("Insert your data \033[1;31;40m*\033[0;37;40m : ")
|
||
if selectData in ['M', 'm']:
|
||
moreData = """
|
||
|
||
------------------------------------------------------------------------------------
|
||
Supported languages
|
||
|
||
ar af be ca da de el es et fr fa hi hu ia id it nb nl
|
||
oc pl pt-br ro ru tr th uk vi zh-cn zh-tw (supported)
|
||
|
||
------------------------------------------------------------------------------------
|
||
------------------------------------------------------------------------------------
|
||
Units
|
||
|
||
m # metric (SI) (used by default everywhere except US)
|
||
u # USCS (used by default in US)
|
||
M # show wind speed in m/s
|
||
|
||
------------------------------------------------------------------------------------
|
||
"""
|
||
print(moreData)
|
||
selectData2 = input("Insert your data \033[1;31;40m*\033[0;37;40m : ")
|
||
lang = input("Insert your language: ")
|
||
unit = input("Insert your metric units: ")
|
||
url = f"https://{lang}.wttr.in/{selectData2}?F&{unit}"
|
||
else:
|
||
url = f"https://wttr.in/{selectData}?F"
|
||
a = requests.get(url, headers={"User-Agent": "curl"}, timeout=15).text
|
||
clear()
|
||
blogo()
|
||
print(a)
|
||
input("Continue...")
|
||
except requests.RequestException as e:
|
||
logger.debug("wttrDataV1 error: %s", e)
|
||
|
||
def wttrDataV2():
|
||
try:
|
||
clear()
|
||
blogo()
|
||
weatherList = """
|
||
------------------------------------------------------------------------------------
|
||
|
||
|
||
|
||
\033[1;31;40m*\033[0;37;40m uruguay # city name
|
||
\033[1;31;40m*\033[0;37;40m ~Giza+pyramid # any location (+ for spaces)
|
||
\033[1;31;40m*\033[0;37;40m Москва # Unicode name of any location in any language
|
||
\033[1;31;40m*\033[0;37;40m muc # airport code (3 letters)
|
||
\033[1;31;40m*\033[0;37;40m @lightninghood.com # domain name
|
||
\033[1;31;40m*\033[0;37;40m 94107 # area codes
|
||
\033[1;31;40m*\033[0;37;40m -78.46,106.79 # GPS coordinates
|
||
|
||
PRESS \033[1;32;40mM\033[0;37;40m TO INSERT MORE DATA
|
||
|
||
------------------------------------------------------------------------------------
|
||
|
||
"""
|
||
print(weatherList)
|
||
selectData = input("Insert your data \033[1;31;40m*\033[0;37;40m : ")
|
||
if selectData in ['M', 'm']:
|
||
moreData = """
|
||
|
||
------------------------------------------------------------------------------------
|
||
Supported languages
|
||
|
||
ar af be ca da de el es et fr fa hi hu ia id it nb nl
|
||
oc pl pt-br ro ru tr th uk vi zh-cn zh-tw (supported)
|
||
|
||
------------------------------------------------------------------------------------
|
||
------------------------------------------------------------------------------------
|
||
Units
|
||
|
||
m # metric (SI) (used by default everywhere except US)
|
||
u # USCS (used by default in US)
|
||
M # show wind speed in m/s
|
||
|
||
------------------------------------------------------------------------------------
|
||
"""
|
||
print(moreData)
|
||
selectData2 = input("Insert your data \033[1;31;40m*\033[0;37;40m : ")
|
||
lang = input("Insert your language: ")
|
||
unit = input("Insert your metric units: ")
|
||
url = f"https://v2.wttr.in/{selectData2}?{unit}&F&lang={lang}"
|
||
else:
|
||
url = f"https://v2.wttr.in/{selectData}?F"
|
||
a = requests.get(url, headers={"User-Agent": "curl"}, timeout=15).text
|
||
clear()
|
||
blogo()
|
||
print(a)
|
||
input("Continue...")
|
||
except requests.RequestException as e:
|
||
logger.debug("wttrDataV2 error: %s", e)
|
||
|
||
|
||
#-----------------------------END wttr.in--------------------------------
|
||
|
||
#-----------------------------RATE.SX--------------------------------
|
||
|
||
def rateSXList():
|
||
try:
|
||
clear()
|
||
blogo()
|
||
fiat = """
|
||
-------------------------------------------
|
||
AUD Australian dollar
|
||
BRL Brazilian real
|
||
CAD Canadian dollar
|
||
CHF Swiss franc
|
||
CLP Chilean peso
|
||
CNY Chinese yuan
|
||
CZK Czech koruna
|
||
DKK Danish krone
|
||
EUR Euro
|
||
GBP Pound sterling
|
||
HKD Hong Kong dollar
|
||
HUF Hungarian forint
|
||
IDR Indonesian rupiah
|
||
ILS Israeli shekel
|
||
INR Indian rupee
|
||
JPY Japanese yen
|
||
KRW South Korean won
|
||
MXN Mexican peso
|
||
MYR Malaysian ringgit
|
||
NOK Norwegian krone
|
||
NZD New Zealand dollar
|
||
PHP Philippine peso
|
||
PKR Pakistani rupee
|
||
PLN Polish zloty
|
||
RUB Russian ruble
|
||
SEK Swedish krona
|
||
SGD Singapore dollar
|
||
THB Thai baht
|
||
TRY Turkish lira
|
||
TWD New Taiwan dollar
|
||
USD Dollars
|
||
-------------------------------------------
|
||
"""
|
||
print(fiat)
|
||
selectFiat = input("Insert a Fiat currency: ").strip().upper()
|
||
if selectFiat not in _VALID_FIAT_CODES:
|
||
print(f"Invalid currency code: {selectFiat}")
|
||
return
|
||
except (KeyboardInterrupt, EOFError):
|
||
return
|
||
while True:
|
||
try:
|
||
url = f"https://{selectFiat}.rate.sx/?F&n=1"
|
||
resp = requests.get(url, headers={"User-Agent": "curl"}, timeout=15)
|
||
a = resp.text
|
||
clear()
|
||
blogo()
|
||
closed()
|
||
print(a)
|
||
t.sleep(20)
|
||
except (requests.RequestException, KeyboardInterrupt):
|
||
break
|
||
|
||
def rateSXGraph():
|
||
try:
|
||
clear()
|
||
blogo()
|
||
fiat = """
|
||
-------------------------------------------
|
||
AUD Australian dollar
|
||
BRL Brazilian real
|
||
CAD Canadian dollar
|
||
CHF Swiss franc
|
||
CLP Chilean peso
|
||
CNY Chinese yuan
|
||
CZK Czech koruna
|
||
DKK Danish krone
|
||
EUR Euro
|
||
GBP Pound sterling
|
||
HKD Hong Kong dollar
|
||
HUF Hungarian forint
|
||
IDR Indonesian rupiah
|
||
ILS Israeli shekel
|
||
INR Indian rupee
|
||
JPY Japanese yen
|
||
KRW South Korean won
|
||
MXN Mexican peso
|
||
MYR Malaysian ringgit
|
||
NOK Norwegian krone
|
||
NZD New Zealand dollar
|
||
PHP Philippine peso
|
||
PKR Pakistani rupee
|
||
PLN Polish zloty
|
||
RUB Russian ruble
|
||
SEK Swedish krona
|
||
SGD Singapore dollar
|
||
THB Thai baht
|
||
TRY Turkish lira
|
||
TWD New Taiwan dollar
|
||
USD Dollars
|
||
-------------------------------------------
|
||
"""
|
||
print(fiat)
|
||
selectFiat = input("Insert a Fiat currency: ").strip().upper()
|
||
if selectFiat not in _VALID_FIAT_CODES:
|
||
print(f"Invalid currency code: {selectFiat}")
|
||
return
|
||
except (KeyboardInterrupt, EOFError):
|
||
return
|
||
while True:
|
||
try:
|
||
url = f"https://{selectFiat}.rate.sx/btc"
|
||
resp = requests.get(url, headers={"User-Agent": "curl"}, timeout=15)
|
||
lines = resp.text.splitlines()
|
||
filtered = [l for l in lines if 'Use' not in l]
|
||
a = '\n'.join(filtered)
|
||
clear()
|
||
blogo()
|
||
closed()
|
||
print(a)
|
||
t.sleep(20)
|
||
except (requests.RequestException, KeyboardInterrupt):
|
||
break
|
||
|
||
#-----------------------------END RATE.SX--------------------------------
|
||
|
||
|
||
|
||
#-----------------------------COINGECKO--------------------------------
|
||
|
||
def CoingeckoPP():
|
||
try:
|
||
btcInfo = CoinGeckoAPI()
|
||
n = btcInfo.get_price(ids='bitcoin', vs_currencies='usd,eur,gbp,jpy,aud')
|
||
q = n['bitcoin']
|
||
usd = q['usd']
|
||
eur = q['eur']
|
||
gbp = q['gbp']
|
||
jpy = q['jpy']
|
||
aud = q['aud']
|
||
|
||
|
||
print("""
|
||
--------------------COINGECKO BITCOIN PRICE-----------------------
|
||
|
||
1 BTC = {} USD
|
||
1 BTC = {} EUR
|
||
1 BTC = {} GBP
|
||
1 BTC = {} JPY
|
||
1 BTC = {} AUD
|
||
|
||
------------------------------------------------------------------
|
||
|
||
...BUT...
|
||
|
||
1 BTC = 1 BTC
|
||
|
||
------------------------------------------------------------------
|
||
""".format(usd,eur,gbp,jpy,aud))
|
||
input("Continue...")
|
||
except (requests.RequestException, KeyError, ValueError) as e:
|
||
logger.debug("CoingeckoPP error: %s", e)
|
||
|
||
#-----------------------------END COINGECKO--------------------------------
|
||
|
||
|
||
#-----------------------------LNBITS--------------------------------
|
||
|
||
def loadFileConnLNBits(lnbitLoad):
|
||
lnbitLoad = {"wallet_name":"", "wallet_id":"", "admin_key":"", "invoice_read_key":""}
|
||
|
||
if os.path.isfile('lnbit.conf'): # Check if the file 'bclock.conf' is in the same folder
|
||
with open("lnbit.conf", "r") as f:
|
||
lnbitData = json.load(f) # Load the file 'bclock.conf'
|
||
lnbitLoad = lnbitData # Copy the variable pathv to 'path'
|
||
else:
|
||
clear()
|
||
blogo()
|
||
print("""\n\t \033[1;33;40mATENTION\033[0;37;40m: YOU ARE GOING TO CREATE A FILE WITH YOUR INFORMATION OF CONNECTION TO LNBITS.COM.
|
||
WE WILL NEED SOME INFORMATION FROM YOUR ACCOUNT THAT THE ONLY ONE THAT WILL HAVE ACCESS IS YOU.
|
||
IF YOU DELETE THIS FILE YOU WILL NEED TO PAY AGAIN TO GET ACCESS FROM PyBLOCK.
|
||
SAVE THE FILE '\033[1;33;40mlnbitSN.conf\033[0;37;40m' IN A SAFE PLACE.\n
|
||
""")
|
||
lnbitLoad["wallet_name"] = input("Wallet name: ") # path to the bitcoin-cli
|
||
lnbitLoad["wallet_id"] = input("Wallet ID: ")
|
||
lnbitLoad["admin_key"] = input("Admin key: ")
|
||
lnbitLoad["invoice_read_key"] = input("Invoice/read key: ")
|
||
with open("lnbit.conf", "w") as f:
|
||
json.dump(lnbitLoad, f)
|
||
return lnbitLoad
|
||
|
||
def createFileConnLNBits():
|
||
clear()
|
||
blogo()
|
||
print("""\n\t \033[1;33;40mATENTION\033[0;37;40m: YOU ARE GOING TO CREATE A FILE WITH YOUR INFORMATION OF CONNECTION TO LNBITS.COM.
|
||
WE WILL NEED SOME INFORMATION FROM YOUR ACCOUNT THAT THE ONLY ONE THAT WILL HAVE ACCESS IS YOU.
|
||
IF YOU DELETE THIS FILE YOU WILL NEED TO PAY AGAIN TO GET ACCESS FROM PyBLOCK.
|
||
SAVE THE FILE '\033[1;33;40mlnbitSN.conf\033[0;37;40m' IN A SAFE PLACE.\n
|
||
""")
|
||
lnbitLoad = {
|
||
'wallet_id': '',
|
||
'admin_key': '',
|
||
'invoice_read_key': '',
|
||
'wallet_name': input("Wallet name: "),
|
||
}
|
||
|
||
lnbitLoad["wallet_id"] = input("Wallet ID: ")
|
||
lnbitLoad["admin_key"] = input("Admin key: ")
|
||
lnbitLoad["invoice_read_key"] = input("Invoice/read key: ")
|
||
|
||
with open("lnbit.conf", "w") as f:
|
||
json.dump(lnbitLoad, f)
|
||
|
||
def lnbitCreateNewInvoice():
|
||
qr = qrcode.QRCode(
|
||
version=1,
|
||
error_correction=qrcode.constants.ERROR_CORRECT_L,
|
||
box_size=10,
|
||
border=4,
|
||
)
|
||
try:
|
||
print("\n\tLNBITS CREATE INVOICE\n")
|
||
amt = input("Amount: ")
|
||
memo = input("Memo: ")
|
||
a = loadFileConnLNBits(['invoice_read_key'])
|
||
b = str(a['invoice_read_key'])
|
||
headers = {"X-Api-Key": b, "Content-type": "application/json"}
|
||
payload = {"out": False, "amount": int(amt), "memo": f"{memo} -PyBLOCK"}
|
||
sh = requests.post("https://legend.lnbits.com/api/v1/payments", json=payload, headers=headers, timeout=10).text
|
||
clear()
|
||
blogo()
|
||
n = str(sh)
|
||
d = json.loads(n)
|
||
q = d['payment_request']
|
||
c = q.lower()
|
||
node_not = input("Do you want to pay this invoice with your node? Y/n: ")
|
||
|
||
while True:
|
||
if node_not in ["Y", "y"]:
|
||
lndconnectload = {"ip_port":"", "tls":"", "macaroon":"", "ln":""}
|
||
with open("blndconnect.conf", "r") as f:
|
||
lndconnectData = json.load(f) # Load the file 'bclock.conf'
|
||
lndconnectload = lndconnectData # Copy the variable pathv to 'path'
|
||
if lndconnectload['ip_port']:
|
||
print("\nInvoice: " + c + "\n")
|
||
payinvoice()
|
||
elif lndconnectload['ln']:
|
||
print("\nInvoice: " + c + "\n")
|
||
localpayinvoice()
|
||
elif node_not in ["N", "n"]:
|
||
print("\033[1;30;47m")
|
||
qr.add_data(c)
|
||
qr.print_ascii()
|
||
print("\033[0;37;40m")
|
||
qr.clear()
|
||
print(f'Lightning Invoice: {c}')
|
||
t.sleep(10)
|
||
dn = str(d['checking_id'])
|
||
headers = {"X-Api-Key": b, "Content-type": "application/json"}
|
||
rsh = requests.get(f"https://legend.lnbits.com/api/v1/payments/{dn}", headers=headers, timeout=10).text
|
||
clear()
|
||
blogo()
|
||
nn = str(rsh)
|
||
dd = json.loads(nn)
|
||
db = dd['paid']
|
||
if db != True:
|
||
continue
|
||
clear()
|
||
blogo()
|
||
tick()
|
||
t.sleep(2)
|
||
break
|
||
except (requests.RequestException, json.JSONDecodeError, KeyError, OSError) as e:
|
||
logger.debug("lnbitCreateNewInvoice error: %s", e)
|
||
|
||
def lnbitPayInvoice():
|
||
bolt = input("Invoice: ")
|
||
a = loadFileConnLNBits(['admin_key'])
|
||
b = str(a['admin_key'])
|
||
headers = {"X-Api-Key": b, "Content-type": "application/json"}
|
||
payload = {"out": True, "bolt11": bolt}
|
||
|
||
try:
|
||
sh = requests.post("https://legend.lnbits.com/api/v1/payments", json=payload, headers=headers, timeout=10).text
|
||
n = str(sh)
|
||
d = json.loads(n)
|
||
dn = str(d['checking_id'])
|
||
a = loadFileConnLNBits(['invoice_read_key'])
|
||
b = str(a['invoice_read_key'])
|
||
while True:
|
||
headers = {"X-Api-Key": b, "Content-type": "application/json"}
|
||
rsh = requests.get(f"https://legend.lnbits.com/api/v1/payments/{dn}", headers=headers, timeout=10).text
|
||
clear()
|
||
blogo()
|
||
nn = str(rsh)
|
||
dd = json.loads(nn)
|
||
db = dd['paid']
|
||
if db != True:
|
||
continue
|
||
tick()
|
||
t.sleep(2)
|
||
break
|
||
except (requests.RequestException, json.JSONDecodeError, KeyError) as e:
|
||
logger.debug("lnbitPayInvoice error: %s", e)
|
||
|
||
def lnbitCreatePayWall():
|
||
while True:
|
||
try:
|
||
url = input("Url: ")
|
||
memo = input("Memo: ")
|
||
desc = input("Description: ")
|
||
amt = input("Amount in sats: ")
|
||
remb = input("Remembers Y/n: ")
|
||
a = loadFileConnLNBits(['admin_key'])
|
||
if remb in ["Y", "y"]:
|
||
remember = "true"
|
||
elif remb in ["N", "n"]:
|
||
remember = "false"
|
||
b = str(a['admin_key'])
|
||
headers = {"X-Api-Key": b, "Content-type": "application/json"}
|
||
payload = {"url": url, "memo": memo, "description": desc, "amount": int(amt), "remembers": remember == "true"}
|
||
sh = requests.post("https://legend.lnbits.com/paywall/api/v1/paywalls", json=payload, headers=headers, timeout=10).text
|
||
clear()
|
||
blogo()
|
||
n = str(sh)
|
||
d = json.loads(n)
|
||
print("\n\tPAYWALL CREATED SUCCESSFULLY\n")
|
||
t.sleep(2)
|
||
clear()
|
||
aa = loadFileConnLNBits(['invoice_read_key'])
|
||
bb = str(a['invoice_read_key'])
|
||
headers = {"X-Api-Key": bb}
|
||
sh = requests.get("https://legend.lnbits.com/paywall/api/v1/paywalls", headers=headers, timeout=10).text
|
||
clear()
|
||
blogo()
|
||
n = str(sh)
|
||
d = json.loads(n)
|
||
while True:
|
||
print("\n\tLNBITS PAYWALL LIST\n")
|
||
for item_ in d:
|
||
s = item_
|
||
print(f'ID: {s["id"]}')
|
||
nd = input("\nSelect ID: ")
|
||
for item in d:
|
||
s = item
|
||
nn = s['id']
|
||
if nd == nn:
|
||
print("\n----------------------------------------------------------------------------------------------------------------")
|
||
print(
|
||
"""
|
||
\tLNBITS PAYWALL DECODED
|
||
|
||
ID: {}
|
||
Amount: {} sats
|
||
Description: {}
|
||
Memo: {}
|
||
Extras: {}
|
||
Remembers: {}
|
||
URL: {}
|
||
Wallet: {}
|
||
""".format(
|
||
nn,
|
||
s['amount'],
|
||
s['description'],
|
||
s['memo'],
|
||
s['extras'],
|
||
s['remembers'],
|
||
s['url'],
|
||
s['wallet'],
|
||
)
|
||
)
|
||
|
||
print("----------------------------------------------------------------------------------------------------------------\n")
|
||
input("Continue...")
|
||
clear()
|
||
blogo()
|
||
except (requests.RequestException, json.JSONDecodeError, KeyError, KeyboardInterrupt):
|
||
break
|
||
|
||
def lnbitListPawWall():
|
||
a = loadFileConnLNBits(['invoice_read_key'])
|
||
b = str(a['invoice_read_key'])
|
||
headers = {"X-Api-Key": b}
|
||
sh = requests.get("https://legend.lnbits.com/paywall/api/v1/paywalls", headers=headers, timeout=10).text
|
||
clear()
|
||
blogo()
|
||
n = str(sh)
|
||
d = json.loads(n)
|
||
while True:
|
||
print("\n\tLNBITS PAYWALL LIST\n")
|
||
try:
|
||
for item_ in d:
|
||
s = item_
|
||
print(f'ID: {s["id"]}')
|
||
nd = input("\nSelect ID: ")
|
||
for item in d:
|
||
s = item
|
||
nn = s['id']
|
||
if nd == nn:
|
||
print("\n----------------------------------------------------------------------------------------------------------------")
|
||
print("""
|
||
\tLNBITS PAYWALL DECODED
|
||
|
||
ID: {}
|
||
Amount: {} sats
|
||
Description: {}
|
||
Memo: {}
|
||
Extras: {}
|
||
Remembers: {}
|
||
URL: {}
|
||
Wallet: {}
|
||
""".format(s['id'], s['amount'], s['description'], s['memo'], s['extras'], s['remembers'], s['url'], s['wallet']))
|
||
print("----------------------------------------------------------------------------------------------------------------\n")
|
||
except (json.JSONDecodeError, KeyError, KeyboardInterrupt):
|
||
break
|
||
input("Continue...")
|
||
clear()
|
||
blogo()
|
||
|
||
def lnbitDeletePayWall():
|
||
while True:
|
||
try:
|
||
a = loadFileConnLNBits(['invoice_read_key'])
|
||
b = str(a['invoice_read_key'])
|
||
headers = {"X-Api-Key": b}
|
||
sh = requests.get("https://legend.lnbits.com/paywall/api/v1/paywalls", headers=headers, timeout=10).text
|
||
clear()
|
||
blogo()
|
||
n = str(sh)
|
||
d = json.loads(n)
|
||
while True:
|
||
print("\n\tLNBITS PAYWALL LIST\n")
|
||
try:
|
||
for item_ in d:
|
||
s = item_
|
||
print(f'ID: {s["id"]}')
|
||
nd = input("\nSelect ID: ")
|
||
for item in d:
|
||
s = item
|
||
nn = s['id']
|
||
if nd == nn:
|
||
print("\n----------------------------------------------------------------------------------------------------------------")
|
||
print("""
|
||
\tLNBITS PAYWALL DECODED
|
||
|
||
ID: {}
|
||
Amount: {} sats
|
||
Description: {}
|
||
Memo: {}
|
||
Extras: {}
|
||
Remembers: {}
|
||
URL: {}
|
||
Wallet: {}
|
||
""".format(s['id'], s['amount'], s['description'], s['memo'], s['extras'], s['remembers'], s['url'], s['wallet']))
|
||
print("----------------------------------------------------------------------------------------------------------------\n")
|
||
except (json.JSONDecodeError, KeyError, KeyboardInterrupt):
|
||
break
|
||
input("Continue...")
|
||
break
|
||
print("\n\tDELETE PAYWALL\n")
|
||
a = loadFileConnLNBits(['admin_key'])
|
||
b = str(a['admin_key'])
|
||
id = input("Insert PayWall ID: ")
|
||
headers = {"X-Api-Key": b}
|
||
sh = requests.delete(f"https://legend.lnbits.com/paywall/api/v1/paywalls/{id}", headers=headers, timeout=10).text
|
||
clear()
|
||
blogo()
|
||
print("\n\tPAYWALL DELETED SUCCESSFULLY\n")
|
||
t.sleep(2)
|
||
clear()
|
||
except (requests.RequestException, json.JSONDecodeError, KeyError, KeyboardInterrupt):
|
||
break
|
||
|
||
def lnbitsLNURLw():
|
||
while True:
|
||
try:
|
||
clear()
|
||
blogo()
|
||
print("""
|
||
----------------------
|
||
CREATE LNURL
|
||
----------------------\n""")
|
||
title = input("Title: ")
|
||
minwith = input("Minimum Withdraw: ")
|
||
maxwith = input("Maximum Withdraw: ")
|
||
usesw = input("Uses: ")
|
||
waittime = input("Wait Time: ")
|
||
isunique = input("Is unique? true/false: ")
|
||
a = loadFileConnLNBits(['admin_key'])
|
||
b = str(a['admin_key'])
|
||
headers = {"X-Api-Key": b, "Content-type": "application/json"}
|
||
payload = {"title": title, "min_withdrawable": int(minwith), "max_withdrawable": int(maxwith), "uses": int(usesw), "wait_time": int(waittime), "is_unique": isunique == "true"}
|
||
sh = requests.post("https://legend.lnbits.com/withdraw/api/v1/links", json=payload, headers=headers, timeout=10).text
|
||
clear()
|
||
blogo()
|
||
n = str(sh)
|
||
d = json.loads(n)
|
||
print("\n\tLNURLW CREATED SUCCESSFULLY\n")
|
||
t.sleep(2)
|
||
clear()
|
||
while True:
|
||
headers = {"X-Api-Key": b}
|
||
sh = requests.get("https://legend.lnbits.com/withdraw/api/v1/links", headers=headers, timeout=10).text
|
||
clear()
|
||
blogo()
|
||
n = str(sh)
|
||
d = json.loads(n)
|
||
print("\n\tLNBITS LNURLW LIST\n")
|
||
for item_ in d:
|
||
s = item_
|
||
print(f'ID: {s["id"]} Uses: ' + str(s['uses']) + " Used: " + str(s['used']))
|
||
nd = input("\nSelect ID: ")
|
||
for item in d:
|
||
s = item
|
||
nn = s['id']
|
||
if nd == nn:
|
||
print("\n----------------------------------------------------------------------------------------------------------------")
|
||
print("""
|
||
\tLNBITS LNURLW DECODED
|
||
|
||
ID: {}
|
||
LNURL: {}
|
||
Wait Time: {}
|
||
Uses: {}
|
||
Used: {}
|
||
Minimum Withdraw: {}
|
||
Maximum Withdraw: {}
|
||
""".format(s['id'], s['lnurl'], s['wait_time'], s['uses'], s['used'], s['min_withdrawable'], s['max_withdrawable']))
|
||
print("----------------------------------------------------------------------------------------------------------------\n")
|
||
input("Continue...")
|
||
clear()
|
||
blogo()
|
||
except (requests.RequestException, json.JSONDecodeError, KeyError, KeyboardInterrupt):
|
||
break
|
||
|
||
def lnbitsLNURLwList():
|
||
try:
|
||
while True:
|
||
a = loadFileConnLNBits(['admin_key'])
|
||
b = str(a['admin_key'])
|
||
headers = {"X-Api-Key": b}
|
||
sh = requests.get("https://legend.lnbits.com/withdraw/api/v1/links", headers=headers, timeout=10).text
|
||
clear()
|
||
blogo()
|
||
n = str(sh)
|
||
d = json.loads(n)
|
||
print("\n\tLNBITS LNURLW LIST\n")
|
||
for item_ in d:
|
||
s = item_
|
||
print(f'ID: {s["id"]} Uses: ' + str(s['uses']) + " Used: " + str(s['used']))
|
||
nd = input("\nSelect ID: ")
|
||
for item in d:
|
||
s = item
|
||
nn = s['id']
|
||
if nd == nn:
|
||
print("\n----------------------------------------------------------------------------------------------------------------")
|
||
print("""
|
||
\tLNBITS LNURLW DECODED
|
||
|
||
ID: {}
|
||
LNURL: {}
|
||
Wait Time: {}
|
||
Uses: {}
|
||
Used: {}
|
||
Minimum Withdraw: {}
|
||
Maximum Withdraw: {}
|
||
""".format(s['id'], s['lnurl'], s['wait_time'], s['uses'], s['used'], s['min_withdrawable'], s['max_withdrawable']))
|
||
print("----------------------------------------------------------------------------------------------------------------\n")
|
||
input("Continue...")
|
||
except (requests.RequestException, json.JSONDecodeError, KeyError, KeyboardInterrupt):
|
||
print("\n")
|
||
|
||
#-------------------------1d646820055e4e2da218e801eaacfc94----END LNBITS--------------------------------
|
||
#-----------------------------LNPAY--------------------------------
|
||
|
||
def loadFileConnLNPay(lnpayLoad):
|
||
lnpayLoad = {"key":""}
|
||
|
||
if os.path.isfile('lnpay.conf'): # Check if the file 'bclock.conf' is in the same folder
|
||
with open("lnpay.conf", "r") as f:
|
||
lnpayData = json.load(f) # Load the file 'bclock.conf'
|
||
lnpayLoad = lnpayData # Copy the variable pathv to 'path'
|
||
else:
|
||
clear()
|
||
blogo()
|
||
print("""\n\t \033[1;33;40mATENTION\033[0;37;40m: YOU ARE GOING TO CREATE A FILE WITH YOUR INFORMATION OF CONNECTION TO LNPAY.CO.
|
||
WE WILL NEED SOME INFORMATION FROM YOUR ACCOUNT THAT THE ONLY ONE THAT WILL HAVE ACCESS IS YOU.
|
||
IF YOU DELETE THIS FILE YOU WILL NEED TO PAY AGAIN TO GET ACCESS FROM PyBLOCK.
|
||
SAVE THE FILE '\033[1;33;40mlnpaySN.conf\033[0;37;40m' IN A SAFE PLACE.\n
|
||
""")
|
||
lnpayLoad["key"] = input("API Key: ")
|
||
print("\n\tWALLET ACCESS KEYS\n")
|
||
lnpayLoad["wallet_key_id"] = input("Wallet Admin: ")
|
||
with open("lnpay.conf", "w") as f:
|
||
json.dump(lnpayLoad, f)
|
||
clear()
|
||
blogo()
|
||
return lnpayLoad
|
||
|
||
def createFileConnLNPay():
|
||
clear()
|
||
blogo()
|
||
print("""\n\t \033[1;33;40mATENTION\033[0;37;40m: YOU ARE GOING TO CREATE A FILE WITH YOUR INFORMATION OF CONNECTION TO LNPAY.CO.
|
||
WE WILL NEED SOME INFORMATION FROM YOUR ACCOUNT THAT THE ONLY ONE THAT WILL HAVE ACCESS IS YOU.
|
||
IF YOU DELETE THIS FILE YOU WILL NEED TO PAY AGAIN TO GET ACCESS FROM PyBLOCK.
|
||
SAVE THE FILE '\033[1;33;40mlnpaySN.conf\033[0;37;40m' IN A SAFE PLACE.\n
|
||
""")
|
||
lnpayLoad["key"] = input("API Key: ")
|
||
print("\n\tWALLET ACCESS KEYS\n")
|
||
lnpayLoad["wallet_key_id"] = input("Wallet Admin: ")
|
||
with open("lnpay.conf", "w") as f:
|
||
json.dump(lnpayLoad, f)
|
||
|
||
|
||
#-----------------------------END LNPAY--------------------------------
|
||
#-----------------------------OPENNODE--------------------------------
|
||
|
||
def loadFileConnOpenNode(opennodeLoad):
|
||
opennodeLoad = {"key":"","wdr":"","inv":""}
|
||
|
||
if os.path.isfile('opennode.conf'): # Check if the file 'bclock.conf' is in the same folder
|
||
with open("opennode.conf", "r") as f:
|
||
opennodeData = json.load(f) # Load the file 'bclock.conf'
|
||
opennodeLoad = opennodeData # Copy the variable pathv to 'path'
|
||
else:
|
||
clear()
|
||
blogo()
|
||
print("""\n\t \033[1;33;40mATENTION\033[0;37;40m: YOU ARE GOING TO CREATE A FILE WITH YOUR INFORMATION OF CONNECTION TO OPENNODE.COM.
|
||
WE WILL NEED SOME INFORMATION FROM YOUR ACCOUNT THAT THE ONLY ONE THAT WILL HAVE ACCESS IS YOU.
|
||
IF YOU DELETE THIS FILE YOU WILL NEED TO PAY AGAIN TO GET ACCESS FROM PyBLOCK.
|
||
SAVE THE FILE '\033[1;33;40mopennodeSN.conf\033[0;37;40m' IN A SAFE PLACE.\n
|
||
""")
|
||
opennodeLoad["key"] = input("API Read Only Key: ")
|
||
opennodeLoad["wdr"] = input("API Withdrawall Key: ")
|
||
opennodeLoad["inv"] = input("API Invoices Key: ")
|
||
with open("opennode.conf", "w") as f:
|
||
json.dump(opennodeLoad, f)
|
||
clear()
|
||
blogo()
|
||
return opennodeLoad
|
||
|
||
def createFileConnOpenNode():
|
||
clear()
|
||
blogo()
|
||
print("""\n\t \033[1;33;40mATENTION\033[0;37;40m: YOU ARE GOING TO CREATE A FILE WITH YOUR INFORMATION OF CONNECTION TO OPENNODE.COM.
|
||
WE WILL NEED SOME INFORMATION FROM YOUR ACCOUNT THAT THE ONLY ONE THAT WILL HAVE ACCESS IS YOU.
|
||
IF YOU DELETE THIS FILE YOU WILL NEED TO PAY AGAIN TO GET ACCESS FROM PyBLOCK.
|
||
SAVE THE FILE '\033[1;33;40mopennodeSN.conf\033[0;37;40m' IN A SAFE PLACE.\n
|
||
""")
|
||
opennodeLoad = {'wdr': '', 'inv': '', 'key': input("API Read Only Key: ")}
|
||
opennodeLoad["wdr"] = input("API Withdrawall Key: ")
|
||
opennodeLoad["inv"] = input("API Invoices Key: ")
|
||
with open("opennode.conf", "w") as f:
|
||
json.dump(opennodeLoad, f)
|
||
|
||
def OpenNodelistfunds():
|
||
a = loadFileConnOpenNode(['wdr'])
|
||
b = str(a['wdr'])
|
||
headers = {"Content-Type": "application/json", "Authorization": b}
|
||
sh = requests.get("https://api.opennode.co/v1/account/balance", headers=headers, timeout=10).text
|
||
clear()
|
||
blogo()
|
||
n = str(sh)
|
||
d = json.loads(n)
|
||
r = d['data']
|
||
print("\n----------------------------------------------------------------------------------------------------")
|
||
p = r['balance']
|
||
print("""
|
||
OPENNODE BALANCE
|
||
|
||
Amount: {} sats
|
||
""".format(p['BTC']))
|
||
print("----------------------------------------------------------------------------------------------------\n")
|
||
input("Continue...")
|
||
|
||
def OpenNodeCheckStatus():
|
||
sh = requests.get("https://status.opennode.com/history.rss", timeout=10).text
|
||
clear()
|
||
blogo()
|
||
my_dict=xmltodict.parse(sh)
|
||
n=json.dumps(my_dict)
|
||
nn = str(n)
|
||
qq = json.loads(n)
|
||
a = qq['rss']
|
||
b = a['channel']
|
||
c = b['title']
|
||
d = b['item']
|
||
dd = d[0]
|
||
e = dd['title']
|
||
print("""
|
||
\n----------------------------------------------------------------------------------------------------
|
||
\n\t{}
|
||
|
||
{}\n
|
||
{}
|
||
|
||
\n----------------------------------------------------------------------------------------------------
|
||
""".format(c.upper(),e,b['pubDate']))
|
||
input("Enter to Continue...")
|
||
|
||
def OpenNodecreatecharge():
|
||
qr = qrcode.QRCode(
|
||
version=1,
|
||
error_correction=qrcode.constants.ERROR_CORRECT_L,
|
||
box_size=10,
|
||
border=4,
|
||
)
|
||
a = loadFileConnOpenNode(['key'])
|
||
b = str(a['key'])
|
||
fiat = input("Are you going to pay in FIAT? Y/n:")
|
||
if fiat in ["Y", "y"]:
|
||
print("\n----------------------------------------------------------------------------------------------------")
|
||
print("""
|
||
\tFIAT supported on OpenNode:
|
||
|
||
AED,AFN,ALL,AMD,ANG,AOA,ARS,AUD,AWG,AZN,BAM,BBD,BDT,BGN,BHD,BIF,BMD,BND,BOB,BRL,BSD,BTN,BWP,
|
||
BYN,BZD,CAD,CDF,CHF,CLF,CLP,CNH,CNY,COP,CRC,CUC,CUP,CVE,CZK,DJF,DKK,DOP,DZD,EGP,ERN,ETB,EUR,
|
||
FJD,FKP,GBP,GEL,GGP,GHS,GIP,GMD,GNF,GTQ,GYD,HKD,HNL,HRK,HTG,HUF,IDR,ILS,IMP,INR,IQD,IRR,ISK,
|
||
JEP,JMD,JOD,JPY,KES,KGS,KHR,KMF,KPW,KRW,KWD,KYD,KZT,LAK,LBP,LKR,LRD,LSL,LYD,MAD,MDL,MGA,MKD,
|
||
MMK,MNT,MOP,MRO,MUR,MVR,MWK,MXN,MYR,MZN,NAD,NGN,NIO,NOK,NPR,NZD,OMR,PAB,PEN,PGK,PHP,PKR,PLN,
|
||
PYG,QAR,RON,RSD,RUB,RWF,SAR,SBD,SCR,SDG,SEK,SGD,SHP,SLL,SOS,SRD,SSP,STD,SVC,SYP,SZL,THB,TJS,
|
||
TMT,TND,TOP,TRY,TTD,TWD,TZS,UAH,UGX,USD,UYU,UZS,VES,VND,VUV,WST,XAF,XAG,XAU,XCD,XDR,XOF,XPD,
|
||
XPF,XPT,YER,ZAR,ZMW,ZWL,USDC.
|
||
""")
|
||
print("\n----------------------------------------------------------------------------------------------------")
|
||
selection = input("Select a FIAT currency: ")
|
||
amt = input(f"Amount in {selection}: ")
|
||
headers = {"Authorization": b, "Content-Type": "application/json"}
|
||
payload = {"amount": amt, "currency": selection.upper()}
|
||
sh = requests.post("https://api.opennode.co/v1/charges", json=payload, headers=headers, timeout=10).text
|
||
clear()
|
||
blogo()
|
||
n = str(sh)
|
||
d = json.loads(n)
|
||
dd = d['data']
|
||
qq = dd['lightning_invoice']
|
||
pp = dd['address']
|
||
nn = qq['payreq']
|
||
mm = nn.lower()
|
||
while True:
|
||
try:
|
||
print("\n----------------------------------------------------------------------------------------------------")
|
||
print("""
|
||
\tOPENNODE PAYMENT REQUEST
|
||
|
||
Amount: {} {}
|
||
ID: {}
|
||
Status: {}
|
||
Invoice: {}
|
||
Onchain Address: {}
|
||
Amount: {} sats
|
||
""".format(amt, selection.upper(), dd['id'], dd['status'], mm, pp, dd['amount']))
|
||
print("----------------------------------------------------------------------------------------------------\n")
|
||
pay = input("Invoice or Onchain Address? I/O: ")
|
||
if pay in ["I", "i"]:
|
||
node_not = input("Do you want to pay this invoice with your node? Y/n: ")
|
||
if node_not in ["Y", "y"]:
|
||
lndconnectload = {"ip_port":"", "tls":"", "macaroon":"", "ln":""}
|
||
with open("blndconnect.conf", "r") as f:
|
||
lndconnectData = json.load(f) # Load the file 'bclock.conf'
|
||
lndconnectload = lndconnectData # Copy the variable pathv to 'path'
|
||
if lndconnectload['ip_port']:
|
||
print("\nInvoice: " + mm + "\n")
|
||
payinvoice()
|
||
elif lndconnectload['ln']:
|
||
print("\nInvoice: " + mm + "\n")
|
||
localpayinvoice()
|
||
elif node_not in ["N", "n"]:
|
||
print("\033[1;30;47m")
|
||
qr.add_data(mm)
|
||
qr.print_ascii()
|
||
print("\033[0;37;40m")
|
||
qr.clear()
|
||
print("\nLightning Invoice: " + mm)
|
||
elif pay in ["O", "o"]:
|
||
print("\033[1;30;47m")
|
||
qr.add_data(pp)
|
||
qr.print_ascii()
|
||
print("\033[0;37;40m")
|
||
qr.clear()
|
||
print("\nAmount in sats: {} sats".format(dd['amount']))
|
||
print("\nOnchain Address: " + pp)
|
||
input("\nContinue...")
|
||
clear()
|
||
blogo()
|
||
except (requests.RequestException, json.JSONDecodeError, KeyError, KeyboardInterrupt):
|
||
break
|
||
elif fiat in ["N", "n"]:
|
||
amt = input("Amount in sats: ")
|
||
headers = {"Authorization": b, "Content-Type": "application/json"}
|
||
payload = {"amount": amt, "currency": "BTC"}
|
||
sh = requests.post("https://api.opennode.co/v1/charges", json=payload, headers=headers, timeout=10).text
|
||
clear()
|
||
blogo()
|
||
n = str(sh)
|
||
d = json.loads(n)
|
||
dd = d['data']
|
||
qq = dd['lightning_invoice']
|
||
nn = qq['payreq']
|
||
pp = dd['address']
|
||
mm = nn.lower()
|
||
while True:
|
||
try:
|
||
print("\n----------------------------------------------------------------------------------------------------")
|
||
print("""
|
||
\tOPENNODE PAYMENT REQUEST
|
||
|
||
Amount: {} sats
|
||
ID: {}
|
||
Status: {}
|
||
Invoice: {}
|
||
Onchain Address: {}
|
||
Amount: {} sats
|
||
""".format(amt, dd['id'], dd['status'], mm, pp, dd['amount']))
|
||
print("----------------------------------------------------------------------------------------------------\n")
|
||
pay = input("Invoice or Onchain Address? I/O: ")
|
||
if pay in ["I", "i"]:
|
||
node_not = input("Do you want to pay this invoice with your node? Y/n: ")
|
||
if node_not in ["Y", "y"]:
|
||
with open("blndconnect.conf", "r") as f:
|
||
lndconnectData = json.load(f) # Load the file 'bclock.conf'
|
||
lndconnectload = {"ip_port":"", "tls":"", "macaroon":"", "ln":""}
|
||
lndconnectload = lndconnectData # Copy the variable pathv to 'path'
|
||
if lndconnectload['ip_port']:
|
||
print("\nInvoice: " + mm + "\n")
|
||
payinvoice()
|
||
elif lndconnectload['ln']:
|
||
print("\nInvoice: " + mm + "\n")
|
||
localpayinvoice()
|
||
elif node_not in ["N", "n"]:
|
||
print("\033[1;30;47m")
|
||
qr.add_data(mm)
|
||
qr.print_ascii()
|
||
print("\033[0;37;40m")
|
||
qr.clear()
|
||
print("\nLightning Invoice: " + mm)
|
||
elif pay in ["O", "o"]:
|
||
print("\033[1;30;47m")
|
||
qr.add_data(pp)
|
||
qr.print_ascii()
|
||
print("\033[0;37;40m")
|
||
qr.clear()
|
||
print("\nAmount in sats: {} sats".format(dd['amount']))
|
||
print("\nOnchain Address: " + pp)
|
||
input("\nContinue...")
|
||
clear()
|
||
blogo()
|
||
except (requests.RequestException, json.JSONDecodeError, KeyError, KeyboardInterrupt):
|
||
break
|
||
|
||
def OpenNodeiniciatewithdrawal():
|
||
a = loadFileConnOpenNode(['wdr'])
|
||
b = str(a['wdr'])
|
||
c = loadFileConnOpenNode(['key'])
|
||
d = str(a['key'])
|
||
lnchain = input("Are you going to pay with Lightning or Onchain? L/O: ")
|
||
clear()
|
||
blogo()
|
||
if lnchain in ["L", "l"]:
|
||
try:
|
||
while True:
|
||
invoice = input("\nInvoice: ")
|
||
headers = {"Authorization": b, "Content-Type": "application/json"}
|
||
payload = {"pay_req": invoice}
|
||
ssh = requests.post("https://api.opennode.co/v1/charge/decode", json=payload, headers=headers, timeout=10).text
|
||
nn = str(ssh)
|
||
dd = json.loads(nn)
|
||
print(dd)
|
||
if invoice != "":
|
||
break
|
||
print("\n----------------------------------------------------------------------------------------------------")
|
||
print("""
|
||
\tOPENNODE TRANSFER REQUEST
|
||
|
||
Message: {}
|
||
""".format(dd['message']))
|
||
print("----------------------------------------------------------------------------------------------------\n")
|
||
rr = dd['data']
|
||
ss = rr['pay_req']
|
||
|
||
print("\n----------------------------------------------------------------------------------------------------")
|
||
print("""
|
||
\tOPENNODE TRANSFER REQUEST
|
||
|
||
Network: {}
|
||
Amount: {} sats
|
||
Destination: {}
|
||
Hash: {}
|
||
""".format(ss['network'],ss['amount'],ss['pub_key'],ss['hash']))
|
||
print("----------------------------------------------------------------------------------------------------\n")
|
||
print("<<< Cancel Control + C")
|
||
input("\nEnter to Continue... ")
|
||
|
||
headers = {"Authorization": b, "Content-Type": "application/json"}
|
||
payload = {"type": "ln", "address": invoice, "callback_url": ""}
|
||
sh = requests.post("https://api.opennode.co/v2/withdrawals", json=payload, headers=headers, timeout=10).text
|
||
n = str(sh)
|
||
d = json.loads(n)
|
||
clear()
|
||
blogo()
|
||
tick()
|
||
t.sleep(2)
|
||
except (requests.RequestException, json.JSONDecodeError, KeyError) as e:
|
||
logger.debug("OpenNodeiniciatewithdrawal LN error: %s", e)
|
||
|
||
elif lnchain in ["O", "o"]:
|
||
try:
|
||
while True:
|
||
print("\n\tOPENNODE TRANSFER REQUEST\n")
|
||
print("\n\tMinimum amount 200000 sats\n")
|
||
address = input("\nBitcoin Address: ")
|
||
amt = int(input("Amount in sats: "))
|
||
headers = {"Authorization": b, "Content-Type": "application/json"}
|
||
payload = {"type": "chain", "amount": amt, "address": address, "callback_url": ""}
|
||
|
||
if amt < 199999:
|
||
sh = requests.post("https://api.opennode.co/v2/withdrawals", json=payload, headers=headers, timeout=10).text
|
||
n = str(sh)
|
||
d = json.loads(n)
|
||
print("\n----------------------------------------------------------------------------------------------------")
|
||
print("""
|
||
\tOPENNODE TRANSFER REQUEST
|
||
|
||
Message: {}
|
||
""".format(d['message']))
|
||
print("----------------------------------------------------------------------------------------------------\n")
|
||
elif amt > 200000:
|
||
sh = requests.post("https://api.opennode.co/v2/withdrawals", json=payload, headers=headers, timeout=10).text
|
||
n = str(sh)
|
||
d = json.loads(n)
|
||
dd = d['data']
|
||
print("\n----------------------------------------------------------------------------------------------------")
|
||
print("""
|
||
\tOPENNODE TRANSFER REQUEST
|
||
|
||
Amount: {} sats
|
||
Address Destination: {}
|
||
Fee: {}
|
||
Status: {}
|
||
""".format(dd['amount'],dd['address'],dd['fee'], dd['status']))
|
||
print("----------------------------------------------------------------------------------------------------\n")
|
||
input("\nContinue... ")
|
||
clear()
|
||
blogo()
|
||
logoB()
|
||
t.sleep(2)
|
||
break
|
||
except (requests.RequestException, json.JSONDecodeError, KeyError, ValueError) as e:
|
||
logger.debug("OpenNodeiniciatewithdrawal onchain error: %s", e)
|
||
|
||
def OpenNodeListPayments():
|
||
qr = qrcode.QRCode(
|
||
version=1,
|
||
error_correction=qrcode.constants.ERROR_CORRECT_L,
|
||
box_size=10,
|
||
border=4,
|
||
)
|
||
a = loadFileConnOpenNode(['wdr'])
|
||
b = str(a['wdr'])
|
||
headers = {"Content-Type": "application/json", "Authorization": b}
|
||
sh = requests.get("https://api.opennode.co/v1/withdrawals", headers=headers, timeout=10).text
|
||
clear()
|
||
blogo()
|
||
print("\n\tOPENNODE TRANSACTIONS LIST\n")
|
||
n = str(sh)
|
||
d = json.loads(n)
|
||
da = d['data']
|
||
while True:
|
||
try:
|
||
for item_ in da:
|
||
s = item_
|
||
n = s['status']
|
||
q = str(n)
|
||
print(f'ID: {s["id"]} {q}')
|
||
nd = input("\nSelect ID: ")
|
||
for item in da:
|
||
s = item
|
||
nn = s['id']
|
||
if nd == nn:
|
||
print("\n----------------------------------------------------------------------------------------------------")
|
||
print("""
|
||
\tOPENNODE TRANSACTION DECODED
|
||
ID: {}
|
||
Amount: {} sats
|
||
Type: {}
|
||
Invoice or Tx ID: {}
|
||
Status: {}
|
||
""".format(s['id'], s['amount'], s['type'], s['reference'], s['status']))
|
||
print("----------------------------------------------------------------------------------------------------\n")
|
||
print("\033[1;30;47m")
|
||
qr.add_data(s['reference'])
|
||
qr.print_ascii()
|
||
print("\033[0;37;40m")
|
||
qr.clear()
|
||
input("Continue...")
|
||
clear()
|
||
blogo()
|
||
print("\n\tOPENNODE TRANSACTIONS LIST\n")
|
||
except (json.JSONDecodeError, KeyError, KeyboardInterrupt):
|
||
break
|
||
|
||
#-----------------------------END OPENNODE--------------------------------
|
||
#-----------------------------TIPPINME--------------------------------
|
||
|
||
def loadFileTippinMe(tippinmeLoad):
|
||
tippinmeLoad = {"key":""}
|
||
|
||
if os.path.isfile('tippinme.conf'): # Check if the file 'bclock.conf' is in the same folder
|
||
with open("tippinme.conf", "r") as f:
|
||
tippinmeData = json.load(f) # Load the file 'bclock.conf'
|
||
tippinmeLoad = tippinmeData # Copy the variable pathv to 'path'
|
||
else:
|
||
clear()
|
||
blogo()
|
||
print("""\n\t \033[1;33;40mATENTION\033[0;37;40m: YOUR CONFIGURATION INFORMATION WILL BE SAVE IN '\033[1;33;40mtippinme.conf\033[0;37;40m'
|
||
IF YOU NEED TO START AGAIN, DELETE IT.\n
|
||
""")
|
||
tippinmeLoad["key"] = input("Twitter @user: ")
|
||
with open("tippinme.conf", "w") as f:
|
||
json.dump(tippinmeLoad, f)
|
||
clear()
|
||
blogo()
|
||
return tippinmeLoad
|
||
|
||
def createFileTippinMe():
|
||
clear()
|
||
blogo()
|
||
print("""\n\t \033[1;33;40mATENTION\033[0;37;40m: YOUR CONFIGURATION INFORMATION WILL BE SAVE IN '\033[1;33;40mtippinme.conf\033[0;37;40m'
|
||
IF YOU NEED TO START AGAIN, DELETE IT.\n
|
||
""")
|
||
tippinmeLoad = {'key': input("Twitter @user: ")}
|
||
with open("tippinme.conf", "w") as f:
|
||
json.dump(tippinmeLoad, f)
|
||
|
||
def tippinmeGetInvoice():
|
||
qr = qrcode.QRCode(
|
||
version=1,
|
||
error_correction=qrcode.constants.ERROR_CORRECT_L,
|
||
box_size=10,
|
||
border=4,
|
||
)
|
||
a = loadFileTippinMe(['key'])
|
||
b = str(a['key'])
|
||
try:
|
||
print("\n\tTIPPINME GENERATE INVOICE\n")
|
||
q = input("Amount in Sats: ")
|
||
clear()
|
||
blogo()
|
||
url = f'https://api.tippin.me/v1/public/addinvoice/{b}/{q}'
|
||
response = requests.get(url, timeout=10)
|
||
responseB = str(response.text)
|
||
responseC = responseB
|
||
lnreq = responseC.split(',')
|
||
lnurl = lnreq[1]
|
||
lnurlS = str(lnurl)
|
||
lnurlR = lnurlS.split(':')
|
||
lnurlW = lnurlR[1]
|
||
ln = str(lnurlW)
|
||
ln1 = ln.strip('"')
|
||
node_not = input("Do you want to pay this invoice with your node? Y/n: ")
|
||
if node_not in ["Y", "y"]:
|
||
lndconnectload = {"ip_port":"", "tls":"", "macaroon":"", "ln":""}
|
||
with open("blndconnect.conf", "r") as f:
|
||
lndconnectData = json.load(f) # Load the file 'bclock.conf'
|
||
lndconnectload = lndconnectData # Copy the variable pathv to 'path'
|
||
if lndconnectload['ip_port']:
|
||
print("\nInvoice: " + ln1 + "\n")
|
||
payinvoice()
|
||
elif lndconnectload['ln']:
|
||
print("\nInvoice: " + ln1 + "\n")
|
||
localpayinvoice()
|
||
elif node_not in ["N", "n"]:
|
||
print("\033[1;30;47m")
|
||
qr.add_data(ln1)
|
||
qr.print_ascii()
|
||
print("\033[0;37;40m")
|
||
print(f'LND Invoice: {ln1}')
|
||
response.close()
|
||
input("Continue...")
|
||
except (requests.RequestException, json.JSONDecodeError, KeyError, IndexError, OSError) as e:
|
||
logger.debug("tippinmeGetInvoice error: %s", e)
|
||
|
||
#-----------------------------END TIPPINME--------------------------------
|
||
#-----------------------------TALLYCOIN------------------------------
|
||
def loadFileConnTallyCo(tallycoLoad):
|
||
tallycoLoad = {"tallyco.conf":"","id":""}
|
||
|
||
if os.path.isfile('tallyco.conf'): # Check if the file 'bclock.conf' is in the same folder
|
||
with open("tallyco.conf", "r") as f:
|
||
tallyData = json.load(f) # Load the file 'bclock.conf'
|
||
tallycoLoad = tallyData # Copy the variable pathv to 'path'
|
||
else:
|
||
clear()
|
||
blogo()
|
||
print("""\n\t \033[1;33;40mATENTION\033[0;37;40m: YOU ARE GOING TO CREATE A FILE WITH YOUR INFORMATION OF CONNECTION TO TALLYCO.IN.
|
||
WE WILL NEED SOME INFORMATION FROM YOUR ACCOUNT THAT THE ONLY ONE THAT WILL HAVE ACCESS IS YOU.
|
||
IF YOU DELETE THIS FILE YOU WILL NEED TO PAY AGAIN TO GET ACCESS FROM PyBLOCK.
|
||
SAVE THE FILE '\033[1;33;40mtallycoSN.conf\033[0;37;40m' IN A SAFE PLACE.\n
|
||
""")
|
||
print("\nEXAMPLE: https://tallyco.in/s/{fundraiser_id}/\n")
|
||
tallycoLoad["id"] = input("User ID or Twitter @USER: ")
|
||
with open("tallyco.conf", "w") as f:
|
||
json.dump(tallycoLoad, f)
|
||
clear()
|
||
blogo()
|
||
return tallycoLoad
|
||
|
||
def createFileConnTallyCo():
|
||
clear()
|
||
blogo()
|
||
print("""\n\t \033[1;33;40mATENTION\033[0;37;40m: YOU ARE GOING TO CREATE A FILE WITH YOUR INFORMATION OF CONNECTION TO TALLYCO.IN.
|
||
WE WILL NEED SOME INFORMATION FROM YOUR ACCOUNT THAT THE ONLY ONE THAT WILL HAVE ACCESS IS YOU.
|
||
IF YOU DELETE THIS FILE YOU WILL NEED TO PAY AGAIN TO GET ACCESS FROM PyBLOCK.
|
||
SAVE THE FILE '\033[1;33;40mtallycoSN.conf\033[0;37;40m' IN A SAFE PLACE.\n
|
||
""")
|
||
print("\nEXAMPLE: https://tallyco.in/s/{fundraiser_id}/\n")
|
||
tallycoLoad = {'fundraiser_id': '', 'id': input("User ID or Twitter @USER: ")}
|
||
with open("tallyco.conf", "w") as f:
|
||
json.dump(tallycoLoad, f)
|
||
|
||
def tallycoGetPayment():
|
||
qr = qrcode.QRCode(
|
||
version=1,
|
||
error_correction=qrcode.constants.ERROR_CORRECT_L,
|
||
box_size=10,
|
||
border=4,
|
||
)
|
||
c = loadFileConnTallyCo(['id'])
|
||
d = str(c['id'])
|
||
try:
|
||
amount = input("Amount in Sats: ")
|
||
print("""\nPayment Method Example: 'ln' or 'btc'
|
||
'ln' = Lightnin Netowrk
|
||
'btc'= Bitcoin Onchain Payment
|
||
\n""")
|
||
lnd_onchain = input("Payment Method: ")
|
||
payload = {"type": "profile", "id": d, "satoshi_amount": amount, "payment_method": lnd_onchain}
|
||
tallycomethod = requests.post("https://api.tallyco.in/v1/payment/request/", data=payload, timeout=10).text
|
||
n = str(tallycomethod)
|
||
d = json.loads(n)
|
||
clear()
|
||
blogo()
|
||
if lnd_onchain == "ln":
|
||
e = d['lightning_pay_request']
|
||
f = e.lower()
|
||
print("\033[1;30;47m")
|
||
qr.add_data(f)
|
||
qr.print_ascii()
|
||
print("\033[0;37;40m")
|
||
print(f'LND Invoice: {f}')
|
||
qr.clear()
|
||
input("\nContinue...")
|
||
elif lnd_onchain == "btc":
|
||
e = d['btc_address']
|
||
print("\033[1;30;47m")
|
||
qr.add_data(e)
|
||
qr.print_ascii()
|
||
print("\033[0;37;40m")
|
||
print(f'Amount: {d["cost"]}')
|
||
print(f'Bitcoin Address: {e}')
|
||
qr.clear()
|
||
input("\nContinue...")
|
||
except (requests.RequestException, json.JSONDecodeError, KeyError) as e:
|
||
logger.debug("tallycoGetPayment error: %s", e)
|
||
|
||
|
||
def tallycoDonateid():
|
||
qr = qrcode.QRCode(
|
||
version=1,
|
||
error_correction=qrcode.constants.ERROR_CORRECT_L,
|
||
box_size=10,
|
||
border=4,
|
||
)
|
||
clear()
|
||
blogo()
|
||
try:
|
||
donate = input("Donate to ID: ")
|
||
amount = input("Amount in Sats: ")
|
||
print("""\nPayment Method Example: 'ln' or 'btc'
|
||
'ln' = Lightnin Netowrk
|
||
'btc'= Bitcoin Onchain Payment
|
||
\n""")
|
||
lnd_onchain = input("Payment Method: ")
|
||
payload = {"type": "profile", "id": donate, "satoshi_amount": amount, "payment_method": lnd_onchain}
|
||
tallycomethod = requests.post("https://api.tallyco.in/v1/payment/request/", data=payload, timeout=10).text
|
||
n = str(tallycomethod)
|
||
d = json.loads(n)
|
||
clear()
|
||
blogo()
|
||
if lnd_onchain in ["ln", "lN", "Ln", "LN"]:
|
||
node_not = input("Do you want to pay this tip with your node? Y/n: ")
|
||
if node_not in ["Y", "y"]:
|
||
lndconnectload = {"ip_port":"", "tls":"", "macaroon":"", "ln":""}
|
||
with open("blndconnect.conf", "r") as f:
|
||
lndconnectData = json.load(f) # Load the file 'bclock.conf'
|
||
lndconnectload = lndconnectData # Copy the variable pathv to 'path'
|
||
if lndconnectload['ip_port']:
|
||
e = d['lightning_pay_request']
|
||
f = e.lower()
|
||
print("\nInvoice: " + f + "\n")
|
||
payinvoice()
|
||
elif lndconnectload['ln']:
|
||
e = d['lightning_pay_request']
|
||
f = e.lower()
|
||
print("\nInvoice: " + f + "\n")
|
||
localpayinvoice()
|
||
elif node_not in ["N", "n"]:
|
||
e = d['lightning_pay_request']
|
||
f = e.lower()
|
||
print("\033[1;30;47m")
|
||
qr.add_data(f)
|
||
qr.print_ascii()
|
||
print("\033[0;37;40m")
|
||
print(f'LND Invoice: {f}')
|
||
qr.clear()
|
||
input("\nContinue...")
|
||
elif lnd_onchain in ["btc", "bTC", "BtC", "BTC", "BTc", "btC"]:
|
||
e = d['btc_address']
|
||
print("\033[1;30;47m")
|
||
qr.add_data(e)
|
||
qr.print_ascii()
|
||
print("\033[0;37;40m")
|
||
print(f'Amount: {d["cost"]}')
|
||
print(f'Bitcoin Address: {e}')
|
||
qr.clear()
|
||
input("\nContinue...")
|
||
except (requests.RequestException, json.JSONDecodeError, KeyError, OSError) as e:
|
||
logger.debug("tallycoDonateid error: %s", e)
|
||
|
||
|
||
#-----------------------------END TALLYCOIN------------------------------
|
||
#-----------------------------MEMPOOL.SPACE------------------------------
|
||
|
||
def fee():
|
||
try:
|
||
while True:
|
||
r = requests.get('https://mempool.space/api/v1/fees/recommended', timeout=10)
|
||
r.headers['Content-Type']
|
||
n = r.text
|
||
di = json.loads(n)
|
||
clear()
|
||
blogo()
|
||
print("""
|
||
------------------------
|
||
Fastest Fee: {}
|
||
Half Hour Fee: {}
|
||
Hour Fee: {}
|
||
------------------------
|
||
<<< Back Control + C
|
||
""".format(di['fastestFee'], di['halfHourFee'], di['hourFee']))
|
||
t.sleep(5)
|
||
print("\n\t Getting New Information")
|
||
except (requests.RequestException, json.JSONDecodeError, KeyError, KeyboardInterrupt) as e:
|
||
logger.debug("fee error: %s", e)
|
||
|
||
def blocks():
|
||
try:
|
||
while True:
|
||
clear()
|
||
blogo()
|
||
print("\n\t Getting New Information")
|
||
r = requests.get('https://mempool.space/api/v1/fees/mempool-blocks', timeout=10)
|
||
r.headers['Content-Type']
|
||
n = r.text
|
||
di = json.loads(n)
|
||
for n in range(len(di)):
|
||
q = di[n]
|
||
clear()
|
||
blogo()
|
||
print("""
|
||
-----------------------------------------
|
||
BLOCK
|
||
-----------------------------------------
|
||
Block Size: {} bytes
|
||
Block VSize: {} bytes
|
||
Transactions: {}
|
||
Total Fees: {}
|
||
Median Fee: {}
|
||
-----------------------------------------
|
||
<<< Back Control + C
|
||
""".format(q['blockSize'], q['blockVSize'], q['nTx'], q['totalFees'], q['medianFee']))
|
||
t.sleep(3)
|
||
except (requests.RequestException, json.JSONDecodeError, KeyError, KeyboardInterrupt) as e:
|
||
logger.debug("blocks error: %s", e)
|
||
|
||
|
||
#-----------------------------END MEMPOOL.SPACE------------------------------
|