async def get_address(ctx, msg):
keychain = await seed.get_keychain(ctx)
await paths.validate_path(ctx, validate_full_path, keychain, msg.address_n,
CURVE)
try:
address, _ = derive_address_and_node(keychain, msg.address_n)
except ValueError as e:
if __debug__:
log.exception(__name__, e)
raise wire.ProcessError("Deriving address failed")
if msg.show_display:
desc = address_n_to_str(msg.address_n)
while True:
if await show_address(ctx, address, desc=desc):
break
if await show_qr(ctx, address, desc=desc):
break
return CardanoAddress(address=address)
async def get_address(ctx, msg, keychain):
await paths.validate_path(ctx, misc.validate_full_path, keychain,
msg.address_n, CURVE)
creds = misc.get_creds(keychain, msg.address_n, msg.network_type)
addr = creds.address
if msg.payment_id:
if len(msg.payment_id) != 8:
raise ValueError("Invalid payment ID length")
addr = addresses.encode_addr(
net_version(msg.network_type, False, True),
crypto.encodepoint(creds.spend_key_public),
crypto.encodepoint(creds.view_key_public),
msg.payment_id,
)
if msg.account or msg.minor:
if msg.payment_id:
raise ValueError("Subaddress cannot be integrated")
pub_spend, pub_view = monero.generate_sub_address_keys(
creds.view_key_private, creds.spend_key_public, msg.account,
msg.minor)
addr = addresses.encode_addr(
net_version(msg.network_type, True, False),
crypto.encodepoint(pub_spend),
crypto.encodepoint(pub_view),
)
if msg.show_display:
desc = address_n_to_str(msg.address_n)
while True:
if await confirms.show_address(ctx, addr.decode(), desc=desc):
break
if await show_qr(ctx, "monero:" + addr.decode(), desc=desc):
break
return MoneroAddress(address=addr)
async def confirm_certificate(ctx: wire.Context,
certificate: CardanoTxCertificateType) -> None:
# stake pool registration requires custom confirmation logic not covered
# in this call
assert certificate.type != CardanoCertificateType.STAKE_POOL_REGISTRATION
pages = []
page1 = Text("Confirm transaction", ui.ICON_SEND, ui.GREEN)
page1.normal("Confirm:")
page1.bold(CERTIFICATE_TYPE_NAMES[certificate.type])
page1.normal("for account:")
page1.bold(address_n_to_str(to_account_path(certificate.path)))
pages.append(page1)
if certificate.type == CardanoCertificateType.STAKE_DELEGATION:
page2 = Text("Confirm transaction", ui.ICON_SEND, ui.GREEN)
page2.normal("to pool:")
page2.bold(hexlify(certificate.pool).decode())
pages.append(page2)
await require_confirm(ctx, Paginated(pages))
async def get_address(ctx, msg, keychain):
await paths.validate_path(ctx, validate_full_path, path=msg.address_n)
node = keychain.derive(msg.address_n)
seckey = node.private_key()
public_key = secp256k1.publickey(seckey, False) # uncompressed
address = sha3_256(public_key[1:], keccak=True).digest()[12:]
if msg.show_display:
if len(msg.address_n) > 1: # path has slip44 network identifier
network = networks.by_slip44(msg.address_n[1] & 0x7FFFFFFF)
else:
network = None
hex_addr = ethereum_address_hex(address, network)
desc = address_n_to_str(msg.address_n)
while True:
if await show_address(ctx, hex_addr, desc=desc):
break
if await show_qr(ctx, hex_addr, desc=desc):
break
return EthereumAddress(address=address)
async def get_address(ctx, msg):
network = validate_network(msg.network)
await validate_path(ctx,
check_path,
path=msg.address_n,
network=msg.network)
node = await seed.derive_node(ctx, msg.address_n, NEM_CURVE)
address = node.nem_address(network)
if msg.show_display:
desc = address_n_to_str(msg.address_n)
while True:
if await show_address(ctx,
address,
desc=desc,
network=get_network_str(network)):
break
if await show_qr(ctx, address.upper(), desc=desc):
break
return NEMAddress(address=address)
async def get_address(ctx, msg, keychain):
coin_name = msg.coin_name or "Bitcoin"
coin = coins.by_name(coin_name)
await validate_path(
ctx,
addresses.validate_full_path,
keychain,
msg.address_n,
coin.curve_name,
coin=coin,
script_type=msg.script_type,
)
node = keychain.derive(msg.address_n, coin.curve_name)
address = addresses.get_address(msg.script_type, coin, node, msg.multisig)
address_short = addresses.address_short(coin, address)
if msg.script_type == InputScriptType.SPENDWITNESS:
address_qr = address.upper() # bech32 address
elif coin.cashaddr_prefix is not None:
address_qr = address.upper() # cashaddr address
else:
address_qr = address # base58 address
if msg.show_display:
if msg.multisig:
desc = "Multisig %d of %d" % (msg.multisig.m,
len(msg.multisig.pubkeys))
else:
desc = address_n_to_str(msg.address_n)
while True:
if await show_address(ctx, address_short, desc=desc):
break
if await show_qr(ctx, address_qr, desc=desc):
break
return Address(address=address)
async def confirm_catalyst_registration(
ctx: wire.Context,
public_key: str,
staking_path: list[int],
reward_address: str,
nonce: int,
) -> None:
pages: list[ui.Component] = []
page1 = Text("Confirm transaction", ui.ICON_SEND, ui.GREEN)
page1.bold("Catalyst voting key")
page1.bold("registration")
pages.append(page1)
page2 = Text("Confirm transaction", ui.ICON_SEND, ui.GREEN)
page2.normal("Voting public key:")
page2.bold(*chunks(public_key, 17))
pages.append(page2)
page3 = Text("Confirm transaction", ui.ICON_SEND, ui.GREEN)
page3.normal("Staking key for")
page3.normal("account %s:" % format_account_number(staking_path))
page3.bold(address_n_to_str(staking_path))
pages.append(page3)
page4 = Text("Confirm transaction", ui.ICON_SEND, ui.GREEN)
page4.normal("Rewards go to:")
pages.extend(
_paginate_text(page4, "Confirm transaction", ui.ICON_SEND,
reward_address))
last_page = Text("Confirm transaction", ui.ICON_SEND, ui.GREEN)
last_page.normal("Nonce: %s" % nonce)
pages.append(last_page)
await require_confirm(ctx, Paginated(pages))
async def get_address(ctx, msg, keychain):
network = validate_network(msg.network)
await validate_path(ctx,
check_path,
keychain,
msg.address_n,
CURVE,
network=network)
node = keychain.derive(msg.address_n)
address = node.nem_address(network)
if msg.show_display:
desc = address_n_to_str(msg.address_n)
while True:
if await show_address(ctx,
address,
desc=desc,
network=get_network_str(network)):
break
if await show_qr(ctx, address.upper(), desc=desc):
break
return NEMAddress(address=address)
async def get_address(ctx, msg):
coin_name = msg.coin_name or "Bitcoin"
coin = coins.by_name(coin_name)
await validate_path(
ctx,
addresses.validate_full_path,
path=msg.address_n,
coin=coin,
script_type=msg.script_type,
)
node = await seed.derive_node(ctx,
msg.address_n,
curve_name=coin.curve_name)
address = addresses.get_address(msg.script_type, coin, node, msg.multisig)
address_short = addresses.address_short(coin, address)
if msg.show_display:
if msg.multisig:
desc = "Multisig %d of %d" % (msg.multisig.m,
len(msg.multisig.pubkeys))
else:
desc = address_n_to_str(msg.address_n)
while True:
if await show_address(ctx, address_short, desc=desc):
break
if await show_qr(
ctx,
address.upper() if msg.script_type
== InputScriptType.SPENDWITNESS else address,
desc=desc,
):
break
return Address(address=address)
def assertMismatch(self, schema, path):
self.assertFalse(
schema.match(path),
"Expected schema {!r} to not match path {}".format(
schema, address_n_to_str(path)),
)
def assertMatch(self, schema, path):
self.assertTrue(
schema.match(path),
"Expected schema {!r} to match path {}".format(
schema, address_n_to_str(path)),
)
