mirror of
https://github.com/LBRYFoundation/LBRY-Vault.git
synced 2025-08-23 17:47:31 +00:00
de83ab6d4a
e.g. when interacting with hw wallets (e.g. signmessage) it does not make sense to time out also, str(e) of some exceptions such as TimeoutError is ""...
419 lines
15 KiB
Python
Executable file
419 lines
15 KiB
Python
Executable file
#!/usr/bin/env python3
|
|
# -*- mode: python -*-
|
|
#
|
|
# Electrum - lightweight Bitcoin client
|
|
# Copyright (C) 2011 thomasv@gitorious
|
|
#
|
|
# Permission is hereby granted, free of charge, to any person
|
|
# obtaining a copy of this software and associated documentation files
|
|
# (the "Software"), to deal in the Software without restriction,
|
|
# including without limitation the rights to use, copy, modify, merge,
|
|
# publish, distribute, sublicense, and/or sell copies of the Software,
|
|
# and to permit persons to whom the Software is furnished to do so,
|
|
# subject to the following conditions:
|
|
#
|
|
# The above copyright notice and this permission notice shall be
|
|
# included in all copies or substantial portions of the Software.
|
|
#
|
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
|
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
|
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
# SOFTWARE.
|
|
import os
|
|
import sys
|
|
import warnings
|
|
import asyncio
|
|
|
|
MIN_PYTHON_VERSION = "3.6.1" # FIXME duplicated from setup.py
|
|
_min_python_version_tuple = tuple(map(int, (MIN_PYTHON_VERSION.split("."))))
|
|
|
|
|
|
if sys.version_info[:3] < _min_python_version_tuple:
|
|
sys.exit("Error: Electrum requires Python version >= %s..." % MIN_PYTHON_VERSION)
|
|
|
|
|
|
script_dir = os.path.dirname(os.path.realpath(__file__))
|
|
is_bundle = getattr(sys, 'frozen', False)
|
|
is_local = not is_bundle and os.path.exists(os.path.join(script_dir, "electrum.desktop"))
|
|
is_android = 'ANDROID_DATA' in os.environ
|
|
|
|
if is_local: # running from source
|
|
# developers should probably see all deprecation warnings.
|
|
warnings.simplefilter('default', DeprecationWarning)
|
|
|
|
# move this back to gui/kivy/__init.py once plugins are moved
|
|
os.environ['KIVY_DATA_DIR'] = os.path.abspath(os.path.dirname(__file__)) + '/electrum/gui/kivy/data/'
|
|
|
|
if is_local or is_android:
|
|
sys.path.insert(0, os.path.join(script_dir, 'packages'))
|
|
|
|
|
|
def check_imports():
|
|
# pure-python dependencies need to be imported here for pyinstaller
|
|
try:
|
|
import dns
|
|
import pyaes
|
|
import ecdsa
|
|
import certifi
|
|
import qrcode
|
|
import google.protobuf
|
|
import aiorpcx
|
|
except ImportError as e:
|
|
sys.exit(f"Error: {str(e)}. Try 'sudo python3 -m pip install <module-name>'")
|
|
# the following imports are for pyinstaller
|
|
from google.protobuf import descriptor
|
|
from google.protobuf import message
|
|
from google.protobuf import reflection
|
|
from google.protobuf import descriptor_pb2
|
|
# make sure that certificates are here
|
|
assert os.path.exists(certifi.where())
|
|
|
|
|
|
if not is_android:
|
|
check_imports()
|
|
|
|
|
|
from electrum.logging import get_logger, configure_logging
|
|
from electrum import util
|
|
from electrum import constants
|
|
from electrum import SimpleConfig
|
|
from electrum.wallet import Wallet
|
|
from electrum.storage import WalletStorage, get_derivation_used_for_hw_device_encryption
|
|
from electrum.util import print_msg, print_stderr, json_encode, json_decode, UserCancelled
|
|
from electrum.util import InvalidPassword
|
|
from electrum.commands import get_parser, known_commands, Commands, config_variables
|
|
from electrum import daemon
|
|
from electrum import keystore
|
|
from electrum.util import create_and_start_event_loop
|
|
|
|
_logger = get_logger(__name__)
|
|
|
|
|
|
# get password routine
|
|
def prompt_password(prompt, confirm=True):
|
|
import getpass
|
|
password = getpass.getpass(prompt, stream=None)
|
|
if password and confirm:
|
|
password2 = getpass.getpass("Confirm: ")
|
|
if password != password2:
|
|
sys.exit("Error: Passwords do not match.")
|
|
if not password:
|
|
password = None
|
|
return password
|
|
|
|
|
|
def init_cmdline(config_options, server):
|
|
config = SimpleConfig(config_options)
|
|
cmdname = config.get('cmd')
|
|
cmd = known_commands[cmdname]
|
|
|
|
if cmdname == 'signtransaction' and config.get('privkey'):
|
|
cmd.requires_wallet = False
|
|
cmd.requires_password = False
|
|
|
|
if cmdname in ['payto', 'paytomany'] and config.get('unsigned'):
|
|
cmd.requires_password = False
|
|
|
|
if cmdname in ['payto', 'paytomany'] and config.get('broadcast'):
|
|
cmd.requires_network = True
|
|
|
|
# instantiate wallet for command-line
|
|
storage = WalletStorage(config.get_wallet_path())
|
|
|
|
if cmd.requires_wallet and not storage.file_exists():
|
|
print_msg("Error: Wallet file not found.")
|
|
print_msg("Type 'electrum create' to create a new wallet, or provide a path to a wallet with the -w option")
|
|
sys_exit(1)
|
|
|
|
# important warning
|
|
if cmd.name in ['getprivatekeys']:
|
|
print_stderr("WARNING: ALL your private keys are secret.")
|
|
print_stderr("Exposing a single private key can compromise your entire wallet!")
|
|
print_stderr("In particular, DO NOT use 'redeem private key' services proposed by third parties.")
|
|
|
|
# commands needing password
|
|
if ( (cmd.requires_wallet and storage.is_encrypted() and server is False)\
|
|
or (cmdname == 'load_wallet' and storage.is_encrypted())\
|
|
or (cmd.requires_password and (storage.is_encrypted() or storage.get('use_encryption')))):
|
|
if storage.is_encrypted_with_hw_device():
|
|
# this case is handled later in the control flow
|
|
password = None
|
|
elif config.get('password'):
|
|
password = config.get('password')
|
|
else:
|
|
password = prompt_password('Password:', False)
|
|
if not password:
|
|
print_msg("Error: Password required")
|
|
sys_exit(1)
|
|
else:
|
|
password = None
|
|
|
|
config_options['password'] = config_options.get('password') or password
|
|
|
|
if cmd.name == 'password':
|
|
new_password = prompt_password('New password:')
|
|
config_options['new_password'] = new_password
|
|
|
|
|
|
def get_connected_hw_devices(plugins):
|
|
supported_plugins = plugins.get_hardware_support()
|
|
# scan devices
|
|
devices = []
|
|
devmgr = plugins.device_manager
|
|
for splugin in supported_plugins:
|
|
name, plugin = splugin.name, splugin.plugin
|
|
if not plugin:
|
|
e = splugin.exception
|
|
_logger.error(f"{name}: error during plugin init: {repr(e)}")
|
|
continue
|
|
try:
|
|
u = devmgr.unpaired_device_infos(None, plugin)
|
|
except Exception as e:
|
|
_logger.error(f'error getting device infos for {name}: {repr(e)}')
|
|
continue
|
|
devices += list(map(lambda x: (name, x), u))
|
|
return devices
|
|
|
|
|
|
def get_password_for_hw_device_encrypted_storage(plugins):
|
|
devices = get_connected_hw_devices(plugins)
|
|
if len(devices) == 0:
|
|
print_msg("Error: No connected hw device found. Cannot decrypt this wallet.")
|
|
sys.exit(1)
|
|
elif len(devices) > 1:
|
|
print_msg("Warning: multiple hardware devices detected. "
|
|
"The first one will be used to decrypt the wallet.")
|
|
# FIXME we use the "first" device, in case of multiple ones
|
|
name, device_info = devices[0]
|
|
plugin = plugins.get_plugin(name)
|
|
derivation = get_derivation_used_for_hw_device_encryption()
|
|
try:
|
|
xpub = plugin.get_xpub(device_info.device.id_, derivation, 'standard', plugin.handler)
|
|
except UserCancelled:
|
|
sys.exit(0)
|
|
password = keystore.Xpub.get_pubkey_from_xpub(xpub, ())
|
|
return password
|
|
|
|
|
|
async def run_offline_command(config, config_options, plugins):
|
|
cmdname = config.get('cmd')
|
|
cmd = known_commands[cmdname]
|
|
password = config_options.get('password')
|
|
if cmd.requires_wallet:
|
|
storage = WalletStorage(config.get_wallet_path())
|
|
if storage.is_encrypted():
|
|
if storage.is_encrypted_with_hw_device():
|
|
password = get_password_for_hw_device_encrypted_storage(plugins)
|
|
config_options['password'] = password
|
|
storage.decrypt(password)
|
|
wallet = Wallet(storage)
|
|
else:
|
|
wallet = None
|
|
# check password
|
|
if cmd.requires_password and wallet.has_password():
|
|
try:
|
|
wallet.check_password(password)
|
|
except InvalidPassword:
|
|
print_msg("Error: This password does not decode this wallet.")
|
|
sys.exit(1)
|
|
if cmd.requires_network:
|
|
print_msg("Warning: running command offline")
|
|
# arguments passed to function
|
|
args = [config.get(x) for x in cmd.params]
|
|
# decode json arguments
|
|
if cmdname not in ('setconfig',):
|
|
args = list(map(json_decode, args))
|
|
# options
|
|
kwargs = {}
|
|
for x in cmd.options:
|
|
kwargs[x] = (config_options.get(x) if x in ['password', 'new_password'] else config.get(x))
|
|
cmd_runner = Commands(config, wallet, None)
|
|
func = getattr(cmd_runner, cmd.name)
|
|
result = await func(*args, **kwargs)
|
|
# save wallet
|
|
if wallet:
|
|
wallet.storage.write()
|
|
return result
|
|
|
|
|
|
def init_plugins(config, gui_name):
|
|
from electrum.plugin import Plugins
|
|
return Plugins(config, gui_name)
|
|
|
|
def sys_exit(i):
|
|
# stop event loop and exit
|
|
loop.call_soon_threadsafe(stop_loop.set_result, 1)
|
|
loop_thread.join(timeout=1)
|
|
sys.exit(i)
|
|
|
|
if __name__ == '__main__':
|
|
# The hook will only be used in the Qt GUI right now
|
|
util.setup_thread_excepthook()
|
|
# on macOS, delete Process Serial Number arg generated for apps launched in Finder
|
|
sys.argv = list(filter(lambda x: not x.startswith('-psn'), sys.argv))
|
|
|
|
# old 'help' syntax
|
|
if len(sys.argv) > 1 and sys.argv[1] == 'help':
|
|
sys.argv.remove('help')
|
|
sys.argv.append('-h')
|
|
|
|
# old '-v' syntax
|
|
# Due to this workaround that keeps old -v working,
|
|
# more advanced usages of -v need to use '-v='.
|
|
# e.g. -v=debug,network=warning,interface=error
|
|
try:
|
|
i = sys.argv.index('-v')
|
|
except ValueError:
|
|
pass
|
|
else:
|
|
sys.argv[i] = '-v*'
|
|
|
|
# read arguments from stdin pipe and prompt
|
|
for i, arg in enumerate(sys.argv):
|
|
if arg == '-':
|
|
if not sys.stdin.isatty():
|
|
sys.argv[i] = sys.stdin.read()
|
|
break
|
|
else:
|
|
raise Exception('Cannot get argument from stdin')
|
|
elif arg == '?':
|
|
sys.argv[i] = input("Enter argument:")
|
|
elif arg == ':':
|
|
sys.argv[i] = prompt_password('Enter argument (will not echo):', False)
|
|
|
|
# parse command line
|
|
parser = get_parser()
|
|
args = parser.parse_args()
|
|
|
|
# config is an object passed to the various constructors (wallet, interface, gui)
|
|
if is_android:
|
|
config_options = {
|
|
'verbosity': '',
|
|
'cmd': 'gui',
|
|
'gui': 'kivy',
|
|
}
|
|
else:
|
|
config_options = args.__dict__
|
|
f = lambda key: config_options[key] is not None and key not in config_variables.get(args.cmd, {}).keys()
|
|
config_options = {key: config_options[key] for key in filter(f, config_options.keys())}
|
|
if config_options.get('server'):
|
|
config_options['auto_connect'] = False
|
|
|
|
config_options['cwd'] = os.getcwd()
|
|
|
|
# fixme: this can probably be achieved with a runtime hook (pyinstaller)
|
|
if is_bundle and os.path.exists(os.path.join(sys._MEIPASS, 'is_portable')):
|
|
config_options['portable'] = True
|
|
|
|
if config_options.get('portable'):
|
|
config_options['electrum_path'] = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'electrum_data')
|
|
|
|
if not config_options.get('verbosity'):
|
|
warnings.simplefilter('ignore', DeprecationWarning)
|
|
|
|
# check uri
|
|
uri = config_options.get('url')
|
|
if uri:
|
|
if not uri.startswith('bitcoin:'):
|
|
print_stderr('unknown command:', uri)
|
|
sys.exit(1)
|
|
config_options['url'] = uri
|
|
|
|
# todo: defer this to gui
|
|
config = SimpleConfig(config_options)
|
|
|
|
cmdname = config.get('cmd')
|
|
|
|
if config.get('testnet'):
|
|
constants.set_testnet()
|
|
elif config.get('regtest'):
|
|
constants.set_regtest()
|
|
elif config.get('simnet'):
|
|
constants.set_simnet()
|
|
elif config.get('lightning') and not config.get('reckless'):
|
|
raise Exception('lightning branch not available on mainnet')
|
|
|
|
if cmdname == 'daemon' and config.get("detach"):
|
|
# fork before creating the asyncio event loop
|
|
pid = os.fork()
|
|
if pid:
|
|
print_stderr("starting daemon (PID %d)" % pid)
|
|
sys.exit(0)
|
|
else:
|
|
# redirect standard file descriptors
|
|
sys.stdout.flush()
|
|
sys.stderr.flush()
|
|
si = open(os.devnull, 'r')
|
|
so = open(os.devnull, 'w')
|
|
se = open(os.devnull, 'w')
|
|
os.dup2(si.fileno(), sys.stdin.fileno())
|
|
os.dup2(so.fileno(), sys.stdout.fileno())
|
|
os.dup2(se.fileno(), sys.stderr.fileno())
|
|
|
|
loop, stop_loop, loop_thread = create_and_start_event_loop()
|
|
|
|
if cmdname == 'gui':
|
|
configure_logging(config)
|
|
fd = daemon.get_file_descriptor(config)
|
|
if fd is not None:
|
|
plugins = init_plugins(config, config.get('gui', 'qt'))
|
|
d = daemon.Daemon(config, fd)
|
|
d.run_gui(config, plugins)
|
|
sys_exit(0)
|
|
else:
|
|
result = daemon.request(config, 'gui', (config_options,))
|
|
|
|
elif cmdname == 'daemon':
|
|
|
|
configure_logging(config)
|
|
fd = daemon.get_file_descriptor(config)
|
|
if fd is not None:
|
|
# run daemon
|
|
init_plugins(config, 'cmdline')
|
|
d = daemon.Daemon(config, fd)
|
|
d.run_daemon()
|
|
sys_exit(0)
|
|
else:
|
|
print_msg("Daemon already running")
|
|
sys_exit(1)
|
|
else:
|
|
# command line
|
|
cmd = known_commands[cmdname]
|
|
if not config.get('offline'):
|
|
init_cmdline(config_options, True)
|
|
timeout = config_options.get('timeout', 60)
|
|
if timeout: timeout = int(timeout)
|
|
try:
|
|
result = daemon.request(config, 'run_cmdline', (config_options,), timeout)
|
|
except daemon.DaemonNotRunning:
|
|
print_msg("Daemon not running; try 'electrum daemon -d'")
|
|
if not cmd.requires_network:
|
|
print_msg("To run this command without a daemon, use --offline")
|
|
sys_exit(1)
|
|
except Exception as e:
|
|
print_stderr(str(e) or repr(e))
|
|
sys_exit(1)
|
|
else:
|
|
if cmd.requires_network:
|
|
print_msg("This command cannot be run offline")
|
|
sys_exit(1)
|
|
init_cmdline(config_options, False)
|
|
plugins = init_plugins(config, 'cmdline')
|
|
coro = run_offline_command(config, config_options, plugins)
|
|
fut = asyncio.run_coroutine_threadsafe(coro, loop)
|
|
try:
|
|
result = fut.result()
|
|
except Exception as e:
|
|
print_stderr(str(e) or repr(e))
|
|
sys_exit(1)
|
|
if isinstance(result, str):
|
|
print_msg(result)
|
|
elif type(result) is dict and result.get('error'):
|
|
print_stderr(result.get('error'))
|
|
elif result is not None:
|
|
print_msg(json_encode(result))
|
|
sys_exit(0)
|