def inspect(ctx, psbt): network = ctx.obj["group_options"].network pretty_echo_header("Inspect", network) bitcoin.SelectParams(network) psbt = deserialize_psbt(psbt) offer = p2oc.offer.get_offer_from_psbt(psbt, raise_if_missing=False) reply = p2oc.offer.get_offer_reply_from_psbt(psbt, raise_if_missing=False) click.echo() click.secho("Inspect PSBT\n", bold=True, underline=True) click.secho("psbt.inputs:", bold=True) click.echo(textwrap.indent(pprint.pretty_psbt_inputs(psbt.inputs), " ")) click.secho("psbt.outputs:", bold=True) click.echo(textwrap.indent(pprint.pretty_outputs(psbt.outputs), " ")) click.secho("psbt.unsigned_tx:", bold=True) click.echo(textwrap.indent(pprint.pretty_tx(psbt.unsigned_tx), " ")) click.secho("Inspect Offer\n", bold=True, underline=True) if offer is not None: click.echo(pprint.pretty_offer(offer)) else: click.echo("N/A") click.secho("Inspect Reply\n", bold=True, underline=True) if reply is not None: click.echo(pprint.pretty_reply(reply)) else: click.echo("N/A")
def __init__(self, addrs, params="mainnet", blockchain=None, user_agent="/pyBitcoin:0.1/", max_connections=10, subscriptions=[], listeners=[]): self.addrs = addrs self.params = params self.blockchain = blockchain self.user_agent = user_agent self.max_connections = max_connections self.testnet = True if params == "testnet" else False self.peers = [] self.inventory = {} self.pending_txs = {} self.subscriptions = {} self.bloom_filter = BloomFilter(10, 0.001, random.getrandbits(32), BloomFilter.UPDATE_NONE) self.download_listener = None self.peer_event_listener = None for s in subscriptions: self.subscribe_address(s[0], s[1]) for l in listeners: self.add_event_listener(l) self._connect_to_peers() if self.blockchain: self._start_chain_download() bitcoin.SelectParams(params)
def openchannel(ctx, unsigned_psbt): network = ctx.obj["group_options"].network pretty_echo_header("Open Channel", network) bitcoin.SelectParams(network) lnd = _lnd_from_options(ctx.obj["group_options"]) unsigned_psbt = deserialize_psbt(unsigned_psbt) pretty_echo_psbt(unsigned_psbt, "taker") click.confirm( "Please confirm if you'd like to proceed in opening the channel", default=True, abort=True, ) half_signed_psbt = p2oc.open_channel(unsigned_psbt, lnd) half_signed_psbt = half_signed_psbt.to_base64() click.secho( "\nYou've successfully signed the funding tx and opened a pending channel. " + "Send the final reply back to the funder for them to finalize and publish. " + "The channel can be used after 6 confirmation.\n", bold=True, ) click.echo(half_signed_psbt)
def _init_task(self, settings): """Initialize task after process is forked""" # Last time bitcoind was polled or reconnect tried self._last_update = time.perf_counter() # We need to create a new DB session for the process, because the # one used by flask can be only be share between threads. self._db_session = configure_db(self._settings['DB_URI']) # Find block number where monitoring stoped last time self._current_block = -1 # Start by newest block if self._settings['START_BLOCK'] == 'last': with make_session_scope(self._db_session) as session: try: block = session.query(Block).one() self._current_block = block.block_number except sqlalchemy.orm.exc.NoResultFound: # Not found, it can happen the first time the app is executed # so there is no need to log the exception pass # bitcoin lib chain selection bitcoin.SelectParams(self._settings['CHAIN']) # It will be initialized later by reconnect code self._monitor = None # Transaction monitor is not provided so it is not initialized here # so it's treated later as if the connection was lost. self._subscription_manager = SubscriptionManager( self._monitor, # Init later self._db_session, settings['RELOAD_SUBSCRIPTIONS'])
def Test(): if 1: bitcoin.SelectParams('mainnet') bitcoin.params.DEFAULT_PORT = 9333 bitcoin.params.RPC_PORT = 9332 bitcoin.params.DNS_SEEDS = tuple() main("join", ["100", "100"])
def get_config(base_config): # configure_logger() # p = configargparse.getArgumentParser(default_config_files=[os.path.join(PATH, 'conf.ini'), # 'D:\PythonCode\cert-issuer\conf_me.ini']) # add_arguments(p) # parsed_config, _ = p.parse_known_args() # print("parsed_config", parsed_config) if not base_config["safe_mode"]: logging.warning( 'Your app is configured to skip the wifi check when the USB is plugged in. Read the ' 'documentation to ensure this is what you want, since this is less secure' ) # overwrite with enum base_config["chain"] = Chain.parse_from_chain(base_config["chain"]) # ensure it's a supported chain if base_config["chain"].blockchain_type != BlockchainType.bitcoin and \ base_config["chain"].blockchain_type != BlockchainType.ethereum and \ base_config["chain"].blockchain_type != BlockchainType.mock: raise UnknownChainError(base_config["chain"].name) logging.info('This run will try to issue on the %s chain', base_config["chain"].name) if base_config["chain"].blockchain_type == BlockchainType.bitcoin: bitcoin_chain_for_python_bitcoinlib = base_config["chain"] if base_config["chain"] == Chain.bitcoin_regtest: bitcoin_chain_for_python_bitcoinlib = Chain.bitcoin_regtest bitcoin.SelectParams( chain_to_bitcoin_network(bitcoin_chain_for_python_bitcoinlib)) global CONFIG CONFIG = base_config return base_config
def get_config(): p = configargparse.getArgumentParser(default_config_files=[ os.path.join(PATH, 'conf.ini'), '/etc/cert-issuer/conf.ini' ]) add_arguments(p) parsed_config, _ = p.parse_known_args() if not parsed_config.safe_mode: logging.warning( 'Your app is configured to skip the wifi check when the USB is plugged in. Read the ' 'documentation to ensure this is what you want, since this is less secure' ) # overwrite with enum parsed_config.bitcoin_chain = Chain.parse_from_chain( parsed_config.bitcoin_chain) if parsed_config.bitcoin_chain == Chain.mocknet or parsed_config.bitcoin_chain == Chain.regtest: parsed_config.bitcoin_chain_for_pycoin = Chain.testnet else: parsed_config.bitcoin_chain_for_pycoin = parsed_config.bitcoin_chain bitcoin.SelectParams(parsed_config.bitcoin_chain_for_pycoin.name) configure_logger() return parsed_config
def initialize(self): cwd = os.getcwd() p = configargparse.getArgumentParser( default_config_files=[os.path.join(cwd, 'conf.ini')]) self.add_arguments(p) args, _ = p.parse_known_args() # overwrite with enum args.chain = Chain.parse_from_chain(args.chain) # ensure it's a supported chain if args.chain.blockchain_type != BlockchainType.bitcoin and \ args.chain.blockchain_type != BlockchainType.ethereum and \ args.chain.blockchain_type != BlockchainType.mock: raise UnknownChainError(args.chain.name) logging.info('This run will try to issue on the %s chain', args.chain.name) if args.chain.blockchain_type == BlockchainType.bitcoin: bitcoin_chain_for_python_bitcoinlib = args.chain if args.chain == Chain.bitcoin_regtest: bitcoin_chain_for_python_bitcoinlib = Chain.bitcoin_regtest bitcoin.SelectParams( chain_to_bitcoin_network(bitcoin_chain_for_python_bitcoinlib)) self.config = args return self
def get_config(): configure_logger() #configure_logger 함수 호출 p = configargparse.getArgumentParser(default_config_files=[ os.path.join(PATH, 'conf.ini'), '/etc/cert-issuer/conf.ini' ]) add_arguments(p) parsed_config, _ = p.parse_known_args() if not parsed_config.safe_mode: logging.warning( 'Your app is configured to skip the wifi check when the USB is plugged in. Read the ' 'documentation to ensure this is what you want, since this is less secure' ) # overwrite with enum parsed_config.chain = Chain.parse_from_chain(parsed_config.chain) # ensure it's a supported chain if parsed_config.chain.blockchain_type != BlockchainType.bitcoin and \ parsed_config.chain.blockchain_type != BlockchainType.ethereum and \ parsed_config.chain.blockchain_type != BlockchainType.mock: raise UnknownChainError(parsed_config.chain.name) logging.info('This run will try to issue on the %s chain', parsed_config.chain.name) if parsed_config.chain.blockchain_type == BlockchainType.bitcoin: bitcoin_chain_for_python_bitcoinlib = parsed_config.chain if parsed_config.chain == Chain.bitcoin_regtest: bitcoin_chain_for_python_bitcoinlib = Chain.bitcoin_regtest bitcoin.SelectParams( chain_to_bitcoin_network(bitcoin_chain_for_python_bitcoinlib)) return parsed_config
def get_config(): p = configargparse.getArgumentParser(default_config_files=[ os.path.join(PATH, 'conf.ini'), '/etc/cert-issuer/conf.ini' ]) add_arguments(p) parsed_config, _ = p.parse_known_args() if not parsed_config.safe_mode: logging.warning( 'Your app is configured to skip the wifi check when the USB is plugged in. Read the ' 'documentation to ensure this is what you want, since this is less secure' ) if parsed_config.wallet_connector_type == 'bitcoind': bitcoin.SelectParams(parsed_config.bitcoin_chain) if parsed_config.bitcoin_chain == 'mainnet': parsed_config.netcode = 'BTC' else: parsed_config.netcode = 'XTN' configure_logger() set_fee_per_trx(parsed_config.tx_fee) set_satoshi_per_byte(parsed_config.satoshi_per_byte) set_min_per_output(parsed_config.dust_threshold) return parsed_config
def page_save_handler(sender, instance, created, **kwargs): if created: response = requests.get(instance.url) body = fromstring(response.content) instance.title = body.findtext('.//title') body.make_links_absolute(instance.url) content = tostring(body) html_file_dir = "%s/%s/%s" % (settings.MEDIA_ROOT, settings.HTML_FILES, instance.id) os.mkdir(html_file_dir) html_file_name = "%s/%s.html" % (html_file_dir, instance.id) args = ['--bitcoin-node=%s' % settings.BITCOIN_NODE, 'stamp'] if settings.BITCOIN_PARAMS == "testnet": args.insert(1, '--btc-testnet') with open(html_file_name, "a+b") as html_file: html_file.write(content) html_file.seek(0) stamp_command(html_file, args) bitcoin.SelectParams(settings.BITCOIN_PARAMS) proxy = bitcoin.rpc.Proxy(settings.BITCOIN_NODE) instance.address = str(proxy.getnewaddress()) instance.save()
def __init__(self, url, port, username="******", password="******"): bitcoin.SelectParams("regtest") # Init Bitcoin RPC url = "http://%s:%s@%s:%s" % (username, password, url, port) rpc_connection = AuthServiceProxy(url) self.connection = rpc_connection
def on_ready(): bitcoin.SelectParams("mainnet") # Decimalの計算:float禁止 getcontext().traps[FloatOperation] = True global syncher if syncher is not None: syncher.stop_sync() syncher = CWalletSyncher(DBNAME, dbaccessor, dblock)
def __init__(self, node, height, testnet, end_height, step): bitcoin.SelectParams('testnet' if testnet else 'mainnet') self._node = node self._connection = bitcoin.rpc.Proxy(service_url=self._node) self._startblock = height self._endblock = end_height self._current_block = self._startblock self._step = step
def main(): bitcoin.SelectParams('mainnet') # 用户私钥 & 用户P2PK锁定脚本 & 地址 & P2PKH锁定脚本 senderSeckey = CBitcoinSecret( 'L2XxuM4B7GiVFwWhtriLugfWxMAB8AAn63dpygovyczESzBK6p4o') senderP2PKScriptPubkey = CScript([senderSeckey.pub, OP_CHECKSIG]) senderP2PKHAddr = P2PKHBitcoinAddress.from_pubkey(senderSeckey.pub) senderP2PKHScriptPubkey = senderP2PKHAddr.to_scriptPubKey() # 商家私钥 & P2PK (非终结) & 地址 & P2PKH锁定脚本 receiverSeckey = CBitcoinSecret( 'KxbMqfhaN8NFXPCmHE4ZupJfBYRDj46iT1YxNqHrJcrpmaKMiL6C') receiverP2PKScriptPubkey = CScript([receiverSeckey.pub, OP_CHECKSIGVERIFY]) receiverP2PKHAddr = P2PKHBitcoinAddress.from_pubkey(receiverSeckey.pub) receiverP2PKHScriptPubkey = receiverP2PKHAddr.to_scriptPubKey() # 1. 商家 & 用户 签名了可以见证 # 2. 指定时间后 用户签名了可以见证 # if # servicePubkey checksigverify # else # [height] checklocktimeverify drop # endif # userPubkey checksig redeemScript = CScript( [OP_IF] + \ list(receiverP2PKScriptPubkey) + \ [OP_ELSE, 300, OP_CHECKLOCKTIMEVERIFY, OP_DROP, OP_ENDIF] + \ list(senderP2PKScriptPubkey), ) # p2sh 的锁定脚本 p2shScriptPubkey = redeemScript.to_p2sh_scriptPubKey() # p2sh 地址 p2shAddr = CBitcoinAddress.from_scriptPubKey(p2shScriptPubkey) print("redeemScript: {}".format(redeemScript.hex())) print("p2shAddr: {}".format(p2shAddr)) preOutPut = COutPoint( lx('79d7b818b6e1a99e2bbdb51263c3d552a25af19f35a1857faf174c0651e5243c'), 0) # 场景1: 超时后退还钱给用户 sense1(preOutPut, redeemScript, senderP2PKHScriptPubkey, senderSeckey) # 场景2: 商家和用户一起签名把钱给商家 sense2(preOutPut, receiverP2PKHScriptPubkey, receiverSeckey, redeemScript, senderSeckey) # 场景3: 用户和商家链下签名,最终商家链上结算 sense3(preOutPut, receiverP2PKHScriptPubkey, receiverSeckey, redeemScript, senderP2PKHScriptPubkey, senderSeckey)
def test_create_trx(self): bitcoin.SelectParams('testnet') b = h2b('8443b07464c762d7fb404ea918a5ac9b3618d5cd6a0c5ea6e4dd5d7bbe28b154') tx_input = Spendable(200, b'18eKkAWyU9kvRNHPKxnZb6wwtPMrNmRRRA', b, 0) tx_outs = [tx_utils.create_transaction_output('mgAqW5ZCnEp7fjvpj8RUL3WxsBy8rcDcCi', 0.0000275)] tx = tx_utils.create_trx('TEST'.encode('utf-8'), 3, 'mgAqW5ZCnEp7fjvpj8RUL3WxsBy8rcDcCi', tx_outs, [tx_input]) hextx = hexlify(tx.serialize()) self.assertEquals(hextx, '01000000018443b07464c762d7fb404ea918a5ac9b3618d5cd6a0c5ea6e4dd5d7bbe28b1540000000000ffffffff0300000000000000001976a914072a22e5913cd939904c46bbd0bc56755543384b88acc5000000000000001976a914072a22e5913cd939904c46bbd0bc56755543384b88ac0000000000000000066a045445535400000000')
def __init__(self): """Uncommon pattern, but a handy one. We setup everything when the wrapper is initialized.""" self.server = Flask(__name__) self.privkey = os.urandom(32) self.pubkey = CKey(self.privkey).pub # List of txids we already signed self.already_signed = [] bitcoin.SelectParams("regtest") self.setup_routes()
def test_auto_switch_params_decorator(network): if network.name == 'bitcoin': assert simple_params_name_return(network) == 'mainnet' elif network.name == 'test-bitcoin': assert simple_params_name_return(network) == 'testnet' else: assert simple_params_name_return(network) == network.name bitcoin.SelectParams('mainnet')
def btc_bech32_check(match: regex.Match): text = match.groupdict().get('valu') prefix, _ = text.split('1', 1) prefix = prefix.lower() if prefix == 'bc': bitcoin.SelectParams('mainnet') elif prefix == 'tb': bitcoin.SelectParams('testnet') elif prefix == 'bcrt': bitcoin.SelectParams('regtest') else: # pragma: no cover raise ValueError(f'Unknown prefix {text}') try: _ = bitcoin_b32.CBech32Data(text) except bitcoin_b32.Bech32Error: return None, {} # The proper form of a bech32 address is lowercased. We do not want to verify # a mixed case form, so lowercase it prior to returning. return ('btc', text.lower()), {}
def setup_bitcoin(): """Setup Bitcoin-related functionality Sets mainnet/testnet and returns a RPC proxy. """ if args.btc_net == 'testnet': bitcoin.SelectParams('testnet') elif args.btc_net == 'regtest': bitcoin.SelectParams('regtest') elif args.btc_net == 'mainnet': bitcoin.SelectParams('mainnet') else: assert False try: return bitcoin.rpc.Proxy(service_url=args.bitcoin_node) except Exception as exp: logging.error("Could not connect to Bitcoin node: %s" % exp) sys.exit(1)
def test_bitcoind_connector_spendables(self): bitcoin.SelectParams('testnet') bc = BitcoindConnector('XTN') spendables = bc.spendables_for_address('mz7poFND7hVGRtPWjiZizcCnjf6wEDWjjT') self.assertEquals(len(spendables), 3) self.assertEquals(b2h(spendables[0].tx_hash), '08f6528ac70c828e1633babc8f0d49ecb11649fd7451f76923821a0dbc81eb34') self.assertEquals(spendables[0].coin_value, 49000000) self.assertEquals(spendables[1].coin_value, 2750) self.assertEquals(spendables[2].coin_value, 2750)
def test_verify_transaction(self): bitcoin.SelectParams('testnet') b = h2b('8443b07464c762d7fb404ea918a5ac9b3618d5cd6a0c5ea6e4dd5d7bbe28b154') tx_input = Spendable(200, b'18eKkAWyU9kvRNHPKxnZb6wwtPMrNmRRRA', b, 0) tx_outs = [tx_utils.create_transaction_output('mgAqW5ZCnEp7fjvpj8RUL3WxsBy8rcDcCi', 0.0000275)] op_return_val = h2b('e9cee71ab932fde863338d08be4de9dfe39ea049bdafb342ce659ec5450b69ae') tx = tx_utils.create_trx(op_return_val, 3, 'mgAqW5ZCnEp7fjvpj8RUL3WxsBy8rcDcCi', tx_outs, [tx_input]) hextx = hexlify(tx.serialize()) tx_utils.verify_transaction(hextx, hexlify(op_return_val))
def verify_v1_2(certificate_json): # removing this check until we have caching for the schemas #try: # schema_validator.validate_v1_2(certificate_json) # logging.debug('The schema validates against v1.2 schema') #except Exception as e: # logging.error('The certificate did not comply with the Blockchain Certificate schema', e) # raise InvalidCertificateError('The certificate did not comply with the Blockchain Certificate schema', e) state = ProcessingStateV2(certificate_json['document'], certificate_json['receipt']) chain = parse_chain_from_address( certificate_json['document']['recipient']['publicKey']) connector = createTransactionLookupConnector(chain) bitcoin.SelectParams(chain.name) validate_receipt = ValidationGroup(steps=[ValidateReceipt()], name='Validate receipt') compute_hash = ValidationGroup( steps=[ComputeHashV2()], name='Computing SHA256 digest of local certificate', success_status=StepStatus.done) fetch_transaction = ValidationGroup( steps=[LookupTransactionId(), FetchTransaction(connector)], name='Fetch Bitcoin Transaction', success_status=StepStatus.done) compare_certificate_hash = ValidationGroup( steps=[CompareHashesV2()], name='Comparing local and merkle hashes') check_signature = ValidationGroup( steps=[FetchIssuerKeys(), CheckIssuerSignature()], name='Checking issuer signature') check_not_revoked = ValidationGroup( steps=[CheckNotRevoked(), CheckRecipientNotRevoked()], name='Checking not revoked by issuer') check_not_expired = ValidationGroup( steps=[CheckNotExpired()], name='Checking certificate has not expired') steps = [ validate_receipt, compute_hash, fetch_transaction, compare_certificate_hash, check_signature, check_not_revoked, check_not_expired ] all_steps = ValidationGroup(steps=steps, name='Validation') all_steps.execute(state) messages = [] all_steps.add_detailed_status(messages) for message in messages: print(message['name'] + ',' + str(message['status'])) return messages
def forge_prevtx( vouts: Sequence[Tuple[str, int]], network: str = "mainnet") -> Tuple[bytes, messages.TransactionType]: """ Forge a transaction with the given vouts. """ bitcoin.SelectParams(network) input = messages.TxInputType( prev_hash=b"\x00" * 32, prev_index=0xFFFFFFFF, script_sig=b"\x00", sequence=0xFFFFFFFF, ) outputs = [ messages.TxOutputBinType( amount=amount, script_pubkey=bytes(CBitcoinAddress(address).to_scriptPubKey()), ) for address, amount in vouts ] tx = messages.TransactionType( version=1, inputs=[input], bin_outputs=outputs, lock_time=0, ) cin = CTxIn( COutPoint(input.prev_hash, input.prev_index), CScript(input.script_sig), input.sequence, ) couts = [ CTxOut(output.amount, CScript(output.script_pubkey)) for output in tx.bin_outputs ] txhash = CTransaction([cin], couts, tx.lock_time, tx.version).GetTxid()[::-1] bitcoin.SelectParams("mainnet") return txhash, tx
def do_execute(self): if self.signing_key is None or self.content_to_verify is None or self.signature_value is None: return False message = BitcoinMessage(self.content_to_verify) try: lock.acquire() # obtain lock while modifying global state bitcoin.SelectParams(self.chain.name) return VerifyMessage(self.signing_key, message, self.signature_value) finally: lock.release()
def SelectParams(name): """Select the chain parameters to use name is one of 'mainnet', 'testnet', or 'regtest' Default chain is 'mainnet' """ global params if name == 'mainnet': bitcoin.SelectParams(name) params = bitcoin.params = MainParams() elif name == 'testnet': bitcoin.SelectParams(name) params = bitcoin.params = TestNetParams() elif name == 'regtest': bitcoin.SelectParams(name) params = bitcoin.params = RegTestParams() elif name == 'simnet': # Should be ok because 'regtest' and 'simnet' use the same magic. bitcoin.SelectParams('regtest') params = bitcoin.params = SimNetParams() else: raise ValueError('Unknown chain %r' % name)
def __init__(self, params, user_agent, inventory, subscriptions, bloom_filter, disconnect_cb, blockchain, download_listener): self.params = params self.user_agent = user_agent self.inventory = inventory self.subscriptions = subscriptions self.bloom_filter = bloom_filter self.cb = disconnect_cb self.protocol = None self.blockchain = blockchain self.download_listener = download_listener bitcoin.SelectParams(params) self.log = Logger(system=self)
def __init__(self, network='regtest', timeout=900): if network not in ['testnet', 'mainnet', 'regtest']: raise ValueError('Allowed networks are regtest, testnet, mainnet.') if not isinstance(timeout, int) or timeout < 1: raise ValueError('Timeout should be a positive integer.') logging.debug("NETWORK in proxy: {0}".format(network)) self.network = network self.timeout = timeout bitcoin.SelectParams(self.network) self.bitcoind = bitcoin.rpc.Proxy(timeout=self.timeout)
def prune_up_to(height: int, btc_conf_file: str, mode: str = 'testnet'): """Tell bitcoind to prune up to given block height (via RPC call). :param height: block height to prune to :param btc_conf_file: path to bitcoind config file :param mode: the target chain/network (mainnet / testnet / regtest) """ bitcoin.SelectParams(mode) proxy = bitcoin.rpc.Proxy(btc_conf_file=btc_conf_file) # TODO if fails, shows meaningful error message? (that user needs to turn on prune, e.g.) proxy.call('pruneblockchain', height)
def get_config(): global parsed_config if parsed_config: return parsed_config parsed_config, _ = parse_args() # populate data and archive subdirs parsed_config.unsigned_certs_file_part = 'unsigned_certs/*.json' parsed_config.signed_certs_file_part = 'signed_certs/*.json' parsed_config.txs_file_part = 'sent_txs/*.txt' parsed_config.receipts_file_part = 'receipts/*.json' parsed_config.blockchain_certificates_file_part = 'blockchain_certificates/*.json' parsed_config.unsigned_certs_file_pattern = str( os.path.join(parsed_config.data_path, parsed_config.unsigned_certs_file_part)) parsed_config.signed_certs_file_pattern = os.path.join( parsed_config.data_path, parsed_config.signed_certs_file_part) parsed_config.hashed_certs_file_pattern = os.path.join( parsed_config.data_path, 'hashed_certs/*.txt') parsed_config.unsigned_txs_file_pattern = os.path.join( parsed_config.data_path, 'unsigned_txs/*.txt') parsed_config.signed_txs_file_pattern = os.path.join( parsed_config.data_path, 'signed_txs/*.txt') parsed_config.sent_txs_file_pattern = os.path.join( parsed_config.data_path, parsed_config.txs_file_part) parsed_config.receipts_file_pattern = os.path.join( parsed_config.data_path, parsed_config.receipts_file_part) parsed_config.blockchain_certificates_file_pattern = os.path.join( parsed_config.data_path, parsed_config.blockchain_certificates_file_part) parsed_config.tree_file_pattern = os.path.join(parsed_config.data_path, 'tree/*.json') if not parsed_config.safe_mode: logging.warning( 'Your app is configured to skip the wifi check when the USB is plugged in. Read the ' 'documentation to ensure this is what you want, since this is less secure' ) if parsed_config.wallet_connector_type == 'bitcoind': bitcoin.SelectParams(parsed_config.bitcoin_chain) if parsed_config.bitcoin_chain == 'mainnet': parsed_config.netcode = 'BTC' else: parsed_config.netcode = 'XTN' configure_logger() return parsed_config