electrum

   1 #!/usr/bin/env python
   2 #
   3 # Electrum - lightweight Bitcoin client
   4 # Copyright (C) 2011 thomasv@gitorious
   5 #
   6 # This program is free software: you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation, either version 3 of the License, or
   9 # (at your option) any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful,
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14 # GNU General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program. If not, see <http://www.gnu.org/licenses/>.
  18
  19 import re
  20 import sys
  21 # import argparse
  22 import optparse
  23
  24 try:
  25     from lib.util import print_error
  26 except ImportError:
  27     from electrum.util import print_error
  28
  29 try:
  30     import ecdsa
  31 except ImportError:
  32     sys.exit("Error: python-ecdsa does not seem to be installed. Try 'sudo pip install ecdsa'")
  33
  34 try:
  35     import aes
  36 except ImportError:
  37     sys.exit("Error: AES does not seem to be installed. Try 'sudo pip install slowaes'")
  38
  39 try:
  40     from lib import Wallet, WalletSynchronizer, format_satoshis, mnemonic, prompt_password, parse_proxy_options, SimpleConfig
  41 except ImportError:
  42     from electrum import Wallet, WalletSynchronizer, format_satoshis, mnemonic, prompt_password, parse_proxy_options, SimpleConfig
  43
  44 from decimal import Decimal
  45
  46 known_commands = {
  47     'help':'Prints this help',
  48     'validateaddress':'Check that the address is valid',
  49     'balance': "Display the balance of your wallet or of an address.\nSyntax: balance [<address>]",
  50     'contacts': "Show your list of contacts",
  51     'create':'Create a wallet',
  52     'restore':'Restore a wallet',
  53     'payto':"""Create and broadcast a transaction.
  54 Syntax: payto <recipient> <amount> [label]
  55 <recipient> can be a bitcoin address or a label
  56 options:\n  --fee, -f: set transaction fee\n  --fromaddr, -s: send from address -\n  --changeaddr, -c: send change to address
  57             """,
  58     'sendtx':
  59             'Broadcasts a transaction to the network. \nSyntax: sendtx <tx>\n<tx> must be in hexadecimal.',
  60     'password':
  61             "Changes your password",
  62     'addresses':
  63             """Shows your list of addresses.
  64 options:
  65   -a: show all addresses, including change addresses
  66   -k: show private keys
  67   -b: show the balance of addresses""",
  68
  69     'history':"Shows the transaction history",
  70     'label':'Assign a label to an item\nSyntax: label <tx_hash> <label>',
  71     'mktx':
  72         """Create a signed transaction, password protected.
  73 Syntax: mktx <recipient> <amount> [label]
  74 options:\n  --fee, -f: set transaction fee\n  --fromaddr, -s: send from address -\n  --changeaddr, -c: send change to address
  75         """,
  76     'seed':
  77             "Print the generation seed of your wallet.",
  78     'import':
  79             'Imports a key pair\nSyntax: import <address>:<privatekey>',
  80     'signmessage':
  81             'Signs a message with a key\nSyntax: signmessage <address> <message>\nIf you want to lead or end a message with spaces, or want double spaces inside the message make sure you quote the string. I.e. " Hello  This is a weird String "',
  82     'verifymessage':
  83              'Verifies a signature\nSyntax: verifymessage <address> <signature> <message>\nIf you want to lead or end a message with spaces, or want double spaces inside the message make sure you quote the string. I.e. " Hello  This is a weird String "',
  84     'eval':
  85              "Run python eval() on an object\nSyntax: eval <expression>\nExample: eval \"wallet.aliases\"",
  86     'deseed':
  87             "Remove seed from the wallet. The seed is stored in a file that has the name of the wallet plus '.seed'",
  88     'reseed':
  89             "Restore seed of the wallet. The wallet must have no seed, and the seed must match the wallet's master public key.",
  90     'freeze':'',
  91     'unfreeze':'',
  92     'prioritize':'',
  93     'unprioritize':'',
  94     }
  95
  96
  97
  98 offline_commands = [ 'password', 'mktx', 'label', 'contacts', 'help', 'validateaddress', 'signmessage', 'verifymessage', 'eval', 'create', 'addresses', 'import', 'seed','deseed','reseed','freeze','unfreeze','prioritize','unprioritize']
  99
 100 protected_commands = ['payto', 'password', 'mktx', 'seed', 'import','signmessage' ]
 101
 102 if __name__ == '__main__':
 103
 104     # Load simple config class
 105     simple_config = SimpleConfig()
 106
 107     usage = "usage: %prog [options] command\nCommands: "+ (', '.join(known_commands))
 108     parser = optparse.OptionParser(prog=usage)
 109     parser.add_option("-g", "--gui", dest="gui", default=simple_config.config["gui"], help="gui")
 110     parser.add_option("-w", "--wallet", dest="wallet_path", help="wallet path (default: electrum.dat)")
 111     parser.add_option("-o", "--offline", action="store_true", dest="offline", default=False, help="remain offline")
 112     parser.add_option("-a", "--all", action="store_true", dest="show_all", default=False, help="show all addresses")
 113     parser.add_option("-b", "--balance", action="store_true", dest="show_balance", default=False, help="show the balance at listed addresses")
 114     parser.add_option("-k", "--keys",action="store_true", dest="show_keys",default=False, help="show the private keys of listed addresses")
 115     parser.add_option("-f", "--fee", dest="tx_fee", default="0.005", help="set tx fee")
 116     parser.add_option("-s", "--fromaddr", dest="from_addr", default=None, help="set source address for payto/mktx. if it isn't in the wallet, it will ask for the private key unless supplied in the format public_key:private_key. It's not saved in the wallet.")
 117     parser.add_option("-c", "--changeaddr", dest="change_addr", default=None, help="set the change address for payto/mktx. default is a spare address, or the source address if it's not in the wallet")
 118     parser.add_option("-r", "--remote", dest="remote_url", default=None, help="URL of a remote wallet")
 119     parser.add_option("-p", "--proxy", dest="proxy", default=simple_config.config["proxy"], help="set proxy [type:]host[:port], where type is socks4,socks5 or http")
 120     options, args = parser.parse_args()
 121
 122     if type(options.proxy) == type(''):
 123                 options.proxy = parse_proxy_options(options.proxy)
 124
 125     wallet = Wallet()
 126     wallet.set_path(options.wallet_path)
 127     wallet.read()
 128     wallet.remote_url = options.remote_url
 129
 130     if len(args)==0:
 131         url = None
 132         cmd = 'gui'
 133     elif len(args)==1 and re.match('^bitcoin:', args[0]):
 134         url = args[0]
 135         cmd = 'gui'
 136     else:
 137         cmd = args[0]
 138         firstarg = args[1] if len(args) > 1 else ''
 139
 140     #this entire if/else block is just concerned with importing the
 141     #right GUI toolkit based the GUI command line option given
 142     if cmd == 'gui':
 143
 144         if options.gui=='gtk':
 145             try:
 146                 import lib.gui as gui
 147             except ImportError:
 148                 import electrum.gui as gui
 149         elif options.gui=='qt':
 150             try:
 151                 import lib.gui_qt as gui
 152             except ImportError:
 153                 import electrum.gui_qt as gui
 154         elif options.gui == 'lite':
 155             # Let's do some dep checking and handle missing ones gracefully
 156             try:
 157               from PyQt4.QtCore import *
 158               from PyQt4.QtGui import *
 159             except ImportError:
 160               print "You need to have PyQT installed to run Electrum in graphical mode."
 161               print "If you have pip installed try 'sudo pip install pyqt' if you are on Debian/Ubuntu try 'sudo apt-get install python-qt4'."
 162               sys.exit(0)
 163
 164             qtVersion = qVersion()
 165             if not(int(qtVersion[0]) >= 4 and int(qtVersion[2]) >= 7):
 166               app = QApplication(sys.argv)
 167               QMessageBox.warning(None,"Could not start Lite GUI.", "Electrum was unable to load the 'Lite GUI' because it needs Qt version >= 4.7.\nElectrum is now setup to load the Pro GUI.")
 168
 169               simple_config.set_key("gui", "qt")
 170
 171               try:
 172                   import lib.gui_qt as gui
 173               except ImportError:
 174                   import electrum.gui_qt as gui
 175             else:
 176               #use the lite version if no toolkit specified
 177               try:
 178                 import lib.gui_lite as gui
 179               except ImportError:
 180                 import electrum.gui_lite as gui
 181         else:
 182             sys.exit("Error: Unknown GUI: " + options.gui)
 183
 184         gui = gui.ElectrumGui(wallet)
 185         interface = WalletSynchronizer(wallet, True, gui.server_list_changed, options.proxy)
 186         interface.start()
 187
 188         try:
 189             found = wallet.file_exists
 190             if not found:
 191                 found = gui.restore_or_create()
 192         except SystemExit, e:
 193             exit(e)
 194         except BaseException, e:
 195             import traceback
 196             traceback.print_exc(file=sys.stdout)
 197             #gui.show_message(e.message)
 198             exit(1)
 199
 200         if not found:
 201             exit(1)
 202         gui.main(url)
 203         wallet.save()
 204         sys.exit(0)
 205
 206     if cmd not in known_commands:
 207         cmd = 'help'
 208
 209     if not wallet.file_exists and cmd not in ['help','create','restore']:
 210         print "Error: Wallet file not found."
 211         print "Type 'electrum create' to create a new wallet, or provide a path to a wallet with the -w option"
 212         sys.exit(0)
 213
 214     if cmd in ['create', 'restore']:
 215         if wallet.file_exists:
 216             sys.exit("Error: Remove the existing wallet first!")
 217         password = prompt_password("Password (hit return if you do not wish to encrypt your wallet):")
 218
 219         w_host, w_port, w_protocol = wallet.server.split(':')
 220         host = raw_input("server (default:%s):"%w_host)
 221         port = raw_input("port (default:%s):"%w_port)
 222         protocol = raw_input("protocol [t=tcp;h=http;n=native] (default:%s):"%w_protocol)
 223         fee = raw_input("fee (default:%s):"%( str(Decimal(wallet.fee)/100000000)) )
 224         gap = raw_input("gap limit (default 5):")
 225         if host: w_host = host
 226         if port: w_port = port
 227         if protocol: w_protocol = protocol
 228         wallet.server = w_host + ':' + w_port + ':' +w_protocol
 229         if fee: wallet.fee = float(fee)
 230         if gap: wallet.gap_limit = int(gap)
 231
 232         if cmd == 'restore':
 233             seed = raw_input("seed:")
 234             try:
 235                 seed.decode('hex')
 236             except:
 237                 print_error("Warning: Not hex, trying decode.")
 238                 seed = mnemonic.mn_decode( seed.split(' ') )
 239             if not seed:
 240                 sys.exit("Error: No seed")
 241
 242             wallet.seed = str(seed)
 243             wallet.init_mpk( wallet.seed )
 244             if not options.offline:
 245                 WalletSynchronizer(wallet).start()
 246                 print "Recovering wallet..."
 247                 wallet.up_to_date_event.clear()
 248                 wallet.up_to_date = False
 249                 wallet.update()
 250                 if wallet.is_found():
 251                     print "Recovery successful"
 252                 else:
 253                     print_error("Warning: Found no history for this wallet")
 254             else:
 255                 wallet.synchronize()
 256             wallet.fill_addressbook()
 257             wallet.save()
 258             print_error("Wallet saved in '" + wallet.path)
 259         else:
 260             wallet.new_seed(None)
 261             wallet.init_mpk( wallet.seed )
 262             wallet.synchronize() # there is no wallet thread
 263             wallet.save()
 264             print "Your wallet generation seed is: " + wallet.seed
 265             print "Please keep it in a safe place; if you lose it, you will not be able to restore your wallet."
 266             print "Equivalently, your wallet seed can be stored and recovered with the following mnemonic code:"
 267             print "\""+' '.join(mnemonic.mn_encode(wallet.seed))+"\""
 268             print "Wallet saved in '%s'"%wallet.path
 269
 270         if password:
 271             wallet.update_password(wallet.seed, None, password)
 272
 273     # check syntax
 274     if cmd in ['payto', 'mktx']:
 275         try:
 276             to_address = args[1]
 277             amount = int( 100000000 * Decimal(args[2]) )
 278             change_addr = None
 279             label = ' '.join(args[3:])
 280             if options.tx_fee:
 281                 options.tx_fee = int( 100000000 * Decimal(options.tx_fee) )
 282         except:
 283             firstarg = cmd
 284             cmd = 'help'
 285
 286     # open session
 287     if cmd not in offline_commands and not options.offline:
 288         WalletSynchronizer(wallet).start()
 289         wallet.update()
 290         wallet.save()
 291
 292     # check if --from_addr not in wallet (for mktx/payto)
 293     is_temporary = False
 294     from_addr = None
 295     if options.from_addr:
 296         from_addr = options.from_addr
 297         if from_addr not in wallet.all_addresses():
 298             is_temporary = True
 299
 300     # commands needing password
 301     if cmd in protected_commands or ( cmd=='addresses' and options.show_keys):
 302         password = prompt_password('Password:', False) if wallet.use_encryption and not is_temporary else None
 303         # check password
 304         try:
 305             wallet.pw_decode( wallet.seed, password)
 306         except:
 307             print_error("Error: This password does not decode this wallet.")
 308             exit(1)
 309
 310     if cmd == 'import':
 311         # See if they specificed a key on the cmd line, if not prompt
 312         if len(args) > 1:
 313             keypair = args[1]
 314         else:
 315             keypair = prompt_password('Enter Address:PrivateKey (will not echo):', False)
 316         try:
 317             wallet.import_key(keypair,password)
 318             wallet.save()
 319             print "Keypair imported"
 320         except BaseException, e:
 321             print_error("Error: Keypair import failed: " + str(e))
 322
 323     if cmd == 'help':
 324         cmd2 = firstarg
 325         if cmd2 not in known_commands:
 326             parser.print_help()
 327             print "Type 'electrum help <command>' to see the help for a specific command"
 328             print "Type 'electrum --help' to see the list of options"
 329             print "List of commands:", ', '.join(known_commands)
 330         else:
 331             print known_commands[cmd2]
 332
 333     elif cmd == 'seed':
 334         seed = wallet.pw_decode( wallet.seed, password)
 335         print seed + ' "' + ' '.join(mnemonic.mn_encode(seed)) + '"'
 336
 337     elif cmd == 'deseed':
 338         if not wallet.seed:
 339             print_error("Error: This wallet has no seed")
 340         elif wallet.use_encryption:
 341             print_error("Error: This wallet is encrypted")
 342         else:
 343             ns = wallet.path + '.seed'
 344             print "Warning: you are going to extract the seed from '%s'\nThe seed will be saved in '%s'"%(wallet.path,ns)
 345             if raw_input("Are you sure you want to continue? (y/n) ") in ['y','Y','yes']:
 346                 f = open(ns,'w')
 347                 f.write(repr({'seed':wallet.seed, 'imported_keys':wallet.imported_keys})+"\n")
 348                 f.close()
 349                 wallet.seed = ''
 350                 for k in wallet.imported_keys.keys(): wallet.imported_keys[k] = ''
 351                 wallet.save()
 352                 print "Done."
 353             else:
 354                 print_error("Action canceled.")
 355
 356     elif cmd == 'reseed':
 357         if wallet.seed:
 358             print "Warning: This wallet already has a seed", wallet.seed
 359         else:
 360             ns = wallet.path + '.seed'
 361             try:
 362                 f = open(ns,'r')
 363                 data = f.read()
 364                 f.close()
 365             except IOError:
 366                 sys.exit("Error: Seed file not found")
 367             try:
 368                 import ast
 369                 d = ast.literal_eval( data )
 370                 seed = d['seed']
 371                 imported_keys = d.get('imported_keys',{})
 372             except:
 373                 sys.exit("Error: Error with seed file")
 374
 375             mpk = wallet.master_public_key
 376             wallet.seed = seed
 377             wallet.imported_keys = imported_keys
 378             wallet.use_encryption = False
 379             wallet.init_mpk(seed)
 380             if mpk == wallet.master_public_key:
 381                 wallet.save()
 382                 print "Done: " + wallet.path
 383             else:
 384                 print_error("Error: Master public key does not match")
 385
 386     elif cmd == 'validateaddress':
 387         addr = args[1]
 388         print wallet.is_valid(addr)
 389
 390     elif cmd == 'balance':
 391         try:
 392             addrs = args[1:]
 393         except:
 394             pass
 395         if addrs == []:
 396             c, u = wallet.get_balance()
 397             if u:
 398                 print Decimal( c ) / 100000000 , Decimal( u ) / 100000000
 399             else:
 400                 print Decimal( c ) / 100000000
 401         else:
 402             for addr in addrs:
 403                 c, u = wallet.get_addr_balance(addr)
 404                 if u:
 405                     print "%s %s, %s" % (addr, str(Decimal(c)/100000000), str(Decimal(u)/100000000))
 406                 else:
 407                     print "%s %s" % (addr, str(Decimal(c)/100000000))
 408
 409     elif cmd in [ 'contacts']:
 410         for addr in wallet.addressbook:
 411             print addr, "   ", wallet.labels.get(addr)
 412
 413     elif cmd == 'eval':
 414         print eval(args[1])
 415         wallet.save()
 416
 417     elif cmd in [ 'addresses']:
 418         for addr in wallet.all_addresses():
 419             if options.show_all or not wallet.is_change(addr):
 420
 421                 flags = wallet.get_address_flags(addr)
 422                 label = wallet.labels.get(addr,'')
 423
 424                 if label: label = "\"%s\""%label
 425
 426                 if options.show_balance:
 427                     h = wallet.history.get(addr,[])
 428                     #ni = no = 0
 429                     #for item in h:
 430                     #    if item['is_input']:  ni += 1
 431                     #    else:              no += 1
 432                     b = format_satoshis(wallet.get_addr_balance(addr)[0])
 433                 else: b=''
 434                 m_addr = "%34s"%addr
 435                 if options.show_keys:
 436                     m_addr += ':' + str(wallet.get_private_key_base58(addr, password))
 437                 print flags, m_addr, b, label
 438
 439     if cmd == 'history':
 440         lines = wallet.get_tx_history()
 441         b = 0
 442         for line in lines:
 443             import datetime
 444             v = line['value']
 445             b += v
 446             try:
 447                 time_str = str( datetime.datetime.fromtimestamp( line['timestamp']))
 448             except:
 449                 print line['timestamp']
 450                 time_str = 'pending'
 451             label = line.get('label')
 452             if not label: label = line['tx_hash']
 453             else: label = label + ' '*(64 - len(label) )
 454
 455             print time_str , "  " + label + "  " + format_satoshis(v)+ "  "+ format_satoshis(b)
 456         print "# balance: ", format_satoshis(b)
 457
 458     elif cmd == 'label':
 459         try:
 460             tx = args[1]
 461             label = ' '.join(args[2:])
 462         except:
 463             print_error("Error. Syntax:  label <tx_hash> <text>")
 464             sys.exit(1)
 465         wallet.labels[tx] = label
 466         wallet.save()
 467
 468     elif cmd in ['payto', 'mktx']:
 469         if from_addr and is_temporary:
 470             if from_addr.find(":") == -1:
 471                 keypair = from_addr + ":" + prompt_password('Private key:', False)
 472             else:
 473                 keypair = from_addr
 474                 from_addr = keypair.split(':')[0]
 475             if not wallet.import_key(keypair,password):
 476                 print_error("Error: Invalid key pair")
 477                 exit(1)
 478             wallet.history[from_addr] = interface.retrieve_history(from_addr)
 479             wallet.update_tx_history()
 480             change_addr = from_addr
 481
 482         if options.change_addr:
 483             change_addr = options.change_addr
 484
 485         for k, v in wallet.labels.items():
 486             if v == to_address:
 487                 to_address = k
 488                 print "alias", to_address
 489                 break
 490             if change_addr and v == change_addr:
 491                 change_addr = k
 492         try:
 493             tx = wallet.mktx( to_address, amount, label, password,
 494                 fee = options.tx_fee, change_addr = change_addr, from_addr = from_addr )
 495         except:
 496             import traceback
 497             traceback.print_exc(file=sys.stdout)
 498             tx = None
 499
 500         if tx and cmd=='payto':
 501             r, h = wallet.sendtx( tx )
 502             print h
 503         else:
 504             print tx
 505
 506         if is_temporary:
 507             wallet.imported_keys.pop(from_addr)
 508             del(wallet.history[from_addr])
 509         wallet.save()
 510
 511     elif cmd == 'sendtx':
 512         tx = args[1]
 513         r, h = wallet.sendtx( tx )
 514         print h
 515
 516     elif cmd == 'password':
 517         try:
 518             seed = wallet.pw_decode( wallet.seed, password)
 519         except ValueError:
 520             sys.exit("Error: Password does not decrypt this wallet.")
 521
 522         new_password = prompt_password('New password:')
 523         wallet.update_password(seed, password, new_password)
 524
 525     elif cmd == 'signmessage':
 526         if len(args) < 3:
 527             print_error("Error: Invalid usage of signmessage.")
 528             print known_commands[cmd]
 529             sys.exit(1)
 530         address = args[1]
 531         message = ' '.join(args[2:])
 532         if len(args) > 3:
 533             print "Warning: Message was reconstructed from several arguments:", repr(message)
 534         print wallet.sign_message(address, message, password)
 535
 536     elif cmd == 'verifymessage':
 537         try:
 538             address = args[1]
 539             signature = args[2]
 540             message = ' '.join(args[3:])
 541         except:
 542             print_error("Error: Not all parameters were given, displaying help instead.")
 543             print known_commands[cmd]
 544             sys.exit(1)
 545         if len(args) > 4:
 546             print "Warning: Message was reconstructed from several arguments:", repr(message)
 547         try:
 548             wallet.verify_message(address, signature, message)
 549             print True
 550         except BaseException as e:
 551             print "Verification error: {0}".format(e)
 552             print False
 553
 554     elif cmd == 'freeze':
 555         addr = args[1]
 556         print self.wallet.freeze(addr)
 557
 558     elif cmd == 'unfreeze':
 559         addr = args[1]
 560         print self.wallet.unfreeze(addr)
 561
 562     elif cmd == 'prioritize':
 563         addr = args[1]
 564         print self.wallet.prioritize(addr)
 565
 566     elif cmd == 'unprioritize':
 567         addr = args[1]
 568         print self.wallet.unprioritize(addr)
 569