def main(): parser = OptionParser( usage='usage: %prog [options] wallet_file_name password', description='Create a wallet with the given wallet name and password.') add_base_options(parser) (options, args) = parser.parse_args() if options.wallet_password_stdin: stdin = sys.stdin.read() password = stdin.encode("utf-8") else: assert len( args ) > 1, "must provide password via stdin (see --help), or as second argument." password = args[1].encode("utf-8") load_program_config(config_path=options.datadir) wallet_root_path = os.path.join(jm_single().datadir, "wallets") wallet_name = os.path.join(wallet_root_path, args[0]) if jm_single().config.get("POLICY", "native") == "true": walletclass = SegwitWallet else: walletclass = SegwitLegacyWallet wallet = create_wallet(wallet_name, password, 4, walletclass) jmprint("recovery_seed:{}".format(wallet.get_mnemonic_words()[0]), "important") wallet.close()
def main(): parser = argparse.ArgumentParser( description="Convert old joinmarket json wallet format to new jmdat " "format") parser.add_argument('old_wallet_file', type=open) parser.add_argument('--name', '-n', required=False, dest='name', help="Name of the new wallet file. Default: [old wallet name].jmdat") # hack; not using jmclient.add_base_options because ArgumentParser not OptionParser: parser.add_argument( '--datadir', dest='datadir', default="", help='Specify the path to a directory you want to use to store your user' 'data - wallets, logs and commitment files - and your joinmarket.cfg. ' 'By default, the directory .' + JM_APP_NAME + ' is used.' ) try: args = parser.parse_args() except Exception as e: print("Error: {}".format(e)) return load_program_config(config_path=args.datadir) data = parse_old_wallet(args.old_wallet_file) if not data: return file_name = args.name or\ os.path.split(args.old_wallet_file.name)[-1].rsplit('.', 1)[0] + '.jmdat' wallet_path = get_wallet_path(file_name, None) if new_wallet_from_data(data, wallet_path): print("New wallet file created at {}".format(wallet_path)) else: print("Failed to convert wallet.")
def setUp(self): global clientfactory print("setUp()") params = [[False, False], [True, False], [False, True], [-1, False]] load_program_config() jm_single().maker_timeout_sec = 1 self.port = reactor.listenTCP(28184, JMTestServerProtocolFactory()) self.addCleanup(self.port.stopListening) def cb(client): self.client = client self.addCleanup(self.client.transport.loseConnection) clientfactories = [] takers = [DummyTaker( None, ["a", "b"], callbacks=( None, None, dummy_taker_finished)) for _ in range(len(params))] for i, p in enumerate(params): takers[i].set_fail_init(p[0]) takers[i].set_fail_utxos(p[1]) takers[i].testflag = True if i != 0: clientfactories.append(JMClientProtocolFactory(takers[i])) clientconn = reactor.connectTCP("localhost", 28184, clientfactories[i]) self.addCleanup(clientconn.disconnect) else: clientfactories.append(DummyClientProtocolFactory(takers[i])) clientfactory = clientfactories[0] clientconn = reactor.connectTCP("localhost", 28184, clientfactories[0]) self.addCleanup(clientconn.disconnect)
def main(): parser = OptionParser( usage='usage: %prog [options]', description='Runs a webservice which shows the orderbook.') add_base_options(parser) parser.add_option('-H', '--host', action='store', type='string', dest='host', default='localhost', help='hostname or IP to bind to, default=localhost') parser.add_option('-p', '--port', action='store', type='int', dest='port', help='port to listen on, default=62601', default=62601) (options, args) = parser.parse_args() load_program_config(config_path=options.datadir) hostport = (options.host, options.port) mcs = [ObIRCMessageChannel(c) for c in get_irc_mchannels()] mcc = MessageChannelCollection(mcs) mcc.set_nick(get_dummy_nick()) taker = ObBasic(mcc, hostport) log.info("Starting ob-watcher") mcc.run()
def main(): parser = OptionParser( usage='usage: %prog [options] wallet_file_name', description='Create a wallet with the given wallet name') (options, args) = parser.parse_args() load_program_config(config_path="/data/.joinmarket") with open(os.path.join(jm_single().datadir, "jm-wallet-seed"), "r") as file: words = file.read().replace('\n', '') words.strip() with open(os.path.join(jm_single().datadir, "jm-wallet-password"), "r") as file: password = file.read().replace('\n', '').encode("utf-8") entropy = SegwitLegacyWallet.entropy_from_mnemonic(str(words)) wallet_root_path = os.path.join(jm_single().datadir, "wallets") # add wallet as first argument wallet_name = os.path.join(wallet_root_path, args[0]) wallet = create_wallet(wallet_name, password, 4, SegwitLegacyWallet, entropy=entropy, entropy_extension=None) jmprint("recovery_seed:{}".format(wallet.get_mnemonic_words()[0]), "important") wallet.close()
def main(): parser = OptionParser( usage= 'usage: %prog [options] utxo destaddr1 destaddr2 ..', description="For creating multiple utxos from one (for commitments in JM)." "Provide a utxo in form txid:N that has some unspent coins;" "Specify a list of destination addresses and the coins will" "be split equally between them (after bitcoin fees)." "You'll be prompted to enter the private key for the utxo" "during the run; it must be in WIF compressed format." "After the transaction is completed, the utxo strings for" "the new outputs will be shown." "Note that these utxos will not be ready for use as external" "commitments in Joinmarket until 5 confirmations have passed." " BE CAREFUL about handling private keys!" " Don't do this in insecure environments." " Also note this ONLY works for standard (p2pkh) utxos." ) parser.add_option( '-v', '--validate-utxos', action='store_true', dest='validate', help='validate the utxos and pubkeys provided against the blockchain', default=False ) parser.add_option( '-o', '--validate-only', action='store_true', dest='vonly', help='only validate the provided utxos (file or command line), not add', default=False ) (options, args) = parser.parse_args() load_program_config() if len(args) < 2: quit(parser, 'Invalid syntax') u = args[0] priv = raw_input( 'input private key for ' + u + ', in WIF compressed format : ') u, priv = get_utxo_info(','.join([u, priv])) if not u: quit(parser, "Failed to parse utxo info: " + u) destaddrs = args[1:] for d in destaddrs: if not validate_address(d): quit(parser, "Address was not valid; wrong network?: " + d) txsigned = sign(u, priv, destaddrs) log.debug("Got signed transaction:\n" + txsigned) log.debug("Deserialized:") log.debug(pformat(btc.deserialize(txsigned))) if raw_input('Would you like to push to the network? (y/n):')[0] != 'y': log.info("You chose not to broadcast the transaction, quitting.") return jm_single().bc_interface.pushtx(txsigned)
def receive_payjoin_main(): parser = OptionParser(usage='usage: %prog [options] [wallet file] [amount-to-receive]') add_base_options(parser) parser.add_option('-P', '--hs-port', action='store', type='int', dest='hsport', default=80, help='port on which to serve the ephemeral hidden service.') parser.add_option('-g', '--gap-limit', action='store', type="int", dest='gaplimit', default=6, help='gap limit for wallet, default=6') parser.add_option('-m', '--mixdepth', action='store', type='int', dest='mixdepth', default=0, help="mixdepth to source coins from") parser.add_option('-a', '--amtmixdepths', action='store', type='int', dest='amtmixdepths', help='number of mixdepths in wallet, default 5', default=5) (options, args) = parser.parse_args() if len(args) < 2: parser.error('Needs a wallet, and a receiving amount in bitcoins or satoshis') sys.exit(EXIT_ARGERROR) wallet_name = args[0] try: # amount is stored internally in sats, but will be decimal in URL. bip78_amount = amount_to_sat(args[1]) except: parser.error("Invalid receiving amount passed: " + bip78_amount) sys.exit(EXIT_FAILURE) if bip78_amount < 0: parser.error("Receiving amount must be a positive number") sys.exit(EXIT_FAILURE) load_program_config(config_path=options.datadir) check_regtest() wallet_path = get_wallet_path(wallet_name, None) max_mix_depth = max([options.mixdepth, options.amtmixdepths - 1]) wallet = open_test_wallet_maybe( wallet_path, wallet_name, max_mix_depth, wallet_password_stdin=options.wallet_password_stdin, gap_limit=options.gaplimit) wallet_service = WalletService(wallet) while not wallet_service.synced: wallet_service.sync_wallet(fast=not options.recoversync) wallet_service.startService() # having enforced wallet sync, we can check if we have coins # to do payjoin in the mixdepth if wallet_service.get_balance_by_mixdepth()[options.mixdepth] == 0: jlog.error("Cannot do payjoin from mixdepth " + str( options.mixdepth) + ", no coins. Shutting down.") sys.exit(EXIT_ARGERROR) receiver_manager = JMBIP78ReceiverManager(wallet_service, options.mixdepth, bip78_amount, options.hsport) receiver_manager.start_pj_server_and_tor() reactor.run()
def get_ob(): load_program_config() dm = DummyDaemon() mc = DummyMC(get_irc_mchannels()[0], "test", dm) ob = OrderbookWatch() ob.on_welcome = on_welcome ob.set_msgchan(mc) return ob
def setUp(self): load_program_config() jm_single().maker_timeout_sec = 1 self.port = reactor.listenTCP(28184, JMDaemonTestServerProtocolFactory()) self.addCleanup(self.port.stopListening) clientconn = reactor.connectTCP("localhost", 28184, JMTestClientProtocolFactory()) self.addCleanup(clientconn.disconnect)
def test_config_get_irc_channel(): load_program_config() channel = "dummy" assert get_config_irc_channel(channel) == "#dummy-test" jm_single().config.set("BLOCKCHAIN", "network", "mainnet") assert get_config_irc_channel(channel) == "#dummy" get_irc_mchannels() load_program_config()
def setup_walletservice(request): load_program_config() old_reuse_freeze_val = jm_single().config.getint("POLICY", "max_sats_freeze_reuse") def reset_config(): set_freeze_reuse_config(old_reuse_freeze_val) request.addfinalizer(reset_config)
def test_imported_privkey(setup_wallets): for n in ["mainnet", "testnet"]: privkey = "7d998b45c219a1e38e99e7cbd312ef67f77a455a9b50c730c27f02c6f730dfb401" jm_single().config.set("BLOCKCHAIN", "network", n) password = "******" password_key = bitcoin.bin_dbl_sha256(password) wifprivkey = bitcoin.wif_compressed_privkey(privkey, get_p2pk_vbyte()) #mainnet is "L1RrrnXkcKut5DEMwtDthjwRcTTwED36thyL1DebVrKuwvohjMNi" #to verify use from_wif_privkey and privkey_to_address if n == "mainnet": iaddr = "1LDsjB43N2NAQ1Vbc2xyHca4iBBciN8iwC" else: iaddr = "mzjq2E92B3oRB7yDKbwM7XnPaAnKfRERw2" privkey_bin = bitcoin.from_wif_privkey( wifprivkey, vbyte=get_p2pk_vbyte()).decode('hex')[:-1] encrypted_privkey = encryptData(password_key, privkey_bin) encrypted_privkey_bad = encryptData(password_key, privkey_bin[:6]) walletdir = "wallets" testwalletname = "test" + n pathtowallet = os.path.join(walletdir, testwalletname) seed = bitcoin.sha256("\xaa" * 64)[:32] encrypted_seed = encryptData(password_key, seed.decode('hex')) timestamp = datetime.datetime.now().strftime("%Y/%m/%d %H:%M:%S") for ep in [encrypted_privkey, encrypted_privkey_bad]: walletfilejson = { 'creator': 'joinmarket project', 'creation_time': timestamp, 'encrypted_seed': encrypted_seed.encode('hex'), 'network': n, 'index_cache': [[0, 0]] * 5, 'imported_keys': [{ 'encrypted_privkey': ep.encode('hex'), 'mixdepth': 0 }] } walletfile = json.dumps(walletfilejson) if not os.path.exists(walletdir): os.makedirs(walletdir) with open(pathtowallet, "wb") as f: f.write(walletfile) if ep == encrypted_privkey_bad: with pytest.raises(Exception) as e_info: Wallet(testwalletname, password, 5, 6, False, False) continue newwallet = Wallet(testwalletname, password, 5, 6, False, False) assert newwallet.seed == seed #test accessing the key from the addr assert newwallet.get_key_from_addr( iaddr) == bitcoin.from_wif_privkey(wifprivkey, vbyte=get_p2pk_vbyte()) if n == "testnet": jm_single().bc_interface.sync_wallet(newwallet) load_program_config()
def setup_blockr(request): def blockr_teardown(): jm_single().config.set("BLOCKCHAIN", "blockchain_source", "regtest") jm_single().config.set("BLOCKCHAIN", "network", "testnet") request.addfinalizer(blockr_teardown) load_program_config() jm_single().config.set("BLOCKCHAIN", "blockchain_source", "blockr") jm_single().bc_interface = BlockrInterface(True)
def setup_cj(): load_program_config() jm_single().config.set('POLICY', 'tx_broadcast', 'self') jm_single().bc_interface.tick_forward_chain_interval = 5 jm_single().bc_interface.simulate_blocks() yield None # teardown for dc in reactor.getDelayedCalls(): dc.cancel()
def createcmtdata(request): def cmtdatateardown(): shutil.rmtree("cmtdata") request.addfinalizer(cmtdatateardown) if not os.path.exists("cmtdata"): os.makedirs("cmtdata") load_program_config() jm_single().bc_interface = DummyBlockchainInterface() jm_single().config.set("BLOCKCHAIN", "network", "testnet")
def test_pushtx_errors(setup_wallets): """Ensure pushtx fails return False """ badtxhex = "aaaa" assert not jm_single().bc_interface.pushtx(badtxhex) #Break the authenticated jsonrpc and try again jm_single().bc_interface.jsonRpc.port = 18333 assert not jm_single().bc_interface.pushtx(t_raw_signed_tx) #rebuild a valid jsonrpc inside the bci load_program_config()
def setup_cj(): load_program_config() jm_single().config.set('POLICY', 'tx_broadcast', 'self') jm_single().bc_interface.tick_forward_chain_interval = 5 jm_single().bc_interface.simulate_blocks() #see note in cryptoengine.py: cryptoengine.BTC_P2WPKH.VBYTE = 100 yield None # teardown for dc in reactor.getDelayedCalls(): dc.cancel()
def main(): parser = OptionParser( usage='usage: %prog [options] utxo destaddr1 destaddr2 ..', description=description, formatter=IndentedHelpFormatterWithNL()) parser.add_option( '-t', '--utxo-address-type', action='store', dest='utxo_address_type', help= ('type of address of coin being spent - one of "p2pkh", "p2wpkh", "p2sh-p2wpkh". ' 'No other scriptpubkey types (e.g. multisig) are supported. If not set, we default ' 'to what is in joinmarket.cfg.'), default="") add_base_options(parser) (options, args) = parser.parse_args() load_program_config(config_path=options.datadir) if len(args) < 2: quit(parser, 'Invalid syntax') u = args[0] priv = input('input private key for ' + u + ', in WIF compressed format : ') u, priv = get_utxo_info(','.join([u, priv])) if not u: quit(parser, "Failed to parse utxo info: " + u) destaddrs = args[1:] for d in destaddrs: if not validate_address(d): quit(parser, "Address was not valid; wrong network?: " + d) success, utxo = utxostr_to_utxo(u) if not success: quit(parser, "Failed to load utxo from string: " + utxo) if options.utxo_address_type == "": if jm_single().config.get("POLICY", "segwit") == "false": utxo_address_type = "p2pkh" elif jm_single().config.get("POLICY", "native") == "false": utxo_address_type = "p2sh-p2wpkh" else: utxo_address_type = "p2wpkh" else: utxo_address_type = options.utxo_address_type txsigned = sign(utxo, priv, destaddrs, utxo_address_type) if not txsigned: log.info( "Transaction signing operation failed, see debug messages for details." ) return log.info("Got signed transaction:\n" + bintohex(txsigned.serialize())) log.info(btc.human_readable_transaction(txsigned)) if input('Would you like to push to the network? (y/n):')[0] != 'y': log.info("You chose not to broadcast the transaction, quitting.") return jm_single().bc_interface.pushtx(txsigned.serialize())
def test_blockchain_sources(): load_program_config() for src in ["electrum", "dummy"]: jm_single().config.set("BLOCKCHAIN", "blockchain_source", src) if src == "electrum": jm_single().config.set("BLOCKCHAIN", "network", "mainnet") if src == "dummy": with pytest.raises(ValueError) as e_info: get_blockchain_interface_instance(jm_single().config) else: get_blockchain_interface_instance(jm_single().config) load_program_config()
def setup_taker(request): def clean(): from twisted.internet import reactor for dc in reactor.getDelayedCalls(): dc.cancel() request.addfinalizer(clean) def cmtdatateardown(): shutil.rmtree("cmtdata") request.addfinalizer(cmtdatateardown) if not os.path.exists("cmtdata"): os.makedirs("cmtdata") load_program_config() jm_single().bc_interface = DummyBlockchainInterface() jm_single().config.set("BLOCKCHAIN", "network", "testnet")
def test_get_schedule(): load_program_config() tsf = "schedulefortesting" for s in [valids, invalids1, invalids2, invalids3, invalids4]: if os.path.exists(tsf): os.remove(tsf) with open(tsf, "wb") as f: f.write(s) result = get_schedule(tsf) if s == valids: assert result[0] assert len(result[1]) == 2 else: assert not result[0]
def test_get_utxo_info(): load_program_config() jm_single().config.set("BLOCKCHAIN", "network", "mainnet") dbci = DummyBlockchainInterface() privkey = "L1RrrnXkcKut5DEMwtDthjwRcTTwED36thyL1DebVrKuwvohjMNi" #to verify use from_wif_privkey and privkey_to_address iaddr = "1LDsjB43N2NAQ1Vbc2xyHca4iBBciN8iwC" fakeutxo = "aa" * 32 + ":08" fake_query_results = [{ 'value': 200000000, 'address': iaddr, 'utxo': fakeutxo, 'confirms': 20 }] dbci.insert_fake_query_results(fake_query_results) jm_single().bc_interface = dbci u, priv = get_utxo_info(fakeutxo + "," + privkey) assert u == fakeutxo assert priv == privkey #invalid format with pytest.raises(Exception) as e_info: u, priv = get_utxo_info(fakeutxo + privkey) #invalid index fu2 = "ab" * 32 + ":00004" with pytest.raises(Exception) as e_info: u, priv = get_utxo_info(fu2 + "," + privkey) #invalid privkey p2 = privkey[:-1] + 'j' with pytest.raises(Exception) as e_info: u, priv = get_utxo_info(fakeutxo + "," + p2) utxodatas = [(fakeutxo, privkey)] retval = validate_utxo_data(utxodatas, False) assert retval #try to retrieve retval = validate_utxo_data(utxodatas, True) assert retval[0] == (fakeutxo, 200000000) fake_query_results[0]['address'] = "fakeaddress" dbci.insert_fake_query_results(fake_query_results) #validate should fail for wrong address retval = validate_utxo_data(utxodatas, False) assert not retval #remove fake query result and trigger not found dbci.fake_query_results = None dbci.setQUSFail(True) retval = validate_utxo_data(utxodatas, False) assert not retval dbci.setQUSFail(False)
def __init__(self, balances): """Creates the wallet, setting the balances of the mixdepths as given by the array. (And the number of mixdepths from the array elements.""" load_program_config() storage = VolatileStorage() super(CustomUtxoWallet, self).initialize(storage, get_network(), max_mixdepth=len(balances) - 1) super(CustomUtxoWallet, self).__init__(storage) for m, b in enumerate(balances): self.add_utxo_at_mixdepth(m, b)
def main(): global bond_exponent parser = OptionParser( usage='usage: %prog [options]', description='Runs a webservice which shows the orderbook.') add_base_options(parser) parser.add_option('-H', '--host', action='store', type='string', dest='host', default='localhost', help='hostname or IP to bind to, default=localhost') parser.add_option('-p', '--port', action='store', type='int', dest='port', help='port to listen on, default=62601', default=62601) (options, args) = parser.parse_args() load_program_config(config_path=options.datadir) # needed to display notional units of FB valuation bond_exponent = jm_single().config.get("POLICY", "bond_value_exponent") try: float(bond_exponent) except ValueError: log.error("Invalid entry for bond_value_exponent, should be decimal " "number: {}".format(bond_exponent)) sys.exit(EXIT_FAILURE) check_and_start_tor() hostport = (options.host, options.port) mcs = [] chan_configs = get_mchannels(mode="PASSIVE") for c in chan_configs: if "type" in c and c["type"] == "onion": mcs.append(OnionMessageChannel(c)) else: # default is IRC; TODO allow others mcs.append(IRCMessageChannel(c)) IRCMessageChannel.on_privmsg = on_privmsg OnionMessageChannel.on_privmsg = on_privmsg mcc = MessageChannelCollection(mcs) mcc.set_nick(get_dummy_nick()) taker = ObBasic(mcc, hostport) log.info("Starting ob-watcher") mcc.run()
def setUp(self): load_program_config() print(get_irc_mchannels()[0]) jm_single().maker_timeout_sec = 1 dm, mc, mcc = getmc("irc_publisher") dm2, mc2, mcc2 = getmc("irc_receiver") mcc.run() mcc2.run() def cb(m): #don't try to reconnect m.give_up = True m.tcp_connector.disconnect() self.addCleanup(cb, mc) self.addCleanup(cb, mc2) #test_junk_messages() print("Got here")
def setup_podle(request): load_program_config() if not os.path.exists("cmtdata"): os.mkdir("cmtdata") prev_commits = False #back up any existing commitments pcf = get_commitment_file() log.debug("Podle file: " + pcf) if os.path.exists(pcf): os.rename(pcf, pcf + ".bak") prev_commits = True def teardown(): if prev_commits: os.rename(pcf + ".bak", pcf) else: if os.path.exists(pcf): os.remove(pcf) request.addfinalizer(teardown)
def test_query_utxo_set(setup_wallets): load_program_config() jm_single().bc_interface.tick_forward_chain_interval = 1 wallet = create_wallet_for_sync([2, 3, 0, 0, 0], ["wallet4utxo.json", "4utxo", [2, 3]]) sync_wallet(wallet, fast=True) txid = do_tx(wallet, 90000000) txid2 = do_tx(wallet, 20000000) print("Got txs: ", txid, txid2) res1 = jm_single().bc_interface.query_utxo_set(txid + ":0", includeunconf=True) res2 = jm_single().bc_interface.query_utxo_set( [txid + ":0", txid2 + ":1"], includeconf=True, includeunconf=True) assert len(res1) == 1 assert len(res2) == 2 assert all([x in res1[0] for x in ['script', 'address', 'value']]) assert not 'confirms' in res1[0] assert 'confirms' in res2[0] assert 'confirms' in res2[1] res3 = jm_single().bc_interface.query_utxo_set("ee" * 32 + ":25") assert res3 == [None]
def main(): parser = OptionParser( usage='usage: %prog [options] wallet_file_name password', description='Create a wallet with the given wallet name and password.') (options, args) = parser.parse_args() # Load up defaults load_program_config(config_path='/data/.joinmarket') wallet_root_path = os.path.join(jm_single().datadir, "wallets") # get wallet from first argument wallet_name = os.path.join(wallet_root_path, args[0]) wallet = create_wallet(wallet_name, args[1].encode("utf-8"), 4, SegwitLegacyWallet) # Open file for writing seedfile = open(os.path.join(jm_single().datadir, "jm-wallet-seed"), "w") seedfile.write(wallet.get_mnemonic_words()[0]) seedfile.write("\n") seedfile.close() jmprint("recovery_seed:{}" .format(wallet.get_mnemonic_words()[0]), "important") wallet.close()
def main(): parser = OptionParser( usage='usage: %prog [options] wallet_file_name [password]', description='Create a wallet with the given wallet name and password.') add_base_options(parser) parser.add_option( '--recovery-seed-file', dest='seed_file', default=None, help= ('File containing a mnemonic recovery phrase. If provided, the wallet ' 'is recovered from this seed instead of being newly generated.')) (options, args) = parser.parse_args() wallet_name = args[0] if options.wallet_password_stdin: password = wallet_utils.read_password_stdin() else: assert len( args ) > 1, "must provide password via stdin (see --help), or as second argument." password = args[1].encode("utf-8") seed = options.seed_file and Path(options.seed_file).read_text().rstrip() load_program_config(config_path=options.datadir) wallet_root_path = os.path.join(jm_single().datadir, "wallets") wallet_path = os.path.join(wallet_root_path, wallet_name) if jm_single().config.get("POLICY", "native") == "true": walletclass = SegwitWalletFidelityBonds else: # Fidelity Bonds are not available for segwit legacy wallets walletclass = SegwitLegacyWallet entropy = seed and SegwitLegacyWallet.entropy_from_mnemonic(seed) wallet = create_wallet(wallet_path, password, wallet_utils.DEFAULT_MIXDEPTH, walletclass, entropy=entropy) jmprint("recovery_seed:{}".format(wallet.get_mnemonic_words()[0]), "important") wallet.close()
def test_load_config(tmpdir): load_program_config(bs="regtest") jm_single().config_location = "joinmarket.cfg" with pytest.raises(SystemExit): load_program_config(config_path=str(tmpdir), bs="regtest") jm_single().config_location = "joinmarket.cfg" load_program_config()
def load_config(self, window): """Load/instantiate the joinmarket config file in electrum's home directory/joinmarket (e.g. ~/.electrum/joinmarket Also load/instantiate the logs/ subdirectory for bot logs, and the cmtdata/ directory for commitments storage. Create and set the commitments.json file. """ try: jm_subdir = os.path.join(window.config.path, "joinmarket") if not os.path.exists(jm_subdir): os.makedirs(jm_subdir) cmttools_dir = os.path.join(jm_subdir, "cmtdata") if not os.path.exists(cmttools_dir): os.makedirs(cmttools_dir) set_commitment_file(os.path.join(cmttools_dir, "commitments.json")) self.config_location = os.path.join(jm_subdir, "joinmarket.cfg") self.logs_location = os.path.join(jm_subdir, "logs") load_program_config(jm_subdir, "electrum") if TESTNET: jm_single().config.set("BLOCKCHAIN", "network", "testnet") log.info('working with testnet') else: jm_single().config.set("BLOCKCHAIN", "network", "mainnet") log.info('working with mainnet') except Exception as e: log.info("thrown: " + repr(e)) JMQtMessageBox(window, "\n".join([ "The joinmarket config failed to load.", "Make sure that blockchain_source = electrum", "is set in the joinmarket.cfg file."]), mbtype='warn', title="Error") return if not os.path.exists(self.logs_location): os.makedirs(self.logs_location) update_config_for_gui()