def perform_hw1_preflight(self):
try:
firmwareInfo = self.dongleObject.getFirmwareVersion()
firmware = firmwareInfo['version']
self.multiOutputSupported = versiontuple(firmware) >= versiontuple(
MULTI_OUTPUT_SUPPORT)
self.canAlternateCoinVersions = (
versiontuple(firmware) >=
versiontuple(ALTERNATIVE_COIN_VERSION)
and firmwareInfo['specialVersion'] >= 0x20)
if not checkFirmware(firmwareInfo):
self.dongleObject.dongle.close()
raise Exception(MSG_NEEDS_FW_UPDATE_GENERIC)
try:
self.dongleObject.getOperationMode()
except BTChipException as e:
if (e.sw == 0x6985):
self.dongleObject.dongle.close()
self.handler.get_setup()
# Acquire the new client on the next run
else:
raise e
if self.has_detached_pin_support(
self.dongleObject) and not self.is_pin_validated(
self.dongleObject) and (self.handler is not None):
remaining_attempts = self.dongleObject.getVerifyPinRemainingAttempts(
)
if remaining_attempts != 1:
msg = "Enter your Ledger PIN - remaining attempts : " + str(
remaining_attempts)
else:
msg = "Enter your Ledger PIN - WARNING : LAST ATTEMPT. If the PIN is not correct, the dongle will be wiped."
confirmed, p, pin = self.password_dialog(msg)
if not confirmed:
raise Exception(
'Aborted by user - please unplug the dongle and plug it again before retrying'
)
pin = pin.encode()
self.dongleObject.verifyPin(pin)
if self.canAlternateCoinVersions:
self.dongleObject.setAlternateCoinVersions(
constants.net.ADDRTYPE_P2PKH,
constants.net.ADDRTYPE_P2SH)
except BTChipException as e:
if (e.sw == 0x6faa):
raise Exception(
"Dongle is temporarily locked - please unplug it and replug it again"
)
if ((e.sw & 0xFFF0) == 0x63c0):
raise Exception(
"Invalid PIN - please unplug the dongle and plug it again before retrying"
)
if e.sw == 0x6f00 and e.message == 'Invalid channel':
# based on docs 0x6f00 might be a more general error, hence we also compare message to be sure
raise Exception(
"Invalid channel.\n"
"Please make sure that 'Browser support' is disabled on your device."
)
raise e
def check_libraries_available(self) -> bool:
def version_str(t):
return ".".join(str(i) for i in t)
try:
# this might raise ImportError or LibraryFoundButUnusable
library_version = self.get_library_version()
# if no exception so far, we might still raise LibraryFoundButUnusable
if (library_version == 'unknown'
or versiontuple(library_version) < self.minimum_library
or hasattr(self, "maximum_library") and versiontuple(library_version) >= self.maximum_library):
raise LibraryFoundButUnusable(library_version=library_version)
except ImportError:
return False
except LibraryFoundButUnusable as e:
library_version = e.library_version
max_version_str = version_str(self.maximum_library) if hasattr(self, "maximum_library") else "inf"
self.libraries_available_message = (
_("Library version for '{}' is incompatible.").format(self.name)
+ '\nInstalled: {}, Needed: {} <= x < {}'
.format(library_version, version_str(self.minimum_library), max_version_str))
self.logger.warning(self.libraries_available_message)
return False
return True
def is_newer(latest_version):
v = version.ELECTRUM_VERSION
if 'rc' in v:
v = v[:v.index('rc')]
if 'rc' in latest_version:
latest_version = latest_version[:latest_version.index('rc')]
return versiontuple(latest_version) > versiontuple(v)
def __init__(self, parent, config, name):
HW_PluginBase.__init__(self, parent, config, name)
try:
# Minimal test if python-trezor is installed
import trezorlib
try:
library_version = trezorlib.__version__
except AttributeError:
# python-trezor only introduced __version__ in 0.9.0
library_version = 'unknown'
if library_version == 'unknown' or \
versiontuple(library_version) < self.minimum_library:
self.libraries_available_message = (
_("Library version for '{}' is too old.").format(name) +
'\nInstalled: {}, Needed: {}'.format(
library_version, self.minimum_library))
self.print_stderr(self.libraries_available_message)
raise ImportError()
self.libraries_available = True
except ImportError:
self.libraries_available = False
return
from . import client
from . import transport
import trezorlib.messages
self.client_class = client.TrezorClient
self.types = trezorlib.messages
self.DEVICE_IDS = ('TREZOR', )
self.transport_handler = transport.TrezorTransport()
self.device_manager().register_enumerate_func(self.enumerate)
def check_libraries_available(self) -> bool:
try:
library_version = self.get_library_version()
except ImportError:
return False
if library_version == 'unknown' or \
versiontuple(library_version) < self.minimum_library:
self.libraries_available_message = (
_("Library version for '{}' is too old.").format(self.name) +
'\nInstalled: {}, Needed: {}'.format(library_version,
self.minimum_library))
self.print_stderr(self.libraries_available_message)
return False
return True
def is_newer(latest_version):
v = version.ELECTRUM_VERSION
return versiontuple(latest_version) > versiontuple(v)