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
