9a38c4d2a1
Previously, during early-startup (until configure_logging(config) is called in run_electrum), - the stderr log handler lost all log messages below warning level, and - the file log handler lost all log messages regardless of log level We now instead start buffering log messages in memory as soon as electrum.logging is imported. The buffer is dumped into the stderr and file log handlers when they are fully set up, and then the buffer is discarded (and the temporary log handler is removed). Note that messages are not logged until configure_logging() is called. Previously WARNING/ERROR messages would get logged immediately to stderr, but not anymore. This was changed so that the order of the log messages can be kept intact. (if we log WARNINGs immediately, but need to delay INFOs until the config is available, messages would either be out of order or alternatively there would be duplicates) Relatedly, we now follow the recommendation of the python docs re logging for libraries [0]: we try to only configure logging if running via run_electrum (the main script) and not when e.g. a 3rd party script imports electrum. [0]: https://docs.python.org/3/howto/logging.html#configuring-logging-for-a-library
477 lines
17 KiB
Python
Executable File
477 lines
17 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
|
|
|
|
|
|
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)
|
|
|
|
|
|
import warnings
|
|
import asyncio
|
|
from typing import TYPE_CHECKING, Optional
|
|
|
|
|
|
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)
|
|
|
|
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 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>'")
|
|
if not ((0, 18, 7) <= aiorpcx._version < (0, 19)):
|
|
raise RuntimeError(f'aiorpcX version {aiorpcx._version} does not match required: 0.18.7<=ver<0.19')
|
|
# 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()
|
|
|
|
|
|
sys._ELECTRUM_RUNNING_VIA_RUNELECTRUM = True # used by logging.py
|
|
|
|
from electrum.logging import get_logger, configure_logging # import logging submodule first
|
|
from electrum import util
|
|
from electrum import constants
|
|
from electrum import SimpleConfig
|
|
from electrum.wallet_db import WalletDB
|
|
from electrum.wallet import Wallet
|
|
from electrum.storage import WalletStorage
|
|
from electrum.util import print_msg, print_stderr, json_encode, json_decode, UserCancelled
|
|
from electrum.util import InvalidPassword, BITCOIN_BIP21_URI_SCHEME
|
|
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
|
|
from electrum.i18n import set_language
|
|
|
|
if TYPE_CHECKING:
|
|
import threading
|
|
|
|
from electrum.plugin import Plugins
|
|
|
|
_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, wallet_path, server, *, config: 'SimpleConfig'):
|
|
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(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.")
|
|
|
|
# will we need a password
|
|
if not storage.is_encrypted():
|
|
db = WalletDB(storage.read(), manual_upgrades=False)
|
|
use_encryption = db.get('use_encryption')
|
|
else:
|
|
use_encryption = True
|
|
|
|
# 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 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: '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: 'Plugins') -> str:
|
|
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]
|
|
devmgr = plugins.device_manager
|
|
try:
|
|
client = devmgr.client_by_id(device_info.device.id_)
|
|
return client.get_password_for_storage_encryption()
|
|
except UserCancelled:
|
|
sys.exit(0)
|
|
|
|
|
|
async def run_offline_command(config, config_options, plugins: 'Plugins'):
|
|
cmdname = config.get('cmd')
|
|
cmd = known_commands[cmdname]
|
|
password = config_options.get('password')
|
|
if 'wallet_path' in cmd.options and config_options.get('wallet_path') is None:
|
|
config_options['wallet_path'] = config.get_wallet_path()
|
|
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)
|
|
db = WalletDB(storage.read(), manual_upgrades=False)
|
|
wallet = Wallet(db, storage, config=config)
|
|
config_options['wallet'] = wallet
|
|
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 ['wallet_path', 'wallet', 'password', 'new_password'] else config.get(x))
|
|
cmd_runner = Commands(config=config)
|
|
func = getattr(cmd_runner, cmd.name)
|
|
result = await func(*args, **kwargs)
|
|
# save wallet
|
|
if wallet:
|
|
wallet.save_db()
|
|
return result
|
|
|
|
|
|
def init_plugins(config, gui_name):
|
|
from electrum.plugin import Plugins
|
|
return Plugins(config, gui_name)
|
|
|
|
|
|
loop = None # type: Optional[asyncio.AbstractEventLoop]
|
|
stop_loop = None # type: Optional[asyncio.Future]
|
|
loop_thread = None # type: Optional[threading.Thread]
|
|
|
|
def sys_exit(i):
|
|
# stop event loop and exit
|
|
if loop:
|
|
loop.call_soon_threadsafe(stop_loop.set_result, 1)
|
|
loop_thread.join(timeout=1)
|
|
sys.exit(i)
|
|
|
|
|
|
def 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:
|
|
from jnius import autoclass
|
|
build_config = autoclass("org.electrum.electrum.BuildConfig")
|
|
config_options = {
|
|
'verbosity': '*' if build_config.DEBUG else '',
|
|
'cmd': 'gui',
|
|
'gui': 'kivy',
|
|
'single_password':True,
|
|
}
|
|
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.lower().startswith(BITCOIN_BIP21_URI_SCHEME + ':'):
|
|
print_stderr('unknown command:', uri)
|
|
sys.exit(1)
|
|
|
|
config = SimpleConfig(config_options)
|
|
|
|
# set language as early as possible
|
|
# Note: we are already too late for strings that are declared in the global scope
|
|
# of an already imported module. However, the GUI and the plugins at least have
|
|
# not been imported yet.
|
|
# Note: it is ok to call set_language() again later. E.g. the Qt GUI has additional
|
|
# tools to figure out the default language so it will get called again there.
|
|
set_language(config.get('language'))
|
|
|
|
if config.get('testnet'):
|
|
constants.set_testnet()
|
|
elif config.get('regtest'):
|
|
constants.set_regtest()
|
|
elif config.get('simnet'):
|
|
constants.set_simnet()
|
|
|
|
cmdname = config.get('cmd')
|
|
|
|
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())
|
|
|
|
global loop, stop_loop, loop_thread
|
|
loop, stop_loop, loop_thread = create_and_start_event_loop()
|
|
|
|
try:
|
|
handle_cmd(
|
|
cmdname=cmdname,
|
|
config=config,
|
|
config_options=config_options,
|
|
)
|
|
except Exception:
|
|
_logger.exception("")
|
|
sys_exit(1)
|
|
|
|
|
|
def handle_cmd(*, cmdname: str, config: 'SimpleConfig', config_options: dict):
|
|
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)
|
|
try:
|
|
d.run_gui(config, plugins)
|
|
except BaseException as e:
|
|
_logger.exception('daemon.run_gui errored')
|
|
sys_exit(1)
|
|
else:
|
|
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:
|
|
# FIXME this message is lost in detached mode (parent process already exited after forking)
|
|
print_msg("Daemon already running")
|
|
sys_exit(1)
|
|
else:
|
|
# command line
|
|
cmd = known_commands[cmdname]
|
|
wallet_path = config.get_wallet_path()
|
|
if not config.get('offline'):
|
|
init_cmdline(config_options, wallet_path, True, config=config)
|
|
timeout = config.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, wallet_path, False, config=config)
|
|
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'))
|
|
sys_exit(1)
|
|
elif result is not None:
|
|
print_msg(json_encode(result))
|
|
sys_exit(0)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|