trun_electrum - electrum - Electrum Bitcoin wallet
(HTM) git clone https://git.parazyd.org/electrum
(DIR) Log
(DIR) Files
(DIR) Refs
(DIR) Submodules
---
trun_electrum (16569B)
---
1 #!/usr/bin/env python3
2 # -*- mode: python -*-
3 #
4 # Electrum - lightweight Bitcoin client
5 # Copyright (C) 2011 thomasv@gitorious
6 #
7 # Permission is hereby granted, free of charge, to any person
8 # obtaining a copy of this software and associated documentation files
9 # (the "Software"), to deal in the Software without restriction,
10 # including without limitation the rights to use, copy, modify, merge,
11 # publish, distribute, sublicense, and/or sell copies of the Software,
12 # and to permit persons to whom the Software is furnished to do so,
13 # subject to the following conditions:
14 #
15 # The above copyright notice and this permission notice shall be
16 # included in all copies or substantial portions of the Software.
17 #
18 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
19 # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
21 # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
22 # BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
23 # ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
24 # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
25 # SOFTWARE.
26 import os
27 import sys
28
29
30 MIN_PYTHON_VERSION = "3.6.1" # FIXME duplicated from setup.py
31 _min_python_version_tuple = tuple(map(int, (MIN_PYTHON_VERSION.split("."))))
32
33
34 if sys.version_info[:3] < _min_python_version_tuple:
35 sys.exit("Error: Electrum requires Python version >= %s..." % MIN_PYTHON_VERSION)
36
37
38 import warnings
39 import asyncio
40 from typing import TYPE_CHECKING, Optional
41
42
43 script_dir = os.path.dirname(os.path.realpath(__file__))
44 is_bundle = getattr(sys, 'frozen', False)
45 is_local = not is_bundle and os.path.exists(os.path.join(script_dir, "electrum.desktop"))
46 is_android = 'ANDROID_DATA' in os.environ
47
48 if is_local: # running from source
49 # developers should probably see all deprecation warnings.
50 warnings.simplefilter('default', DeprecationWarning)
51
52 if is_local or is_android:
53 sys.path.insert(0, os.path.join(script_dir, 'packages'))
54
55
56 def check_imports():
57 # pure-python dependencies need to be imported here for pyinstaller
58 try:
59 import dns
60 import certifi
61 import qrcode
62 import google.protobuf
63 import aiorpcx
64 except ImportError as e:
65 sys.exit(f"Error: {str(e)}. Try 'sudo python3 -m pip install <module-name>'")
66 # the following imports are for pyinstaller
67 from google.protobuf import descriptor
68 from google.protobuf import message
69 from google.protobuf import reflection
70 from google.protobuf import descriptor_pb2
71 # make sure that certificates are here
72 assert os.path.exists(certifi.where())
73
74
75 if not is_android:
76 check_imports()
77
78
79 from electrum.logging import get_logger, configure_logging
80 from electrum import util
81 from electrum import constants
82 from electrum import SimpleConfig
83 from electrum.wallet_db import WalletDB
84 from electrum.wallet import Wallet
85 from electrum.storage import WalletStorage
86 from electrum.util import print_msg, print_stderr, json_encode, json_decode, UserCancelled
87 from electrum.util import InvalidPassword, BITCOIN_BIP21_URI_SCHEME
88 from electrum.commands import get_parser, known_commands, Commands, config_variables
89 from electrum import daemon
90 from electrum import keystore
91 from electrum.util import create_and_start_event_loop
92
93 if TYPE_CHECKING:
94 import threading
95
96 from electrum.plugin import Plugins
97
98 _logger = get_logger(__name__)
99
100
101 # get password routine
102 def prompt_password(prompt, confirm=True):
103 import getpass
104 password = getpass.getpass(prompt, stream=None)
105 if password and confirm:
106 password2 = getpass.getpass("Confirm: ")
107 if password != password2:
108 sys.exit("Error: Passwords do not match.")
109 if not password:
110 password = None
111 return password
112
113
114 def init_cmdline(config_options, wallet_path, server, *, config: 'SimpleConfig'):
115 cmdname = config.get('cmd')
116 cmd = known_commands[cmdname]
117
118 if cmdname == 'signtransaction' and config.get('privkey'):
119 cmd.requires_wallet = False
120 cmd.requires_password = False
121
122 if cmdname in ['payto', 'paytomany'] and config.get('unsigned'):
123 cmd.requires_password = False
124
125 if cmdname in ['payto', 'paytomany'] and config.get('broadcast'):
126 cmd.requires_network = True
127
128 # instantiate wallet for command-line
129 storage = WalletStorage(wallet_path)
130
131 if cmd.requires_wallet and not storage.file_exists():
132 print_msg("Error: Wallet file not found.")
133 print_msg("Type 'electrum create' to create a new wallet, or provide a path to a wallet with the -w option")
134 sys_exit(1)
135
136 # important warning
137 if cmd.name in ['getprivatekeys']:
138 print_stderr("WARNING: ALL your private keys are secret.")
139 print_stderr("Exposing a single private key can compromise your entire wallet!")
140 print_stderr("In particular, DO NOT use 'redeem private key' services proposed by third parties.")
141
142 # will we need a password
143 if not storage.is_encrypted():
144 db = WalletDB(storage.read(), manual_upgrades=False)
145 use_encryption = db.get('use_encryption')
146 else:
147 use_encryption = True
148
149 # commands needing password
150 if ( (cmd.requires_wallet and storage.is_encrypted() and server is False)\
151 or (cmdname == 'load_wallet' and storage.is_encrypted())\
152 or (cmd.requires_password and use_encryption)):
153 if storage.is_encrypted_with_hw_device():
154 # this case is handled later in the control flow
155 password = None
156 elif config.get('password'):
157 password = config.get('password')
158 else:
159 password = prompt_password('Password:', False)
160 if not password:
161 print_msg("Error: Password required")
162 sys_exit(1)
163 else:
164 password = None
165
166 config_options['password'] = config_options.get('password') or password
167
168 if cmd.name == 'password':
169 new_password = prompt_password('New password:')
170 config_options['new_password'] = new_password
171
172
173 def get_connected_hw_devices(plugins: 'Plugins'):
174 supported_plugins = plugins.get_hardware_support()
175 # scan devices
176 devices = []
177 devmgr = plugins.device_manager
178 for splugin in supported_plugins:
179 name, plugin = splugin.name, splugin.plugin
180 if not plugin:
181 e = splugin.exception
182 _logger.error(f"{name}: error during plugin init: {repr(e)}")
183 continue
184 try:
185 u = devmgr.unpaired_device_infos(None, plugin)
186 except Exception as e:
187 _logger.error(f'error getting device infos for {name}: {repr(e)}')
188 continue
189 devices += list(map(lambda x: (name, x), u))
190 return devices
191
192
193 def get_password_for_hw_device_encrypted_storage(plugins: 'Plugins') -> str:
194 devices = get_connected_hw_devices(plugins)
195 if len(devices) == 0:
196 print_msg("Error: No connected hw device found. Cannot decrypt this wallet.")
197 sys.exit(1)
198 elif len(devices) > 1:
199 print_msg("Warning: multiple hardware devices detected. "
200 "The first one will be used to decrypt the wallet.")
201 # FIXME we use the "first" device, in case of multiple ones
202 name, device_info = devices[0]
203 devmgr = plugins.device_manager
204 try:
205 client = devmgr.client_by_id(device_info.device.id_)
206 return client.get_password_for_storage_encryption()
207 except UserCancelled:
208 sys.exit(0)
209
210
211 async def run_offline_command(config, config_options, plugins: 'Plugins'):
212 cmdname = config.get('cmd')
213 cmd = known_commands[cmdname]
214 password = config_options.get('password')
215 if 'wallet_path' in cmd.options and config_options.get('wallet_path') is None:
216 config_options['wallet_path'] = config.get_wallet_path()
217 if cmd.requires_wallet:
218 storage = WalletStorage(config.get_wallet_path())
219 if storage.is_encrypted():
220 if storage.is_encrypted_with_hw_device():
221 password = get_password_for_hw_device_encrypted_storage(plugins)
222 config_options['password'] = password
223 storage.decrypt(password)
224 db = WalletDB(storage.read(), manual_upgrades=False)
225 wallet = Wallet(db, storage, config=config)
226 config_options['wallet'] = wallet
227 else:
228 wallet = None
229 # check password
230 if cmd.requires_password and wallet.has_password():
231 try:
232 wallet.check_password(password)
233 except InvalidPassword:
234 print_msg("Error: This password does not decode this wallet.")
235 sys.exit(1)
236 if cmd.requires_network:
237 print_msg("Warning: running command offline")
238 # arguments passed to function
239 args = [config.get(x) for x in cmd.params]
240 # decode json arguments
241 if cmdname not in ('setconfig',):
242 args = list(map(json_decode, args))
243 # options
244 kwargs = {}
245 for x in cmd.options:
246 kwargs[x] = (config_options.get(x) if x in ['wallet_path', 'wallet', 'password', 'new_password'] else config.get(x))
247 cmd_runner = Commands(config=config)
248 func = getattr(cmd_runner, cmd.name)
249 result = await func(*args, **kwargs)
250 # save wallet
251 if wallet:
252 wallet.save_db()
253 return result
254
255
256 def init_plugins(config, gui_name):
257 from electrum.plugin import Plugins
258 return Plugins(config, gui_name)
259
260
261 loop = None # type: Optional[asyncio.AbstractEventLoop]
262 stop_loop = None # type: Optional[asyncio.Future]
263 loop_thread = None # type: Optional[threading.Thread]
264
265 def sys_exit(i):
266 # stop event loop and exit
267 if loop:
268 loop.call_soon_threadsafe(stop_loop.set_result, 1)
269 loop_thread.join(timeout=1)
270 sys.exit(i)
271
272
273 def main():
274 # The hook will only be used in the Qt GUI right now
275 util.setup_thread_excepthook()
276 # on macOS, delete Process Serial Number arg generated for apps launched in Finder
277 sys.argv = list(filter(lambda x: not x.startswith('-psn'), sys.argv))
278
279 # old 'help' syntax
280 if len(sys.argv) > 1 and sys.argv[1] == 'help':
281 sys.argv.remove('help')
282 sys.argv.append('-h')
283
284 # old '-v' syntax
285 # Due to this workaround that keeps old -v working,
286 # more advanced usages of -v need to use '-v='.
287 # e.g. -v=debug,network=warning,interface=error
288 try:
289 i = sys.argv.index('-v')
290 except ValueError:
291 pass
292 else:
293 sys.argv[i] = '-v*'
294
295 # read arguments from stdin pipe and prompt
296 for i, arg in enumerate(sys.argv):
297 if arg == '-':
298 if not sys.stdin.isatty():
299 sys.argv[i] = sys.stdin.read()
300 break
301 else:
302 raise Exception('Cannot get argument from stdin')
303 elif arg == '?':
304 sys.argv[i] = input("Enter argument:")
305 elif arg == ':':
306 sys.argv[i] = prompt_password('Enter argument (will not echo):', False)
307
308 # parse command line
309 parser = get_parser()
310 args = parser.parse_args()
311
312 # config is an object passed to the various constructors (wallet, interface, gui)
313 if is_android:
314 from jnius import autoclass
315 build_config = autoclass("org.electrum.electrum.BuildConfig")
316 config_options = {
317 'verbosity': '*' if build_config.DEBUG else '',
318 'cmd': 'gui',
319 'gui': 'kivy',
320 'single_password':True,
321 }
322 else:
323 config_options = args.__dict__
324 f = lambda key: config_options[key] is not None and key not in config_variables.get(args.cmd, {}).keys()
325 config_options = {key: config_options[key] for key in filter(f, config_options.keys())}
326 if config_options.get('server'):
327 config_options['auto_connect'] = False
328
329 config_options['cwd'] = os.getcwd()
330
331 # fixme: this can probably be achieved with a runtime hook (pyinstaller)
332 if is_bundle and os.path.exists(os.path.join(sys._MEIPASS, 'is_portable')):
333 config_options['portable'] = True
334
335 if config_options.get('portable'):
336 config_options['electrum_path'] = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'electrum_data')
337
338 if not config_options.get('verbosity'):
339 warnings.simplefilter('ignore', DeprecationWarning)
340
341 # check uri
342 uri = config_options.get('url')
343 if uri:
344 if not uri.lower().startswith(BITCOIN_BIP21_URI_SCHEME + ':'):
345 print_stderr('unknown command:', uri)
346 sys.exit(1)
347
348 config = SimpleConfig(config_options)
349
350 if config.get('testnet'):
351 constants.set_testnet()
352 elif config.get('regtest'):
353 constants.set_regtest()
354 elif config.get('simnet'):
355 constants.set_simnet()
356
357 cmdname = config.get('cmd')
358
359 if cmdname == 'daemon' and config.get("detach"):
360 # fork before creating the asyncio event loop
361 pid = os.fork()
362 if pid:
363 print_stderr("starting daemon (PID %d)" % pid)
364 sys.exit(0)
365 else:
366 # redirect standard file descriptors
367 sys.stdout.flush()
368 sys.stderr.flush()
369 si = open(os.devnull, 'r')
370 so = open(os.devnull, 'w')
371 se = open(os.devnull, 'w')
372 os.dup2(si.fileno(), sys.stdin.fileno())
373 os.dup2(so.fileno(), sys.stdout.fileno())
374 os.dup2(se.fileno(), sys.stderr.fileno())
375
376 global loop, stop_loop, loop_thread
377 loop, stop_loop, loop_thread = create_and_start_event_loop()
378
379 try:
380 handle_cmd(
381 cmdname=cmdname,
382 config=config,
383 config_options=config_options,
384 )
385 except Exception:
386 _logger.exception("")
387 sys_exit(1)
388
389
390 def handle_cmd(*, cmdname: str, config: 'SimpleConfig', config_options: dict):
391 if cmdname == 'gui':
392 configure_logging(config)
393 fd = daemon.get_file_descriptor(config)
394 if fd is not None:
395 plugins = init_plugins(config, config.get('gui', 'qt'))
396 d = daemon.Daemon(config, fd)
397 try:
398 d.run_gui(config, plugins)
399 except BaseException as e:
400 _logger.exception('daemon.run_gui errored')
401 sys_exit(1)
402 else:
403 sys_exit(0)
404 else:
405 result = daemon.request(config, 'gui', (config_options,))
406
407 elif cmdname == 'daemon':
408
409 configure_logging(config)
410 fd = daemon.get_file_descriptor(config)
411 if fd is not None:
412 # run daemon
413 init_plugins(config, 'cmdline')
414 d = daemon.Daemon(config, fd)
415 d.run_daemon()
416 sys_exit(0)
417 else:
418 # FIXME this message is lost in detached mode (parent process already exited after forking)
419 print_msg("Daemon already running")
420 sys_exit(1)
421 else:
422 # command line
423 cmd = known_commands[cmdname]
424 wallet_path = config.get_wallet_path()
425 if not config.get('offline'):
426 init_cmdline(config_options, wallet_path, True, config=config)
427 timeout = config.get('timeout', 60)
428 if timeout: timeout = int(timeout)
429 try:
430 result = daemon.request(config, 'run_cmdline', (config_options,), timeout)
431 except daemon.DaemonNotRunning:
432 print_msg("Daemon not running; try 'electrum daemon -d'")
433 if not cmd.requires_network:
434 print_msg("To run this command without a daemon, use --offline")
435 sys_exit(1)
436 except Exception as e:
437 print_stderr(str(e) or repr(e))
438 sys_exit(1)
439 else:
440 if cmd.requires_network:
441 print_msg("This command cannot be run offline")
442 sys_exit(1)
443 init_cmdline(config_options, wallet_path, False, config=config)
444 plugins = init_plugins(config, 'cmdline')
445 coro = run_offline_command(config, config_options, plugins)
446 fut = asyncio.run_coroutine_threadsafe(coro, loop)
447 try:
448 result = fut.result()
449 except Exception as e:
450 print_stderr(str(e) or repr(e))
451 sys_exit(1)
452 if isinstance(result, str):
453 print_msg(result)
454 elif type(result) is dict and result.get('error'):
455 print_stderr(result.get('error'))
456 sys_exit(1)
457 elif result is not None:
458 print_msg(json_encode(result))
459 sys_exit(0)
460
461
462 if __name__ == '__main__':
463 main()