Functions
def	write_support_info ()

def	support_dicts (device)

def	all_support_dicts ()

def	clear_support (device, key)

def	set_supported (device, key, value)

def	set_unsupported (device, key, value)

def	print_support (coin)

def	check_support_values ()

def	find_unsupported_coins (coins_dict)

def	find_orphaned_support_keys (coins_dict)

def	find_supported_duplicate_tokens (coins_dict)

def	process_erc20 (coins_dict)

def	clear_erc20_mixed_buckets (buckets)

def	cli ()

def	fix (dry_run)

def	check (check_tokens, ignore_missing)

def	release (ctx, str device, version, git_tag, release_missing, dry_run, soon, force, add_all, verbose)

def	show (keyword)

def	set_support_value (key, entries, reason)

Variables
coin_info	SUPPORT_INFO = coin_info.get_support_data()

re	VERSION_RE = re.compile(r"\d+.\d+.\d+")

str	ERC20_DUPLICATE_KEY = "(AUTO) duplicate key"

Function Documentation

◆ all_support_dicts()

def support.all_support_dicts ( )

◆ check()

def support.check	(	check_tokens,
		ignore_missing
	)

Check validity of support information.

Ensures that `support.json` data is well formed, there are no keys without
corresponding coins, and there are no coins without corresponding keys.

If `--check-tokens` is specified, the check will also take into account ERC20 tokens
without support info. This is disabled by default, because support info for ERC20
tokens is not strictly required.

If `--ignore-missing` is specified, the check will display coins with missing
support info, but will not fail when missing coins are found. This is
useful in Travis.

◆ check_support_values()

def support.check_support_values ( )

◆ clear_erc20_mixed_buckets()

def support.clear_erc20_mixed_buckets ( buckets )

◆ clear_support()

def support.clear_support	(	device,
		key
	)

◆ cli()

def support.cli ( )

◆ find_orphaned_support_keys()

def support.find_orphaned_support_keys ( coins_dict )

◆ find_supported_duplicate_tokens()

def support.find_supported_duplicate_tokens ( coins_dict )

◆ find_unsupported_coins()

def support.find_unsupported_coins ( coins_dict )

◆ fix()

def support.fix ( dry_run )

Fix expected problems.

Prunes orphaned keys and ensures that ERC20 duplicate info matches support info.

◆ print_support()

def support.print_support ( coin )

◆ process_erc20()

def support.process_erc20 ( coins_dict )

Make sure that:
* orphaned ERC20 support info is cleared out
* duplicate ERC20 tokens are not listed as supported
* non-duplicate ERC20 tokens are cleared out from the unsupported list

◆ release()

def support.release	(		ctx,
		str	device,
			version,
			git_tag,
			release_missing,
			dry_run,
			soon,
			force,
			add_all,
			verbose
	)

Release a new Trezor firmware.

Update support infos so that all coins have a clear support status.
By default, marks duplicate tokens as unsupported, and all coins that either
don't have support info, or they are supported "soon", are set to the
released firmware version.

Optionally tags the repository with the given version.

`device` can be "1", "2", or a string matching `support.json` key. Version
is autodetected by downloading a list of latest releases and incrementing
micro version by one, or you can specify `--version` explicitly.

Unless `--add-all` is specified, the tool will ask you to confirm each added
coin. ERC20 tokens are added automatically. Use `--verbose` to see them.

◆ set_support_value()

def support.set_support_value	(	key,
		entries,
		reason
	)

Set a support info variable.

Examples:
support.py set coin:BTC trezor1=soon trezor2=2.0.7 webwallet=yes connect=no
support.py set coin:LTC trezor1=yes connect=

Setting a variable to "yes", "true" or "1" sets support to true.
Setting a variable to "no", "false" or "0" sets support to false.
(or null, in case of trezor1/2)
Setting variable to empty ("trezor1=") will set to null, or clear the entry.
Setting to "soon", "planned", "2.1.1" etc. will set the literal string.

◆ set_supported()

def support.set_supported	(	device,
		key,
		value
	)

◆ set_unsupported()

def support.set_unsupported	(	device,
		key,
		value
	)

◆ show()

def support.show ( keyword )

Show support status of specified coins.

Keywords match against key, name or shortcut (ticker symbol) of coin.

◆ support_dicts()

def support.support_dicts ( device )

◆ write_support_info()

def support.write_support_info ( )

Variable Documentation

◆ ERC20_DUPLICATE_KEY

str support.ERC20_DUPLICATE_KEY = "(AUTO) duplicate key"

◆ SUPPORT_INFO

coin_info support.SUPPORT_INFO = coin_info.get_support_data()

◆ VERSION_RE

re support.VERSION_RE = re.compile(r"\d+.\d+.\d+")

Functions

Variables