def do_show_seed(self, args):
if not self.seed:
raise Exception("show seed xpub: Load or generate a seed first")
master_xpriv = self.seed.as_HD_root()
master_xpub = bitcoin.bip32_privtopub(master_xpriv)
encrypted_customer_seed = seedlib.encrypt(
self.seed.bin_seed(), self.stretched_master.bin_seed())
encrypted_mnemonic = seedlib.mnemonic.to_mnemonic(
encrypted_customer_seed)
print "Seed fingerprint :", self.seed.fingerprint()
print "Seed mnemonic :", seedlib.mnemonic.to_mnemonic(
self.seed.bin_seed())
print "Encrypted mnemonic :", encrypted_mnemonic
print "Master xpub :", master_xpub
print "0H xpub :", bitcoin.bip32_privtopub(
seedlib.bip32_child(master_xpriv, "0H"))
print "0H/0 xpub :", bitcoin.bip32_privtopub(
seedlib.bip32_child(master_xpriv, "0H/0"))
print "44H/0H/0H/0/0 xpub :", bitcoin.bip32_privtopub(
seedlib.bip32_child(master_xpriv, "44H/0H/0H/0/0"))
if args:
print "{0} xpub : {1}".format(
args,
bitcoin.bip32_privtopub(seedlib.bip32_child(
master_xpriv, args)))
def _derive_and_print(master_key: str,
*path: int,
derive_pub_key: bool = True,
magicbyte: int = 0):
master_pub_key = bitcoin.bip32_privtopub(master_key)
derived_key = _derived_key(master_key, *path)
if derive_pub_key:
derived_bip32_pub_key = _derived_key(master_pub_key, *path)
derived_pub_key = bitcoin.bip32_extract_key(derived_bip32_pub_key)
else:
derived_bip32_pub_key = derived_pub_key = 'N.A.'
derived_pub_key_from_key = bitcoin.bip32_privtopub(derived_key)
print(''' Derivation path: ({}),
Derived BIP32 key: {},
Derived BIP32 public key: {},
BIP32 public key from derived BIP32 private: {},
Derived key: {},
Derived public key: {},
Public key from derived key: {},
BTC address: {}
'''.format(
', '.join(
str(x) if x <= 2**31 else str(x - 2**31) + '\'' for x in path),
derived_key, derived_bip32_pub_key, derived_pub_key_from_key,
bitcoin.bip32_extract_key(derived_key), derived_pub_key,
bitcoin.privtopub(bitcoin.bip32_extract_key(derived_key)),
bitcoin.pubtoaddr(bitcoin.privtopub(
bitcoin.bip32_extract_key(derived_key)),
magicbyte=magicbyte)))
def showDetails(mnemonic, passphrase="", i=1):
myMnemonic = mnemonic
passphrase = passphrase
mnemo = Mnemonic('english')
seed = hexlify(mnemo.to_seed(myMnemonic, passphrase=passphrase))
print 'Seed:\t\t\t\t', seed
priv = bitcoin.bip32_master_key(unhexlify(seed))
print 'Xpriv:\t\t\t\t', priv
key = bitcoin.encode_privkey(bitcoin.bip32_extract_key(priv),
'wif_compressed')
print 'Key:\t\t\t\t', key
pub = bitcoin.bip32_privtopub(priv)
print 'Derived public key:\t', pub
pubHex = bitcoin.bip32_extract_key(pub)
print 'public key (hex):\t', pubHex
print 'Master Key address:\t', bitcoin.pubtoaddr(pubHex)
print ""
print "TREZOR Keys:"
account = 0
derivedPrivateKey = bitcoin.bip32_ckd(
bitcoin.bip32_ckd(bitcoin.bip32_ckd(priv, 44 + HARDENED), HARDENED),
HARDENED + account)
print 'Derived private key:', derivedPrivateKey
privateKey = bitcoin.encode_privkey(
bitcoin.bip32_extract_key(derivedPrivateKey), 'wif_compressed')
print 'private key (wif):\t', privateKey
derivedPublicKey = bitcoin.bip32_privtopub(derivedPrivateKey)
print 'Derived public key:', derivedPublicKey
publicKeyHex = bitcoin.privtopub(privateKey)
print 'public key (hex):\t', publicKeyHex
address = bitcoin.pubtoaddr(publicKeyHex)
print 'address:\t\t\t', address
print ""
print "Account public keys (XPUB)"
xpubs = []
for i in range(0, i):
derivedPrivateKey = bitcoin.bip32_ckd(
bitcoin.bip32_ckd(bitcoin.bip32_ckd(priv, 44 + HARDENED),
HARDENED), HARDENED + i)
xpub = bitcoin.bip32_privtopub(derivedPrivateKey)
print 'Account', i, 'xpub:', xpub
xpubs.append(xpub)
return xpubs
def pubkey(args):
master_key = get_master_key()
if args.root or (args.account and args.account < 0):
#print("The following is your master root extended public key:")
print(bitcoin.bip32_privtopub(master_key))
else:
account_privkey = bitcoin.hd_lookup(master_key, account = args.account)
#print("The following is the extended public key for account #%d:" % (args.account))
print(bitcoin.bip32_privtopub(account_privkey))
def pubkey(args):
master_key = get_master_key()
if (args.root or (args.account and args.account < 0)):
#print("The following is your master root extended public key:")
print(bitcoin.bip32_privtopub(master_key))
else:
account_privkey = bitcoin.hd_lookup(master_key, account=args.account)
#print("The following is the extended public key for account #%d:" % (args.account))
print(bitcoin.bip32_privtopub(account_privkey))
def showDetails(mnemonic, passphrase="", i=1):
myMnemonic = mnemonic
passphrase = passphrase
mnemo = Mnemonic('english')
seed = hexlify(mnemo.to_seed(myMnemonic, passphrase=passphrase))
print 'Seed:\t\t\t\t', seed
priv = bitcoin.bip32_master_key(unhexlify(seed))
print 'Xpriv:\t\t\t\t', priv
key = bitcoin.encode_privkey(bitcoin.bip32_extract_key(priv), 'wif_compressed')
print 'Key:\t\t\t\t', key
pub = bitcoin.bip32_privtopub(priv)
print 'Derived public key:\t', pub
pubHex = bitcoin.bip32_extract_key(pub)
print 'public key (hex):\t', pubHex
print 'Master Key address:\t', bitcoin.pubtoaddr(pubHex)
print ""
print "TREZOR Keys:"
account = 0
derivedPrivateKey = bitcoin.bip32_ckd(bitcoin.bip32_ckd(bitcoin.bip32_ckd(priv, 44+HARDENED), HARDENED), HARDENED+account)
print 'Derived private key:', derivedPrivateKey
privateKey = bitcoin.encode_privkey(bitcoin.bip32_extract_key(derivedPrivateKey), 'wif_compressed')
print 'private key (wif):\t', privateKey
derivedPublicKey = bitcoin.bip32_privtopub(derivedPrivateKey)
print 'Derived public key:', derivedPublicKey
publicKeyHex = bitcoin.privtopub(privateKey)
print 'public key (hex):\t', publicKeyHex
address = bitcoin.pubtoaddr(publicKeyHex)
print 'address:\t\t\t', address
print ""
print "Account public keys (XPUB)"
xpubs = []
for i in range(0, i):
derivedPrivateKey = bitcoin.bip32_ckd(bitcoin.bip32_ckd(bitcoin.bip32_ckd(priv, 44+HARDENED), HARDENED), HARDENED+i)
xpub = bitcoin.bip32_privtopub(derivedPrivateKey)
print 'Account', i, 'xpub:', xpub
xpubs.append(xpub)
return xpubs
def _generate_new_keypair(self):
seed = str(random.randrange(2 ** 256))
# Deprecated (pre-BIP32)
# self.secret = hashlib.sha256(secret).hexdigest()
# self.pubkey = privkey_to_pubkey(self.secret)
# self.log.debug('Keys %s %s', self.secret, self.pubkey)
# Move to BIP32 keys m/0/0/0
wallet = bitcoin.bip32_ckd(bitcoin.bip32_master_key(seed), 0)
wallet_chain = bitcoin.bip32_ckd(wallet, 0)
bip32_identity_priv = bitcoin.bip32_ckd(wallet_chain, 0)
identity_priv = bitcoin.bip32_extract_key(bip32_identity_priv)
bip32_identity_pub = bitcoin.bip32_privtopub(bip32_identity_priv)
identity_pub = bitcoin.encode_pubkey(bitcoin.bip32_extract_key(bip32_identity_pub), 'hex')
self.pubkey = identity_pub
self.secret = identity_priv
new_settings = {
"secret": self.secret,
"pubkey": self.pubkey,
"bip32_seed": seed
}
self.db_connection.update_entries("settings", new_settings, {"market_id": self.market_id})
self.settings.update(new_settings)
def create_keychain(self):
"""
The guid generation can take a while. While it's doing that we will
open a port to allow a UI to connect and listen for generation to
complete.
"""
print "Generating GUID, this may take a few minutes..."
d = Deferred()
api = GUIDGenerationListener(d)
site = Site(api, timeout=None)
connector = reactor.listenTCP(18470, site, interface="127.0.0.1")
start = time.time()
g = GUID()
d.callback((round(time.time() - start, 2), connector))
self.guid = g.guid
self.guid_privkey = g.privkey
self.signing_key = nacl.signing.SigningKey(self.guid_privkey)
self.guid_signed_pubkey = g.signed_pubkey
self.db.set_key("guid", self.guid_privkey, self.guid_signed_pubkey)
self.bitcoin_master_privkey = bitcoin.bip32_master_key(bitcoin.sha256(self.guid_privkey))
self.bitcoin_master_pubkey = bitcoin.bip32_privtopub(self.bitcoin_master_privkey)
self.db.set_key("bitcoin", self.bitcoin_master_privkey, self.bitcoin_master_pubkey)
self.encryption_key = PrivateKey(self.guid_privkey)
self.encryption_pubkey = self.encryption_key.public_key.encode()
def _generate_new_keypair(self):
seed = str(random.randrange(2**256))
# Deprecated (pre-BIP32)
# self.secret = hashlib.sha256(secret).hexdigest()
# self.pubkey = privkey_to_pubkey(self.secret)
# self.log.debug('Keys %s %s', self.secret, self.pubkey)
# Move to BIP32 keys m/0/0/0
wallet = bitcoin.bip32_ckd(bitcoin.bip32_master_key(seed), 0)
wallet_chain = bitcoin.bip32_ckd(wallet, 0)
bip32_identity_priv = bitcoin.bip32_ckd(wallet_chain, 0)
identity_priv = bitcoin.bip32_extract_key(bip32_identity_priv)
bip32_identity_pub = bitcoin.bip32_privtopub(bip32_identity_priv)
identity_pub = bitcoin.encode_pubkey(
bitcoin.bip32_extract_key(bip32_identity_pub), 'hex')
self.pubkey = identity_pub
self.secret = identity_priv
new_settings = {
"secret": self.secret,
"pubkey": self.pubkey,
"bip32_seed": seed
}
self.db_connection.update_entries("settings", new_settings,
{"market_id": self.market_id})
self.settings.update(new_settings)
def create_keychain(self):
"""
The guid generation can take a while. While it's doing that we will
open a port to allow a UI to connect and listen for generation to
complete.
"""
print "Generating GUID, this may take a few minutes..."
d = Deferred()
api = GUIDGenerationListener(d)
site = Site(api, timeout=None)
connector = reactor.listenTCP(18470, site, interface="127.0.0.1")
start = time.time()
g = GUID()
d.callback((round(time.time() - start, 2), connector))
self.guid = g.guid
self.guid_privkey = g.privkey
self.signing_key = nacl.signing.SigningKey(self.guid_privkey)
self.guid_signed_pubkey = g.signed_pubkey
self.db.set_key("guid", self.guid_privkey, self.guid_signed_pubkey)
self.bitcoin_master_privkey = bitcoin.bip32_master_key(
bitcoin.sha256(self.guid_privkey))
self.bitcoin_master_pubkey = bitcoin.bip32_privtopub(
self.bitcoin_master_privkey)
self.db.set_key("bitcoin", self.bitcoin_master_privkey,
self.bitcoin_master_pubkey)
self.encryption_key = PrivateKey(self.guid_privkey)
self.encryption_pubkey = self.encryption_key.public_key.encode()
def test_bip32_vector(vector):
master = btc.bip32_master_key(vector['seed'])
assert master == vector['keys'][0][0], 'failed: master xpriv'
masterpub = btc.bip32_privtopub(master)
assert masterpub == vector['keys'][0][1], 'failed: master xpub'
currentkey = master
for i in range(1, len(vector['depths'])):
currentkey = btc.bip32_ckd(currentkey, vector['depths'][i])
print currentkey
print vector['keys'][i][0]
assert currentkey == vector['keys'][i][
0], 'failed: child priv key, should be: ' + vector['keys'][i][0]
pub = btc.bip32_privtopub(currentkey)
print pub
print vector['keys'][i][1]
assert pub == vector['keys'][i][
1], 'failed: child pub key, should be: ' + vector['keys'][i][1]
def do_show_seed(self, args):
if not self.seed:
raise Exception("show seed xpub: Load or generate a seed first")
master_xpriv = self.seed.as_HD_root()
master_xpub = bitcoin.bip32_privtopub(master_xpriv)
encrypted_customer_seed = seedlib.encrypt(self.seed.bin_seed(), self.stretched_master.bin_seed())
encrypted_mnemonic = seedlib.mnemonic.to_mnemonic(encrypted_customer_seed)
print "Seed fingerprint :", self.seed.fingerprint()
print "Seed mnemonic :", seedlib.mnemonic.to_mnemonic(self.seed.bin_seed())
print "Encrypted mnemonic :", encrypted_mnemonic
print "Master xpub :", master_xpub
print "0H xpub :", bitcoin.bip32_privtopub(seedlib.bip32_child(master_xpriv, "0H"))
print "0H/0 xpub :", bitcoin.bip32_privtopub(seedlib.bip32_child(master_xpriv, "0H/0"))
print "44H/0H/0H/0/0 xpub :", bitcoin.bip32_privtopub(seedlib.bip32_child(master_xpriv, "44H/0H/0H/0/0"))
if args:
print "{0} xpub : {1}".format(args,bitcoin.bip32_privtopub(seedlib.bip32_child(master_xpriv, args)))
def key_address(masterkey, path):
"""Compute address and private key (hex) for path"""
derived_key = descend(masterkey, path)
priv_key = btc.bip32_deserialize(derived_key)[-1]
pub_key = btc.bip32_extract_key(btc.bip32_privtopub(derived_key))
priv_key_hex = btc.encode_privkey(
btc.decode_privkey(priv_key, 'bin_compressed'), 'hex')
address = btc.pubkey_to_address(pub_key)
return priv_key_hex, address
def create_keychain(self):
print "Generating GUID, stand by..."
g = GUID()
self.guid = g.guid
self.guid_privkey = g.privkey
self.signing_key = nacl.signing.SigningKey(self.guid_privkey)
self.guid_signed_pubkey = g.signed_pubkey
self.db.set_key("guid", self.guid_privkey, self.guid_signed_pubkey)
self.bitcoin_master_privkey = bitcoin.bip32_master_key(bitcoin.sha256(self.guid_privkey))
self.bitcoin_master_pubkey = bitcoin.bip32_privtopub(self.bitcoin_master_privkey)
self.db.set_key("bitcoin", self.bitcoin_master_privkey, self.bitcoin_master_pubkey)
self.encryption_key = PrivateKey(self.guid_privkey)
self.encryption_pubkey = self.encryption_key.public_key.encode()
def sign(args):
master_key = get_master_key()
input_transaction = json.load(args.input_file)
privs = input_transaction['keys']
tx = input_transaction['tx']
for k, p in privs.items():
pstr = bitcoin.bip32_path_from_string(p['path'])
xpubk = p['m']
a = 0
priv_key = bitcoin.hd_lookup(master_key, account=a)
while (bitcoin.bip32_privtopub(priv_key) != xpubk):
priv_key = bitcoin.hd_lookup(master_key, account=a)
a += 1
privs[k] = bitcoin.bip32_descend(priv_key, pstr[0], pstr[1])
print(bitcoin.signall(str(tx), privs))
def sign(args):
master_key = get_master_key()
input_transaction = json.load(args.input_file)
privs = input_transaction['keys']
tx = input_transaction['tx']
for k, p in privs.items():
pstr = bitcoin.bip32_path_from_string(p['path'])
xpubk = p['m']
a = 0
priv_key = bitcoin.hd_lookup(master_key, account = a)
while bitcoin.bip32_privtopub(priv_key) != xpubk:
priv_key = bitcoin.hd_lookup(master_key, account = a)
a += 1
privs[k] = bitcoin.bip32_descend(priv_key, pstr[0], pstr[1])
print(bitcoin.signall(str(tx), privs))
def create_keychain(self):
print "Generating GUID, stand by..."
g = GUID()
self.guid = g.guid
self.guid_privkey = g.privkey
self.signing_key = nacl.signing.SigningKey(self.guid_privkey)
self.guid_signed_pubkey = g.signed_pubkey
self.db.set_key("guid", self.guid_privkey, self.guid_signed_pubkey)
self.bitcoin_master_privkey = bitcoin.bip32_master_key(
bitcoin.sha256(self.guid_privkey))
self.bitcoin_master_pubkey = bitcoin.bip32_privtopub(
self.bitcoin_master_privkey)
self.db.set_key("bitcoin", self.bitcoin_master_privkey,
self.bitcoin_master_pubkey)
self.encryption_key = PrivateKey(self.guid_privkey)
self.encryption_pubkey = self.encryption_key.public_key.encode()
def getTrezorXPUBKeys(mnemonic, passphrase="", i=1):
myMnemonic = mnemonic
passphrase = passphrase
mnemo = Mnemonic('english')
seed = hexlify(mnemo.to_seed(myMnemonic, passphrase=passphrase))
priv = bitcoin.bip32_master_key(unhexlify(seed))
account = 0
derivedPrivateKey = bitcoin.bip32_ckd(bitcoin.bip32_ckd(bitcoin.bip32_ckd(priv, 44+HARDENED), HARDENED), HARDENED+account)
xpubs = []
for i in range(0, i):
derivedPrivateKey = bitcoin.bip32_ckd(bitcoin.bip32_ckd(bitcoin.bip32_ckd(priv, 44+HARDENED), HARDENED), HARDENED+i)
xpub = bitcoin.bip32_privtopub(derivedPrivateKey)
xpubs.append(xpub)
return xpubs
def _generate_new_keypair(self):
seed = str(random.randrange(2**256))
# Deprecated (pre-BIP32)
# self.secret = hashlib.sha256(secret).hexdigest()
# self.pubkey = privkey_to_pubkey(self.secret)
# self.log.debug('Keys %s %s', self.secret, self.pubkey)
# Move to BIP32 keys m/0/0/0
wallet = bitcoin.bip32_ckd(bitcoin.bip32_master_key(seed), 0)
wallet_chain = bitcoin.bip32_ckd(wallet, 0)
bip32_identity_priv = bitcoin.bip32_ckd(wallet_chain, 0)
identity_priv = bitcoin.bip32_extract_key(bip32_identity_priv)
bip32_identity_pub = bitcoin.bip32_privtopub(bip32_identity_priv)
identity_pub = bitcoin.encode_pubkey(
bitcoin.bip32_extract_key(bip32_identity_pub), 'hex')
self.pubkey = identity_pub
self.secret = identity_priv
# Generate SIN
sha_hash = hashlib.sha256()
sha_hash.update(self.pubkey)
ripe_hash = hashlib.new('ripemd160')
ripe_hash.update(sha_hash.digest())
self.guid = ripe_hash.hexdigest()
self.sin = obelisk.EncodeBase58Check('\x0F\x02%s' % ripe_hash.digest())
newsettings = {
"secret": self.secret,
"pubkey": self.pubkey,
"guid": self.guid,
"sin": self.sin,
"bip32_seed": seed
}
self.db_connection.update_entries("settings", newsettings,
{"market_id": self.market_id})
self.settings.update(newsettings)
def generate_new_pubkey(self, contract_id):
self.log.debug('Generating new pubkey for contract')
# Retrieve next key id from DB
next_key_id = len(
self.db_connection.select_entries("keystore",
select_fields="id")) + 1
# Store updated key in DB
self.db_connection.insert_entry("keystore",
{'contract_id': contract_id})
# Generate new child key (m/1/0/n)
wallet = bitcoin.bip32_ckd(
bitcoin.bip32_master_key(self.settings.get('bip32_seed')), 1)
wallet_chain = bitcoin.bip32_ckd(wallet, 0)
bip32_identity_priv = bitcoin.bip32_ckd(wallet_chain, next_key_id)
bip32_identity_pub = bitcoin.bip32_privtopub(bip32_identity_priv)
pubkey = bitcoin.encode_pubkey(
bitcoin.bip32_extract_key(bip32_identity_pub), 'hex')
return pubkey
def generate_new_pubkey(self, contract_id):
self.log.debug('Generating new pubkey for contract')
# Retrieve next key id from DB
next_key_id = len(self.db_connection.select_entries("keystore", select_fields="id")) + 1
# Store updated key in DB
self.db_connection.insert_entry(
"keystore",
{
'contract_id': contract_id
}
)
# Generate new child key (m/1/0/n)
wallet = bitcoin.bip32_ckd(bitcoin.bip32_master_key(self.settings.get('bip32_seed')), 1)
wallet_chain = bitcoin.bip32_ckd(wallet, 0)
bip32_identity_priv = bitcoin.bip32_ckd(wallet_chain, next_key_id)
bip32_identity_pub = bitcoin.bip32_privtopub(bip32_identity_priv)
pubkey = bitcoin.encode_pubkey(bitcoin.bip32_extract_key(bip32_identity_pub), 'hex')
return pubkey
def _generate_new_keypair(self):
seed = str(random.randrange(2 ** 256))
# Deprecated (pre-BIP32)
# self.secret = hashlib.sha256(secret).hexdigest()
# self.pubkey = privkey_to_pubkey(self.secret)
# self.log.debug('Keys %s %s', self.secret, self.pubkey)
# Move to BIP32 keys m/0/0/0
wallet = bitcoin.bip32_ckd(bitcoin.bip32_master_key(seed), 0)
wallet_chain = bitcoin.bip32_ckd(wallet, 0)
bip32_identity_priv = bitcoin.bip32_ckd(wallet_chain, 0)
identity_priv = bitcoin.bip32_extract_key(bip32_identity_priv)
bip32_identity_pub = bitcoin.bip32_privtopub(bip32_identity_priv)
identity_pub = bitcoin.encode_pubkey(bitcoin.bip32_extract_key(bip32_identity_pub), 'hex')
self.pubkey = identity_pub
self.secret = identity_priv
# Generate SIN
sha_hash = hashlib.sha256()
sha_hash.update(self.pubkey)
ripe_hash = hashlib.new('ripemd160')
ripe_hash.update(sha_hash.digest())
self.guid = ripe_hash.hexdigest()
self.sin = obelisk.EncodeBase58Check('\x0F\x02%s' % ripe_hash.digest())
newsettings = {
"secret": self.secret,
"pubkey": self.pubkey,
"guid": self.guid,
"sin": self.sin,
"bip32_seed": seed
}
self.db_connection.update_entries("settings", newsettings, {"market_id": self.market_id})
self.settings.update(newsettings)
def get_extended_public_key(account_key):
return bitcoin.bip32_privtopub(account_key)
print(json.dumps(unsp, indent=4))
sys.exit(0)
if method == 'display' or method == 'displayall' or method == 'summary':
def cus_print(s):
if method != 'summary':
print(s)
total_balance = 0
for m in range(wallet.max_mix_depth):
cus_print('mixing depth %d m/0/%d/' % (m, m))
balance_depth = 0
for forchange in [0, 1]:
if forchange == 0:
xpub_key = btc.bip32_privtopub(wallet.keys[m][forchange])
else:
xpub_key = ''
cus_print(' ' + ('external' if forchange == 0 else 'internal') +
' addresses m/0/%d/%d' % (m, forchange) + ' ' + xpub_key)
for k in range(wallet.index[m][forchange] + options.gaplimit):
addr = wallet.get_addr(m, forchange, k)
balance = 0.0
for addrvalue in wallet.unspent.values():
if addr == addrvalue['address']:
balance += addrvalue['value']
balance_depth += balance
used = ('used' if k < wallet.index[m][forchange] else ' new')
if options.showprivkey:
privkey = btc.wif_compressed_privkey(
jm_single().config.set('POLICY','listunspent_args', '[0]')
jm_single().bc_interface.sync_wallet(wallet)
if method == 'display' or method == 'displayall' or method == 'summary':
def cus_print(s):
if method != 'summary':
print(s)
total_balance = 0
for m in range(wallet.max_mix_depth):
cus_print('mixing depth %d m/0/%d/' % (m, m))
balance_depth = 0
for forchange in [0, 1]:
if forchange == 0:
xpub_key = btc.bip32_privtopub(wallet.keys[m][forchange])
else:
xpub_key = ''
cus_print(' ' + ('external' if forchange == 0 else 'internal') +
' addresses m/0/%d/%d' % (m, forchange) + ' ' + xpub_key)
for k in range(wallet.index[m][forchange] + options.gaplimit):
addr = wallet.get_addr(m, forchange, k)
balance = 0.0
for addrvalue in wallet.unspent.values():
if addr == addrvalue['address']:
balance += addrvalue['value']
balance_depth += balance
used = ('used' if k < wallet.index[m][forchange] else ' new')
if options.showprivkey:
if btc.secp_present:
if method not in noscan_methods:
# if nothing was configured, we override bitcoind's options so that
# unconfirmed balance is included in the wallet display by default
if 'listunspent_args' not in jm_single().config.options('POLICY'):
jm_single().config.set('POLICY', 'listunspent_args', '[0]')
jm_single().bc_interface.sync_wallet(wallet)
if method == 'display' or method == 'displayall' or method == 'summary':
def cus_print(s):
if method != 'summary':
print(s)
if options.showxpub:
cus_print('wallet xpub: %s\n' %
(btc.bip32_privtopub(wallet.master_key)))
total_balance = 0
rows = []
for m in range(wallet.max_mix_depth):
cus_print('mixing depth %d m/0/%d/' % (m, m))
if options.showxpub:
cus_print(' xpub: %s\n' %
(btc.bip32_privtopub(wallet.mixing_depth_keys[m])))
balance_depth = 0
for forchange in [0, 1]:
cus_print(' ' + ('external' if forchange == 0 else 'internal') +
' addresses m/0/%d/%d' % (m, forchange))
trows = []
for k in range(wallet.index[m][forchange] + options.gaplimit):
sys.exit(0)
if method not in noscan_methods:
# if nothing was configured, we override bitcoind's options so that
# unconfirmed balance is included in the wallet display by default
if 'listunspent_args' not in jm_single().config.options('POLICY'):
jm_single().config.set('POLICY','listunspent_args', '[0]')
jm_single().bc_interface.sync_wallet(wallet)
if method == 'display' or method == 'displayall' or method == 'summary':
def cus_print(s):
if method != 'summary':
print(s)
if options.showxpub:
cus_print('wallet xpub: %s\n' % (btc.bip32_privtopub(wallet.master_key)))
total_balance = 0
rows = []
for m in range(wallet.max_mix_depth):
cus_print('mixing depth %d m/0/%d/' % (m, m))
if options.showxpub:
cus_print(' xpub: %s\n' % (btc.bip32_privtopub(wallet.mixing_depth_keys[m])))
balance_depth = 0
for forchange in [0, 1]:
cus_print(' ' + ('external' if forchange == 0 else 'internal') +
' addresses m/0/%d/%d' % (m, forchange) )
trows = []
for k in range(wallet.index[m][forchange] + options.gaplimit):
addr = wallet.get_addr(m, forchange, k)
def getxpub(args):
print(bitcoin.bip32_privtopub(_get_xprv(args)))
def get_extended_public_key( account_key ):
return bitcoin.bip32_privtopub( account_key )
