From c0ef1ec53502a95c09ca52a6a4658a3900cf6d48 Mon Sep 17 00:00:00 2001 From: matejcik Date: Fri, 10 Aug 2018 14:04:58 +0200 Subject: [PATCH] tests: use new API --- trezorlib/tests/device_tests/common.py | 45 ++++++++----- trezorlib/tests/device_tests/test_basic.py | 3 +- .../tests/device_tests/test_bip32_speed.py | 13 ++-- trezorlib/tests/device_tests/test_cosi.py | 28 ++++---- .../device_tests/test_msg_applysettings.py | 17 ++--- .../device_tests/test_msg_cipherkeyvalue.py | 33 +++++----- .../test_msg_ethereum_getaddress.py | 11 ++-- .../test_msg_ethereum_signmessage.py | 3 +- .../device_tests/test_msg_ethereum_signtx.py | 40 +++++++---- .../test_msg_ethereum_signtx_eip155.py | 4 +- .../test_msg_ethereum_verifymessage.py | 4 +- .../tests/device_tests/test_msg_getaddress.py | 41 ++++++------ .../test_msg_getaddress_segwit.py | 13 ++-- .../test_msg_getaddress_segwit_native.py | 15 +++-- .../device_tests/test_msg_getaddress_show.py | 11 ++-- .../test_msg_getecdhsessionkey.py | 7 +- .../tests/device_tests/test_msg_getentropy.py | 3 +- .../device_tests/test_msg_getpublickey.py | 45 ++++++------- .../test_msg_getpublickey_curve.py | 19 +++--- .../device_tests/test_msg_lisk_getaddress.py | 9 +-- .../test_msg_lisk_getpublickey.py | 3 +- .../device_tests/test_msg_lisk_signmessage.py | 5 +- .../device_tests/test_msg_lisk_signtx.py | 13 ++-- .../test_msg_lisk_verifymessage.py | 9 ++- .../tests/device_tests/test_msg_loaddevice.py | 31 +++++---- .../device_tests/test_msg_loaddevice_xprv.py | 10 +-- .../device_tests/test_msg_nem_getaddress.py | 5 +- .../test_msg_nem_signtx_mosaics.py | 8 +-- .../test_msg_nem_signtx_mosaics_t2.py | 2 +- .../test_msg_nem_signtx_multisig.py | 10 +-- .../test_msg_nem_signtx_others.py | 4 +- .../test_msg_nem_signtx_transfers.py | 14 ++-- .../device_tests/test_msg_recoverydevice.py | 3 +- .../test_msg_recoverydevice_t2.py | 3 +- .../device_tests/test_msg_resetdevice.py | 3 +- .../device_tests/test_msg_resetdevice_t2.py | 3 +- .../test_msg_ripple_get_address.py | 4 +- .../device_tests/test_msg_signidentity.py | 9 +-- .../device_tests/test_msg_signmessage.py | 13 ++-- .../test_msg_signmessage_segwit.py | 11 ++-- .../test_msg_signmessage_segwit_native.py | 11 ++-- .../tests/device_tests/test_msg_signtx.py | 35 +++++----- .../device_tests/test_msg_signtx_bcash.py | 23 +++---- .../device_tests/test_msg_signtx_bgold.py | 23 +++---- .../device_tests/test_msg_signtx_decred.py | 9 +-- .../device_tests/test_msg_signtx_segwit.py | 15 +++-- .../test_msg_signtx_segwit_native.py | 35 +++++----- .../device_tests/test_msg_signtx_zcash.py | 3 +- .../test_msg_stellar_get_address.py | 16 +++-- .../test_msg_stellar_get_public_key.py | 4 +- .../test_msg_stellar_sign_transaction.py | 14 ++-- .../device_tests/test_msg_verifymessage.py | 66 ++++++++++++------- .../test_msg_verifymessage_segwit.py | 30 +++++---- .../test_msg_verifymessage_segwit_native.py | 30 +++++---- .../tests/device_tests/test_msg_wipedevice.py | 3 +- trezorlib/tests/device_tests/test_multisig.py | 9 +-- .../device_tests/test_multisig_change.py | 17 ++--- .../tests/device_tests/test_op_return.py | 5 +- .../device_tests/test_protection_levels.py | 35 +++++----- trezorlib/tests/device_tests/test_zerosig.py | 5 +- 60 files changed, 517 insertions(+), 398 deletions(-) diff --git a/trezorlib/tests/device_tests/common.py b/trezorlib/tests/device_tests/common.py index 525c9b6360..4917e5ae43 100644 --- a/trezorlib/tests/device_tests/common.py +++ b/trezorlib/tests/device_tests/common.py @@ -21,12 +21,23 @@ from . import conftest from trezorlib import coins from trezorlib import tx_api from trezorlib.client import TrezorClientDebugLink +from trezorlib import debuglink +from trezorlib import device tests_dir = os.path.dirname(os.path.abspath(__file__)) tx_api.cache_dir = os.path.join(tests_dir, '../txcache') class TrezorTest: + # 1 2 3 4 5 6 7 8 9 10 11 12 + mnemonic12 = 'alcohol woman abuse must during monitor noble actual mixed trade anger aisle' + mnemonic18 = 'owner little vague addict embark decide pink prosper true fork panda embody mixture exchange choose canoe electric jewel' + mnemonic24 = 'dignity pass list indicate nasty swamp pool script soccer toe leaf photo multiply desk host tomato cradle drill spread actor shine dismiss champion exotic' + mnemonic_all = ' '.join(['all'] * 12) + + pin4 = '1234' + pin6 = '789456' + pin8 = '45678978' def setup_method(self, method): wirelink = conftest.get_device() @@ -36,37 +47,39 @@ class TrezorTest: self.client.set_tx_api(coins.tx_api['Bitcoin']) # self.client.set_buttonwait(3) - # 1 2 3 4 5 6 7 8 9 10 11 12 - self.mnemonic12 = 'alcohol woman abuse must during monitor noble actual mixed trade anger aisle' - self.mnemonic18 = 'owner little vague addict embark decide pink prosper true fork panda embody mixture exchange choose canoe electric jewel' - self.mnemonic24 = 'dignity pass list indicate nasty swamp pool script soccer toe leaf photo multiply desk host tomato cradle drill spread actor shine dismiss champion exotic' - self.mnemonic_all = ' '.join(['all'] * 12) - - self.pin4 = '1234' - self.pin6 = '789456' - self.pin8 = '45678978' - - self.client.wipe_device() + device.wipe(self.client) self.client.transport.session_begin() def teardown_method(self, method): self.client.transport.session_end() self.client.close() + def _setup_mnemonic(self, mnemonic=None, pin='', passphrase=False): + if mnemonic is None: + mnemonic = TrezorTest.mnemonic12 + debuglink.load_device_by_mnemonic( + self.client, + mnemonic=mnemonic, + pin=pin, + passphrase_protection=passphrase, + label="test", + language="english", + ) + def setup_mnemonic_allallall(self): - self.client.load_device_by_mnemonic(mnemonic=self.mnemonic_all, pin='', passphrase_protection=False, label='test', language='english') + self._setup_mnemonic(mnemonic=TrezorTest.mnemonic_all) def setup_mnemonic_nopin_nopassphrase(self): - self.client.load_device_by_mnemonic(mnemonic=self.mnemonic12, pin='', passphrase_protection=False, label='test', language='english') + self._setup_mnemonic() def setup_mnemonic_nopin_passphrase(self): - self.client.load_device_by_mnemonic(mnemonic=self.mnemonic12, pin='', passphrase_protection=True, label='test', language='english') + self._setup_mnemonic(passphrase=True) def setup_mnemonic_pin_nopassphrase(self): - self.client.load_device_by_mnemonic(mnemonic=self.mnemonic12, pin=self.pin4, passphrase_protection=False, label='test', language='english') + self._setup_mnemonic(pin=TrezorTest.pin4) def setup_mnemonic_pin_passphrase(self): - self.client.load_device_by_mnemonic(mnemonic=self.mnemonic12, pin=self.pin4, passphrase_protection=True, label='test', language='english') + self._setup_mnemonic(pin=TrezorTest.pin4, passphrase=True) def generate_entropy(strength, internal_entropy, external_entropy): diff --git a/trezorlib/tests/device_tests/test_basic.py b/trezorlib/tests/device_tests/test_basic.py index 0d9d4ac80b..e3203e059e 100644 --- a/trezorlib/tests/device_tests/test_basic.py +++ b/trezorlib/tests/device_tests/test_basic.py @@ -17,6 +17,7 @@ from .common import TrezorTest from trezorlib import messages +from trezorlib import device class TestBasic(TrezorTest): @@ -43,7 +44,7 @@ class TestBasic(TrezorTest): def test_device_id_different(self): id1 = self.client.get_device_id() - self.client.wipe_device() + device.wipe(self.client) id2 = self.client.get_device_id() # Device ID must be fresh after every reset diff --git a/trezorlib/tests/device_tests/test_bip32_speed.py b/trezorlib/tests/device_tests/test_bip32_speed.py index 946399289d..001e6fae5e 100644 --- a/trezorlib/tests/device_tests/test_bip32_speed.py +++ b/trezorlib/tests/device_tests/test_bip32_speed.py @@ -20,6 +20,7 @@ import pytest from .common import TrezorTest from trezorlib.tools import H_ +from trezorlib import btc class TestBip32Speed(TrezorTest): @@ -27,11 +28,11 @@ class TestBip32Speed(TrezorTest): def test_public_ckd(self): self.setup_mnemonic_nopin_nopassphrase() - self.client.get_address('Bitcoin', []) # to compute root node via BIP39 + btc.get_address(self.client, 'Bitcoin', []) # to compute root node via BIP39 for depth in range(8): start = time.time() - self.client.get_address('Bitcoin', range(depth)) + btc.get_address(self.client, 'Bitcoin', range(depth)) delay = time.time() - start expected = (depth + 1) * 0.26 print("DEPTH", depth, "EXPECTED DELAY", expected, "REAL DELAY", delay) @@ -40,12 +41,12 @@ class TestBip32Speed(TrezorTest): def test_private_ckd(self): self.setup_mnemonic_nopin_nopassphrase() - self.client.get_address('Bitcoin', []) # to compute root node via BIP39 + btc.get_address(self.client, 'Bitcoin', []) # to compute root node via BIP39 for depth in range(8): start = time.time() address_n = [H_(-i) for i in range(-depth, 0)] - self.client.get_address('Bitcoin', address_n) + btc.get_address(self.client, 'Bitcoin', address_n) delay = time.time() - start expected = (depth + 1) * 0.26 print("DEPTH", depth, "EXPECTED DELAY", expected, "REAL DELAY", delay) @@ -57,12 +58,12 @@ class TestBip32Speed(TrezorTest): start = time.time() for x in range(10): - self.client.get_address('Bitcoin', [x, 2, 3, 4, 5, 6, 7, 8]) + btc.get_address(self.client, 'Bitcoin', [x, 2, 3, 4, 5, 6, 7, 8]) nocache_time = time.time() - start start = time.time() for x in range(10): - self.client.get_address('Bitcoin', [1, 2, 3, 4, 5, 6, 7, x]) + btc.get_address(self.client, 'Bitcoin', [1, 2, 3, 4, 5, 6, 7, x]) cache_time = time.time() - start print("NOCACHE TIME", nocache_time) diff --git a/trezorlib/tests/device_tests/test_cosi.py b/trezorlib/tests/device_tests/test_cosi.py index 698d512b01..162ef76236 100644 --- a/trezorlib/tests/device_tests/test_cosi.py +++ b/trezorlib/tests/device_tests/test_cosi.py @@ -31,9 +31,9 @@ class TestCosi(TrezorTest): digest = sha256(b'this is a message').digest() - c0 = self.client.cosi_commit(parse_path("10018'/0'"), digest) - c1 = self.client.cosi_commit(parse_path("10018'/1'"), digest) - c2 = self.client.cosi_commit(parse_path("10018'/2'"), digest) + c0 = cosi.commit(self.client, parse_path("10018'/0'"), digest) + c1 = cosi.commit(self.client, parse_path("10018'/1'"), digest) + c2 = cosi.commit(self.client, parse_path("10018'/2'"), digest) assert c0.pubkey != c1.pubkey assert c0.pubkey != c2.pubkey @@ -45,9 +45,9 @@ class TestCosi(TrezorTest): digestb = sha256(b'this is a different message').digest() - c0b = self.client.cosi_commit(parse_path("10018'/0'"), digestb) - c1b = self.client.cosi_commit(parse_path("10018'/1'"), digestb) - c2b = self.client.cosi_commit(parse_path("10018'/2'"), digestb) + c0b = cosi.commit(self.client, parse_path("10018'/0'"), digestb) + c1b = cosi.commit(self.client, parse_path("10018'/1'"), digestb) + c2b = cosi.commit(self.client, parse_path("10018'/2'"), digestb) assert c0.pubkey == c0b.pubkey assert c1.pubkey == c1b.pubkey @@ -62,16 +62,16 @@ class TestCosi(TrezorTest): digest = sha256(b'this is a message').digest() - c0 = self.client.cosi_commit(parse_path("10018'/0'"), digest) - c1 = self.client.cosi_commit(parse_path("10018'/1'"), digest) - c2 = self.client.cosi_commit(parse_path("10018'/2'"), digest) + c0 = cosi.commit(self.client, parse_path("10018'/0'"), digest) + c1 = cosi.commit(self.client, parse_path("10018'/1'"), digest) + c2 = cosi.commit(self.client, parse_path("10018'/2'"), digest) global_pk = cosi.combine_keys([c0.pubkey, c1.pubkey, c2.pubkey]) global_R = cosi.combine_keys([c0.commitment, c1.commitment, c2.commitment]) - sig0 = self.client.cosi_sign(parse_path("10018'/0'"), digest, global_R, global_pk) - sig1 = self.client.cosi_sign(parse_path("10018'/1'"), digest, global_R, global_pk) - sig2 = self.client.cosi_sign(parse_path("10018'/2'"), digest, global_R, global_pk) + sig0 = cosi.sign(self.client, parse_path("10018'/0'"), digest, global_R, global_pk) + sig1 = cosi.sign(self.client, parse_path("10018'/1'"), digest, global_R, global_pk) + sig2 = cosi.sign(self.client, parse_path("10018'/2'"), digest, global_R, global_pk) sig = cosi.combine_sig(global_R, [sig0.signature, sig1.signature, sig2.signature]) @@ -81,7 +81,7 @@ class TestCosi(TrezorTest): self.setup_mnemonic_pin_passphrase() digest = sha256(b'this is not a pipe').digest() - remote_commit = self.client.cosi_commit(parse_path("10018'/0'"), digest) + remote_commit = cosi.commit(self.client, parse_path("10018'/0'"), digest) local_privkey = sha256(b'private key').digest()[:32] local_pubkey = cosi.pubkey_from_privkey(local_privkey) @@ -90,7 +90,7 @@ class TestCosi(TrezorTest): global_pk = cosi.combine_keys([remote_commit.pubkey, local_pubkey]) global_R = cosi.combine_keys([remote_commit.commitment, local_commitment]) - remote_sig = self.client.cosi_sign(parse_path("10018'/0'"), digest, global_R, global_pk) + remote_sig = cosi.sign(self.client, parse_path("10018'/0'"), digest, global_R, global_pk) local_sig = cosi.sign_with_privkey(digest, local_privkey, global_pk, local_nonce, global_R) sig = cosi.combine_sig(global_R, [remote_sig.signature, local_sig]) diff --git a/trezorlib/tests/device_tests/test_msg_applysettings.py b/trezorlib/tests/device_tests/test_msg_applysettings.py index 23238fc46a..f5541d6383 100644 --- a/trezorlib/tests/device_tests/test_msg_applysettings.py +++ b/trezorlib/tests/device_tests/test_msg_applysettings.py @@ -20,6 +20,7 @@ from .common import TrezorTest import time from trezorlib import messages as proto +from trezorlib import device class TestMsgApplysettings(TrezorTest): @@ -35,7 +36,7 @@ class TestMsgApplysettings(TrezorTest): proto.Features()]) if self.client.features.major_version >= 2: self.client.expected_responses.pop(0) # skip PinMatrixRequest - self.client.apply_settings(label='new label') + device.apply_settings(self.client, label='new label') assert self.client.features.label == 'new label' @@ -49,7 +50,7 @@ class TestMsgApplysettings(TrezorTest): proto.ButtonRequest(), proto.Success(), proto.Features()]) - self.client.apply_settings(language='nonexistent') + device.apply_settings(self.client, language='nonexistent') assert self.client.features.language == 'english' @@ -65,7 +66,7 @@ class TestMsgApplysettings(TrezorTest): proto.Features()]) if self.client.features.major_version >= 2: self.client.expected_responses.pop(0) # skip PinMatrixRequest - self.client.apply_settings(use_passphrase=True) + device.apply_settings(self.client, use_passphrase=True) assert self.client.features.passphrase_protection is True @@ -73,7 +74,7 @@ class TestMsgApplysettings(TrezorTest): self.client.set_expected_responses([proto.ButtonRequest(), proto.Success(), proto.Features()]) - self.client.apply_settings(use_passphrase=False) + device.apply_settings(self.client, use_passphrase=False) assert self.client.features.passphrase_protection is False @@ -81,7 +82,7 @@ class TestMsgApplysettings(TrezorTest): self.client.set_expected_responses([proto.ButtonRequest(), proto.Success(), proto.Features()]) - self.client.apply_settings(use_passphrase=True) + device.apply_settings(self.client, use_passphrase=True) assert self.client.features.passphrase_protection is True @@ -96,7 +97,7 @@ class TestMsgApplysettings(TrezorTest): proto.ButtonRequest(), proto.Success(), proto.Features()]) - self.client.apply_settings(homescreen=img) + device.apply_settings(self.client, homescreen=img) @pytest.mark.skip_t2 def test_apply_auto_lock_delay(self): @@ -107,7 +108,7 @@ class TestMsgApplysettings(TrezorTest): proto.ButtonRequest(), proto.Success(), proto.Features()]) - self.client.apply_settings(auto_lock_delay_ms=int(10e3)) # 10 secs + device.apply_settings(self.client, auto_lock_delay_ms=int(10e3)) # 10 secs time.sleep(0.1) # sleep less than auto-lock delay with self.client: @@ -135,7 +136,7 @@ class TestMsgApplysettings(TrezorTest): proto.Success(), proto.Features()]) # Note: the actual delay will be 10 secs (see above). - self.client.apply_settings(auto_lock_delay_ms=int(1e3)) + device.apply_settings(self.client, auto_lock_delay_ms=int(1e3)) time.sleep(0.1) # sleep less than auto-lock delay with self.client: diff --git a/trezorlib/tests/device_tests/test_msg_cipherkeyvalue.py b/trezorlib/tests/device_tests/test_msg_cipherkeyvalue.py index f9c92a82d0..5527580453 100644 --- a/trezorlib/tests/device_tests/test_msg_cipherkeyvalue.py +++ b/trezorlib/tests/device_tests/test_msg_cipherkeyvalue.py @@ -18,6 +18,7 @@ from binascii import hexlify, unhexlify import pytest from .common import TrezorTest +from trezorlib import misc class TestMsgCipherkeyvalue(TrezorTest): @@ -26,64 +27,64 @@ class TestMsgCipherkeyvalue(TrezorTest): self.setup_mnemonic_nopin_nopassphrase() # different ask values - res = self.client.encrypt_keyvalue([0, 1, 2], b"test", b"testing message!", ask_on_encrypt=True, ask_on_decrypt=True) + res = misc.encrypt_keyvalue(self.client, [0, 1, 2], b"test", b"testing message!", ask_on_encrypt=True, ask_on_decrypt=True) assert hexlify(res) == b'676faf8f13272af601776bc31bc14e8f' - res = self.client.encrypt_keyvalue([0, 1, 2], b"test", b"testing message!", ask_on_encrypt=True, ask_on_decrypt=False) + res = misc.encrypt_keyvalue(self.client, [0, 1, 2], b"test", b"testing message!", ask_on_encrypt=True, ask_on_decrypt=False) assert hexlify(res) == b'5aa0fbcb9d7fa669880745479d80c622' - res = self.client.encrypt_keyvalue([0, 1, 2], b"test", b"testing message!", ask_on_encrypt=False, ask_on_decrypt=True) + res = misc.encrypt_keyvalue(self.client, [0, 1, 2], b"test", b"testing message!", ask_on_encrypt=False, ask_on_decrypt=True) assert hexlify(res) == b'958d4f63269b61044aaedc900c8d6208' - res = self.client.encrypt_keyvalue([0, 1, 2], b"test", b"testing message!", ask_on_encrypt=False, ask_on_decrypt=False) + res = misc.encrypt_keyvalue(self.client, [0, 1, 2], b"test", b"testing message!", ask_on_encrypt=False, ask_on_decrypt=False) assert hexlify(res) == b'e0cf0eb0425947000eb546cc3994bc6c' # different key - res = self.client.encrypt_keyvalue([0, 1, 2], b"test2", b"testing message!", ask_on_encrypt=True, ask_on_decrypt=True) + res = misc.encrypt_keyvalue(self.client, [0, 1, 2], b"test2", b"testing message!", ask_on_encrypt=True, ask_on_decrypt=True) assert hexlify(res) == b'de247a6aa6be77a134bb3f3f925f13af' # different message - res = self.client.encrypt_keyvalue([0, 1, 2], b"test", b"testing message! it is different", ask_on_encrypt=True, ask_on_decrypt=True) + res = misc.encrypt_keyvalue(self.client, [0, 1, 2], b"test", b"testing message! it is different", ask_on_encrypt=True, ask_on_decrypt=True) assert hexlify(res) == b'676faf8f13272af601776bc31bc14e8f3ae1c88536bf18f1b44f1e4c2c4a613d' # different path - res = self.client.encrypt_keyvalue([0, 1, 3], b"test", b"testing message!", ask_on_encrypt=True, ask_on_decrypt=True) + res = misc.encrypt_keyvalue(self.client, [0, 1, 3], b"test", b"testing message!", ask_on_encrypt=True, ask_on_decrypt=True) assert hexlify(res) == b'b4811a9d492f5355a5186ddbfccaae7b' def test_decrypt(self): self.setup_mnemonic_nopin_nopassphrase() # different ask values - res = self.client.decrypt_keyvalue([0, 1, 2], b"test", unhexlify("676faf8f13272af601776bc31bc14e8f"), ask_on_encrypt=True, ask_on_decrypt=True) + res = misc.decrypt_keyvalue(self.client, [0, 1, 2], b"test", unhexlify("676faf8f13272af601776bc31bc14e8f"), ask_on_encrypt=True, ask_on_decrypt=True) assert res == b'testing message!' - res = self.client.decrypt_keyvalue([0, 1, 2], b"test", unhexlify("5aa0fbcb9d7fa669880745479d80c622"), ask_on_encrypt=True, ask_on_decrypt=False) + res = misc.decrypt_keyvalue(self.client, [0, 1, 2], b"test", unhexlify("5aa0fbcb9d7fa669880745479d80c622"), ask_on_encrypt=True, ask_on_decrypt=False) assert res == b'testing message!' - res = self.client.decrypt_keyvalue([0, 1, 2], b"test", unhexlify("958d4f63269b61044aaedc900c8d6208"), ask_on_encrypt=False, ask_on_decrypt=True) + res = misc.decrypt_keyvalue(self.client, [0, 1, 2], b"test", unhexlify("958d4f63269b61044aaedc900c8d6208"), ask_on_encrypt=False, ask_on_decrypt=True) assert res == b'testing message!' - res = self.client.decrypt_keyvalue([0, 1, 2], b"test", unhexlify("e0cf0eb0425947000eb546cc3994bc6c"), ask_on_encrypt=False, ask_on_decrypt=False) + res = misc.decrypt_keyvalue(self.client, [0, 1, 2], b"test", unhexlify("e0cf0eb0425947000eb546cc3994bc6c"), ask_on_encrypt=False, ask_on_decrypt=False) assert res == b'testing message!' # different key - res = self.client.decrypt_keyvalue([0, 1, 2], b"test2", unhexlify("de247a6aa6be77a134bb3f3f925f13af"), ask_on_encrypt=True, ask_on_decrypt=True) + res = misc.decrypt_keyvalue(self.client, [0, 1, 2], b"test2", unhexlify("de247a6aa6be77a134bb3f3f925f13af"), ask_on_encrypt=True, ask_on_decrypt=True) assert res == b'testing message!' # different message - res = self.client.decrypt_keyvalue([0, 1, 2], b"test", unhexlify("676faf8f13272af601776bc31bc14e8f3ae1c88536bf18f1b44f1e4c2c4a613d"), ask_on_encrypt=True, ask_on_decrypt=True) + res = misc.decrypt_keyvalue(self.client, [0, 1, 2], b"test", unhexlify("676faf8f13272af601776bc31bc14e8f3ae1c88536bf18f1b44f1e4c2c4a613d"), ask_on_encrypt=True, ask_on_decrypt=True) assert res == b'testing message! it is different' # different path - res = self.client.decrypt_keyvalue([0, 1, 3], b"test", unhexlify("b4811a9d492f5355a5186ddbfccaae7b"), ask_on_encrypt=True, ask_on_decrypt=True) + res = misc.decrypt_keyvalue(self.client, [0, 1, 3], b"test", unhexlify("b4811a9d492f5355a5186ddbfccaae7b"), ask_on_encrypt=True, ask_on_decrypt=True) assert res == b'testing message!' def test_encrypt_badlen(self): self.setup_mnemonic_nopin_nopassphrase() with pytest.raises(Exception): - self.client.encrypt_keyvalue([0, 1, 2], b"test", b"testing") + misc.encrypt_keyvalue(self.client, [0, 1, 2], b"test", b"testing") def test_decrypt_badlen(self): self.setup_mnemonic_nopin_nopassphrase() with pytest.raises(Exception): - self.client.decrypt_keyvalue([0, 1, 2], b"test", b"testing") + misc.decrypt_keyvalue(self.client, [0, 1, 2], b"test", b"testing") diff --git a/trezorlib/tests/device_tests/test_msg_ethereum_getaddress.py b/trezorlib/tests/device_tests/test_msg_ethereum_getaddress.py index fb26777662..9e8e48bda5 100644 --- a/trezorlib/tests/device_tests/test_msg_ethereum_getaddress.py +++ b/trezorlib/tests/device_tests/test_msg_ethereum_getaddress.py @@ -20,6 +20,7 @@ import pytest from .common import TrezorTest from trezorlib.tools import H_ +from trezorlib import ethereum @pytest.mark.ethereum @@ -27,8 +28,8 @@ class TestMsgEthereumGetaddress(TrezorTest): def test_ethereum_getaddress(self): self.setup_mnemonic_nopin_nopassphrase() - assert hexlify(self.client.ethereum_get_address([])) == b'1d1c328764a41bda0492b66baa30c4a339ff85ef' - assert hexlify(self.client.ethereum_get_address([1])) == b'437207ca3cf43bf2e47dea0756d736c5df4f597a' - assert hexlify(self.client.ethereum_get_address([0, H_(1)])) == b'e5d96dfa07bcf1a3ae43677840c31394258861bf' - assert hexlify(self.client.ethereum_get_address([H_(9), 0])) == b'f68804ac9eca9483ab4241d3e4751590d2c05102' - assert hexlify(self.client.ethereum_get_address([0, 9999999])) == b'7a6366ecfcaf0d5dcc1539c171696c6cdd1eb8ed' + assert hexlify(ethereum.get_address(self.client, [])) == b'1d1c328764a41bda0492b66baa30c4a339ff85ef' + assert hexlify(ethereum.get_address(self.client, [1])) == b'437207ca3cf43bf2e47dea0756d736c5df4f597a' + assert hexlify(ethereum.get_address(self.client, [0, H_(1)])) == b'e5d96dfa07bcf1a3ae43677840c31394258861bf' + assert hexlify(ethereum.get_address(self.client, [H_(9), 0])) == b'f68804ac9eca9483ab4241d3e4751590d2c05102' + assert hexlify(ethereum.get_address(self.client, [0, 9999999])) == b'7a6366ecfcaf0d5dcc1539c171696c6cdd1eb8ed' diff --git a/trezorlib/tests/device_tests/test_msg_ethereum_signmessage.py b/trezorlib/tests/device_tests/test_msg_ethereum_signmessage.py index 55b1913590..41c122e20d 100644 --- a/trezorlib/tests/device_tests/test_msg_ethereum_signmessage.py +++ b/trezorlib/tests/device_tests/test_msg_ethereum_signmessage.py @@ -18,6 +18,7 @@ from binascii import hexlify import pytest from .common import TrezorTest +from trezorlib import ethereum @pytest.mark.ethereum @@ -33,6 +34,6 @@ class TestMsgEthereumSignmessage(TrezorTest): def test_sign(self): self.setup_mnemonic_nopin_nopassphrase() for msg, sig in self.VECTORS: - res = self.client.ethereum_sign_message(self.PATH, msg) + res = ethereum.sign_message(self.client, self.PATH, msg) assert hexlify(res.address) == self.ADDRESS assert hexlify(res.signature) == sig diff --git a/trezorlib/tests/device_tests/test_msg_ethereum_signtx.py b/trezorlib/tests/device_tests/test_msg_ethereum_signtx.py index 25d284a280..020b978055 100644 --- a/trezorlib/tests/device_tests/test_msg_ethereum_signtx.py +++ b/trezorlib/tests/device_tests/test_msg_ethereum_signtx.py @@ -19,6 +19,7 @@ import pytest from .common import TrezorTest from trezorlib import messages as proto +from trezorlib import ethereum @pytest.mark.ethereum @@ -43,7 +44,8 @@ class TestMsgEthereumSigntx(TrezorTest): data.extend(unhexlify('000000000000000000000000000000000000000000000000000000000bebc200')) # 200 000 000 in dec, divisibility of ADT = 9, trezor1 displays 0.2 ADT, Trezor T 200 000 000 Wei ADT - sig_v, sig_r, sig_s = self.client.ethereum_sign_tx( + sig_v, sig_r, sig_s = ethereum.sign_tx( + self.client, n=[0, 0], nonce=0, gas_price=20, @@ -78,7 +80,8 @@ class TestMsgEthereumSigntx(TrezorTest): data.extend(unhexlify('0000000000000000000000000000000000000000000000000000000000000123')) # since this token is unknown trezor should display "unknown token value" - sig_v, sig_r, sig_s = self.client.ethereum_sign_tx( + sig_v, sig_r, sig_s = ethereum.sign_tx( + self.client, n=[0, 0], nonce=0, gas_price=20, @@ -104,7 +107,8 @@ class TestMsgEthereumSigntx(TrezorTest): proto.EthereumTxRequest(data_length=None), # v,r,s checked with assert ]) - sig_v, sig_r, sig_s = self.client.ethereum_sign_tx( + sig_v, sig_r, sig_s = ethereum.sign_tx( + self.client, n=[0, 0], nonce=0, gas_price=20, @@ -123,7 +127,8 @@ class TestMsgEthereumSigntx(TrezorTest): proto.EthereumTxRequest(data_length=None), ]) - sig_v, sig_r, sig_s = self.client.ethereum_sign_tx( + sig_v, sig_r, sig_s = ethereum.sign_tx( + self.client, n=[0, 0], nonce=123456, gas_price=20000, @@ -145,7 +150,8 @@ class TestMsgEthereumSigntx(TrezorTest): proto.EthereumTxRequest(data_length=None), ]) - sig_v, sig_r, sig_s = self.client.ethereum_sign_tx( + sig_v, sig_r, sig_s = ethereum.sign_tx( + self.client, n=[0, 0], nonce=0, gas_price=20, @@ -169,7 +175,8 @@ class TestMsgEthereumSigntx(TrezorTest): proto.EthereumTxRequest(), ]) - sig_v, sig_r, sig_s = self.client.ethereum_sign_tx( + sig_v, sig_r, sig_s = ethereum.sign_tx( + self.client, n=[0, 0], nonce=123456, gas_price=20000, @@ -196,7 +203,8 @@ class TestMsgEthereumSigntx(TrezorTest): proto.EthereumTxRequest(), ]) - sig_v, sig_r, sig_s = self.client.ethereum_sign_tx( + sig_v, sig_r, sig_s = ethereum.sign_tx( + self.client, n=[0, 0], nonce=0, gas_price=20000, @@ -213,7 +221,8 @@ class TestMsgEthereumSigntx(TrezorTest): # contract creation without data should fail. with pytest.raises(Exception): - self.client.ethereum_sign_tx( + ethereum.sign_tx( + self.client, n=[0, 0], nonce=123456, gas_price=20000, @@ -234,7 +243,8 @@ class TestMsgEthereumSigntx(TrezorTest): proto.EthereumTxRequest(), ]) - sig_v, sig_r, sig_s = self.client.ethereum_sign_tx( + sig_v, sig_r, sig_s = ethereum.sign_tx( + self.client, n=[0, 0], nonce=0, gas_price=20000, @@ -249,7 +259,8 @@ class TestMsgEthereumSigntx(TrezorTest): def test_ethereum_sanity_checks(self): # gas overflow with pytest.raises(Exception): - self.client.ethereum_sign_tx( + ethereum.sign_tx( + self.client, n=[0, 0], nonce=123456, gas_price=0xffffffffffffffffffffffffffffffff, @@ -260,7 +271,8 @@ class TestMsgEthereumSigntx(TrezorTest): # no gas price with pytest.raises(Exception): - self.client.ethereum_sign_tx( + ethereum.sign_tx( + self.client, n=[0, 0], nonce=123456, gas_limit=10000, @@ -270,7 +282,8 @@ class TestMsgEthereumSigntx(TrezorTest): # no gas limit with pytest.raises(Exception): - self.client.ethereum_sign_tx( + ethereum.sign_tx( + self.client, n=[0, 0], nonce=123456, gas_price=10000, @@ -280,7 +293,8 @@ class TestMsgEthereumSigntx(TrezorTest): # no nonce with pytest.raises(Exception): - self.client.ethereum_sign_tx( + ethereum.sign_tx( + self.client, n=[0, 0], gas_price=10000, gas_limit=123456, diff --git a/trezorlib/tests/device_tests/test_msg_ethereum_signtx_eip155.py b/trezorlib/tests/device_tests/test_msg_ethereum_signtx_eip155.py index d34bd82ad3..da05adf004 100644 --- a/trezorlib/tests/device_tests/test_msg_ethereum_signtx_eip155.py +++ b/trezorlib/tests/device_tests/test_msg_ethereum_signtx_eip155.py @@ -19,6 +19,7 @@ import pytest from .common import TrezorTest from trezorlib import messages as proto +from trezorlib import ethereum @pytest.mark.ethereum @@ -162,7 +163,8 @@ class TestMsgEthereumSigntxChainId(TrezorTest): self.setup_mnemonic_allallall() for ci, n, sv, sr, ss, v, gl, d in VECTORS: - sig_v, sig_r, sig_s = self.client.ethereum_sign_tx( + sig_v, sig_r, sig_s = ethereum.sign_tx( + self.client, n=[0x80000000 | 44, 0x80000000 | 1, 0x80000000, 0, 0], nonce=n, gas_price=20000000000, diff --git a/trezorlib/tests/device_tests/test_msg_ethereum_verifymessage.py b/trezorlib/tests/device_tests/test_msg_ethereum_verifymessage.py index fd8ee20f57..3eae048c7c 100644 --- a/trezorlib/tests/device_tests/test_msg_ethereum_verifymessage.py +++ b/trezorlib/tests/device_tests/test_msg_ethereum_verifymessage.py @@ -19,6 +19,7 @@ from binascii import unhexlify import pytest from .common import TrezorTest +from trezorlib import ethereum @pytest.mark.ethereum @@ -33,7 +34,8 @@ class TestMsgEthereumVerifymessage(TrezorTest): def test_verify(self): self.setup_mnemonic_nopin_nopassphrase() for msg, sig in self.VECTORS: - res = self.client.ethereum_verify_message( + res = ethereum.verify_message( + self.client, unhexlify(self.ADDRESS), unhexlify(sig), msg diff --git a/trezorlib/tests/device_tests/test_msg_getaddress.py b/trezorlib/tests/device_tests/test_msg_getaddress.py index 8acb4d4d2f..d1d4f245ec 100644 --- a/trezorlib/tests/device_tests/test_msg_getaddress.py +++ b/trezorlib/tests/device_tests/test_msg_getaddress.py @@ -21,40 +21,41 @@ from ..support import ckd_public as bip32 from trezorlib import messages as proto from trezorlib.tools import parse_path, H_ +from trezorlib import btc class TestMsgGetaddress(TrezorTest): def test_btc(self): self.setup_mnemonic_nopin_nopassphrase() - assert self.client.get_address('Bitcoin', []) == '1EfKbQupktEMXf4gujJ9kCFo83k1iMqwqK' - assert self.client.get_address('Bitcoin', [1]) == '1CK7SJdcb8z9HuvVft3D91HLpLC6KSsGb' - assert self.client.get_address('Bitcoin', [0, H_(1)]) == '1JVq66pzRBvqaBRFeU9SPVvg3er4ZDgoMs' - assert self.client.get_address('Bitcoin', [H_(9), 0]) == '1F4YdQdL9ZQwvcNTuy5mjyQxXkyCfMcP2P' - assert self.client.get_address('Bitcoin', [0, 9999999]) == '1GS8X3yc7ntzwGw9vXwj9wqmBWZkTFewBV' + assert btc.get_address(self.client, 'Bitcoin', []) == '1EfKbQupktEMXf4gujJ9kCFo83k1iMqwqK' + assert btc.get_address(self.client, 'Bitcoin', [1]) == '1CK7SJdcb8z9HuvVft3D91HLpLC6KSsGb' + assert btc.get_address(self.client, 'Bitcoin', [0, H_(1)]) == '1JVq66pzRBvqaBRFeU9SPVvg3er4ZDgoMs' + assert btc.get_address(self.client, 'Bitcoin', [H_(9), 0]) == '1F4YdQdL9ZQwvcNTuy5mjyQxXkyCfMcP2P' + assert btc.get_address(self.client, 'Bitcoin', [0, 9999999]) == '1GS8X3yc7ntzwGw9vXwj9wqmBWZkTFewBV' def test_ltc(self): self.setup_mnemonic_nopin_nopassphrase() - assert self.client.get_address('Litecoin', []) == 'LYtGrdDeqYUQnTkr5sHT2DKZLG7Hqg7HTK' - assert self.client.get_address('Litecoin', [1]) == 'LKRGNecThFP3Q6c5fosLVA53Z2hUDb1qnE' - assert self.client.get_address('Litecoin', [0, H_(1)]) == 'LcinMK8pVrAtpz7Qpc8jfWzSFsDLgLYfG6' - assert self.client.get_address('Litecoin', [H_(9), 0]) == 'LZHVtcwAEDf1BR4d67551zUijyLUpDF9EX' - assert self.client.get_address('Litecoin', [0, 9999999]) == 'Laf5nGHSCT94C5dK6fw2RxuXPiw2ZuRR9S' + assert btc.get_address(self.client, 'Litecoin', []) == 'LYtGrdDeqYUQnTkr5sHT2DKZLG7Hqg7HTK' + assert btc.get_address(self.client, 'Litecoin', [1]) == 'LKRGNecThFP3Q6c5fosLVA53Z2hUDb1qnE' + assert btc.get_address(self.client, 'Litecoin', [0, H_(1)]) == 'LcinMK8pVrAtpz7Qpc8jfWzSFsDLgLYfG6' + assert btc.get_address(self.client, 'Litecoin', [H_(9), 0]) == 'LZHVtcwAEDf1BR4d67551zUijyLUpDF9EX' + assert btc.get_address(self.client, 'Litecoin', [0, 9999999]) == 'Laf5nGHSCT94C5dK6fw2RxuXPiw2ZuRR9S' def test_tbtc(self): self.setup_mnemonic_nopin_nopassphrase() - assert self.client.get_address('Testnet', [111, 42]) == 'moN6aN6NP1KWgnPSqzrrRPvx2x1UtZJssa' + assert btc.get_address(self.client, 'Testnet', [111, 42]) == 'moN6aN6NP1KWgnPSqzrrRPvx2x1UtZJssa' def test_bch(self): self.setup_mnemonic_allallall() - assert self.client.get_address('Bcash', parse_path("44'/145'/0'/0/0")) == 'bitcoincash:qr08q88p9etk89wgv05nwlrkm4l0urz4cyl36hh9sv' - assert self.client.get_address('Bcash', parse_path("44'/145'/0'/0/1")) == 'bitcoincash:qr23ajjfd9wd73l87j642puf8cad20lfmqdgwvpat4' - assert self.client.get_address('Bcash', parse_path("44'/145'/0'/1/0")) == 'bitcoincash:qzc5q87w069lzg7g3gzx0c8dz83mn7l02scej5aluw' + assert btc.get_address(self.client, 'Bcash', parse_path("44'/145'/0'/0/0")) == 'bitcoincash:qr08q88p9etk89wgv05nwlrkm4l0urz4cyl36hh9sv' + assert btc.get_address(self.client, 'Bcash', parse_path("44'/145'/0'/0/1")) == 'bitcoincash:qr23ajjfd9wd73l87j642puf8cad20lfmqdgwvpat4' + assert btc.get_address(self.client, 'Bcash', parse_path("44'/145'/0'/1/0")) == 'bitcoincash:qzc5q87w069lzg7g3gzx0c8dz83mn7l02scej5aluw' def test_bch_multisig(self): self.setup_mnemonic_allallall() xpubs = [] - for n in map(lambda index: self.client.get_public_node(parse_path("44'/145'/" + str(index) + "'")), range(1, 4)): + for n in map(lambda index: btc.get_public_node(self.client, parse_path("44'/145'/" + str(index) + "'")), range(1, 4)): xpubs.append(n.xpub) def getmultisig(chain, nr, signatures=[b'', b'', b''], xpubs=xpubs): @@ -64,20 +65,20 @@ class TestMsgGetaddress(TrezorTest): m=2, ) for nr in range(1, 4): - assert self.client.get_address('Bcash', parse_path("44'/145'/" + str(nr) + "'/0/0"), show_display=(nr == 1), multisig=getmultisig(0, 0)) == 'bitcoincash:pqguz4nqq64jhr5v3kvpq4dsjrkda75hwy86gq0qzw' - assert self.client.get_address('Bcash', parse_path("44'/145'/" + str(nr) + "'/1/0"), show_display=(nr == 1), multisig=getmultisig(1, 0)) == 'bitcoincash:pp6kcpkhua7789g2vyj0qfkcux3yvje7euhyhltn0a' + assert btc.get_address(self.client, 'Bcash', parse_path("44'/145'/" + str(nr) + "'/0/0"), show_display=(nr == 1), multisig=getmultisig(0, 0)) == 'bitcoincash:pqguz4nqq64jhr5v3kvpq4dsjrkda75hwy86gq0qzw' + assert btc.get_address(self.client, 'Bcash', parse_path("44'/145'/" + str(nr) + "'/1/0"), show_display=(nr == 1), multisig=getmultisig(1, 0)) == 'bitcoincash:pp6kcpkhua7789g2vyj0qfkcux3yvje7euhyhltn0a' def test_public_ckd(self): self.setup_mnemonic_nopin_nopassphrase() - node = self.client.get_public_node([]).node - node_sub1 = self.client.get_public_node([1]).node + node = btc.get_public_node(self.client, []).node + node_sub1 = btc.get_public_node(self.client, [1]).node node_sub2 = bip32.public_ckd(node, [1]) assert node_sub1.chain_code == node_sub2.chain_code assert node_sub1.public_key == node_sub2.public_key - address1 = self.client.get_address('Bitcoin', [1]) + address1 = btc.get_address(self.client, 'Bitcoin', [1]) address2 = bip32.get_address(node_sub2, 0) assert address2 == '1CK7SJdcb8z9HuvVft3D91HLpLC6KSsGb' diff --git a/trezorlib/tests/device_tests/test_msg_getaddress_segwit.py b/trezorlib/tests/device_tests/test_msg_getaddress_segwit.py index a5a0563452..79575c51d6 100644 --- a/trezorlib/tests/device_tests/test_msg_getaddress_segwit.py +++ b/trezorlib/tests/device_tests/test_msg_getaddress_segwit.py @@ -18,20 +18,21 @@ from .common import TrezorTest from ..support import ckd_public as bip32 from trezorlib import messages as proto from trezorlib.tools import parse_path +from trezorlib import btc class TestMsgGetaddressSegwit(TrezorTest): def test_show_segwit(self): self.setup_mnemonic_allallall() - assert self.client.get_address("Testnet", parse_path("49'/1'/0'/1/0"), True, None, script_type=proto.InputScriptType.SPENDP2SHWITNESS) == '2N1LGaGg836mqSQqiuUBLfcyGBhyZbremDX' - assert self.client.get_address("Testnet", parse_path("49'/1'/0'/0/0"), False, None, script_type=proto.InputScriptType.SPENDP2SHWITNESS) == '2N4Q5FhU2497BryFfUgbqkAJE87aKHUhXMp' - assert self.client.get_address("Testnet", parse_path("44'/1'/0'/0/0"), False, None, script_type=proto.InputScriptType.SPENDP2SHWITNESS) == '2N6UeBoqYEEnybg4cReFYDammpsyDw8R2Mc' - assert self.client.get_address("Testnet", parse_path("44'/1'/0'/0/0"), False, None, script_type=proto.InputScriptType.SPENDADDRESS) == 'mvbu1Gdy8SUjTenqerxUaZyYjmveZvt33q' + assert btc.get_address(self.client, "Testnet", parse_path("49'/1'/0'/1/0"), True, None, script_type=proto.InputScriptType.SPENDP2SHWITNESS) == '2N1LGaGg836mqSQqiuUBLfcyGBhyZbremDX' + assert btc.get_address(self.client, "Testnet", parse_path("49'/1'/0'/0/0"), False, None, script_type=proto.InputScriptType.SPENDP2SHWITNESS) == '2N4Q5FhU2497BryFfUgbqkAJE87aKHUhXMp' + assert btc.get_address(self.client, "Testnet", parse_path("44'/1'/0'/0/0"), False, None, script_type=proto.InputScriptType.SPENDP2SHWITNESS) == '2N6UeBoqYEEnybg4cReFYDammpsyDw8R2Mc' + assert btc.get_address(self.client, "Testnet", parse_path("44'/1'/0'/0/0"), False, None, script_type=proto.InputScriptType.SPENDADDRESS) == 'mvbu1Gdy8SUjTenqerxUaZyYjmveZvt33q' def test_show_multisig_3(self): self.setup_mnemonic_allallall() - nodes = map(lambda index: self.client.get_public_node(parse_path("999'/1'/%d'" % index)), range(1, 4)) + nodes = map(lambda index: btc.get_public_node(self.client, parse_path("999'/1'/%d'" % index)), range(1, 4)) multisig1 = proto.MultisigRedeemScriptType( pubkeys=list(map(lambda n: proto.HDNodePathType(node=bip32.deserialize(n.xpub), address_n=[2, 0]), nodes)), signatures=[b'', b'', b''], @@ -43,4 +44,4 @@ class TestMsgGetaddressSegwit(TrezorTest): # m=2, # ) for i in [1, 2, 3]: - assert self.client.get_address("Testnet", parse_path("999'/1'/%d'/2/0" % i), False, multisig1, script_type=proto.InputScriptType.SPENDP2SHWITNESS) == '2N2MxyAfifVhb3AMagisxaj3uij8bfXqf4Y' + assert btc.get_address(self.client, "Testnet", parse_path("999'/1'/%d'/2/0" % i), False, multisig1, script_type=proto.InputScriptType.SPENDP2SHWITNESS) == '2N2MxyAfifVhb3AMagisxaj3uij8bfXqf4Y' diff --git a/trezorlib/tests/device_tests/test_msg_getaddress_segwit_native.py b/trezorlib/tests/device_tests/test_msg_getaddress_segwit_native.py index d6c1d7f24e..e54ecbb6ef 100644 --- a/trezorlib/tests/device_tests/test_msg_getaddress_segwit_native.py +++ b/trezorlib/tests/device_tests/test_msg_getaddress_segwit_native.py @@ -18,20 +18,21 @@ from .common import TrezorTest from ..support import ckd_public as bip32 from trezorlib import messages as proto from trezorlib.tools import parse_path +from trezorlib import btc class TestMsgGetaddressSegwitNative(TrezorTest): def test_show_segwit(self): self.setup_mnemonic_allallall() - assert self.client.get_address("Testnet", parse_path("49'/1'/0'/0/0"), True, None, script_type=proto.InputScriptType.SPENDWITNESS) == 'tb1qqzv60m9ajw8drqulta4ld4gfx0rdh82un5s65s' - assert self.client.get_address("Testnet", parse_path("49'/1'/0'/1/0"), False, None, script_type=proto.InputScriptType.SPENDWITNESS) == 'tb1q694ccp5qcc0udmfwgp692u2s2hjpq5h407urtu' - assert self.client.get_address("Testnet", parse_path("44'/1'/0'/0/0"), False, None, script_type=proto.InputScriptType.SPENDWITNESS) == 'tb1q54un3q39sf7e7tlfq99d6ezys7qgc62a6rxllc' - assert self.client.get_address("Testnet", parse_path("44'/1'/0'/0/0"), False, None, script_type=proto.InputScriptType.SPENDADDRESS) == 'mvbu1Gdy8SUjTenqerxUaZyYjmveZvt33q' + assert btc.get_address(self.client, "Testnet", parse_path("49'/1'/0'/0/0"), True, None, script_type=proto.InputScriptType.SPENDWITNESS) == 'tb1qqzv60m9ajw8drqulta4ld4gfx0rdh82un5s65s' + assert btc.get_address(self.client, "Testnet", parse_path("49'/1'/0'/1/0"), False, None, script_type=proto.InputScriptType.SPENDWITNESS) == 'tb1q694ccp5qcc0udmfwgp692u2s2hjpq5h407urtu' + assert btc.get_address(self.client, "Testnet", parse_path("44'/1'/0'/0/0"), False, None, script_type=proto.InputScriptType.SPENDWITNESS) == 'tb1q54un3q39sf7e7tlfq99d6ezys7qgc62a6rxllc' + assert btc.get_address(self.client, "Testnet", parse_path("44'/1'/0'/0/0"), False, None, script_type=proto.InputScriptType.SPENDADDRESS) == 'mvbu1Gdy8SUjTenqerxUaZyYjmveZvt33q' def test_show_multisig_3(self): self.setup_mnemonic_allallall() - nodes = [self.client.get_public_node(parse_path("999'/1'/%d'" % index)) for index in range(1, 4)] + nodes = [btc.get_public_node(self.client, parse_path("999'/1'/%d'" % index)) for index in range(1, 4)] multisig1 = proto.MultisigRedeemScriptType( pubkeys=list(map(lambda n: proto.HDNodePathType(node=bip32.deserialize(n.xpub), address_n=[2, 0]), nodes)), signatures=[b'', b'', b''], @@ -43,5 +44,5 @@ class TestMsgGetaddressSegwitNative(TrezorTest): m=2, ) for i in [1, 2, 3]: - assert self.client.get_address("Testnet", parse_path("999'/1'/%d'/2/1" % i), False, multisig2, script_type=proto.InputScriptType.SPENDWITNESS) == 'tb1qch62pf820spe9mlq49ns5uexfnl6jzcezp7d328fw58lj0rhlhasge9hzy' - assert self.client.get_address("Testnet", parse_path("999'/1'/%d'/2/0" % i), False, multisig1, script_type=proto.InputScriptType.SPENDWITNESS) == 'tb1qr6xa5v60zyt3ry9nmfew2fk5g9y3gerkjeu6xxdz7qga5kknz2ssld9z2z' + assert btc.get_address(self.client, "Testnet", parse_path("999'/1'/%d'/2/1" % i), False, multisig2, script_type=proto.InputScriptType.SPENDWITNESS) == 'tb1qch62pf820spe9mlq49ns5uexfnl6jzcezp7d328fw58lj0rhlhasge9hzy' + assert btc.get_address(self.client, "Testnet", parse_path("999'/1'/%d'/2/0" % i), False, multisig1, script_type=proto.InputScriptType.SPENDWITNESS) == 'tb1qr6xa5v60zyt3ry9nmfew2fk5g9y3gerkjeu6xxdz7qga5kknz2ssld9z2z' diff --git a/trezorlib/tests/device_tests/test_msg_getaddress_show.py b/trezorlib/tests/device_tests/test_msg_getaddress_show.py index 5192b73297..360a9560ed 100644 --- a/trezorlib/tests/device_tests/test_msg_getaddress_show.py +++ b/trezorlib/tests/device_tests/test_msg_getaddress_show.py @@ -17,15 +17,16 @@ from .common import TrezorTest from ..support import ckd_public as bip32 from trezorlib import messages as proto +from trezorlib import btc class TestMsgGetaddressShow(TrezorTest): def test_show(self): self.setup_mnemonic_nopin_nopassphrase() - assert self.client.get_address('Bitcoin', [1], show_display=True) == '1CK7SJdcb8z9HuvVft3D91HLpLC6KSsGb' - assert self.client.get_address('Bitcoin', [2], show_display=True) == '15AeAhtNJNKyowK8qPHwgpXkhsokzLtUpG' - assert self.client.get_address('Bitcoin', [3], show_display=True) == '1CmzyJp9w3NafXMSEFH4SLYUPAVCSUrrJ5' + assert btc.get_address(self.client, 'Bitcoin', [1], show_display=True) == '1CK7SJdcb8z9HuvVft3D91HLpLC6KSsGb' + assert btc.get_address(self.client, 'Bitcoin', [2], show_display=True) == '15AeAhtNJNKyowK8qPHwgpXkhsokzLtUpG' + assert btc.get_address(self.client, 'Bitcoin', [3], show_display=True) == '1CmzyJp9w3NafXMSEFH4SLYUPAVCSUrrJ5' def test_show_multisig_3(self): self.setup_mnemonic_nopin_nopassphrase() @@ -42,7 +43,7 @@ class TestMsgGetaddressShow(TrezorTest): ) for i in [1, 2, 3]: - assert self.client.get_address('Bitcoin', [i], show_display=True, multisig=multisig) == '3E7GDtuHqnqPmDgwH59pVC7AvySiSkbibz' + assert btc.get_address(self.client, 'Bitcoin', [i], show_display=True, multisig=multisig) == '3E7GDtuHqnqPmDgwH59pVC7AvySiSkbibz' def test_show_multisig_15(self): self.setup_mnemonic_nopin_nopassphrase() @@ -60,4 +61,4 @@ class TestMsgGetaddressShow(TrezorTest): ) for i in range(15): - assert self.client.get_address('Bitcoin', [i], show_display=True, multisig=multisig) == '3QaKF8zobqcqY8aS6nxCD5ZYdiRfL3RCmU' + assert btc.get_address(self.client, 'Bitcoin', [i], show_display=True, multisig=multisig) == '3QaKF8zobqcqY8aS6nxCD5ZYdiRfL3RCmU' diff --git a/trezorlib/tests/device_tests/test_msg_getecdhsessionkey.py b/trezorlib/tests/device_tests/test_msg_getecdhsessionkey.py index 988128c439..db1c95f27b 100644 --- a/trezorlib/tests/device_tests/test_msg_getecdhsessionkey.py +++ b/trezorlib/tests/device_tests/test_msg_getecdhsessionkey.py @@ -18,6 +18,7 @@ from binascii import unhexlify from .common import TrezorTest from trezorlib import messages as proto +from trezorlib import misc class TestMsgGetECDHSessionKey(TrezorTest): @@ -29,13 +30,13 @@ class TestMsgGetECDHSessionKey(TrezorTest): identity = proto.IdentityType(proto='gpg', user='', host='Satoshi Nakamoto ', port='', path='', index=0) peer_public_key = unhexlify('0407f2c6e5becf3213c1d07df0cfbe8e39f70a8c643df7575e5c56859ec52c45ca950499c019719dae0fda04248d851e52cf9d66eeb211d89a77be40de22b6c89d') - result = self.client.get_ecdh_session_key(identity=identity, peer_public_key=peer_public_key, ecdsa_curve_name='secp256k1') + result = misc.get_ecdh_session_key(self.client, identity=identity, peer_public_key=peer_public_key, ecdsa_curve_name='secp256k1') assert result.session_key == unhexlify('0495e5d8c9e5cc09e7cf4908774f52decb381ce97f2fc9ba56e959c13f03f9f47a03dd151cbc908bc1db84d46e2c33e7bbb9daddc800f985244c924fd64adf6647') peer_public_key = unhexlify('04811a6c2bd2a547d0dd84747297fec47719e7c3f9b0024f027c2b237be99aac39a9230acbd163d0cb1524a0f5ea4bfed6058cec6f18368f72a12aa0c4d083ff64') - result = self.client.get_ecdh_session_key(identity=identity, peer_public_key=peer_public_key, ecdsa_curve_name='nist256p1') + result = misc.get_ecdh_session_key(self.client, identity=identity, peer_public_key=peer_public_key, ecdsa_curve_name='nist256p1') assert result.session_key == unhexlify('046d1f5c48af2cf2c57076ac2c9d7808db2086f614cb7b8107119ff2c6270cd209749809efe0196f01a0cc633788cef1f4a2bd650c99570d06962f923fca6d8fdf') peer_public_key = unhexlify('40a8cf4b6a64c4314e80f15a8ea55812bd735fbb365936a48b2d78807b575fa17a') - result = self.client.get_ecdh_session_key(identity=identity, peer_public_key=peer_public_key, ecdsa_curve_name='curve25519') + result = misc.get_ecdh_session_key(self.client, identity=identity, peer_public_key=peer_public_key, ecdsa_curve_name='curve25519') assert result.session_key == unhexlify('04e24516669e0b7d3d72e5129fddd07b6644c30915f5c8b7f1f62324afb3624311') diff --git a/trezorlib/tests/device_tests/test_msg_getentropy.py b/trezorlib/tests/device_tests/test_msg_getentropy.py index 0c30a987ff..fb65bbc6bc 100644 --- a/trezorlib/tests/device_tests/test_msg_getentropy.py +++ b/trezorlib/tests/device_tests/test_msg_getentropy.py @@ -16,6 +16,7 @@ import math from .common import TrezorTest +from trezorlib import misc import trezorlib.messages as proto @@ -40,6 +41,6 @@ class TestMsgGetentropy(TrezorTest): for l in [0, 1, 2, 3, 4, 5, 8, 9, 16, 17, 32, 33, 64, 65, 128, 129, 256, 257, 512, 513, 1024]: with self.client: self.client.set_expected_responses([proto.ButtonRequest(code=proto.ButtonRequestType.ProtectCall), proto.Entropy()]) - ent = self.client.get_entropy(l) + ent = misc.get_entropy(self.client, l) assert len(ent) == l print('entropy = ', entropy(ent)) diff --git a/trezorlib/tests/device_tests/test_msg_getpublickey.py b/trezorlib/tests/device_tests/test_msg_getpublickey.py index bb0792c4ef..4c5c01cb72 100644 --- a/trezorlib/tests/device_tests/test_msg_getpublickey.py +++ b/trezorlib/tests/device_tests/test_msg_getpublickey.py @@ -18,37 +18,38 @@ from .common import TrezorTest from ..support import ckd_public as bip32 from trezorlib.tools import H_ +from trezorlib import btc class TestMsgGetpublickey(TrezorTest): def test_btc(self): self.setup_mnemonic_nopin_nopassphrase() - assert bip32.serialize(self.client.get_public_node([]).node, 0x0488B21E) == 'xpub661MyMwAqRbcF1zGijBb2K6x9YiJPh58xpcCeLvTxMX6spkY3PcpJ4ABcCyWfskq5DDxM3e6Ez5ePCqG5bnPUXR4wL8TZWyoDaUdiWW7bKy' - assert self.client.get_public_node([], coin_name='Bitcoin').xpub == 'xpub661MyMwAqRbcF1zGijBb2K6x9YiJPh58xpcCeLvTxMX6spkY3PcpJ4ABcCyWfskq5DDxM3e6Ez5ePCqG5bnPUXR4wL8TZWyoDaUdiWW7bKy' - assert bip32.serialize(self.client.get_public_node([1]).node, 0x0488B21E) == 'xpub68zNxjsTrV8y9AadThLW7dTAqEpZ7xBLFSyJ3X9pjTv6Njg6kxgjXJkzxq8u3ttnjBw1jupQHMP3gpGZzZqd1eh5S4GjkaMhPR18vMyUi8N' - assert self.client.get_public_node([1], coin_name='Bitcoin').xpub == 'xpub68zNxjsTrV8y9AadThLW7dTAqEpZ7xBLFSyJ3X9pjTv6Njg6kxgjXJkzxq8u3ttnjBw1jupQHMP3gpGZzZqd1eh5S4GjkaMhPR18vMyUi8N' - assert bip32.serialize(self.client.get_public_node([0, H_(1)]).node, 0x0488B21E) == 'xpub6A3FoZqYXj1AbW4thRwBh26YwZWbmoyjTaZwwxJjY1oKUpefLepL3RFS9DHKQrjAfxDrzDepYMDZPqXN6upQm3bHQ9xaXD5a3mqni3goF4v' - assert self.client.get_public_node([0, H_(1)], coin_name='Bitcoin').xpub == 'xpub6A3FoZqYXj1AbW4thRwBh26YwZWbmoyjTaZwwxJjY1oKUpefLepL3RFS9DHKQrjAfxDrzDepYMDZPqXN6upQm3bHQ9xaXD5a3mqni3goF4v' - assert bip32.serialize(self.client.get_public_node([H_(9), 0]).node, 0x0488B21E) == 'xpub6A2h5mzLDfYginoD7q7wCWbq18wTbN9gducRr2w5NRTwdLeoT3cJSwefFqW7uXTpVFGtpUyDMBNYs3DNvvXx6NPjF9YEbUQrtxFSWnPtVrv' - assert self.client.get_public_node([H_(9), 0], coin_name='Bitcoin').xpub == 'xpub6A2h5mzLDfYginoD7q7wCWbq18wTbN9gducRr2w5NRTwdLeoT3cJSwefFqW7uXTpVFGtpUyDMBNYs3DNvvXx6NPjF9YEbUQrtxFSWnPtVrv' - assert bip32.serialize(self.client.get_public_node([0, 9999999]).node, 0x0488B21E) == 'xpub6A3FoZqQEK6iwLZ4HFkqSo5fb35BH4bpjC4SPZ63prfLdGYPwYxEuC6o91bUvFFdMzKWe5rs3axHRUjxJaSvBnKKFtnfLwDACRxPxabsv2r' - assert self.client.get_public_node([0, 9999999], coin_name='Bitcoin').xpub == 'xpub6A3FoZqQEK6iwLZ4HFkqSo5fb35BH4bpjC4SPZ63prfLdGYPwYxEuC6o91bUvFFdMzKWe5rs3axHRUjxJaSvBnKKFtnfLwDACRxPxabsv2r' + assert bip32.serialize(btc.get_public_node(self.client, []).node, 0x0488B21E) == 'xpub661MyMwAqRbcF1zGijBb2K6x9YiJPh58xpcCeLvTxMX6spkY3PcpJ4ABcCyWfskq5DDxM3e6Ez5ePCqG5bnPUXR4wL8TZWyoDaUdiWW7bKy' + assert btc.get_public_node(self.client, [], coin_name='Bitcoin').xpub == 'xpub661MyMwAqRbcF1zGijBb2K6x9YiJPh58xpcCeLvTxMX6spkY3PcpJ4ABcCyWfskq5DDxM3e6Ez5ePCqG5bnPUXR4wL8TZWyoDaUdiWW7bKy' + assert bip32.serialize(btc.get_public_node(self.client, [1]).node, 0x0488B21E) == 'xpub68zNxjsTrV8y9AadThLW7dTAqEpZ7xBLFSyJ3X9pjTv6Njg6kxgjXJkzxq8u3ttnjBw1jupQHMP3gpGZzZqd1eh5S4GjkaMhPR18vMyUi8N' + assert btc.get_public_node(self.client, [1], coin_name='Bitcoin').xpub == 'xpub68zNxjsTrV8y9AadThLW7dTAqEpZ7xBLFSyJ3X9pjTv6Njg6kxgjXJkzxq8u3ttnjBw1jupQHMP3gpGZzZqd1eh5S4GjkaMhPR18vMyUi8N' + assert bip32.serialize(btc.get_public_node(self.client, [0, H_(1)]).node, 0x0488B21E) == 'xpub6A3FoZqYXj1AbW4thRwBh26YwZWbmoyjTaZwwxJjY1oKUpefLepL3RFS9DHKQrjAfxDrzDepYMDZPqXN6upQm3bHQ9xaXD5a3mqni3goF4v' + assert btc.get_public_node(self.client, [0, H_(1)], coin_name='Bitcoin').xpub == 'xpub6A3FoZqYXj1AbW4thRwBh26YwZWbmoyjTaZwwxJjY1oKUpefLepL3RFS9DHKQrjAfxDrzDepYMDZPqXN6upQm3bHQ9xaXD5a3mqni3goF4v' + assert bip32.serialize(btc.get_public_node(self.client, [H_(9), 0]).node, 0x0488B21E) == 'xpub6A2h5mzLDfYginoD7q7wCWbq18wTbN9gducRr2w5NRTwdLeoT3cJSwefFqW7uXTpVFGtpUyDMBNYs3DNvvXx6NPjF9YEbUQrtxFSWnPtVrv' + assert btc.get_public_node(self.client, [H_(9), 0], coin_name='Bitcoin').xpub == 'xpub6A2h5mzLDfYginoD7q7wCWbq18wTbN9gducRr2w5NRTwdLeoT3cJSwefFqW7uXTpVFGtpUyDMBNYs3DNvvXx6NPjF9YEbUQrtxFSWnPtVrv' + assert bip32.serialize(btc.get_public_node(self.client, [0, 9999999]).node, 0x0488B21E) == 'xpub6A3FoZqQEK6iwLZ4HFkqSo5fb35BH4bpjC4SPZ63prfLdGYPwYxEuC6o91bUvFFdMzKWe5rs3axHRUjxJaSvBnKKFtnfLwDACRxPxabsv2r' + assert btc.get_public_node(self.client, [0, 9999999], coin_name='Bitcoin').xpub == 'xpub6A3FoZqQEK6iwLZ4HFkqSo5fb35BH4bpjC4SPZ63prfLdGYPwYxEuC6o91bUvFFdMzKWe5rs3axHRUjxJaSvBnKKFtnfLwDACRxPxabsv2r' def test_ltc(self): self.setup_mnemonic_nopin_nopassphrase() - assert bip32.serialize(self.client.get_public_node([]).node, 0x019DA462) == 'Ltub2SSUS19CirucVPGDKDBatBDBEM2s9UbH66pBURfaKrMocCPLhQ7Z7hecy5VYLHA5fRdXwB2e61j2VJCNzVsqKTCVEU1vECjqi5EyczFX9xp' - assert self.client.get_public_node([], coin_name='Litecoin').xpub == 'Ltub2SSUS19CirucVPGDKDBatBDBEM2s9UbH66pBURfaKrMocCPLhQ7Z7hecy5VYLHA5fRdXwB2e61j2VJCNzVsqKTCVEU1vECjqi5EyczFX9xp' - assert bip32.serialize(self.client.get_public_node([1]).node, 0x019DA462) == 'Ltub2VRVRP5VjvSyPXra4BLVyVZPv397sjhUNjBGsbtw6xko77JuQyBULxFSKheviJJ3KQLbL3Cx8P2RnudguTw4raUVjCACRG7jsumUptYx55C' - assert self.client.get_public_node([1], coin_name='Litecoin').xpub == 'Ltub2VRVRP5VjvSyPXra4BLVyVZPv397sjhUNjBGsbtw6xko77JuQyBULxFSKheviJJ3KQLbL3Cx8P2RnudguTw4raUVjCACRG7jsumUptYx55C' - assert bip32.serialize(self.client.get_public_node([0, H_(1)]).node, 0x019DA462) == 'Ltub2WUNGD3aRAKAqsLqHuwBYtCn2MqAXbVsarmvn33quWe2DCHTzfK4s4jsW5oM5G8RGAdSaM3NPNrwVvtV1ourbyNhhHr3BtqcYGc8caf5GoT' - assert self.client.get_public_node([0, H_(1)], coin_name='Litecoin').xpub == 'Ltub2WUNGD3aRAKAqsLqHuwBYtCn2MqAXbVsarmvn33quWe2DCHTzfK4s4jsW5oM5G8RGAdSaM3NPNrwVvtV1ourbyNhhHr3BtqcYGc8caf5GoT' - assert bip32.serialize(self.client.get_public_node([H_(9), 0]).node, 0x019DA462) == 'Ltub2WToYRCN76rgyA59iK7w4Ni45wG2M9fpmBpQg7gBjvJeMiHc7473Gb96ci29Zvs55TgUQcMmCD1vy8aVqpdPwJB9YHRhGAAuPT1nRLLXmFu' - assert self.client.get_public_node([H_(9), 0], coin_name='Litecoin').xpub == 'Ltub2WToYRCN76rgyA59iK7w4Ni45wG2M9fpmBpQg7gBjvJeMiHc7473Gb96ci29Zvs55TgUQcMmCD1vy8aVqpdPwJB9YHRhGAAuPT1nRLLXmFu' - assert bip32.serialize(self.client.get_public_node([0, 9999999]).node, 0x019DA462) == 'Ltub2WUNGD3S7kQjBhpzsjkqJfBtfqPk2r7xrUGRDdqACMW3MeBCbZSyiqbEVt7WaeesxCj6EDFQtcbfXa75DUYN2i6jZ2g81cyCgvijs9J2u2n' - assert self.client.get_public_node([0, 9999999], coin_name='Litecoin').xpub == 'Ltub2WUNGD3S7kQjBhpzsjkqJfBtfqPk2r7xrUGRDdqACMW3MeBCbZSyiqbEVt7WaeesxCj6EDFQtcbfXa75DUYN2i6jZ2g81cyCgvijs9J2u2n' + assert bip32.serialize(btc.get_public_node(self.client, []).node, 0x019DA462) == 'Ltub2SSUS19CirucVPGDKDBatBDBEM2s9UbH66pBURfaKrMocCPLhQ7Z7hecy5VYLHA5fRdXwB2e61j2VJCNzVsqKTCVEU1vECjqi5EyczFX9xp' + assert btc.get_public_node(self.client, [], coin_name='Litecoin').xpub == 'Ltub2SSUS19CirucVPGDKDBatBDBEM2s9UbH66pBURfaKrMocCPLhQ7Z7hecy5VYLHA5fRdXwB2e61j2VJCNzVsqKTCVEU1vECjqi5EyczFX9xp' + assert bip32.serialize(btc.get_public_node(self.client, [1]).node, 0x019DA462) == 'Ltub2VRVRP5VjvSyPXra4BLVyVZPv397sjhUNjBGsbtw6xko77JuQyBULxFSKheviJJ3KQLbL3Cx8P2RnudguTw4raUVjCACRG7jsumUptYx55C' + assert btc.get_public_node(self.client, [1], coin_name='Litecoin').xpub == 'Ltub2VRVRP5VjvSyPXra4BLVyVZPv397sjhUNjBGsbtw6xko77JuQyBULxFSKheviJJ3KQLbL3Cx8P2RnudguTw4raUVjCACRG7jsumUptYx55C' + assert bip32.serialize(btc.get_public_node(self.client, [0, H_(1)]).node, 0x019DA462) == 'Ltub2WUNGD3aRAKAqsLqHuwBYtCn2MqAXbVsarmvn33quWe2DCHTzfK4s4jsW5oM5G8RGAdSaM3NPNrwVvtV1ourbyNhhHr3BtqcYGc8caf5GoT' + assert btc.get_public_node(self.client, [0, H_(1)], coin_name='Litecoin').xpub == 'Ltub2WUNGD3aRAKAqsLqHuwBYtCn2MqAXbVsarmvn33quWe2DCHTzfK4s4jsW5oM5G8RGAdSaM3NPNrwVvtV1ourbyNhhHr3BtqcYGc8caf5GoT' + assert bip32.serialize(btc.get_public_node(self.client, [H_(9), 0]).node, 0x019DA462) == 'Ltub2WToYRCN76rgyA59iK7w4Ni45wG2M9fpmBpQg7gBjvJeMiHc7473Gb96ci29Zvs55TgUQcMmCD1vy8aVqpdPwJB9YHRhGAAuPT1nRLLXmFu' + assert btc.get_public_node(self.client, [H_(9), 0], coin_name='Litecoin').xpub == 'Ltub2WToYRCN76rgyA59iK7w4Ni45wG2M9fpmBpQg7gBjvJeMiHc7473Gb96ci29Zvs55TgUQcMmCD1vy8aVqpdPwJB9YHRhGAAuPT1nRLLXmFu' + assert bip32.serialize(btc.get_public_node(self.client, [0, 9999999]).node, 0x019DA462) == 'Ltub2WUNGD3S7kQjBhpzsjkqJfBtfqPk2r7xrUGRDdqACMW3MeBCbZSyiqbEVt7WaeesxCj6EDFQtcbfXa75DUYN2i6jZ2g81cyCgvijs9J2u2n' + assert btc.get_public_node(self.client, [0, 9999999], coin_name='Litecoin').xpub == 'Ltub2WUNGD3S7kQjBhpzsjkqJfBtfqPk2r7xrUGRDdqACMW3MeBCbZSyiqbEVt7WaeesxCj6EDFQtcbfXa75DUYN2i6jZ2g81cyCgvijs9J2u2n' def test_tbtc(self): self.setup_mnemonic_nopin_nopassphrase() - assert bip32.serialize(self.client.get_public_node([111, 42]).node, 0x043587CF) == 'tpubDAgixSyai5PWbc8N1mBkHDR5nLgAnHFtY7r4y5EzxqAxrt9YUDpZL3kaRoHVvCfrcwNo31c2isBP2uTHcZxEosuKbyJhCAbrvGoPuLUZ7Mz' - assert self.client.get_public_node([111, 42], coin_name='Testnet').xpub == 'tpubDAgixSyai5PWbc8N1mBkHDR5nLgAnHFtY7r4y5EzxqAxrt9YUDpZL3kaRoHVvCfrcwNo31c2isBP2uTHcZxEosuKbyJhCAbrvGoPuLUZ7Mz' + assert bip32.serialize(btc.get_public_node(self.client, [111, 42]).node, 0x043587CF) == 'tpubDAgixSyai5PWbc8N1mBkHDR5nLgAnHFtY7r4y5EzxqAxrt9YUDpZL3kaRoHVvCfrcwNo31c2isBP2uTHcZxEosuKbyJhCAbrvGoPuLUZ7Mz' + assert btc.get_public_node(self.client, [111, 42], coin_name='Testnet').xpub == 'tpubDAgixSyai5PWbc8N1mBkHDR5nLgAnHFtY7r4y5EzxqAxrt9YUDpZL3kaRoHVvCfrcwNo31c2isBP2uTHcZxEosuKbyJhCAbrvGoPuLUZ7Mz' diff --git a/trezorlib/tests/device_tests/test_msg_getpublickey_curve.py b/trezorlib/tests/device_tests/test_msg_getpublickey_curve.py index a6d9550ea7..500476ea96 100644 --- a/trezorlib/tests/device_tests/test_msg_getpublickey_curve.py +++ b/trezorlib/tests/device_tests/test_msg_getpublickey_curve.py @@ -19,30 +19,31 @@ import pytest from .common import TrezorTest from trezorlib.tools import CallException +from trezorlib import btc class TestMsgGetpublickeyCurve(TrezorTest): def test_default_curve(self): self.setup_mnemonic_nopin_nopassphrase() - assert hexlify(self.client.get_public_node([0x80000000 | 111, 42]).node.public_key).decode() == '02e7fcec053f0df94d88c86447970743e8a1979d242d09338dcf8687a9966f7fbc' - assert hexlify(self.client.get_public_node([0x80000000 | 111, 0x80000000 | 42]).node.public_key).decode() == '03ce7b690969d773ba9ed212464eb2b534b87b9b8a9383300bddabe1f093f79220' + assert hexlify(btc.get_public_node(self.client, [0x80000000 | 111, 42]).node.public_key).decode() == '02e7fcec053f0df94d88c86447970743e8a1979d242d09338dcf8687a9966f7fbc' + assert hexlify(btc.get_public_node(self.client, [0x80000000 | 111, 0x80000000 | 42]).node.public_key).decode() == '03ce7b690969d773ba9ed212464eb2b534b87b9b8a9383300bddabe1f093f79220' def test_secp256k1_curve(self): self.setup_mnemonic_nopin_nopassphrase() - assert hexlify(self.client.get_public_node([0x80000000 | 111, 42], ecdsa_curve_name='secp256k1').node.public_key).decode() == '02e7fcec053f0df94d88c86447970743e8a1979d242d09338dcf8687a9966f7fbc' - assert hexlify(self.client.get_public_node([0x80000000 | 111, 0x80000000 | 42], ecdsa_curve_name='secp256k1').node.public_key).decode() == '03ce7b690969d773ba9ed212464eb2b534b87b9b8a9383300bddabe1f093f79220' + assert hexlify(btc.get_public_node(self.client, [0x80000000 | 111, 42], ecdsa_curve_name='secp256k1').node.public_key).decode() == '02e7fcec053f0df94d88c86447970743e8a1979d242d09338dcf8687a9966f7fbc' + assert hexlify(btc.get_public_node(self.client, [0x80000000 | 111, 0x80000000 | 42], ecdsa_curve_name='secp256k1').node.public_key).decode() == '03ce7b690969d773ba9ed212464eb2b534b87b9b8a9383300bddabe1f093f79220' def test_nist256p1_curve(self): self.setup_mnemonic_nopin_nopassphrase() - assert hexlify(self.client.get_public_node([0x80000000 | 111, 42], ecdsa_curve_name='nist256p1').node.public_key).decode() == '02a9ce59b32bd64a70bc52aca96e5d09af65c6b9593ba2a60af8fccfe1437f2129' - assert hexlify(self.client.get_public_node([0x80000000 | 111, 0x80000000 | 42], ecdsa_curve_name='nist256p1').node.public_key).decode() == '026fe35d8afed67dbf0561a1d32922e8ad0cd0d86effbc82be970cbed7d9bab2c2' + assert hexlify(btc.get_public_node(self.client, [0x80000000 | 111, 42], ecdsa_curve_name='nist256p1').node.public_key).decode() == '02a9ce59b32bd64a70bc52aca96e5d09af65c6b9593ba2a60af8fccfe1437f2129' + assert hexlify(btc.get_public_node(self.client, [0x80000000 | 111, 0x80000000 | 42], ecdsa_curve_name='nist256p1').node.public_key).decode() == '026fe35d8afed67dbf0561a1d32922e8ad0cd0d86effbc82be970cbed7d9bab2c2' def test_ed25519_curve(self): self.setup_mnemonic_nopin_nopassphrase() # ed25519 curve does not support public derivation, so test only private derivation paths - assert hexlify(self.client.get_public_node([0x80000000 | 111, 0x80000000 | 42], ecdsa_curve_name='ed25519').node.public_key).decode() == '0069a14b478e508eab6e93303f4e6f5c50b8136627830f2ed5c3a835fc6c0ea2b7' - assert hexlify(self.client.get_public_node([0x80000000 | 111, 0x80000000 | 65535], ecdsa_curve_name='ed25519').node.public_key).decode() == '00514f73a05184458611b14c348fee4fd988d36cf3aee7207737861bac611de991' + assert hexlify(btc.get_public_node(self.client, [0x80000000 | 111, 0x80000000 | 42], ecdsa_curve_name='ed25519').node.public_key).decode() == '0069a14b478e508eab6e93303f4e6f5c50b8136627830f2ed5c3a835fc6c0ea2b7' + assert hexlify(btc.get_public_node(self.client, [0x80000000 | 111, 0x80000000 | 65535], ecdsa_curve_name='ed25519').node.public_key).decode() == '00514f73a05184458611b14c348fee4fd988d36cf3aee7207737861bac611de991' # test failure when using public derivation with pytest.raises(CallException): - self.client.get_public_node([0x80000000 | 111, 42], ecdsa_curve_name='ed25519') + btc.get_public_node(self.client, [0x80000000 | 111, 42], ecdsa_curve_name='ed25519') diff --git a/trezorlib/tests/device_tests/test_msg_lisk_getaddress.py b/trezorlib/tests/device_tests/test_msg_lisk_getaddress.py index 9ad64dc0bb..37376a6753 100644 --- a/trezorlib/tests/device_tests/test_msg_lisk_getaddress.py +++ b/trezorlib/tests/device_tests/test_msg_lisk_getaddress.py @@ -17,6 +17,7 @@ import pytest from .common import TrezorTest +from trezorlib import lisk @pytest.mark.lisk @@ -25,7 +26,7 @@ class TestMsgLiskGetaddress(TrezorTest): def test_lisk_getaddress(self): self.setup_mnemonic_nopin_nopassphrase() - assert self.client.lisk_get_address([2147483692, 2147483782]) == '1431530009238518937L' - assert self.client.lisk_get_address([2147483692, 2147483782, 2147483648]) == '17563781916205589679L' - assert self.client.lisk_get_address([2147483692, 2147483782, 2147483648, 2147483649]) == '1874186517773691964L' - assert self.client.lisk_get_address([2147483692, 2147483782, 2147484647, 2147484647]) == '16295203558710684671L' + assert lisk.get_address(self.client, [2147483692, 2147483782]) == '1431530009238518937L' + assert lisk.get_address(self.client, [2147483692, 2147483782, 2147483648]) == '17563781916205589679L' + assert lisk.get_address(self.client, [2147483692, 2147483782, 2147483648, 2147483649]) == '1874186517773691964L' + assert lisk.get_address(self.client, [2147483692, 2147483782, 2147484647, 2147484647]) == '16295203558710684671L' diff --git a/trezorlib/tests/device_tests/test_msg_lisk_getpublickey.py b/trezorlib/tests/device_tests/test_msg_lisk_getpublickey.py index 164d7a2d8d..9ade7cf2c9 100644 --- a/trezorlib/tests/device_tests/test_msg_lisk_getpublickey.py +++ b/trezorlib/tests/device_tests/test_msg_lisk_getpublickey.py @@ -18,6 +18,7 @@ from binascii import hexlify import pytest from .common import TrezorTest +from trezorlib import lisk @pytest.mark.lisk @@ -26,5 +27,5 @@ class TestMsgLiskGetPublicKey(TrezorTest): def test_lisk_get_public_key(self): self.setup_mnemonic_nopin_nopassphrase() - sig = self.client.lisk_get_public_key([2147483692, 2147483782, 2147483648, 2147483648]) + sig = lisk.get_public_key(self.client, [2147483692, 2147483782, 2147483648, 2147483648]) assert hexlify(sig.public_key) == b'eb56d7bbb5e8ea9269405f7a8527fe126023d1db2c973cfac6f760b60ae27294' diff --git a/trezorlib/tests/device_tests/test_msg_lisk_signmessage.py b/trezorlib/tests/device_tests/test_msg_lisk_signmessage.py index 8dd1cc8ad2..c1dfa25d9e 100644 --- a/trezorlib/tests/device_tests/test_msg_lisk_signmessage.py +++ b/trezorlib/tests/device_tests/test_msg_lisk_signmessage.py @@ -18,6 +18,7 @@ from binascii import hexlify import pytest from .common import TrezorTest +from trezorlib import lisk @pytest.mark.lisk @@ -26,12 +27,12 @@ class TestMsgLiskSignmessage(TrezorTest): def test_sign(self): self.setup_mnemonic_nopin_nopassphrase() - sig = self.client.lisk_sign_message([2147483692, 2147483782, 2147483648, 2147483648], 'This is an example of a signed message.') + sig = lisk.sign_message(self.client, [2147483692, 2147483782, 2147483648, 2147483648], 'This is an example of a signed message.') assert hexlify(sig.public_key) == b'eb56d7bbb5e8ea9269405f7a8527fe126023d1db2c973cfac6f760b60ae27294' assert hexlify(sig.signature) == b'7858ae7cd52ea6d4b17e800ca60144423db5560bfd618b663ffbf26ab66758563df45cbffae8463db22dc285dd94309083b8c807776085b97d05374d79867d05' def test_sign_long(self): self.setup_mnemonic_nopin_nopassphrase() - sig = self.client.lisk_sign_message([2147483692, 2147483782, 2147483648], 'VeryLongMessage!' * 64) + sig = lisk.sign_message(self.client, [2147483692, 2147483782, 2147483648], 'VeryLongMessage!' * 64) assert hexlify(sig.public_key) == b'8bca6b65a1a877767b746ea0b3c4310d404aa113df99c1b554e1802d70185ab5' assert hexlify(sig.signature) == b'458ca5896d0934866992268f7509b5e954d568b1251e20c19bd3149ee3c86ffb5a44d1c2a0abbb99a3ab4767272dbb0e419b4579e890a24919ebbbe6cc0f970f' diff --git a/trezorlib/tests/device_tests/test_msg_lisk_signtx.py b/trezorlib/tests/device_tests/test_msg_lisk_signtx.py index 69280a50a5..a45cb0b5e1 100644 --- a/trezorlib/tests/device_tests/test_msg_lisk_signtx.py +++ b/trezorlib/tests/device_tests/test_msg_lisk_signtx.py @@ -20,6 +20,7 @@ import pytest from .common import TrezorTest from trezorlib import messages as proto from trezorlib.tools import parse_path +from trezorlib import lisk PUBLIC_KEY = unhexlify('eb56d7bbb5e8ea9269405f7a8527fe126023d1db2c973cfac6f760b60ae27294') @@ -40,7 +41,7 @@ class TestMsgLiskSignTx(TrezorTest): ) ]) - self.client.lisk_sign_tx(parse_path("m/44'/134'/0'/0'"), { + lisk.sign_tx(self.client, parse_path("m/44'/134'/0'/0'"), { "amount": "10000000", "recipientId": "9971262264659915921L", "timestamp": 57525937, @@ -61,7 +62,7 @@ class TestMsgLiskSignTx(TrezorTest): ) ]) - self.client.lisk_sign_tx(parse_path("m/44'/134'/0'/0'"), { + lisk.sign_tx(self.client, parse_path("m/44'/134'/0'/0'"), { "amount": "10000000", "recipientId": "9971262264659915921L", "timestamp": 57525937, @@ -84,7 +85,7 @@ class TestMsgLiskSignTx(TrezorTest): ) ]) - self.client.lisk_sign_tx(parse_path("m/44'/134'/0'/0'"), { + lisk.sign_tx(self.client, parse_path("m/44'/134'/0'/0'"), { "amount": "0", "timestamp": 57525937, "type": 1, @@ -108,7 +109,7 @@ class TestMsgLiskSignTx(TrezorTest): ) ]) - self.client.lisk_sign_tx(parse_path("m/44'/134'/0'/0'"), { + lisk.sign_tx(self.client, parse_path("m/44'/134'/0'/0'"), { "amount": "0", "timestamp": 57525937, "type": 2, @@ -132,7 +133,7 @@ class TestMsgLiskSignTx(TrezorTest): ) ]) - self.client.lisk_sign_tx(parse_path("m/44'/134'/0'/0'"), { + lisk.sign_tx(self.client, parse_path("m/44'/134'/0'/0'"), { "amount": "0", "timestamp": 57525937, "type": 3, @@ -157,7 +158,7 @@ class TestMsgLiskSignTx(TrezorTest): ) ]) - self.client.lisk_sign_tx(parse_path("m/44'/134'/0'/0'"), { + lisk.sign_tx(self.client, parse_path("m/44'/134'/0'/0'"), { "amount": "0", "timestamp": 57525937, "type": 4, diff --git a/trezorlib/tests/device_tests/test_msg_lisk_verifymessage.py b/trezorlib/tests/device_tests/test_msg_lisk_verifymessage.py index 0a5b120080..d4018bd303 100644 --- a/trezorlib/tests/device_tests/test_msg_lisk_verifymessage.py +++ b/trezorlib/tests/device_tests/test_msg_lisk_verifymessage.py @@ -19,6 +19,7 @@ import pytest from .common import TrezorTest from trezorlib import messages as proto +from trezorlib import lisk @pytest.mark.lisk @@ -33,11 +34,12 @@ class TestMsgLiskVerifymessage(TrezorTest): proto.ButtonRequest(code=proto.ButtonRequestType.Other), proto.Success(message='Message verified') ]) - self.client.lisk_verify_message( + lisk.verify_message( + self.client, unhexlify('eb56d7bbb5e8ea9269405f7a8527fe126023d1db2c973cfac6f760b60ae27294'), unhexlify('7858ae7cd52ea6d4b17e800ca60144423db5560bfd618b663ffbf26ab66758563df45cbffae8463db22dc285dd94309083b8c807776085b97d05374d79867d05'), 'This is an example of a signed message.' - ) + ) def test_verify_long(self): self.setup_mnemonic_nopin_nopassphrase() @@ -47,7 +49,8 @@ class TestMsgLiskVerifymessage(TrezorTest): proto.ButtonRequest(code=proto.ButtonRequestType.Other), proto.Success(message='Message verified') ]) - self.client.lisk_verify_message( + lisk.verify_message( + self.client, unhexlify('8bca6b65a1a877767b746ea0b3c4310d404aa113df99c1b554e1802d70185ab5'), unhexlify('458ca5896d0934866992268f7509b5e954d568b1251e20c19bd3149ee3c86ffb5a44d1c2a0abbb99a3ab4767272dbb0e419b4579e890a24919ebbbe6cc0f970f'), 'VeryLongMessage!' * 64 diff --git a/trezorlib/tests/device_tests/test_msg_loaddevice.py b/trezorlib/tests/device_tests/test_msg_loaddevice.py index 4c097e366d..60ba94f45a 100644 --- a/trezorlib/tests/device_tests/test_msg_loaddevice.py +++ b/trezorlib/tests/device_tests/test_msg_loaddevice.py @@ -17,6 +17,9 @@ import pytest from .common import TrezorTest +from trezorlib import btc +from trezorlib import debuglink +from trezorlib import device @pytest.mark.skip_t2 @@ -33,7 +36,7 @@ class TestDeviceLoad(TrezorTest): passphrase_protection = self.client.debug.read_passphrase_protection() assert passphrase_protection is False - address = self.client.get_address('Bitcoin', []) + address = btc.get_address(self.client, 'Bitcoin', []) assert address == '1EfKbQupktEMXf4gujJ9kCFo83k1iMqwqK' def test_load_device_2(self): @@ -49,7 +52,7 @@ class TestDeviceLoad(TrezorTest): passphrase_protection = self.client.debug.read_passphrase_protection() assert passphrase_protection is True - address = self.client.get_address('Bitcoin', []) + address = btc.get_address(self.client, 'Bitcoin', []) assert address == '15fiTDFwZd2kauHYYseifGi9daH2wniDHH' def test_load_device_utf(self): @@ -63,25 +66,25 @@ class TestDeviceLoad(TrezorTest): passphrase_nfkc = u'Neuv\u011b\u0159iteln\u011b bezpe\u010dn\xe9 hesl\xed\u010dko' passphrase_nfd = u'Neuve\u030cr\u030citelne\u030c bezpec\u030cne\u0301 hesli\u0301c\u030cko' - self.client.wipe_device() - self.client.load_device_by_mnemonic(mnemonic=words_nfkd, pin='', passphrase_protection=True, label='test', language='english', skip_checksum=True) + device.wipe(self.client) + debuglink.load_device_by_mnemonic(self.client, mnemonic=words_nfkd, pin='', passphrase_protection=True, label='test', language='english', skip_checksum=True) self.client.set_passphrase(passphrase_nfkd) - address_nfkd = self.client.get_address('Bitcoin', []) + address_nfkd = btc.get_address(self.client, 'Bitcoin', []) - self.client.wipe_device() - self.client.load_device_by_mnemonic(mnemonic=words_nfc, pin='', passphrase_protection=True, label='test', language='english', skip_checksum=True) + device.wipe(self.client) + debuglink.load_device_by_mnemonic(self.client, mnemonic=words_nfc, pin='', passphrase_protection=True, label='test', language='english', skip_checksum=True) self.client.set_passphrase(passphrase_nfc) - address_nfc = self.client.get_address('Bitcoin', []) + address_nfc = btc.get_address(self.client, 'Bitcoin', []) - self.client.wipe_device() - self.client.load_device_by_mnemonic(mnemonic=words_nfkc, pin='', passphrase_protection=True, label='test', language='english', skip_checksum=True) + device.wipe(self.client) + debuglink.load_device_by_mnemonic(self.client, mnemonic=words_nfkc, pin='', passphrase_protection=True, label='test', language='english', skip_checksum=True) self.client.set_passphrase(passphrase_nfkc) - address_nfkc = self.client.get_address('Bitcoin', []) + address_nfkc = btc.get_address(self.client, 'Bitcoin', []) - self.client.wipe_device() - self.client.load_device_by_mnemonic(mnemonic=words_nfd, pin='', passphrase_protection=True, label='test', language='english', skip_checksum=True) + device.wipe(self.client) + debuglink.load_device_by_mnemonic(self.client, mnemonic=words_nfd, pin='', passphrase_protection=True, label='test', language='english', skip_checksum=True) self.client.set_passphrase(passphrase_nfd) - address_nfd = self.client.get_address('Bitcoin', []) + address_nfd = btc.get_address(self.client, 'Bitcoin', []) assert address_nfkd == address_nfc assert address_nfkd == address_nfkc diff --git a/trezorlib/tests/device_tests/test_msg_loaddevice_xprv.py b/trezorlib/tests/device_tests/test_msg_loaddevice_xprv.py index 2b397822a5..3fec436301 100644 --- a/trezorlib/tests/device_tests/test_msg_loaddevice_xprv.py +++ b/trezorlib/tests/device_tests/test_msg_loaddevice_xprv.py @@ -17,27 +17,29 @@ import pytest from .common import TrezorTest +from trezorlib import btc +from trezorlib import debuglink @pytest.mark.skip_t2 class TestDeviceLoadXprv(TrezorTest): def test_load_device_xprv_1(self): - self.client.load_device_by_xprv(xprv='xprv9s21ZrQH143K2JF8RafpqtKiTbsbaxEeUaMnNHsm5o6wCW3z8ySyH4UxFVSfZ8n7ESu7fgir8imbZKLYVBxFPND1pniTZ81vKfd45EHKX73', pin='', passphrase_protection=False, label='test', language='english') + debuglink.load_device_by_xprv(self.client, xprv='xprv9s21ZrQH143K2JF8RafpqtKiTbsbaxEeUaMnNHsm5o6wCW3z8ySyH4UxFVSfZ8n7ESu7fgir8imbZKLYVBxFPND1pniTZ81vKfd45EHKX73', pin='', passphrase_protection=False, label='test', language='english') passphrase_protection = self.client.debug.read_passphrase_protection() assert passphrase_protection is False - address = self.client.get_address('Bitcoin', []) + address = btc.get_address(self.client, 'Bitcoin', []) assert address == '128RdrAkJDmqasgvfRf6MC5VcX4HKqH4mR' def test_load_device_xprv_2(self): - self.client.load_device_by_xprv(xprv='xprv9s21ZrQH143K2JF8RafpqtKiTbsbaxEeUaMnNHsm5o6wCW3z8ySyH4UxFVSfZ8n7ESu7fgir8imbZKLYVBxFPND1pniTZ81vKfd45EHKX73', pin='', passphrase_protection=True, label='test', language='english') + debuglink.load_device_by_xprv(self.client, xprv='xprv9s21ZrQH143K2JF8RafpqtKiTbsbaxEeUaMnNHsm5o6wCW3z8ySyH4UxFVSfZ8n7ESu7fgir8imbZKLYVBxFPND1pniTZ81vKfd45EHKX73', pin='', passphrase_protection=True, label='test', language='english') self.client.set_passphrase('passphrase') passphrase_protection = self.client.debug.read_passphrase_protection() assert passphrase_protection is True - address = self.client.get_address('Bitcoin', []) + address = btc.get_address(self.client, 'Bitcoin', []) assert address == '1CHUbFa4wTTPYgkYaw2LHSd5D4qJjMU8ri' diff --git a/trezorlib/tests/device_tests/test_msg_nem_getaddress.py b/trezorlib/tests/device_tests/test_msg_nem_getaddress.py index 2b16dd9807..9ab5be75e9 100644 --- a/trezorlib/tests/device_tests/test_msg_nem_getaddress.py +++ b/trezorlib/tests/device_tests/test_msg_nem_getaddress.py @@ -18,6 +18,7 @@ import pytest from .common import TrezorTest from trezorlib.tools import parse_path +from trezorlib import nem @pytest.mark.nem @@ -25,5 +26,5 @@ class TestMsgNEMGetaddress(TrezorTest): def test_nem_getaddress(self): self.setup_mnemonic_nopin_nopassphrase() - assert self.client.nem_get_address(parse_path("m/44'/1'/0'/0'/0'"), 0x68) == "NB3JCHVARQNGDS3UVGAJPTFE22UQFGMCQGHUBWQN" - assert self.client.nem_get_address(parse_path("m/44'/1'/0'/0'/0'"), 0x98) == "TB3JCHVARQNGDS3UVGAJPTFE22UQFGMCQHSBNBMF" + assert nem.get_address(self.client, parse_path("m/44'/1'/0'/0'/0'"), 0x68) == "NB3JCHVARQNGDS3UVGAJPTFE22UQFGMCQGHUBWQN" + assert nem.get_address(self.client, parse_path("m/44'/1'/0'/0'/0'"), 0x98) == "TB3JCHVARQNGDS3UVGAJPTFE22UQFGMCQHSBNBMF" diff --git a/trezorlib/tests/device_tests/test_msg_nem_signtx_mosaics.py b/trezorlib/tests/device_tests/test_msg_nem_signtx_mosaics.py index e493ba32cd..1ab6b5437d 100644 --- a/trezorlib/tests/device_tests/test_msg_nem_signtx_mosaics.py +++ b/trezorlib/tests/device_tests/test_msg_nem_signtx_mosaics.py @@ -30,7 +30,7 @@ class TestMsgNEMSignTxMosaics(TrezorTest): def test_nem_signtx_mosaic_supply_change(self): self.setup_mnemonic_nopin_nopassphrase() - tx = self.client.nem_sign_tx(parse_path("m/44'/1'/0'/0'/0'"), { + tx = nem.sign_tx(self.client, parse_path("m/44'/1'/0'/0'/0'"), { "timeStamp": 74649215, "fee": 2000000, "type": nem.TYPE_MOSAIC_SUPPLY_CHANGE, @@ -54,7 +54,7 @@ class TestMsgNEMSignTxMosaics(TrezorTest): def test_nem_signtx_mosaic_creation(self): self.setup_mnemonic_nopin_nopassphrase() - tx = self.client.nem_sign_tx(parse_path("m/44'/1'/0'/0'/0'"), { + tx = nem.sign_tx(self.client, parse_path("m/44'/1'/0'/0'/0'"), { "timeStamp": 74649215, "fee": 2000000, "type": nem.TYPE_MOSAIC_CREATION, @@ -81,7 +81,7 @@ class TestMsgNEMSignTxMosaics(TrezorTest): def test_nem_signtx_mosaic_creation_properties(self): self.setup_mnemonic_nopin_nopassphrase() - tx = self.client.nem_sign_tx(parse_path("m/44'/1'/0'/0'/0'"), { + tx = nem.sign_tx(self.client, parse_path("m/44'/1'/0'/0'/0'"), { "timeStamp": 74649215, "fee": 2000000, "type": nem.TYPE_MOSAIC_CREATION, @@ -125,7 +125,7 @@ class TestMsgNEMSignTxMosaics(TrezorTest): def test_nem_signtx_mosaic_creation_levy(self): self.setup_mnemonic_nopin_nopassphrase() - tx = self.client.nem_sign_tx(parse_path("m/44'/1'/0'/0'/0'"), { + tx = nem.sign_tx(self.client, parse_path("m/44'/1'/0'/0'/0'"), { "timeStamp": 74649215, "fee": 2000000, "type": nem.TYPE_MOSAIC_CREATION, diff --git a/trezorlib/tests/device_tests/test_msg_nem_signtx_mosaics_t2.py b/trezorlib/tests/device_tests/test_msg_nem_signtx_mosaics_t2.py index dc5e771280..adf1f56ef4 100644 --- a/trezorlib/tests/device_tests/test_msg_nem_signtx_mosaics_t2.py +++ b/trezorlib/tests/device_tests/test_msg_nem_signtx_mosaics_t2.py @@ -33,7 +33,7 @@ class TestMsgNEMSignTxMosaics(TrezorTest): self.setup_mnemonic_nopin_nopassphrase() with self.client: - tx = self.client.nem_sign_tx(parse_path("m/44'/1'/0'/0'/0'"), { + tx = nem.sign_tx(self.client, parse_path("m/44'/1'/0'/0'/0'"), { "timeStamp": 74649215, "fee": 2000000, "type": nem.TYPE_MOSAIC_SUPPLY_CHANGE, diff --git a/trezorlib/tests/device_tests/test_msg_nem_signtx_multisig.py b/trezorlib/tests/device_tests/test_msg_nem_signtx_multisig.py index c646d48a40..6b265698bc 100644 --- a/trezorlib/tests/device_tests/test_msg_nem_signtx_multisig.py +++ b/trezorlib/tests/device_tests/test_msg_nem_signtx_multisig.py @@ -30,7 +30,7 @@ class TestMsgNEMSignTxMultisig(TrezorTest): def test_nem_signtx_aggregate_modification(self): self.setup_mnemonic_nopin_nopassphrase() - tx = self.client.nem_sign_tx(parse_path("m/44'/1'/0'/0'/0'"), { + tx = nem.sign_tx(self.client, parse_path("m/44'/1'/0'/0'/0'"), { "timeStamp": 74649215, "fee": 2000000, "type": nem.TYPE_AGGREGATE_MODIFICATION, @@ -54,7 +54,7 @@ class TestMsgNEMSignTxMultisig(TrezorTest): def test_nem_signtx_multisig(self): self.setup_mnemonic_nopin_nopassphrase() - tx = self.client.nem_sign_tx(parse_path("m/44'/1'/0'/0'/0'"), { + tx = nem.sign_tx(self.client, parse_path("m/44'/1'/0'/0'/0'"), { "timeStamp": 1, "fee": 10000, "type": nem.TYPE_MULTISIG, @@ -79,7 +79,7 @@ class TestMsgNEMSignTxMultisig(TrezorTest): assert hexlify(tx.data) == b'04100000010000980100000020000000edfd32f6e760648c032f9acb4b30d514265f6a5b5f8a7154f2618922b40620841027000000000000ff5f74049900000001010000010000980200000020000000c5f54ba980fcbb657dbaaa42700539b207873e134d2375efeab5f1ab52f87844983a000000000000320901002800000054414c49434532474d4133344358484437584c4a513533364e4d35554e4b5148544f524e4e54324a80841e000000000025000000010000001d000000746573745f6e656d5f7472616e73616374696f6e5f7472616e73666572' assert hexlify(tx.signature) == b'0cab2fddf2f02b5d7201675b9a71869292fe25ed33a366c7d2cbea7676fed491faaa03310079b7e17884b6ba2e3ea21c4f728d1cca8f190b8288207f6514820a' - tx = self.client.nem_sign_tx(parse_path("m/44'/1'/0'/0'/0'"), { + tx = nem.sign_tx(self.client, parse_path("m/44'/1'/0'/0'/0'"), { "timeStamp": 74649215, "fee": 150, "type": nem.TYPE_MULTISIG, @@ -107,7 +107,7 @@ class TestMsgNEMSignTxMultisig(TrezorTest): def test_nem_signtx_multisig_signer(self): self.setup_mnemonic_nopin_nopassphrase() - tx = self.client.nem_sign_tx(parse_path("m/44'/1'/0'/0'/0'"), { + tx = nem.sign_tx(self.client, parse_path("m/44'/1'/0'/0'/0'"), { "timeStamp": 333, "fee": 200, "type": nem.TYPE_MULTISIG_SIGNATURE, @@ -132,7 +132,7 @@ class TestMsgNEMSignTxMultisig(TrezorTest): assert hexlify(tx.data) == b'02100000010000984d01000020000000edfd32f6e760648c032f9acb4b30d514265f6a5b5f8a7154f2618922b4062084c800000000000000bc010000240000002000000087923cd4805f3babe6b5af9cbb2b08be4458e39531618aed73c911f160c8e38528000000544444324354364c514c49595135364b49584933454e544d36454b3344343450354b5a50464d4b32' assert hexlify(tx.signature) == b'286358a16ae545bff798feab93a713440c7c2f236d52ac0e995669d17a1915b0903667c97fa04418eccb42333cba95b19bccc8ac1faa8224dcfaeb41890ae807' - tx = self.client.nem_sign_tx(parse_path("m/44'/1'/0'/0'/0'"), { + tx = nem.sign_tx(self.client, parse_path("m/44'/1'/0'/0'/0'"), { "timeStamp": 900000, "fee": 200000, "type": nem.TYPE_MULTISIG_SIGNATURE, diff --git a/trezorlib/tests/device_tests/test_msg_nem_signtx_others.py b/trezorlib/tests/device_tests/test_msg_nem_signtx_others.py index d191712e0c..18052c2ee3 100644 --- a/trezorlib/tests/device_tests/test_msg_nem_signtx_others.py +++ b/trezorlib/tests/device_tests/test_msg_nem_signtx_others.py @@ -31,7 +31,7 @@ class TestMsgNEMSignTxOther(TrezorTest): self.setup_mnemonic_nopin_nopassphrase() with self.client: - tx = self.client.nem_sign_tx(parse_path("m/44'/1'/0'/0'/0'"), { + tx = nem.sign_tx(self.client, parse_path("m/44'/1'/0'/0'/0'"), { "timeStamp": 12349215, "fee": 9900, "type": nem.TYPE_IMPORTANCE_TRANSFER, @@ -52,7 +52,7 @@ class TestMsgNEMSignTxOther(TrezorTest): self.setup_mnemonic_nopin_nopassphrase() - tx = self.client.nem_sign_tx(parse_path("m/44'/1'/0'/0'/0'"), { + tx = nem.sign_tx(self.client, parse_path("m/44'/1'/0'/0'/0'"), { "timeStamp": 74649215, "fee": 2000000, "type": nem.TYPE_PROVISION_NAMESPACE, diff --git a/trezorlib/tests/device_tests/test_msg_nem_signtx_transfers.py b/trezorlib/tests/device_tests/test_msg_nem_signtx_transfers.py index 19352cea96..6159aaaa91 100644 --- a/trezorlib/tests/device_tests/test_msg_nem_signtx_transfers.py +++ b/trezorlib/tests/device_tests/test_msg_nem_signtx_transfers.py @@ -46,7 +46,7 @@ class TestMsgNEMSignTx(TrezorTest): proto.NEMSignedTx(), ]) - tx = self.client.nem_sign_tx(parse_path("m/44'/1'/0'/0'/0'"), { + tx = nem.sign_tx(self.client, parse_path("m/44'/1'/0'/0'/0'"), { "timeStamp": 74649215, "amount": 2000000, "fee": 2000000, @@ -77,7 +77,7 @@ class TestMsgNEMSignTx(TrezorTest): proto.NEMSignedTx(), ]) - tx = self.client.nem_sign_tx(parse_path("m/44'/1'/0'/0'/0'"), { + tx = nem.sign_tx(self.client, parse_path("m/44'/1'/0'/0'/0'"), { "timeStamp": 74649215, "amount": 2000000, "fee": 2000000, @@ -103,7 +103,7 @@ class TestMsgNEMSignTx(TrezorTest): def test_nem_signtx_xem_as_mosaic(self): self.setup_mnemonic_nopin_nopassphrase() - tx = self.client.nem_sign_tx(parse_path("m/44'/1'/0'/0'/0'"), { + tx = nem.sign_tx(self.client, parse_path("m/44'/1'/0'/0'/0'"), { "timeStamp": 76809215, "amount": 5000000, "fee": 1000000, @@ -131,7 +131,7 @@ class TestMsgNEMSignTx(TrezorTest): def test_nem_signtx_unknown_mosaic(self): self.setup_mnemonic_nopin_nopassphrase() - tx = self.client.nem_sign_tx(parse_path("m/44'/1'/0'/0'/0'"), { + tx = nem.sign_tx(self.client, parse_path("m/44'/1'/0'/0'/0'"), { "timeStamp": 76809215, "amount": 2000000, "fee": 1000000, @@ -160,7 +160,7 @@ class TestMsgNEMSignTx(TrezorTest): self.setup_mnemonic_nopin_nopassphrase() - tx = self.client.nem_sign_tx(parse_path("m/44'/1'/0'/0'/0'"), { + tx = nem.sign_tx(self.client, parse_path("m/44'/1'/0'/0'/0'"), { "timeStamp": 76809215, "amount": 3000000, "fee": 1000000, @@ -189,7 +189,7 @@ class TestMsgNEMSignTx(TrezorTest): self.setup_mnemonic_nopin_nopassphrase() - tx = self.client.nem_sign_tx(parse_path("m/44'/1'/0'/0'/0'"), { + tx = nem.sign_tx(self.client, parse_path("m/44'/1'/0'/0'/0'"), { "timeStamp": 76809215, "amount": 2000000, "fee": 1000000, @@ -217,7 +217,7 @@ class TestMsgNEMSignTx(TrezorTest): def test_nem_signtx_multiple_mosaics(self): self.setup_mnemonic_nopin_nopassphrase() - tx = self.client.nem_sign_tx(parse_path("m/44'/1'/0'/0'/0'"), { + tx = nem.sign_tx(self.client, parse_path("m/44'/1'/0'/0'/0'"), { "timeStamp": 76809215, "amount": 2000000, "fee": 1000000, diff --git a/trezorlib/tests/device_tests/test_msg_recoverydevice.py b/trezorlib/tests/device_tests/test_msg_recoverydevice.py index c95e981143..cdabc18f1c 100644 --- a/trezorlib/tests/device_tests/test_msg_recoverydevice.py +++ b/trezorlib/tests/device_tests/test_msg_recoverydevice.py @@ -18,6 +18,7 @@ import pytest from .common import TrezorTest from trezorlib import messages as proto +from trezorlib import device @pytest.mark.skip_t2 @@ -189,4 +190,4 @@ class TestMsgRecoverydevice(TrezorTest): def test_already_initialized(self): self.setup_mnemonic_nopin_nopassphrase() with pytest.raises(Exception): - self.client.recovery_device(12, False, False, 'label', 'english') + device.recover(self.client, 12, False, False, 'label', 'english') diff --git a/trezorlib/tests/device_tests/test_msg_recoverydevice_t2.py b/trezorlib/tests/device_tests/test_msg_recoverydevice_t2.py index 73ad3f805e..43304ea3c1 100644 --- a/trezorlib/tests/device_tests/test_msg_recoverydevice_t2.py +++ b/trezorlib/tests/device_tests/test_msg_recoverydevice_t2.py @@ -20,6 +20,7 @@ import pytest from .common import TrezorTest from trezorlib import messages as proto +from trezorlib import device @pytest.mark.skip_t1 @@ -100,4 +101,4 @@ class TestMsgRecoverydeviceT2(TrezorTest): def test_already_initialized(self): self.setup_mnemonic_nopin_nopassphrase() with pytest.raises(Exception): - self.client.recovery_device(12, False, False, 'label', 'english') + device.recover(self.client, 12, False, False, 'label', 'english') diff --git a/trezorlib/tests/device_tests/test_msg_resetdevice.py b/trezorlib/tests/device_tests/test_msg_resetdevice.py index 47f6c5f611..784e5730d6 100644 --- a/trezorlib/tests/device_tests/test_msg_resetdevice.py +++ b/trezorlib/tests/device_tests/test_msg_resetdevice.py @@ -19,6 +19,7 @@ import pytest from .common import TrezorTest, generate_entropy from trezorlib import messages as proto +from trezorlib import device from mnemonic import Mnemonic @@ -203,4 +204,4 @@ class TestMsgResetDevice(TrezorTest): def test_already_initialized(self): self.setup_mnemonic_nopin_nopassphrase() with pytest.raises(Exception): - self.client.reset_device(False, 128, True, True, 'label', 'english') + device.reset(self.client, False, 128, True, True, 'label', 'english') diff --git a/trezorlib/tests/device_tests/test_msg_resetdevice_t2.py b/trezorlib/tests/device_tests/test_msg_resetdevice_t2.py index d363c5cd1b..4236950e83 100644 --- a/trezorlib/tests/device_tests/test_msg_resetdevice_t2.py +++ b/trezorlib/tests/device_tests/test_msg_resetdevice_t2.py @@ -20,6 +20,7 @@ import pytest from .common import TrezorTest, generate_entropy from trezorlib import messages as proto +from trezorlib import device from mnemonic import Mnemonic @@ -203,4 +204,4 @@ class TestMsgResetDeviceT2(TrezorTest): def test_already_initialized(self): self.setup_mnemonic_nopin_nopassphrase() with pytest.raises(Exception): - self.client.reset_device(False, 128, True, True, 'label', 'english') + device.reset(self.client, False, 128, True, True, 'label', 'english') diff --git a/trezorlib/tests/device_tests/test_msg_ripple_get_address.py b/trezorlib/tests/device_tests/test_msg_ripple_get_address.py index 8c1e1c2da0..ed4d420a07 100644 --- a/trezorlib/tests/device_tests/test_msg_ripple_get_address.py +++ b/trezorlib/tests/device_tests/test_msg_ripple_get_address.py @@ -21,6 +21,7 @@ from .conftest import TREZOR_VERSION from binascii import hexlify from trezorlib.ripple import get_address from trezorlib.tools import parse_path, CallException +from trezorlib import debuglink @pytest.mark.ripple @@ -41,7 +42,8 @@ class TestMsgRippleGetAddress(TrezorTest): def test_ripple_get_address_other(self): # data from https://github.com/you21979/node-ripple-bip32/blob/master/test/test.js - self.client.load_device_by_mnemonic( + debuglink.load_device_by_mnemonic( + self.client, mnemonic='armed bundle pudding lazy strategy impulse where identify submit weekend physical antenna flight social acoustic absurd whip snack decide blur unfold fiction pumpkin athlete', pin='', passphrase_protection=False, diff --git a/trezorlib/tests/device_tests/test_msg_signidentity.py b/trezorlib/tests/device_tests/test_msg_signidentity.py index 583340ce0d..efc8db2864 100644 --- a/trezorlib/tests/device_tests/test_msg_signidentity.py +++ b/trezorlib/tests/device_tests/test_msg_signidentity.py @@ -20,6 +20,7 @@ from binascii import hexlify, unhexlify from .common import TrezorTest from trezorlib import messages as proto +from trezorlib import misc def check_path(identity): @@ -56,7 +57,7 @@ class TestMsgSignidentity(TrezorTest): # hash : d0e2389d4c8394a9f3e32de01104bf6e8db2d9e2bb0905d60fffa5a18fd696db # path : m/2147483661/2637750992/2845082444/3761103859/4005495825 identity = proto.IdentityType(proto='https', user='satoshi', host='bitcoin.org', port='', path='/login', index=0) - sig = self.client.sign_identity(identity, hidden, visual) + sig = misc.sign_identity(self.client, identity, hidden, visual) assert sig.address == '17F17smBTX9VTZA9Mj8LM5QGYNZnmziCjL' assert hexlify(sig.public_key) == b'023a472219ad3327b07c18273717bb3a40b39b743756bf287fbd5fa9d263237f45' assert hexlify(sig.signature) == b'20f2d1a42d08c3a362be49275c3ffeeaa415fc040971985548b9f910812237bb41770bf2c8d488428799fbb7e52c11f1a3404011375e4080e077e0e42ab7a5ba02' @@ -65,7 +66,7 @@ class TestMsgSignidentity(TrezorTest): # hash : 79a6b53831c6ff224fb283587adc4ebae8fb0d734734a46c876838f52dff53f3 # path : m/2147483661/3098912377/2734671409/3632509519/3125730426 identity = proto.IdentityType(proto='ftp', user='satoshi', host='bitcoin.org', port='2323', path='/pub', index=3) - sig = self.client.sign_identity(identity, hidden, visual) + sig = misc.sign_identity(self.client, identity, hidden, visual) assert sig.address == '1KAr6r5qF2kADL8bAaRQBjGKYEGxn9WrbS' assert hexlify(sig.public_key) == b'0266cf12d2ba381c5fd797da0d64f59c07a6f1b034ad276cca6bf2729e92b20d9c' assert hexlify(sig.signature) == b'20bbd12dc657d534fc0f7e40186e22c447e0866a016f654f380adffa9a84e9faf412a1bb0ae908296537838cf91145e77da08681c63d07b7dca40728b9e6cb17cf' @@ -74,7 +75,7 @@ class TestMsgSignidentity(TrezorTest): # hash : 5fa612f558a1a3b1fb7f010b2ea0a25cb02520a0ffa202ce74a92fc6145da5f3 # path : m/2147483661/4111640159/2980290904/2332131323/3701645358 identity = proto.IdentityType(proto='ssh', user='satoshi', host='bitcoin.org', port='', path='', index=47) - sig = self.client.sign_identity(identity, hidden, visual, ecdsa_curve_name='nist256p1') + sig = misc.sign_identity(self.client, identity, hidden, visual, ecdsa_curve_name='nist256p1') assert sig.address is None assert hexlify(sig.public_key) == b'0373f21a3da3d0e96fc2189f81dd826658c3d76b2d55bd1da349bc6c3573b13ae4' assert hexlify(sig.signature) == b'005122cebabb852cdd32103b602662afa88e54c0c0c1b38d7099c64dcd49efe908288114e66ed2d8c82f23a70b769a4db723173ec53840c08aafb840d3f09a18d3' @@ -83,7 +84,7 @@ class TestMsgSignidentity(TrezorTest): # hash : 5fa612f558a1a3b1fb7f010b2ea0a25cb02520a0ffa202ce74a92fc6145da5f3 # path : m/2147483661/4111640159/2980290904/2332131323/3701645358 identity = proto.IdentityType(proto='ssh', user='satoshi', host='bitcoin.org', port='', path='', index=47) - sig = self.client.sign_identity(identity, hidden, visual, ecdsa_curve_name='ed25519') + sig = misc.sign_identity(self.client, identity, hidden, visual, ecdsa_curve_name='ed25519') assert sig.address is None assert hexlify(sig.public_key) == b'000fac2a491e0f5b871dc48288a4cae551bac5cb0ed19df0764d6e721ec5fade18' assert hexlify(sig.signature) == b'00f05e5085e666429de397c70a081932654369619c0bd2a6579ea6c1ef2af112ef79998d6c862a16b932d44b1ac1b83c8cbcd0fbda228274fde9e0d0ca6e9cb709' diff --git a/trezorlib/tests/device_tests/test_msg_signmessage.py b/trezorlib/tests/device_tests/test_msg_signmessage.py index e86824a718..1db56bd669 100644 --- a/trezorlib/tests/device_tests/test_msg_signmessage.py +++ b/trezorlib/tests/device_tests/test_msg_signmessage.py @@ -17,31 +17,32 @@ from binascii import hexlify from .common import TrezorTest +from trezorlib import btc class TestMsgSignmessage(TrezorTest): def test_sign(self): self.setup_mnemonic_nopin_nopassphrase() - sig = self.client.sign_message('Bitcoin', [0], "This is an example of a signed message.") + sig = btc.sign_message(self.client, 'Bitcoin', [0], "This is an example of a signed message.") assert sig.address == '14LmW5k4ssUrtbAB4255zdqv3b4w1TuX9e' assert hexlify(sig.signature) == b'209e23edf0e4e47ff1dec27f32cd78c50e74ef018ee8a6adf35ae17c7a9b0dd96f48b493fd7dbab03efb6f439c6383c9523b3bbc5f1a7d158a6af90ab154e9be80' def test_sign_testnet(self): self.setup_mnemonic_nopin_nopassphrase() - sig = self.client.sign_message('Testnet', [0], "This is an example of a signed message.") + sig = btc.sign_message(self.client, 'Testnet', [0], "This is an example of a signed message.") assert sig.address == 'mirio8q3gtv7fhdnmb3TpZ4EuafdzSs7zL' assert hexlify(sig.signature) == b'209e23edf0e4e47ff1dec27f32cd78c50e74ef018ee8a6adf35ae17c7a9b0dd96f48b493fd7dbab03efb6f439c6383c9523b3bbc5f1a7d158a6af90ab154e9be80' def test_sign_bch(self): self.setup_mnemonic_nopin_nopassphrase() - sig = self.client.sign_message('Bcash', [0], "This is an example of a signed message.") + sig = btc.sign_message(self.client, 'Bcash', [0], "This is an example of a signed message.") assert sig.address == 'bitcoincash:qqj22md58nm09vpwsw82fyletkxkq36zxyxh322pru' assert hexlify(sig.signature) == b'209e23edf0e4e47ff1dec27f32cd78c50e74ef018ee8a6adf35ae17c7a9b0dd96f48b493fd7dbab03efb6f439c6383c9523b3bbc5f1a7d158a6af90ab154e9be80' def test_sign_long(self): self.setup_mnemonic_nopin_nopassphrase() - sig = self.client.sign_message('Bitcoin', [0], "VeryLongMessage!" * 64) + sig = btc.sign_message(self.client, 'Bitcoin', [0], "VeryLongMessage!" * 64) assert sig.address == '14LmW5k4ssUrtbAB4255zdqv3b4w1TuX9e' assert hexlify(sig.signature) == b'205ff795c29aef7538f8b3bdb2e8add0d0722ad630a140b6aefd504a5a895cbd867cbb00981afc50edd0398211e8d7c304bb8efa461181bc0afa67ea4a720a89ed' @@ -51,10 +52,10 @@ class TestMsgSignmessage(TrezorTest): words_nfkd = u'Pr\u030ci\u0301s\u030cerne\u030c z\u030clut\u030couc\u030cky\u0301 ku\u030an\u030c u\u0301pe\u030cl d\u030ca\u0301belske\u0301 o\u0301dy za\u0301ker\u030cny\u0301 uc\u030cen\u030c be\u030cz\u030ci\u0301 pode\u0301l zo\u0301ny u\u0301lu\u030a' words_nfc = u'P\u0159\xed\u0161ern\u011b \u017elu\u0165ou\u010dk\xfd k\u016f\u0148 \xfap\u011bl \u010f\xe1belsk\xe9 \xf3dy z\xe1ke\u0159n\xfd u\u010de\u0148 b\u011b\u017e\xed pod\xe9l z\xf3ny \xfal\u016f' - sig_nfkd = self.client.sign_message('Bitcoin', [0], words_nfkd) + sig_nfkd = btc.sign_message(self.client, 'Bitcoin', [0], words_nfkd) assert sig_nfkd.address == '14LmW5k4ssUrtbAB4255zdqv3b4w1TuX9e' assert hexlify(sig_nfkd.signature) == b'20d0ec02ed8da8df23e7fe9e680e7867cc290312fe1c970749d8306ddad1a1eda41c6a771b13d495dd225b13b0a9d0f915a984ee3d0703f92287bf8009fbb9f7d6' - sig_nfc = self.client.sign_message('Bitcoin', [0], words_nfc) + sig_nfc = btc.sign_message(self.client, 'Bitcoin', [0], words_nfc) assert sig_nfc.address == '14LmW5k4ssUrtbAB4255zdqv3b4w1TuX9e' assert hexlify(sig_nfc.signature) == b'20d0ec02ed8da8df23e7fe9e680e7867cc290312fe1c970749d8306ddad1a1eda41c6a771b13d495dd225b13b0a9d0f915a984ee3d0703f92287bf8009fbb9f7d6' diff --git a/trezorlib/tests/device_tests/test_msg_signmessage_segwit.py b/trezorlib/tests/device_tests/test_msg_signmessage_segwit.py index e7981c2edf..4f537be3ed 100644 --- a/trezorlib/tests/device_tests/test_msg_signmessage_segwit.py +++ b/trezorlib/tests/device_tests/test_msg_signmessage_segwit.py @@ -18,25 +18,26 @@ from binascii import hexlify from .common import TrezorTest from trezorlib import messages as proto +from trezorlib import btc class TestMsgSignmessageSegwit(TrezorTest): def test_sign(self): self.setup_mnemonic_nopin_nopassphrase() - sig = self.client.sign_message('Bitcoin', [0], "This is an example of a signed message.", script_type=proto.InputScriptType.SPENDP2SHWITNESS) + sig = btc.sign_message(self.client, 'Bitcoin', [0], "This is an example of a signed message.", script_type=proto.InputScriptType.SPENDP2SHWITNESS) assert sig.address == '3CwYaeWxhpXXiHue3ciQez1DLaTEAXcKa1' assert hexlify(sig.signature) == b'249e23edf0e4e47ff1dec27f32cd78c50e74ef018ee8a6adf35ae17c7a9b0dd96f48b493fd7dbab03efb6f439c6383c9523b3bbc5f1a7d158a6af90ab154e9be80' def test_sign_testnet(self): self.setup_mnemonic_nopin_nopassphrase() - sig = self.client.sign_message('Testnet', [0], "This is an example of a signed message.", script_type=proto.InputScriptType.SPENDP2SHWITNESS) + sig = btc.sign_message(self.client, 'Testnet', [0], "This is an example of a signed message.", script_type=proto.InputScriptType.SPENDP2SHWITNESS) assert sig.address == '2N4VkePSzKH2sv5YBikLHGvzUYvfPxV6zS9' assert hexlify(sig.signature) == b'249e23edf0e4e47ff1dec27f32cd78c50e74ef018ee8a6adf35ae17c7a9b0dd96f48b493fd7dbab03efb6f439c6383c9523b3bbc5f1a7d158a6af90ab154e9be80' def test_sign_long(self): self.setup_mnemonic_nopin_nopassphrase() - sig = self.client.sign_message('Bitcoin', [0], "VeryLongMessage!" * 64, script_type=proto.InputScriptType.SPENDP2SHWITNESS) + sig = btc.sign_message(self.client, 'Bitcoin', [0], "VeryLongMessage!" * 64, script_type=proto.InputScriptType.SPENDP2SHWITNESS) assert sig.address == '3CwYaeWxhpXXiHue3ciQez1DLaTEAXcKa1' assert hexlify(sig.signature) == b'245ff795c29aef7538f8b3bdb2e8add0d0722ad630a140b6aefd504a5a895cbd867cbb00981afc50edd0398211e8d7c304bb8efa461181bc0afa67ea4a720a89ed' @@ -46,10 +47,10 @@ class TestMsgSignmessageSegwit(TrezorTest): words_nfkd = u'Pr\u030ci\u0301s\u030cerne\u030c z\u030clut\u030couc\u030cky\u0301 ku\u030an\u030c u\u0301pe\u030cl d\u030ca\u0301belske\u0301 o\u0301dy za\u0301ker\u030cny\u0301 uc\u030cen\u030c be\u030cz\u030ci\u0301 pode\u0301l zo\u0301ny u\u0301lu\u030a' words_nfc = u'P\u0159\xed\u0161ern\u011b \u017elu\u0165ou\u010dk\xfd k\u016f\u0148 \xfap\u011bl \u010f\xe1belsk\xe9 \xf3dy z\xe1ke\u0159n\xfd u\u010de\u0148 b\u011b\u017e\xed pod\xe9l z\xf3ny \xfal\u016f' - sig_nfkd = self.client.sign_message('Bitcoin', [0], words_nfkd, script_type=proto.InputScriptType.SPENDP2SHWITNESS) + sig_nfkd = btc.sign_message(self.client, 'Bitcoin', [0], words_nfkd, script_type=proto.InputScriptType.SPENDP2SHWITNESS) assert sig_nfkd.address == '3CwYaeWxhpXXiHue3ciQez1DLaTEAXcKa1' assert hexlify(sig_nfkd.signature) == b'24d0ec02ed8da8df23e7fe9e680e7867cc290312fe1c970749d8306ddad1a1eda41c6a771b13d495dd225b13b0a9d0f915a984ee3d0703f92287bf8009fbb9f7d6' - sig_nfc = self.client.sign_message('Bitcoin', [0], words_nfc, script_type=proto.InputScriptType.SPENDP2SHWITNESS) + sig_nfc = btc.sign_message(self.client, 'Bitcoin', [0], words_nfc, script_type=proto.InputScriptType.SPENDP2SHWITNESS) assert sig_nfc.address == '3CwYaeWxhpXXiHue3ciQez1DLaTEAXcKa1' assert hexlify(sig_nfc.signature) == b'24d0ec02ed8da8df23e7fe9e680e7867cc290312fe1c970749d8306ddad1a1eda41c6a771b13d495dd225b13b0a9d0f915a984ee3d0703f92287bf8009fbb9f7d6' diff --git a/trezorlib/tests/device_tests/test_msg_signmessage_segwit_native.py b/trezorlib/tests/device_tests/test_msg_signmessage_segwit_native.py index 748f9f98a8..b5afd6071d 100644 --- a/trezorlib/tests/device_tests/test_msg_signmessage_segwit_native.py +++ b/trezorlib/tests/device_tests/test_msg_signmessage_segwit_native.py @@ -18,25 +18,26 @@ from binascii import hexlify from .common import TrezorTest from trezorlib import messages as proto +from trezorlib import btc class TestMsgSignmessageSegwitNative(TrezorTest): def test_sign(self): self.setup_mnemonic_nopin_nopassphrase() - sig = self.client.sign_message('Bitcoin', [0], "This is an example of a signed message.", script_type=proto.InputScriptType.SPENDWITNESS) + sig = btc.sign_message(self.client, 'Bitcoin', [0], "This is an example of a signed message.", script_type=proto.InputScriptType.SPENDWITNESS) assert sig.address == 'bc1qyjjkmdpu7metqt5r36jf872a34syws33s82q2j' assert hexlify(sig.signature) == b'289e23edf0e4e47ff1dec27f32cd78c50e74ef018ee8a6adf35ae17c7a9b0dd96f48b493fd7dbab03efb6f439c6383c9523b3bbc5f1a7d158a6af90ab154e9be80' def test_sign_testnet(self): self.setup_mnemonic_nopin_nopassphrase() - sig = self.client.sign_message('Testnet', [0], "This is an example of a signed message.", script_type=proto.InputScriptType.SPENDWITNESS) + sig = btc.sign_message(self.client, 'Testnet', [0], "This is an example of a signed message.", script_type=proto.InputScriptType.SPENDWITNESS) assert sig.address == 'tb1qyjjkmdpu7metqt5r36jf872a34syws336p3n3p' assert hexlify(sig.signature) == b'289e23edf0e4e47ff1dec27f32cd78c50e74ef018ee8a6adf35ae17c7a9b0dd96f48b493fd7dbab03efb6f439c6383c9523b3bbc5f1a7d158a6af90ab154e9be80' def test_sign_long(self): self.setup_mnemonic_nopin_nopassphrase() - sig = self.client.sign_message('Bitcoin', [0], "VeryLongMessage!" * 64, script_type=proto.InputScriptType.SPENDWITNESS) + sig = btc.sign_message(self.client, 'Bitcoin', [0], "VeryLongMessage!" * 64, script_type=proto.InputScriptType.SPENDWITNESS) assert sig.address == 'bc1qyjjkmdpu7metqt5r36jf872a34syws33s82q2j' assert hexlify(sig.signature) == b'285ff795c29aef7538f8b3bdb2e8add0d0722ad630a140b6aefd504a5a895cbd867cbb00981afc50edd0398211e8d7c304bb8efa461181bc0afa67ea4a720a89ed' @@ -46,10 +47,10 @@ class TestMsgSignmessageSegwitNative(TrezorTest): words_nfkd = u'Pr\u030ci\u0301s\u030cerne\u030c z\u030clut\u030couc\u030cky\u0301 ku\u030an\u030c u\u0301pe\u030cl d\u030ca\u0301belske\u0301 o\u0301dy za\u0301ker\u030cny\u0301 uc\u030cen\u030c be\u030cz\u030ci\u0301 pode\u0301l zo\u0301ny u\u0301lu\u030a' words_nfc = u'P\u0159\xed\u0161ern\u011b \u017elu\u0165ou\u010dk\xfd k\u016f\u0148 \xfap\u011bl \u010f\xe1belsk\xe9 \xf3dy z\xe1ke\u0159n\xfd u\u010de\u0148 b\u011b\u017e\xed pod\xe9l z\xf3ny \xfal\u016f' - sig_nfkd = self.client.sign_message('Bitcoin', [0], words_nfkd, script_type=proto.InputScriptType.SPENDWITNESS) + sig_nfkd = btc.sign_message(self.client, 'Bitcoin', [0], words_nfkd, script_type=proto.InputScriptType.SPENDWITNESS) assert sig_nfkd.address == 'bc1qyjjkmdpu7metqt5r36jf872a34syws33s82q2j' assert hexlify(sig_nfkd.signature) == b'28d0ec02ed8da8df23e7fe9e680e7867cc290312fe1c970749d8306ddad1a1eda41c6a771b13d495dd225b13b0a9d0f915a984ee3d0703f92287bf8009fbb9f7d6' - sig_nfc = self.client.sign_message('Bitcoin', [0], words_nfc, script_type=proto.InputScriptType.SPENDWITNESS) + sig_nfc = btc.sign_message(self.client, 'Bitcoin', [0], words_nfc, script_type=proto.InputScriptType.SPENDWITNESS) assert sig_nfc.address == 'bc1qyjjkmdpu7metqt5r36jf872a34syws33s82q2j' assert hexlify(sig_nfc.signature) == b'28d0ec02ed8da8df23e7fe9e680e7867cc290312fe1c970749d8306ddad1a1eda41c6a771b13d495dd225b13b0a9d0f915a984ee3d0703f92287bf8009fbb9f7d6' diff --git a/trezorlib/tests/device_tests/test_msg_signtx.py b/trezorlib/tests/device_tests/test_msg_signtx.py index ec0dfecd00..49360f2ff2 100644 --- a/trezorlib/tests/device_tests/test_msg_signtx.py +++ b/trezorlib/tests/device_tests/test_msg_signtx.py @@ -23,6 +23,7 @@ from .conftest import TREZOR_VERSION from trezorlib import messages as proto from trezorlib.tx_api import TxApiInsight from trezorlib.tools import parse_path, CallException +from trezorlib import btc TxApiTestnet = TxApiInsight("insight_testnet") @@ -78,7 +79,7 @@ class TestMsgSigntx(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures, serialized_tx) = self.client.sign_tx('Bitcoin', [inp1, ], [out1, ]) + (signatures, serialized_tx) = btc.sign_tx(self.client, 'Bitcoin', [inp1, ], [out1, ]) # Accepted by network: tx fd79435246dee76b2f159d2db08032d666c95adc544de64c8c49f474df4a7fee assert hexlify(serialized_tx) == b'010000000182488650ef25a58fef6788bd71b8212038d7f2bbe4750bc7bcb44701e85ef6d5000000006b4830450221009a0b7be0d4ed3146ee262b42202841834698bb3ee39c24e7437df208b8b7077102202b79ab1e7736219387dffe8d615bbdba87e11477104b867ef47afed1a5ede7810121023230848585885f63803a0a8aecdd6538792d5c539215c91698e315bf0253b43dffffffff0160cc0500000000001976a914de9b2a8da088824e8fe51debea566617d851537888ac00000000' @@ -127,7 +128,7 @@ class TestMsgSigntx(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXOUTPUT, details=proto.TxRequestDetailsType(request_index=1)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures, serialized_tx) = self.client.sign_tx('Testnet', [inp1, ], [out1, out2]) + (signatures, serialized_tx) = btc.sign_tx(self.client, 'Testnet', [inp1, ], [out1, out2]) assert hexlify(serialized_tx) == b'0100000001cd3b93f5b24ae190ce5141235091cd93fbb2908e24e5b9ff6776aec11b0e04e5000000006b483045022100eba3bbcbb82ab1ebac88a394e8fb53b0263dadbb3e8072f0a21ee62818c911060220686a9b7f306d028b54a228b5c47cc6c27b1d01a3b0770440bcc64d55d8bace2c0121030e669acac1f280d1ddf441cd2ba5e97417bf2689e4bbec86df4f831bf9f7ffd0ffffffff021023cb01000000001976a91485eb47fe98f349065d6f044e27a4ac541af79ee288aca0bb0d00000000001976a9143d3cca567e00a04819742b21a696a67da796498b88ac00000000' @@ -177,7 +178,7 @@ class TestMsgSigntx(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXOUTPUT, details=proto.TxRequestDetailsType(request_index=1)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures, serialized_tx) = self.client.sign_tx('Testnet', [inp1, ], [out1, out2]) + (signatures, serialized_tx) = btc.sign_tx(self.client, 'Testnet', [inp1, ], [out1, out2]) assert hexlify(serialized_tx) == b'0100000001549d2977998f899a63c0a9da30dedb2841e33fef561097b05822eccbc7f3906f010000006a47304402205ea68e9d52d4be14420ccecf7f2e11489d49b86bedb79ee99b5e9b7188884150022056219cb3384a5df8048cca286a9533403dbda1571afd84b51379cdaee6a6dea80121023230848585885f63803a0a8aecdd6538792d5c539215c91698e315bf0253b43dffffffff020084d717000000001976a9140223b1a09138753c9cb0baf95a0a62c82711567a88ac0065cd1d000000001976a9142db345c36563122e2fd0f5485fb7ea9bbf7cb5a288ac00000000' @@ -223,7 +224,7 @@ class TestMsgSigntx(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXOUTPUT, details=proto.TxRequestDetailsType(request_index=1)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures, serialized_tx) = self.client.sign_tx('Bitcoin', [inp1, ], [out1, out2]) + (signatures, serialized_tx) = btc.sign_tx(self.client, 'Bitcoin', [inp1, ], [out1, out2]) assert hexlify(serialized_tx) == b'01000000016d20f69067ad1ffd50ee7c0f377dde2c932ccb03e84b5659732da99c20f1f650010000006a47304402203429bd3ce7b38c5c1e8a15340edd79ced41a2939aae62e259d2e3d18e0c5ee7602201b83b10ebc4d6dcee3f9eb42ba8f1ef8a059a05397e0c1b9223d1565a3e6ec01012102a7a079c1ef9916b289c2ff21a992c808d0de3dfcf8a9f163205c5c9e21f55d5cffffffff0230750000000000001976a914954820f1de627a703596ac0396f986d958e3de4c88ac10270000000000001976a91405427736705cfbfaff76b1cff48283707fb1037088ac00000000' @@ -281,7 +282,7 @@ class TestMsgSigntx(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXOUTPUT, details=proto.TxRequestDetailsType(request_index=2)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures, serialized_tx) = self.client.sign_tx('Bitcoin', [inp1, ], [out1, out2, out3]) + (signatures, serialized_tx) = btc.sign_tx(self.client, 'Bitcoin', [inp1, ], [out1, out2, out3]) assert hexlify(serialized_tx) == b'010000000182488650ef25a58fef6788bd71b8212038d7f2bbe4750bc7bcb44701e85ef6d5000000006b483045022100e695e2c530c7c0fc32e6b79b7cff56a7f70a8c9da787534f46b4204070f914fc02207b0879a81408a11e23b11d4c7965c62b5fc6d5c2d92340f5ee2da7b40e99314a0121023230848585885f63803a0a8aecdd6538792d5c539215c91698e315bf0253b43dffffffff0300650400000000001976a914de9b2a8da088824e8fe51debea566617d851537888ace02e0000000000001976a9141fe1d337fb81afca42818051e12fd18245d1b17288ac80380100000000001976a9140223b1a09138753c9cb0baf95a0a62c82711567a88ac00000000' @@ -349,7 +350,7 @@ class TestMsgSigntx(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXOUTPUT, details=proto.TxRequestDetailsType(request_index=1)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures, serialized_tx) = self.client.sign_tx('Bitcoin', [inp1, inp2], [out1, out2]) + (signatures, serialized_tx) = btc.sign_tx(self.client, 'Bitcoin', [inp1, inp2], [out1, out2]) # Accepted by network: tx c63e24ed820c5851b60c54613fbc4bcb37df6cd49b4c96143e99580a472f79fb assert hexlify(serialized_tx) == b'01000000021c032e5715d1da8115a2fe4f57699e15742fe113b0d2d1ca3b594649d322bec6010000006b483045022100f773c403b2f85a5c1d6c9c4ad69c43de66930fff4b1bc818eb257af98305546a0220443bde4be439f276a6ce793664b463580e210ec6c9255d68354449ac0443c76501210338d78612e990f2eea0c426b5e48a8db70b9d7ed66282b3b26511e0b1c75515a6ffffffff6ea42cd8d9c8e5441c4c5f85bfe50311078730d2881494f11f4d2257777a4958010000006b48304502210090cff1c1911e771605358a8cddd5ae94c7b60cc96e50275908d9bf9d6367c79f02202bfa72e10260a146abd59d0526e1335bacfbb2b4401780e9e3a7441b0480c8da0121038caebd6f753bbbd2bb1f3346a43cd32140648583673a31d62f2dfb56ad0ab9e3ffffffff02a0860100000000001976a9142f4490d5263906e4887ca2996b9e207af3e7824088aca0860100000000001976a914812c13d97f9159e54e326b481b8f88a73df8507a88ac00000000' @@ -441,7 +442,7 @@ class TestMsgSigntx(TrezorTest): ] + [ proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures, serialized_tx) = self.client.sign_tx('Bitcoin', [inp1, inp2], outputs) + (signatures, serialized_tx) = btc.sign_tx(self.client, 'Bitcoin', [inp1, inp2], outputs) if cnt == 255: assert hexlify(serialized_tx) == b'0100000002fb792f470a58993e14964c9bd46cdf37cb4bbc3f61540cb651580c82ed243ec6010000006b483045022100969da46f94a81f34f3717b014e0c3e1826eda1b0022ec2f9ce39f3d750ab9235022026da269770993211a1503413566a339bbb4389a482fffcf8e1f76713fc3b94f5012103477b9f0f34ae85434ce795f0c5e1e90c9420e5b5fad084d7cce9a487b94a7902ffffffffe56582d2119100cb1d3da8232291e053f71e25fb669c87b32a667749959ea239010000006a473044022052e1419bb237b9db400ab5e3df16db6355619d545fde9030924a360763ae9ad40220704beab04d72ecaeb42eca7d98faca7a0941e65f2e1341f183be2b83e6b09e1c012103477b9f0f34ae85434ce795f0c5e1e90c9420e5b5fad084d7cce9a487b94a7902fffffffffdff00' + b'd8270000000000001976a914f0a2b64e56ee2ff57126232f84af6e3a41d4055088ac' * cnt + b'00000000' @@ -481,7 +482,7 @@ class TestMsgSigntx(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXOUTPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures, serialized_tx) = self.client.sign_tx('Bitcoin', [inp1, ], [out1, ]) + (signatures, serialized_tx) = btc.sign_tx(self.client, 'Bitcoin', [inp1, ], [out1, ]) assert hexlify(serialized_tx) == b'0100000001a6cab19c507e547ec87c1f3074d8fdd8379e90e6d5af7929f52c30b46e417015000000006b483045022100dc3531da7feb261575f03b5b9bbb35edc7f73bb081c92538827105de4102737002200161e34395f6a8ee93979200cb974fa75ccef6d7c14021511cf468eece90d6450121023230848585885f63803a0a8aecdd6538792d5c539215c91698e315bf0253b43dffffffff01d018ee05000000001976a914de9b2a8da088824e8fe51debea566617d851537888ac00000000' @@ -517,7 +518,7 @@ class TestMsgSigntx(TrezorTest): ]) with pytest.raises(CallException) as exc: - self.client.sign_tx('Bitcoin', [inp1, ], [out1, ]) + btc.sign_tx(self.client, 'Bitcoin', [inp1, ], [out1, ]) assert exc.value.args[0] == proto.FailureType.NotEnoughFunds def test_p2sh(self): @@ -551,7 +552,7 @@ class TestMsgSigntx(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXOUTPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures, serialized_tx) = self.client.sign_tx('Bitcoin', [inp1, ], [out1, ]) + (signatures, serialized_tx) = btc.sign_tx(self.client, 'Bitcoin', [inp1, ], [out1, ]) # Accepted by network: tx 8cc1f4adf7224ce855cf535a5104594a0004cb3b640d6714fdb00b9128832dd5 assert hexlify(serialized_tx) == b'0100000001a3fb2d38322c3b327e54005cebc0686d52fcdf536e53bb5ef481a7de8056aa54010000006b4830450221009e020b0390ccad533b73b552f8a99a9d827212c558e4f755503674d07c92ad4502202d606f7316990e0461c51d4add25054f19c697aa3e3c2ced4d568f0b2c57e62f0121023230848585885f63803a0a8aecdd6538792d5c539215c91698e315bf0253b43dffffffff0170f305000000000017a9147f844bdb0b8fd54b64e3d16c85dc1170f1ff97c18700000000' @@ -616,14 +617,14 @@ class TestMsgSigntx(TrezorTest): return msg # Test if the transaction can be signed normally - (_, serialized_tx) = self.client.sign_tx('Bitcoin', [inp1, inp2], [out1, out2]) + (_, serialized_tx) = btc.sign_tx(self.client, 'Bitcoin', [inp1, inp2], [out1, out2]) # Accepted by network: tx c63e24ed820c5851b60c54613fbc4bcb37df6cd49b4c96143e99580a472f79fb assert hexlify(serialized_tx) == b'01000000021c032e5715d1da8115a2fe4f57699e15742fe113b0d2d1ca3b594649d322bec6010000006b483045022100f773c403b2f85a5c1d6c9c4ad69c43de66930fff4b1bc818eb257af98305546a0220443bde4be439f276a6ce793664b463580e210ec6c9255d68354449ac0443c76501210338d78612e990f2eea0c426b5e48a8db70b9d7ed66282b3b26511e0b1c75515a6ffffffff6ea42cd8d9c8e5441c4c5f85bfe50311078730d2881494f11f4d2257777a4958010000006b48304502210090cff1c1911e771605358a8cddd5ae94c7b60cc96e50275908d9bf9d6367c79f02202bfa72e10260a146abd59d0526e1335bacfbb2b4401780e9e3a7441b0480c8da0121038caebd6f753bbbd2bb1f3346a43cd32140648583673a31d62f2dfb56ad0ab9e3ffffffff02a0860100000000001976a9142f4490d5263906e4887ca2996b9e207af3e7824088aca0860100000000001976a914812c13d97f9159e54e326b481b8f88a73df8507a88ac00000000' # Now run the attack, must trigger the exception with pytest.raises(CallException) as exc: - self.client.sign_tx('Bitcoin', [inp1, inp2], [out1, out2], debug_processor=attack_processor) + btc.sign_tx(self.client, 'Bitcoin', [inp1, inp2], [out1, out2], debug_processor=attack_processor) assert exc.value.args[0] in (proto.FailureType.ProcessError, proto.FailureType.DataError) assert exc.value.args[1].endswith('Transaction has changed during signing') @@ -677,7 +678,7 @@ class TestMsgSigntx(TrezorTest): return msg # Test if the transaction can be signed normally - (_, serialized_tx) = self.client.sign_tx('Testnet', [inp1], [out1, out2]) + (_, serialized_tx) = btc.sign_tx(self.client, 'Testnet', [inp1], [out1, out2]) assert hexlify(serialized_tx) == b'0100000001243e15b53cc553d93ec4e27e16984adc3d885ef107c613a7577fea47f5dadcd2010000006a47304402207d517dcb6b823bba4d252da096795a7f914d0c477aee26e554ba61653c45608a02202cba1e805c586c830472f399510be5d42c2fcfd67b8a6b0690cbe8a3e6e475e801210364430c9122948e525e2f1c6d88f00f47679274f0810fd8c63754954f310995c1ffffffff02a0860100000000001976a914b3cc67f3349974d0f1b50e9bb5dfdf226f888fa088ac18555907000000001976a91485a3f5b0d23cdd61f5f8e1eb8c9ca0890dd15a9788ac00000000' @@ -698,7 +699,7 @@ class TestMsgSigntx(TrezorTest): ]) # Now run the attack, must trigger the exception with pytest.raises(CallException) as exc: - self.client.sign_tx('Testnet', [inp1], [out1, out2], debug_processor=attack_processor) + btc.sign_tx(self.client, 'Testnet', [inp1], [out1, out2], debug_processor=attack_processor) assert exc.value.args[0] == proto.FailureType.ProcessError if TREZOR_VERSION == 1: @@ -741,7 +742,7 @@ class TestMsgSigntx(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXOUTPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures, serialized_tx) = self.client.sign_tx('Testnet', [inp1, ], [out1, ]) + (signatures, serialized_tx) = btc.sign_tx(self.client, 'Testnet', [inp1, ], [out1, ]) # Accepted by network: tx assert hexlify(serialized_tx) == b'010000000136825bfdb78c8ede226c7c4f25a018e99a2c061d63c7fb425fca7c7d6721dad6000000006a473044022047845c366eb24f40be315c7815a154513c444c7989eb80f7ce7ff6aeb703d26a022007c1f5efadf67c5889634fd7ac39a7ce78bffac291673e8772ecd8389c901d9f01210338d78612e990f2eea0c426b5e48a8db70b9d7ed66282b3b26511e0b1c75515a6ffffffff01c6100795000000001976a9143d2496e67f5f57a924353da42d4725b318e7a8ea88ac00000000' @@ -803,7 +804,7 @@ class TestMsgSigntx(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - self.client.sign_tx('Testnet', [inp1, ], [out1, out_change1, out_change2]) + btc.sign_tx(self.client, 'Testnet', [inp1, ], [out1, out_change1, out_change2]) def test_change_on_main_chain_allowed(self): self.setup_mnemonic_allallall() @@ -854,4 +855,4 @@ class TestMsgSigntx(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - self.client.sign_tx('Testnet', [inp1, ], [out1, out_change]) + btc.sign_tx(self.client, 'Testnet', [inp1, ], [out1, out_change]) diff --git a/trezorlib/tests/device_tests/test_msg_signtx_bcash.py b/trezorlib/tests/device_tests/test_msg_signtx_bcash.py index e9abbbac5f..32978b8687 100644 --- a/trezorlib/tests/device_tests/test_msg_signtx_bcash.py +++ b/trezorlib/tests/device_tests/test_msg_signtx_bcash.py @@ -22,6 +22,7 @@ from ..support.ckd_public import deserialize from trezorlib import coins from trezorlib import messages as proto from trezorlib.tools import parse_path, CallException +from trezorlib import btc TxApiBcash = coins.tx_api['Bcash'] @@ -61,7 +62,7 @@ class TestMsgSigntxBch(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXOUTPUT, details=proto.TxRequestDetailsType(request_index=1)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures, serialized_tx) = self.client.sign_tx('Bcash', [inp1], [out1, out2]) + (signatures, serialized_tx) = btc.sign_tx(self.client, 'Bcash', [inp1], [out1, out2]) assert hexlify(serialized_tx) == b'0100000001781a716b1e15b41b07157933e5d777392a75bf87132650cb2e7d46fb8dc237bc000000006a473044022061aee4f17abe044d5df8c52c9ffd3b84e5a29743517e488b20ecf1ae0b3e4d3a02206bb84c55e407f3b684ff8d9bea0a3409cfd865795a19d10b3d3c31f12795c34a412103a020b36130021a0f037c1d1a02042e325c0cb666d6478c1afdcd9d913b9ef080ffffffff0272ee1c00000000001976a914b1401fce7e8bf123c88a0467e0ed11e3b9fbef5488acec1e0100000000001976a914d51eca49695cdf47e7f4b55507893e3ad53fe9d888ac00000000' @@ -101,7 +102,7 @@ class TestMsgSigntxBch(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXOUTPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures, serialized_tx) = self.client.sign_tx('Bcash', [inp1, inp2], [out1]) + (signatures, serialized_tx) = btc.sign_tx(self.client, 'Bcash', [inp1, inp2], [out1]) assert hexlify(serialized_tx) == b'01000000022c06cf6f215c5cbfd7caa8e71b1b32630cabf1f816a4432815b037b277852e50000000006a47304402207a2a955f1cb3dc5f03f2c82934f55654882af4e852e5159639f6349e9386ec4002205fb8419dce4e648eae8f67bc4e369adfb130a87d2ea2d668f8144213b12bb457412103174c61e9c5362507e8061e28d2c0ce3d4df4e73f3535ae0b12f37809e0f92d2dffffffff2c06cf6f215c5cbfd7caa8e71b1b32630cabf1f816a4432815b037b277852e50010000006a473044022062151cf960b71823bbe68c7ed2c2a93ad1b9706a30255fddb02fcbe056d8c26102207bad1f0872bc5f0cfaf22e45c925c35d6c1466e303163b75cb7688038f1a5541412102595caf9aeb6ffdd0e82b150739a83297358b9a77564de382671056ad9e5b8c58ffffffff0170861d00000000001976a91434e9cec317896e818619ab7dc99d2305216ff4af88ac00000000' @@ -141,7 +142,7 @@ class TestMsgSigntxBch(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXOUTPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures, serialized_tx) = self.client.sign_tx('Bcash', [inp1, inp2], [out1]) + (signatures, serialized_tx) = btc.sign_tx(self.client, 'Bcash', [inp1, inp2], [out1]) assert hexlify(serialized_tx) == b'01000000022c06cf6f215c5cbfd7caa8e71b1b32630cabf1f816a4432815b037b277852e50000000006a47304402207a2a955f1cb3dc5f03f2c82934f55654882af4e852e5159639f6349e9386ec4002205fb8419dce4e648eae8f67bc4e369adfb130a87d2ea2d668f8144213b12bb457412103174c61e9c5362507e8061e28d2c0ce3d4df4e73f3535ae0b12f37809e0f92d2dffffffff2c06cf6f215c5cbfd7caa8e71b1b32630cabf1f816a4432815b037b277852e50010000006a473044022062151cf960b71823bbe68c7ed2c2a93ad1b9706a30255fddb02fcbe056d8c26102207bad1f0872bc5f0cfaf22e45c925c35d6c1466e303163b75cb7688038f1a5541412102595caf9aeb6ffdd0e82b150739a83297358b9a77564de382671056ad9e5b8c58ffffffff0170861d00000000001976a91434e9cec317896e818619ab7dc99d2305216ff4af88ac00000000' @@ -208,7 +209,7 @@ class TestMsgSigntxBch(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXOUTPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - self.client.sign_tx('Bcash', [inp1, inp2], [out1]) + btc.sign_tx(self.client, 'Bcash', [inp1, inp2], [out1]) # now fails with self.client: @@ -224,7 +225,7 @@ class TestMsgSigntxBch(TrezorTest): ]) with pytest.raises(CallException) as exc: - self.client.sign_tx('Bcash', [inp1, inp2], [out1], debug_processor=attack_processor) + btc.sign_tx(self.client, 'Bcash', [inp1, inp2], [out1], debug_processor=attack_processor) assert exc.value.args[0] in (proto.FailureType.ProcessError, proto.FailureType.DataError) assert exc.value.args[1].endswith('Transaction has changed during signing') @@ -281,13 +282,13 @@ class TestMsgSigntxBch(TrezorTest): proto.Failure(code=proto.FailureType.ProcessError), ]) with pytest.raises(CallException): - self.client.sign_tx('Bcash', [inp1], [out1, out2], debug_processor=attack_processor) + btc.sign_tx(self.client, 'Bcash', [inp1], [out1, out2], debug_processor=attack_processor) def test_send_bch_multisig_wrongchange(self): self.setup_mnemonic_allallall() self.client.set_tx_api(TxApiBcash) xpubs = [] - for n in map(lambda index: self.client.get_public_node(parse_path("44'/145'/" + str(index) + "'")), range(1, 4)): + for n in map(lambda index: btc.get_public_node(self.client, parse_path("44'/145'/" + str(index) + "'")), range(1, 4)): xpubs.append(n.xpub) def getmultisig(chain, nr, signatures=[b'', b'', b''], xpubs=xpubs): @@ -332,7 +333,7 @@ class TestMsgSigntxBch(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXOUTPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures1, serialized_tx) = self.client.sign_tx('Bcash', [inp1], [out1]) + (signatures1, serialized_tx) = btc.sign_tx(self.client, 'Bcash', [inp1], [out1]) assert hexlify(signatures1[0]) == b'3044022052ccf022b3684ecce9f961ce8828387b97267c86bedf0ce16a24bf014e62e42c022035d315ddbeeef7ab3456bd09aed8b625ea58852216b60e4b84ba9f85827d305c' assert hexlify(serialized_tx) == b'01000000015f3d291cae106548f3be5ed0f4cbedc65668fa881d60347ab0d512df10af8cf601000000fc00473044022052ccf022b3684ecce9f961ce8828387b97267c86bedf0ce16a24bf014e62e42c022035d315ddbeeef7ab3456bd09aed8b625ea58852216b60e4b84ba9f85827d305c4147304402207274b5a4d15e75f3df7319a375557b0efba9b27bc63f9f183a17da95a6125c94022000efac57629f1522e2d3958430e2ef073b0706cfac06cce492651b79858f09ae414c69522103d62b2af2272bbd67cbe30eeaf4226c7f2d57d2a0ed1aab5ab736fb40bb2f5ffe21036d5e0d7ca3589465711eec91436249d7234d3a994c219024fc75cec98fc02ae221024f58378a69b68e89301a6ff882116e0fa35446ec9bfd86532eeb05941ec1f8c853aeffffffff01d85900000000000017a9140bb11de6558871f49fc241341992ece9986f7c5c8700000000' @@ -340,7 +341,7 @@ class TestMsgSigntxBch(TrezorTest): self.setup_mnemonic_allallall() self.client.set_tx_api(TxApiBcash) xpubs = [] - for n in map(lambda index: self.client.get_public_node(parse_path("44'/145'/" + str(index) + "'")), range(1, 4)): + for n in map(lambda index: btc.get_public_node(self.client, parse_path("44'/145'/" + str(index) + "'")), range(1, 4)): xpubs.append(n.xpub) def getmultisig(chain, nr, signatures=[b'', b'', b''], xpubs=xpubs): @@ -381,7 +382,7 @@ class TestMsgSigntxBch(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXOUTPUT, details=proto.TxRequestDetailsType(request_index=1)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures1, serialized_tx) = self.client.sign_tx('Bcash', [inp1], [out1, out2]) + (signatures1, serialized_tx) = btc.sign_tx(self.client, 'Bcash', [inp1], [out1, out2]) assert hexlify(signatures1[0]) == b'3045022100bcb1a7134a13025a06052546ee1c6ac3640a0abd2d130190ed13ed7fcb43e9cd02207c381478e2ee123c850425bfbf6d3c691230eb37e333832cb32a1ed3f2cd9e85' @@ -408,7 +409,7 @@ class TestMsgSigntxBch(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXOUTPUT, details=proto.TxRequestDetailsType(request_index=1)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures1, serialized_tx) = self.client.sign_tx('Bcash', [inp1], [out1, out2]) + (signatures1, serialized_tx) = btc.sign_tx(self.client, 'Bcash', [inp1], [out1, out2]) assert hexlify(signatures1[0]) == b'3045022100f1153636371ba1f84389460e1265a8fa296569bc18e117c31f4e8f0fc0650c01022022932cc84766ff0c0f65ed9633ad311ae90d4c8fe71f5e1890b1e8f74dd516fa' assert hexlify(serialized_tx) == b'0100000001a07660b10df9868df9393c9cf8962bc34f48cb2cea53b0865d2324bab8b96d8b00000000fdfe0000483045022100f1153636371ba1f84389460e1265a8fa296569bc18e117c31f4e8f0fc0650c01022022932cc84766ff0c0f65ed9633ad311ae90d4c8fe71f5e1890b1e8f74dd516fa41483045022100bcb1a7134a13025a06052546ee1c6ac3640a0abd2d130190ed13ed7fcb43e9cd02207c381478e2ee123c850425bfbf6d3c691230eb37e333832cb32a1ed3f2cd9e85414c69522102fcf63419c319ce1a42d69120a3599d6da8c5dd4caf2888220eccde5a1ff7c5d021036d7d5ef79370b7fabe2c058698a20219e97fc70868e65ecdd6b37cc18e8a88bd2103505dc649dab8cd1655a4c0daf0ec5f955881c9d7011478ea881fac11cab1e49953aeffffffff02c05d0000000000001976a91400741952f6a6eab5394f366db5cc5a54b0c2429f88acc05d00000000000017a914756c06d7e77de3950a6124f026d8e1a2464b3ecf8700000000' diff --git a/trezorlib/tests/device_tests/test_msg_signtx_bgold.py b/trezorlib/tests/device_tests/test_msg_signtx_bgold.py index 27717a0938..d3423629d9 100644 --- a/trezorlib/tests/device_tests/test_msg_signtx_bgold.py +++ b/trezorlib/tests/device_tests/test_msg_signtx_bgold.py @@ -22,6 +22,7 @@ from ..support.ckd_public import deserialize from trezorlib import coins from trezorlib import messages as proto from trezorlib.tools import parse_path, CallException +from trezorlib import btc TxApiBitcoinGold = coins.tx_api["Bgold"] @@ -61,7 +62,7 @@ class TestMsgSigntxBitcoinGold(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXOUTPUT, details=proto.TxRequestDetailsType(request_index=1)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures, serialized_tx) = self.client.sign_tx('Bgold', [inp1], [out1, out2]) + (signatures, serialized_tx) = btc.sign_tx(self.client, 'Bgold', [inp1], [out1, out2]) assert hexlify(serialized_tx) == b'010000000185c9dd4ae1071affd77d90b9d03c1b5fdd7c62cf30a9bb8230ad766cf06b5225000000006b483045022100963904da0731b71ce468afd45366dd80fbff566ec0d39c1161ab85d17459c7ca02202f5c24a7a7272d98b14a3f5bc000c7cde8ac0eb773f20f4c3131518186cc98854121023bd0ec4022d12d0106c5b7308a25572953ba1951f576f691354a7b147ee0cc1fffffffff0272ee1c00000000001976a9141c82b9c11f193ad82413caadc0955730572b50ae88acec1e0100000000001976a914ea5f904d195079a350b534db4446433b3cec222e88ac00000000' @@ -100,7 +101,7 @@ class TestMsgSigntxBitcoinGold(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXOUTPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures, serialized_tx) = self.client.sign_tx('Bgold', [inp1, inp2], [out1]) + (signatures, serialized_tx) = btc.sign_tx(self.client, 'Bgold', [inp1, inp2], [out1]) assert hexlify(serialized_tx) == b'010000000285c9dd4ae1071affd77d90b9d03c1b5fdd7c62cf30a9bb8230ad766cf06b5225000000006b483045022100928852076c9fab160c07564cd54691af1cbc37fb28f0b7bee7299c7925ef62f0022058856387afecc6508f2f04ecdfd292a13026a5b2107ebdd2cc789bdf8820d552412102a6c3998d0d4e5197ff41aab5c53580253b3b91f583f4c31f7624be7dc83ce15fffffffff18fba85125ef7ccb651b5c79d920e0984a18430028f9e7db6e0e841b46c277db010000006b483045022100faa2f4f01cc95e680349a093923aae0aa2ea01429873555aa8a84bf630ef33a002204c3f4bf567e2d20540c0f71dc278481d6ccb6b95acda2a2f87ce521c79d6b872412102d54a7e5733b1635e5e9442943f48179b1700206b2d1925250ba10f1c86878be8ffffffff0170861d00000000001976a914ea5f904d195079a350b534db4446433b3cec222e88ac00000000' @@ -156,13 +157,13 @@ class TestMsgSigntxBitcoinGold(TrezorTest): proto.Failure(code=proto.FailureType.ProcessError), ]) with pytest.raises(CallException): - self.client.sign_tx('Bgold', [inp1], [out1, out2], debug_processor=attack_processor) + btc.sign_tx(self.client, 'Bgold', [inp1], [out1, out2], debug_processor=attack_processor) def test_send_bch_multisig_change(self): self.setup_mnemonic_allallall() self.client.set_tx_api(TxApiBitcoinGold) xpubs = [] - for n in map(lambda index: self.client.get_public_node(parse_path("44'/156'/" + str(index) + "'")), range(1, 4)): + for n in map(lambda index: btc.get_public_node(self.client, parse_path("44'/156'/" + str(index) + "'")), range(1, 4)): xpubs.append(n.xpub) def getmultisig(chain, nr, signatures=[b'', b'', b''], xpubs=xpubs): @@ -203,7 +204,7 @@ class TestMsgSigntxBitcoinGold(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXOUTPUT, details=proto.TxRequestDetailsType(request_index=1)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures1, serialized_tx) = self.client.sign_tx('Bgold', [inp1], [out1, out2]) + (signatures1, serialized_tx) = btc.sign_tx(self.client, 'Bgold', [inp1], [out1, out2]) assert hexlify(signatures1[0]) == b'3045022100b1594f3b186d0dedbf61e53a1c407b1e0747098b7375941df85af045040f578e022013ba1893eb9e2fd854dd07073a83b261cf4beba76f66b07742e462b4088a7e4a' @@ -230,7 +231,7 @@ class TestMsgSigntxBitcoinGold(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXOUTPUT, details=proto.TxRequestDetailsType(request_index=1)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures1, serialized_tx) = self.client.sign_tx('Bgold', [inp1], [out1, out2]) + (signatures1, serialized_tx) = btc.sign_tx(self.client, 'Bgold', [inp1], [out1, out2]) assert hexlify(signatures1[0]) == b'3044022006da8dbd14e6656ac8dcb956f4c0498574e88680eaeceb2cbafd8d2b2329d8cc02200972d076d444c5ff8f2ab18e14d8249ab661cb9c53335039bedcde037a40d747' assert hexlify(serialized_tx) == b'010000000185c9dd4ae1071affd77d90b9d03c1b5fdd7c62cf30a9bb8230ad766cf06b522500000000fdfd0000473044022006da8dbd14e6656ac8dcb956f4c0498574e88680eaeceb2cbafd8d2b2329d8cc02200972d076d444c5ff8f2ab18e14d8249ab661cb9c53335039bedcde037a40d74741483045022100b1594f3b186d0dedbf61e53a1c407b1e0747098b7375941df85af045040f578e022013ba1893eb9e2fd854dd07073a83b261cf4beba76f66b07742e462b4088a7e4a414c69522102290e6649574d17938c1ecb959ae92954f9ee48e1bd5b73f35ea931a3ab8a6087210379e0107b173e2c143426760627128c5eea3f862e8df92f3c2558eeeae4e347842103ff1746ca7dcf9e5c2eea9a73779b7c5bafed549f45cf3638a94cdf1e89c7f28f53aeffffffff02c05d0000000000001976a914ea5f904d195079a350b534db4446433b3cec222e88acc05d00000000000017a91445e917e46815d2b38d3f1cf072e63dd4f3b7a7e38700000000' @@ -269,7 +270,7 @@ class TestMsgSigntxBitcoinGold(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXINPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures, serialized_tx) = self.client.sign_tx('Bgold', [inp1], [out1, out2]) + (signatures, serialized_tx) = btc.sign_tx(self.client, 'Bgold', [inp1], [out1, out2]) assert hexlify(serialized_tx) == b'0100000000010185c9dd4ae1071affd77d90b9d03c1b5fdd7c62cf30a9bb8230ad766cf06b52250000000017160014b5355d001e720d8f4513da00ff2bba4dcf9d39fcffffffff02e0aebb00000000001976a914ea5f904d195079a350b534db4446433b3cec222e88ac3df39f06000000001976a914a8f757819ec6779409f45788f7b4a0e8f51ec50488ac02473044022073fcbf2876f073f78923ab427f14de5b2a0fbeb313a9b2b650b3567061f242a702202f45fc22c501108ff6222afe3aca7da9d8c7dc860f9cda335bef31fa184e7bef412102ecea08b559fc5abd009acf77cfae13fa8a3b1933e3e031956c65c12cec8ca3e300000000' @@ -306,7 +307,7 @@ class TestMsgSigntxBitcoinGold(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXINPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures, serialized_tx) = self.client.sign_tx('Bgold', [inp1], [out1, out2]) + (signatures, serialized_tx) = btc.sign_tx(self.client, 'Bgold', [inp1], [out1, out2]) # print(hexlify(serialized_tx)) # assert False @@ -315,7 +316,7 @@ class TestMsgSigntxBitcoinGold(TrezorTest): def test_send_multisig_1(self): self.setup_mnemonic_allallall() self.client.set_tx_api(TxApiBitcoinGold) - nodes = map(lambda index: self.client.get_public_node(parse_path("999'/1'/%d'" % index)), range(1, 4)) + nodes = map(lambda index: btc.get_public_node(self.client, parse_path("999'/1'/%d'" % index)), range(1, 4)) multisig = proto.MultisigRedeemScriptType( pubkeys=list(map(lambda n: proto.HDNodePathType(node=deserialize(n.xpub), address_n=[2, 0]), nodes)), signatures=[b'', b'', b''], @@ -346,7 +347,7 @@ class TestMsgSigntxBitcoinGold(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXINPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures1, _) = self.client.sign_tx('Bgold', [inp1], [out1]) + (signatures1, _) = btc.sign_tx(self.client, 'Bgold', [inp1], [out1]) # store signature inp1.multisig.signatures[0] = signatures1[0] # sign with third key @@ -361,6 +362,6 @@ class TestMsgSigntxBitcoinGold(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXINPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures2, serialized_tx) = self.client.sign_tx('Bgold', [inp1], [out1]) + (signatures2, serialized_tx) = btc.sign_tx(self.client, 'Bgold', [inp1], [out1]) assert hexlify(serialized_tx) == b'0100000000010185c9dd4ae1071affd77d90b9d03c1b5fdd7c62cf30a9bb8230ad766cf06b522501000000232200201e8dda334f11171190b3da72e526d441491464769679a319a2f011da5ad312a1ffffffff01887d1800000000001976a914ea5f904d195079a350b534db4446433b3cec222e88ac0400483045022100e728485c8337f9a09ebbf36edc0fef10f8bcf5c1ba601b7d8ba43a9250a898f002206b9e3401c297f9ab9afb7f1be59bb342db53b5b65aff7c557e3109679697df0f41473044022062ea69ecdc07d0dadc1971fbda50a629a56dd30f431db26327428f4992601ce602204a1c8ab9c7d81c36cb6f819109a26f9baaa9607b8d37bff5e24eee6fab4a04e441695221038e81669c085a5846e68e03875113ddb339ecbb7cb11376d4163bca5dc2e2a0c1210348c5c3be9f0e6cf1954ded1c0475beccc4d26aaa9d0cce2dd902538ff1018a112103931140ebe0fbbb7df0be04ed032a54e9589e30339ba7bbb8b0b71b15df1294da53ae00000000' diff --git a/trezorlib/tests/device_tests/test_msg_signtx_decred.py b/trezorlib/tests/device_tests/test_msg_signtx_decred.py index 7662834bf5..cff4bf227b 100644 --- a/trezorlib/tests/device_tests/test_msg_signtx_decred.py +++ b/trezorlib/tests/device_tests/test_msg_signtx_decred.py @@ -22,6 +22,7 @@ from .common import TrezorTest from trezorlib import coins from trezorlib import messages as proto from trezorlib.tools import parse_path +from trezorlib import btc TxApiDecredTestnet = coins.tx_api['Decred Testnet'] @@ -72,7 +73,7 @@ class TestMsgSigntxDecred(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXINPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures, serialized_tx) = self.client.sign_tx("Decred Testnet", [inp1], [out1]) + (signatures, serialized_tx) = btc.sign_tx(self.client, "Decred Testnet", [inp1], [out1]) # Accepted by network: 5e6e3500a333c53c02f523db5f1a9b17538a8850b4c2c24ecb9b7ba48059b970 assert serialized_tx == unhexlify("0100000001edd579e9462ee0e80127a817e0500d4f942a4cf8f2d6530e0c0a9ab3f04862e10100000000ffffffff01802b530b0000000000001976a914819d291a2f7fbf770e784bfd78b5ce92c58e95ea88ac000000000000000001000000000000000000000000ffffffff6b483045022100bad68486491e449a731513805c129201d7f65601d6f07c97fda0588453c97d22022013e9ef59657ae4f344ac4f0db2b7a23dbfcdb51ebeb85277146ac189e547d3f7012102f5a745afb96077c071e4d19911a5d3d024faa1314ee8688bc6eec39751d0818f") @@ -148,7 +149,7 @@ class TestMsgSigntxDecred(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXINPUT, details=proto.TxRequestDetailsType(request_index=2)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures, serialized_tx) = self.client.sign_tx("Decred Testnet", [inp1, inp2, inp3], [out1, out2]) + (signatures, serialized_tx) = btc.sign_tx(self.client, "Decred Testnet", [inp1, inp2, inp3], [out1, out2]) # Accepted by network: c5ff767141a162b665acf775fcc35b60ff622fbe21a21e0a6609ed768c3737f4 assert serialized_tx == unhexlify("010000000370b95980a47b9bcb4ec2c2b450888a53179b1a5fdb23f5023cc533a300356e5e0000000000ffffffff74bc93bcfce18aff2e522d6822817522e2815a00175b2eae59ef20d20f5bf9cc0100000000ffffffff13317ab453832deabd684d2302eed42580c28ba3e715db66a731a8723eef95f30000000000ffffffff02d86c341d0000000000001976a9143eb656115197956125365348c542e37b6d3d259988ac00e1f5050000000000001976a9146748ebb8694c069742ee69eab2159c33c7f57d2b88ac000000000000000003000000000000000000000000ffffffff6b483045022100d91237a32b8968e1d3316b76f045cc18fed12736aebd570dd023a61826279cc102204222b133189762368d3398d11eb9a6843a67de11d70ac58426a28b605fa102b1012102f5a745afb96077c071e4d19911a5d3d024faa1314ee8688bc6eec39751d0818f000000000000000000000000ffffffff69463043021f7cf9b0b180f3fcde8d3d036d81e575e368d6ab5c8c6a2ffef47c06a0170023022036b964bf26ff276c58862dfacafa93216618832d6240f16b6100a9d10d5eb753012102f5a745afb96077c071e4d19911a5d3d024faa1314ee8688bc6eec39751d0818f000000000000000000000000ffffffff6b48304502210098f3a0cc17c3383f5998c542950b5cccb1175cc94b8d0343f420dc64abe9a50e0220507974c6ef0761925634fe3e13ec458b8cd3e42856828d584d4a5d39cc4d0f890121022c6099c7af8124d58e97beefc85c529dcfb3865794d46ec04095e70872e32a2e") @@ -158,7 +159,7 @@ class TestMsgSigntxDecred(TrezorTest): self.client.set_tx_api(TxApiDecredTestnet) paths = [parse_path("m/48'/1'/%d'" % index) for index in range(3)] - nodes = [self.client.get_public_node(address_n, coin_name="Decred Testnet").node for address_n in paths] + nodes = [btc.get_public_node(self.client, address_n, coin_name="Decred Testnet").node for address_n in paths] signatures = [ [b'', b'', b''], @@ -235,7 +236,7 @@ class TestMsgSigntxDecred(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXINPUT, details=proto.TxRequestDetailsType(request_index=1)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signature, serialized_tx) = self.client.sign_tx("Decred Testnet", [inp1, inp2], [out1, out2]) + (signature, serialized_tx) = btc.sign_tx(self.client, "Decred Testnet", [inp1, inp2], [out1, out2]) signatures[0][index] = signature[0] signatures[1][index] = signature[1] diff --git a/trezorlib/tests/device_tests/test_msg_signtx_segwit.py b/trezorlib/tests/device_tests/test_msg_signtx_segwit.py index 5c1f37efb7..e823af10fd 100644 --- a/trezorlib/tests/device_tests/test_msg_signtx_segwit.py +++ b/trezorlib/tests/device_tests/test_msg_signtx_segwit.py @@ -24,6 +24,7 @@ from .common import TrezorTest from trezorlib import messages as proto from trezorlib.tx_api import TxApiInsight from trezorlib.tools import parse_path, CallException +from trezorlib import btc TxApiTestnet = TxApiInsight("insight_testnet") @@ -65,7 +66,7 @@ class TestMsgSigntxSegwit(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXINPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures, serialized_tx) = self.client.sign_tx('Testnet', [inp1], [out1, out2]) + (signatures, serialized_tx) = btc.sign_tx(self.client, 'Testnet', [inp1], [out1, out2]) assert hexlify(serialized_tx) == b'0100000000010137c361fb8f2d9056ba8c98c5611930fcb48cacfdd0fe2e0449d83eea982f91200000000017160014d16b8c0680c61fc6ed2e407455715055e41052f5ffffffff02e0aebb00000000001976a91414fdede0ddc3be652a0ce1afbc1b509a55b6b94888ac3df39f060000000017a91458b53ea7f832e8f096e896b8713a8c6df0e892ca8702483045022100ccd253bfdf8a5593cd7b6701370c531199f0f05a418cd547dfc7da3f21515f0f02203fa08a0753688871c220648f9edadbdb98af42e5d8269364a326572cf703895b012103e7bfe10708f715e8538c92d46ca50db6f657bbc455b7494e6a0303ccdb868b7900000000' @@ -103,14 +104,14 @@ class TestMsgSigntxSegwit(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXINPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures, serialized_tx) = self.client.sign_tx('Testnet', [inp1], [out1, out2]) + (signatures, serialized_tx) = btc.sign_tx(self.client, 'Testnet', [inp1], [out1, out2]) assert hexlify(serialized_tx) == b'0100000000010137c361fb8f2d9056ba8c98c5611930fcb48cacfdd0fe2e0449d83eea982f91200000000017160014d16b8c0680c61fc6ed2e407455715055e41052f5ffffffff02e0aebb00000000001976a91414fdede0ddc3be652a0ce1afbc1b509a55b6b94888ac3df39f060000000017a91458b53ea7f832e8f096e896b8713a8c6df0e892ca8702483045022100ccd253bfdf8a5593cd7b6701370c531199f0f05a418cd547dfc7da3f21515f0f02203fa08a0753688871c220648f9edadbdb98af42e5d8269364a326572cf703895b012103e7bfe10708f715e8538c92d46ca50db6f657bbc455b7494e6a0303ccdb868b7900000000' def test_send_multisig_1(self): self.setup_mnemonic_allallall() self.client.set_tx_api(TxApiTestnet) - nodes = map(lambda index: self.client.get_public_node(parse_path("999'/1'/%d'" % index)), range(1, 4)) + nodes = map(lambda index: btc.get_public_node(self.client, parse_path("999'/1'/%d'" % index)), range(1, 4)) multisig = proto.MultisigRedeemScriptType( pubkeys=list(map(lambda n: proto.HDNodePathType(node=deserialize(n.xpub), address_n=[2, 0]), nodes)), signatures=[b'', b'', b''], @@ -141,7 +142,7 @@ class TestMsgSigntxSegwit(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXINPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures1, _) = self.client.sign_tx('Testnet', [inp1], [out1]) + (signatures1, _) = btc.sign_tx(self.client, 'Testnet', [inp1], [out1]) # store signature inp1.multisig.signatures[0] = signatures1[0] # sign with third key @@ -156,7 +157,7 @@ class TestMsgSigntxSegwit(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXINPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures2, serialized_tx) = self.client.sign_tx('Testnet', [inp1], [out1]) + (signatures2, serialized_tx) = btc.sign_tx(self.client, 'Testnet', [inp1], [out1]) assert hexlify(serialized_tx) == b'01000000000101be0210025c5be68a473f6a38bf53b53bc88d5c46567616026dc056e72b92319c01000000232200201e8dda334f11171190b3da72e526d441491464769679a319a2f011da5ad312a1ffffffff01887d1800000000001976a91414fdede0ddc3be652a0ce1afbc1b509a55b6b94888ac040047304402205b44c20cf2681690edaaf7cd2e30d4704124dd8b7eb1fb7f459d3906c3c374a602205ca359b6544ce2c101c979899c782f7d141c3b0454ea69202b1fb4c09d3b715701473044022052fafa64022554ae436dbf781e550bf0d326fef31eea1438350b3ff1940a180102202851bd19203b7fe8582a9ef52e82aa9f61cd52d4bcedfe6dcc0cf782468e6a8e01695221038e81669c085a5846e68e03875113ddb339ecbb7cb11376d4163bca5dc2e2a0c1210348c5c3be9f0e6cf1954ded1c0475beccc4d26aaa9d0cce2dd902538ff1018a112103931140ebe0fbbb7df0be04ed032a54e9589e30339ba7bbb8b0b71b15df1294da53ae00000000' @@ -222,7 +223,7 @@ class TestMsgSigntxSegwit(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXINPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures, serialized_tx) = self.client.sign_tx('Testnet', [inp1], [out1, out2]) + (signatures, serialized_tx) = btc.sign_tx(self.client, 'Testnet', [inp1], [out1, out2]) assert hexlify(serialized_tx) == b'0100000000010137c361fb8f2d9056ba8c98c5611930fcb48cacfdd0fe2e0449d83eea982f91200000000017160014d16b8c0680c61fc6ed2e407455715055e41052f5ffffffff02e0aebb00000000001976a91414fdede0ddc3be652a0ce1afbc1b509a55b6b94888ac3df39f060000000017a914dae9e09a7fc3bbe5a716fffec1bbb340b82a4fb9870248304502210099b5c4f8fd4402c9c0136fee5f711137d64fc9f14587e01bfa7798f5428f845d0220253e21c98f5b1b64efae69bc2ea9799c5620a43450baa6762a0c3cf4fdc886e5012103e7bfe10708f715e8538c92d46ca50db6f657bbc455b7494e6a0303ccdb868b7900000000' @@ -238,7 +239,7 @@ class TestMsgSigntxSegwit(TrezorTest): proto.Failure(code=proto.FailureType.ProcessError), ]) with pytest.raises(CallException) as exc: - self.client.sign_tx('Testnet', [inp1], [out1, out2], debug_processor=attack_processor) + btc.sign_tx(self.client, 'Testnet', [inp1], [out1, out2], debug_processor=attack_processor) assert exc.value.args[0] == proto.FailureType.ProcessError if TREZOR_VERSION == 1: assert exc.value.args[1].endswith("Failed to compile input") diff --git a/trezorlib/tests/device_tests/test_msg_signtx_segwit_native.py b/trezorlib/tests/device_tests/test_msg_signtx_segwit_native.py index 4851afb831..66034e5c44 100644 --- a/trezorlib/tests/device_tests/test_msg_signtx_segwit_native.py +++ b/trezorlib/tests/device_tests/test_msg_signtx_segwit_native.py @@ -21,6 +21,7 @@ from ..support.ckd_public import deserialize from trezorlib import messages as proto from trezorlib.tools import parse_path from trezorlib.tx_api import TxApiInsight +from trezorlib import btc TxApiTestnet = TxApiInsight("insight_testnet") @@ -62,7 +63,7 @@ class TestMsgSigntxSegwitNative(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXINPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures, serialized_tx) = self.client.sign_tx('Testnet', [inp1], [out1, out2]) + (signatures, serialized_tx) = btc.sign_tx(self.client, 'Testnet', [inp1], [out1, out2]) assert hexlify(serialized_tx) == b'0100000000010137c361fb8f2d9056ba8c98c5611930fcb48cacfdd0fe2e0449d83eea982f91200000000017160014d16b8c0680c61fc6ed2e407455715055e41052f5ffffffff02e0aebb00000000001600140099a7ecbd938ed1839f5f6bf6d50933c6db9d5c3df39f060000000017a91458b53ea7f832e8f096e896b8713a8c6df0e892ca8702483045022100bd3d8b8ad35c094e01f6282277300e575f1021678fc63ec3f9945d6e35670da3022052e26ef0dd5f3741c9d5939d1dec5464c15ab5f2c85245e70a622df250d4eb7c012103e7bfe10708f715e8538c92d46ca50db6f657bbc455b7494e6a0303ccdb868b7900000000' @@ -100,7 +101,7 @@ class TestMsgSigntxSegwitNative(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXINPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures, serialized_tx) = self.client.sign_tx('Testnet', [inp1], [out1, out2]) + (signatures, serialized_tx) = btc.sign_tx(self.client, 'Testnet', [inp1], [out1, out2]) assert hexlify(serialized_tx) == b'0100000000010137c361fb8f2d9056ba8c98c5611930fcb48cacfdd0fe2e0449d83eea982f91200000000017160014d16b8c0680c61fc6ed2e407455715055e41052f5ffffffff02e0aebb00000000001600140099a7ecbd938ed1839f5f6bf6d50933c6db9d5c3df39f060000000017a91458b53ea7f832e8f096e896b8713a8c6df0e892ca8702483045022100bd3d8b8ad35c094e01f6282277300e575f1021678fc63ec3f9945d6e35670da3022052e26ef0dd5f3741c9d5939d1dec5464c15ab5f2c85245e70a622df250d4eb7c012103e7bfe10708f715e8538c92d46ca50db6f657bbc455b7494e6a0303ccdb868b7900000000' @@ -139,7 +140,7 @@ class TestMsgSigntxSegwitNative(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXINPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures, serialized_tx) = self.client.sign_tx('Testnet', [inp1], [out1, out2]) + (signatures, serialized_tx) = btc.sign_tx(self.client, 'Testnet', [inp1], [out1, out2]) assert hexlify(serialized_tx) == b'010000000001018a44999c07bba32df1cacdc50987944e68e3205b4429438fdde35c76024614090000000000ffffffff02404b4c000000000017a9147a55d61848e77ca266e79a39bfc85c580a6426c987a8386f0000000000160014d16b8c0680c61fc6ed2e407455715055e41052f502483045022100a7ca8f097525f9044e64376dc0a0f5d4aeb8d15d66808ba97979a0475b06b66502200597c8ebcef63e047f9aeef1a8001d3560470cf896c12f6990eec4faec599b950121033add1f0e8e3c3136f7428dd4a4de1057380bd311f5b0856e2269170b4ffa65bf00000000' @@ -177,7 +178,7 @@ class TestMsgSigntxSegwitNative(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXINPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures, serialized_tx) = self.client.sign_tx('Testnet', [inp1], [out1, out2]) + (signatures, serialized_tx) = btc.sign_tx(self.client, 'Testnet', [inp1], [out1, out2]) assert hexlify(serialized_tx) == b'010000000001018a44999c07bba32df1cacdc50987944e68e3205b4429438fdde35c76024614090000000000ffffffff02404b4c000000000017a9147a55d61848e77ca266e79a39bfc85c580a6426c987a8386f0000000000160014d16b8c0680c61fc6ed2e407455715055e41052f502483045022100a7ca8f097525f9044e64376dc0a0f5d4aeb8d15d66808ba97979a0475b06b66502200597c8ebcef63e047f9aeef1a8001d3560470cf896c12f6990eec4faec599b950121033add1f0e8e3c3136f7428dd4a4de1057380bd311f5b0856e2269170b4ffa65bf00000000' @@ -238,7 +239,7 @@ class TestMsgSigntxSegwitNative(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXINPUT, details=proto.TxRequestDetailsType(request_index=1)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures, serialized_tx) = self.client.sign_tx('Testnet', [inp1, inp2], [out1, out2, out3]) + (signatures, serialized_tx) = btc.sign_tx(self.client, 'Testnet', [inp1, inp2], [out1, out2, out3]) # 0e480a97c7a545c85e101a2f13c9af0e115d43734e1448f0cac3e55fe8e7399d assert hexlify(serialized_tx) == b'010000000001028a44999c07bba32df1cacdc50987944e68e3205b4429438fdde35c76024614090100000017160014d16b8c0680c61fc6ed2e407455715055e41052f5ffffffff7b010c5faeb41cc5c253121b6bf69bf1a7c5867cd7f2d91569fea0ecd311b8650100000000ffffffff03e0aebb0000000000160014a579388225827d9f2fe9014add644487808c695d00cdb7020000000017a91491233e24a9bf8dbb19c1187ad876a9380c12e787870d859b03000000001976a914a579388225827d9f2fe9014add644487808c695d88ac02483045022100ead79ee134f25bb585b48aee6284a4bb14e07f03cc130253e83450d095515e5202201e161e9402c8b26b666f2b67e5b668a404ef7e57858ae9a6a68c3837e65fdc69012103e7bfe10708f715e8538c92d46ca50db6f657bbc455b7494e6a0303ccdb868b7902483045022100b4099ec4c7b3123795b3c080a86f4b745f3784eb3f77de79bef1d8da319cbee5022039766865d448a4a3e435a95d0df3ff56ebc6532bf538988a7e8a679b40ec41b6012103e7bfe10708f715e8538c92d46ca50db6f657bbc455b7494e6a0303ccdb868b7900000000' @@ -246,7 +247,7 @@ class TestMsgSigntxSegwitNative(TrezorTest): def test_send_multisig_1(self): self.setup_mnemonic_allallall() self.client.set_tx_api(TxApiTestnet) - nodes = [self.client.get_public_node(parse_path("999'/1'/%d'" % index)) for index in range(1, 4)] + nodes = [btc.get_public_node(self.client, parse_path("999'/1'/%d'" % index)) for index in range(1, 4)] multisig = proto.MultisigRedeemScriptType( pubkeys=list(map(lambda n: proto.HDNodePathType(node=deserialize(n.xpub), address_n=[2, 0]), nodes)), signatures=[b'', b'', b''], @@ -279,7 +280,7 @@ class TestMsgSigntxSegwitNative(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXINPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures1, _) = self.client.sign_tx('Testnet', [inp1], [out1]) + (signatures1, _) = btc.sign_tx(self.client, 'Testnet', [inp1], [out1]) # store signature inp1.multisig.signatures[0] = signatures1[0] # sign with third key @@ -294,7 +295,7 @@ class TestMsgSigntxSegwitNative(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXINPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures2, serialized_tx) = self.client.sign_tx('Testnet', [inp1], [out1]) + (signatures2, serialized_tx) = btc.sign_tx(self.client, 'Testnet', [inp1], [out1]) # f41cbedd8becee05a830f418d13aa665125464547db5c7a6cd28f21639fe1228 assert hexlify(serialized_tx) == b'01000000000101be0210025c5be68a473f6a38bf53b53bc88d5c46567616026dc056e72b92319c01000000232200201e8dda334f11171190b3da72e526d441491464769679a319a2f011da5ad312a1ffffffff01887d180000000000220020c5f4a0a4ea7c0392efe0a9670a73264cffa90b19107cd8a8e9750ff93c77fdfb0400483045022100a9b681f324ff4cf419ab06820d07248cc4e359c77334bf448ae7b5cdf3995ddf022039811f91f55b602368b4ba08a217b82bfd62d1a97dc635deb1457e7cfcc1550b0147304402201ad86a795c3d26881d696fa0a0619c24c4d505718132a82965cc2a609c9d8798022067cd490ce1366cde77e307ced5b13040bbc04991619ea6f49e06cece9a83268b01695221038e81669c085a5846e68e03875113ddb339ecbb7cb11376d4163bca5dc2e2a0c1210348c5c3be9f0e6cf1954ded1c0475beccc4d26aaa9d0cce2dd902538ff1018a112103931140ebe0fbbb7df0be04ed032a54e9589e30339ba7bbb8b0b71b15df1294da53ae00000000' @@ -302,7 +303,7 @@ class TestMsgSigntxSegwitNative(TrezorTest): def test_send_multisig_2(self): self.setup_mnemonic_allallall() self.client.set_tx_api(TxApiTestnet) - nodes = [self.client.get_public_node(parse_path("999'/1'/%d'" % index)) for index in range(1, 4)] + nodes = [btc.get_public_node(self.client, parse_path("999'/1'/%d'" % index)) for index in range(1, 4)] multisig = proto.MultisigRedeemScriptType( pubkeys=list(map(lambda n: proto.HDNodePathType(node=deserialize(n.xpub), address_n=[2, 1]), nodes)), signatures=[b'', b'', b''], @@ -335,7 +336,7 @@ class TestMsgSigntxSegwitNative(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXINPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures1, _) = self.client.sign_tx('Testnet', [inp1], [out1]) + (signatures1, _) = btc.sign_tx(self.client, 'Testnet', [inp1], [out1]) # store signature inp1.multisig.signatures[1] = signatures1[0] # sign with first key @@ -350,7 +351,7 @@ class TestMsgSigntxSegwitNative(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXINPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures2, serialized_tx) = self.client.sign_tx('Testnet', [inp1], [out1]) + (signatures2, serialized_tx) = btc.sign_tx(self.client, 'Testnet', [inp1], [out1]) # c9348040bbc2024e12dcb4a0b4806b0398646b91acf314da028c3f03dd0179fc assert hexlify(serialized_tx) == b'010000000001012812fe3916f228cda6c7b57d5464541265a63ad118f430a805eeec8bddbe1cf40000000000ffffffff01a0791800000000002200201e8dda334f11171190b3da72e526d441491464769679a319a2f011da5ad312a10400483045022100cc97f21a7cabc543a9b4ac52424e8f7e420622903f2417a1c08a6af68058ec4a02200baca0b222fc825078d94e8e1b55f174c4828bed16697e4281cda2a0c799eecf01473044022009b8058dc30fa7a13310dd8f1a99c4341c4cd95f771c5a41c4381f956e2344c102205e829c560c0184fd4b4db8971f99711e2a87409afa4df0840b4f12a87b2c8afc0169522102740ec30d0af8591a0dd4a3e3b274e57f3f73bdc0638a9603f9ee6ade0475ba57210311aada919974e882abf0c67b5c0fba00000b26997312ca00345027d22359443021029382591271a79d4b12365fa27c67fad3753150d8eaa987e5a12dc5ba1bb2fa1653ae00000000' @@ -358,7 +359,7 @@ class TestMsgSigntxSegwitNative(TrezorTest): def test_send_multisig_3_change(self): self.setup_mnemonic_allallall() self.client.set_tx_api(TxApiTestnet) - nodes = [self.client.get_public_node(parse_path("999'/1'/%d'" % index)) for index in range(1, 4)] + nodes = [btc.get_public_node(self.client, parse_path("999'/1'/%d'" % index)) for index in range(1, 4)] multisig = proto.MultisigRedeemScriptType( pubkeys=list(map(lambda n: proto.HDNodePathType(node=deserialize(n.xpub), address_n=[2, 0]), nodes)), signatures=[b'', b'', b''], @@ -396,7 +397,7 @@ class TestMsgSigntxSegwitNative(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXINPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures1, _) = self.client.sign_tx('Testnet', [inp1], [out1]) + (signatures1, _) = btc.sign_tx(self.client, 'Testnet', [inp1], [out1]) # store signature inp1.multisig.signatures[0] = signatures1[0] # sign with third key @@ -411,7 +412,7 @@ class TestMsgSigntxSegwitNative(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXINPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures2, serialized_tx) = self.client.sign_tx('Testnet', [inp1], [out1]) + (signatures2, serialized_tx) = btc.sign_tx(self.client, 'Testnet', [inp1], [out1]) # 31bc1c88ce6ae337a6b3057a16d5bad0b561ad1dfc047d0a7fbb8814668f91e5 assert hexlify(serialized_tx) == b'01000000000101fc7901dd033f8c02da14f3ac916b6498036b80b4a0b4dc124e02c2bb408034c90000000000ffffffff01b87518000000000017a914a8655acf68f785125561158b0f4db9b5d0044047870400473044022057b571986c07f8ccb231811334ad06ee6f87b722495def2e9511c1da46f3433202207b6e95bdd99e7fc7d319486437cb930d40a4af3cd753c4cb960b330badbf7f35014730440220517ecc6d0a2544276921d8fc2077aec4285ab83b1b21f5eb73cdb6187a0583e4022043fb5ab942f8981c04a54c66a57c4d291fad8514d4a8afea09f01f2db7a8f32901695221038e81669c085a5846e68e03875113ddb339ecbb7cb11376d4163bca5dc2e2a0c1210348c5c3be9f0e6cf1954ded1c0475beccc4d26aaa9d0cce2dd902538ff1018a112103931140ebe0fbbb7df0be04ed032a54e9589e30339ba7bbb8b0b71b15df1294da53ae00000000' @@ -419,7 +420,7 @@ class TestMsgSigntxSegwitNative(TrezorTest): def test_send_multisig_4_change(self): self.setup_mnemonic_allallall() self.client.set_tx_api(TxApiTestnet) - nodes = [self.client.get_public_node(parse_path("999'/1'/%d'" % index)) for index in range(1, 4)] + nodes = [btc.get_public_node(self.client, parse_path("999'/1'/%d'" % index)) for index in range(1, 4)] multisig = proto.MultisigRedeemScriptType( pubkeys=list(map(lambda n: proto.HDNodePathType(node=deserialize(n.xpub), address_n=[1, 1]), nodes)), signatures=[b'', b'', b''], @@ -457,7 +458,7 @@ class TestMsgSigntxSegwitNative(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXINPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures1, _) = self.client.sign_tx('Testnet', [inp1], [out1]) + (signatures1, _) = btc.sign_tx(self.client, 'Testnet', [inp1], [out1]) # store signature inp1.multisig.signatures[0] = signatures1[0] # sign with third key @@ -472,7 +473,7 @@ class TestMsgSigntxSegwitNative(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXINPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures2, serialized_tx) = self.client.sign_tx('Testnet', [inp1], [out1]) + (signatures2, serialized_tx) = btc.sign_tx(self.client, 'Testnet', [inp1], [out1]) # c0bf56060a109624b4635222696d94a7d533cacea1b3f8245417a4348c045829 assert hexlify(serialized_tx) == b'01000000000101e5918f661488bb7f0a7d04fc1dad61b5d0bad5167a05b3a637e36ace881cbc3100000000232200205b9824093eaf5cdcf8247c00dc0b557a7720957828fcde8384ac11f80a91f403ffffffff01d071180000000000220020e77caf5fbef07b1e461475c02afd4aed877693263d69c81e14617304349b629a040047304402204832553b0da1009da496881e58e8e2e41010cfe5c0161623048093f1b1a817b7022020dad8bf887acf574af80bfe4b39cd24e95019fd5e6b8ae967471e21ddc67354014830450221009e5d60847e7275edcf4619ed8ee462c56a042eef75d17da2d44e6b13d78e50e50220665195492900ef87a5eb8a924fa0ac9afc4fc75ca704ff356dc3a213979970c80169522103f4040006e3561b3e76c6d4113225c84748ab9d55ffd23f9578ab4c18fb0c3b9721020975f2e6922897ff6b80da6412a8d6ebd67e33c9611d081656a53ef967964e5021026b0546f23a6ce6b756c2c30b4176ce6f1c3268744f7aca82668d5116c4f764e453ae00000000' diff --git a/trezorlib/tests/device_tests/test_msg_signtx_zcash.py b/trezorlib/tests/device_tests/test_msg_signtx_zcash.py index 1bb1b13e02..d0d218be77 100644 --- a/trezorlib/tests/device_tests/test_msg_signtx_zcash.py +++ b/trezorlib/tests/device_tests/test_msg_signtx_zcash.py @@ -22,6 +22,7 @@ from .common import TrezorTest from trezorlib import coins from trezorlib import messages as proto from trezorlib.tools import parse_path +from trezorlib import btc TxApiZcashTestnet = coins.tx_api['Zcash Testnet'] @@ -62,7 +63,7 @@ class TestMsgSigntxZcash(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures, serialized_tx) = self.client.sign_tx('Zcash Testnet', [inp1, ], [out1, ], version=3, overwintered=True) + (signatures, serialized_tx) = btc.sign_tx(self.client, 'Zcash Testnet', [inp1, ], [out1, ], version=3, overwintered=True) # Accepted by network: tx eda9b772c47f0c29310759960e0081c98707aa67a0a2738bcc71439fcf360675 assert hexlify(serialized_tx) == b'030000807082c40301dc754d63eff4698ee321476872519c53f14cfe58c9425c7ee464c206461ef5aa010000006a47304402207e45f303b4e42be824513855eb21653e1d2749cd94dcd0f0613d3f85d4efd1e20220699ffbdbcad889af7ede5ce9febf7a5ef8f5619b2464824529974c400cffaebc0121030e669acac1f280d1ddf441cd2ba5e97417bf2689e4bbec86df4f831bf9f7ffd0ffffffff016c9be111000000001976a9145b157a678a10021243307e4bb58f36375aa80e1088ac000000000000000000' diff --git a/trezorlib/tests/device_tests/test_msg_stellar_get_address.py b/trezorlib/tests/device_tests/test_msg_stellar_get_address.py index 16de53daf3..1a6385528c 100644 --- a/trezorlib/tests/device_tests/test_msg_stellar_get_address.py +++ b/trezorlib/tests/device_tests/test_msg_stellar_get_address.py @@ -22,6 +22,7 @@ from binascii import hexlify from trezorlib import stellar from trezorlib import messages as proto from trezorlib.tools import parse_path, CallException +from trezorlib import debuglink @pytest.mark.stellar @@ -30,30 +31,31 @@ class TestMsgStellarGetAddress(TrezorTest): def test_stellar_get_address(self): self.setup_mnemonic_nopin_nopassphrase() - address = self.client.stellar_get_address(parse_path(stellar.DEFAULT_BIP32_PATH)) + address = stellar.get_address(self.client, parse_path(stellar.DEFAULT_BIP32_PATH)) assert address == 'GAK5MSF74TJW6GLM7NLTL76YZJKM2S4CGP3UH4REJHPHZ4YBZW2GSBPW' def test_stellar_get_address_sep(self): # data from https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0005.md - self.client.load_device_by_mnemonic( + debuglink.load_device_by_mnemonic( + self.client, mnemonic='illness spike retreat truth genius clock brain pass fit cave bargain toe', pin='', passphrase_protection=False, label='test', language='english') - address = self.client.stellar_get_address(parse_path(stellar.DEFAULT_BIP32_PATH)) + address = stellar.get_address(self.client, parse_path(stellar.DEFAULT_BIP32_PATH)) assert address == 'GDRXE2BQUC3AZNPVFSCEZ76NJ3WWL25FYFK6RGZGIEKWE4SOOHSUJUJ6' - address = self.client.stellar_get_address(parse_path("m/44h/148h/1h"), show_display=True) + address = stellar.get_address(self.client, parse_path("m/44h/148h/1h"), show_display=True) assert address == 'GBAW5XGWORWVFE2XTJYDTLDHXTY2Q2MO73HYCGB3XMFMQ562Q2W2GJQX' def test_stellar_get_address_get_pubkey(self): self.setup_mnemonic_nopin_nopassphrase() - pubkey = self.client.stellar_get_public_key(parse_path(stellar.DEFAULT_BIP32_PATH)) + pubkey = stellar.get_public_key(self.client, parse_path(stellar.DEFAULT_BIP32_PATH)) # GAK5MSF74TJW6GLM7NLTL76YZJKM2S4CGP3UH4REJHPHZ4YBZW2GSBPW - address = self.client.stellar_get_address(parse_path(stellar.DEFAULT_BIP32_PATH)) + address = stellar.get_address(self.client, parse_path(stellar.DEFAULT_BIP32_PATH)) assert stellar.address_from_public_key(pubkey) == address @@ -61,7 +63,7 @@ class TestMsgStellarGetAddress(TrezorTest): self.setup_mnemonic_nopin_nopassphrase() with pytest.raises(CallException) as exc: - self.client.stellar_get_address(parse_path('m/0/1')) + stellar.get_address(self.client, parse_path('m/0/1')) if TREZOR_VERSION == 1: assert exc.value.args[0] == proto.FailureType.ProcessError diff --git a/trezorlib/tests/device_tests/test_msg_stellar_get_public_key.py b/trezorlib/tests/device_tests/test_msg_stellar_get_public_key.py index f1837d399c..0c28998472 100644 --- a/trezorlib/tests/device_tests/test_msg_stellar_get_public_key.py +++ b/trezorlib/tests/device_tests/test_msg_stellar_get_public_key.py @@ -31,7 +31,7 @@ class TestMsgStellarGetPublicKey(TrezorTest): self.setup_mnemonic_nopin_nopassphrase() # GAK5MSF74TJW6GLM7NLTL76YZJKM2S4CGP3UH4REJHPHZ4YBZW2GSBPW - response = self.client.stellar_get_public_key(parse_path(stellar.DEFAULT_BIP32_PATH), show_display=True) + response = stellar.get_public_key(self.client, parse_path(stellar.DEFAULT_BIP32_PATH), show_display=True) assert hexlify(response) == b'15d648bfe4d36f196cfb5735ffd8ca54cd4b8233f743f22449de7cf301cdb469' assert stellar.address_from_public_key(response) == 'GAK5MSF74TJW6GLM7NLTL76YZJKM2S4CGP3UH4REJHPHZ4YBZW2GSBPW' @@ -39,7 +39,7 @@ class TestMsgStellarGetPublicKey(TrezorTest): self.setup_mnemonic_nopin_nopassphrase() with pytest.raises(CallException) as exc: - self.client.stellar_get_public_key(parse_path('m/0/1')) + stellar.get_public_key(self.client, parse_path('m/0/1')) if TREZOR_VERSION == 1: assert exc.value.args[0] == messages.FailureType.ProcessError diff --git a/trezorlib/tests/device_tests/test_msg_stellar_sign_transaction.py b/trezorlib/tests/device_tests/test_msg_stellar_sign_transaction.py index e66de3160c..12bc2830c9 100644 --- a/trezorlib/tests/device_tests/test_msg_stellar_sign_transaction.py +++ b/trezorlib/tests/device_tests/test_msg_stellar_sign_transaction.py @@ -69,7 +69,7 @@ class TestMsgStellarSignTransaction(TrezorTest): op.bump_to = 0x7fffffffffffffff tx = self._create_msg() - response = self.client.stellar_sign_transaction(tx, [op], self.ADDRESS_N, self.NETWORK_PASSPHRASE) + response = stellar.sign_tx(self.client, tx, [op], self.ADDRESS_N, self.NETWORK_PASSPHRASE) assert b64encode(response.signature) == b'ZMIfHWhpyXdg40PzwOtkcXYnbZIO12Qy0WvkGqoYpb7jyWbG2HQCG7dgWhCoU5K81pvZTA2pMwiPjMwCXA//Bg==' def test_sign_tx_account_merge_op(self): @@ -80,7 +80,7 @@ class TestMsgStellarSignTransaction(TrezorTest): tx = self._create_msg() - response = self.client.stellar_sign_transaction(tx, [op], self.ADDRESS_N, self.NETWORK_PASSPHRASE) + response = stellar.sign_tx(self.client, tx, [op], self.ADDRESS_N, self.NETWORK_PASSPHRASE) assert hexlify(response.public_key) == b'15d648bfe4d36f196cfb5735ffd8ca54cd4b8233f743f22449de7cf301cdb469' assert b64encode(response.signature) == b'2R3Pj89U+dWrqy7otUrLLjtANjAg0lmBQL8E+89Po0Y94oqZkauP8j3WE7+/z7vF6XvAMLoOdqRYkUzr2oh7Dg==' @@ -95,7 +95,7 @@ class TestMsgStellarSignTransaction(TrezorTest): tx = self._create_msg() - response = self.client.stellar_sign_transaction(tx, [op], self.ADDRESS_N, self.NETWORK_PASSPHRASE) + response = stellar.sign_tx(self.client, tx, [op], self.ADDRESS_N, self.NETWORK_PASSPHRASE) assert b64encode(response.signature) == b'vrRYqkM4b54NrDR05UrW7ZHU7CNcidV0fn+bk9dqOW1bCbmX3YfeRbk2Tf1aea8nr9SD0sfBhtrDpdyxUenjBw==' @@ -109,7 +109,7 @@ class TestMsgStellarSignTransaction(TrezorTest): tx = self._create_msg() - response = self.client.stellar_sign_transaction(tx, [op], self.ADDRESS_N, self.NETWORK_PASSPHRASE) + response = stellar.sign_tx(self.client, tx, [op], self.ADDRESS_N, self.NETWORK_PASSPHRASE) assert b64encode(response.signature) == b'pDc6ghKCLNoYbt3h4eBw+533237m0BB0Jp/d/TxJCA83mF3o5Fr4l5vwAWBR62hdTWAP9MhVluY0cd5i54UwDg==' @@ -124,7 +124,7 @@ class TestMsgStellarSignTransaction(TrezorTest): op.asset = proto.StellarAssetType(1, 'X', 'GAUYJFQCYIHFQNS7CI6BFWD2DSSFKDIQZUQ3BLQODDKE4PSW7VVBKENC') tx = self._create_msg() - response = self.client.stellar_sign_transaction(tx, [op], self.ADDRESS_N, self.NETWORK_PASSPHRASE) + response = stellar.sign_tx(self.client, tx, [op], self.ADDRESS_N, self.NETWORK_PASSPHRASE) assert b64encode(response.signature) == b'ArZydOtXU2whoRuSjJLFIWPSIsq3AbsncJZ+THF24CRSriVWw5Fy/dHrDlUOu4fzU28I6osDMeI39aWezg5tDw==' @@ -139,7 +139,7 @@ class TestMsgStellarSignTransaction(TrezorTest): op.asset = proto.StellarAssetType(2, 'ABCDEFGHIJKL', 'GAUYJFQCYIHFQNS7CI6BFWD2DSSFKDIQZUQ3BLQODDKE4PSW7VVBKENC') tx = self._create_msg() - response = self.client.stellar_sign_transaction(tx, [op], self.ADDRESS_N, self.NETWORK_PASSPHRASE) + response = stellar.sign_tx(self.client, tx, [op], self.ADDRESS_N, self.NETWORK_PASSPHRASE) assert b64encode(response.signature) == b'QZIP4XKPfe4OpZtuJiyrMZBX9YBzvGpHGcngdgFfHn2kcdONreF384/pCF80xfEnGm8grKaoOnUEKxqcMKvxAA==' @@ -151,7 +151,7 @@ class TestMsgStellarSignTransaction(TrezorTest): op.inflation_destination_account = 'GAFXTC5OV5XQD66T7WGOB2HUVUC3ZVJDJMBDPTVQYV3G3K7TUHC6CLBR' tx = self._create_msg() - response = self.client.stellar_sign_transaction(tx, [op], self.ADDRESS_N, self.NETWORK_PASSPHRASE) + response = stellar.sign_tx(self.client, tx, [op], self.ADDRESS_N, self.NETWORK_PASSPHRASE) assert b64encode(response.signature) == b'dveWhKY8x7b0YqGHWH6Fo1SskxaHP11NXd2n6oHKGiv+T/LqB+CCzbmJA0tplZ+0HNPJbHD7L3Bsg/y462qLDA==' diff --git a/trezorlib/tests/device_tests/test_msg_verifymessage.py b/trezorlib/tests/device_tests/test_msg_verifymessage.py index 80ee934e51..9f887b97d8 100644 --- a/trezorlib/tests/device_tests/test_msg_verifymessage.py +++ b/trezorlib/tests/device_tests/test_msg_verifymessage.py @@ -17,13 +17,15 @@ from binascii import unhexlify from .common import TrezorTest +from trezorlib import btc class TestMsgVerifymessage(TrezorTest): def test_message_long(self): self.setup_mnemonic_nopin_nopassphrase() - ret = self.client.verify_message( + ret = btc.verify_message( + self.client, 'Bitcoin', '14LmW5k4ssUrtbAB4255zdqv3b4w1TuX9e', unhexlify('205ff795c29aef7538f8b3bdb2e8add0d0722ad630a140b6aefd504a5a895cbd867cbb00981afc50edd0398211e8d7c304bb8efa461181bc0afa67ea4a720a89ed'), @@ -33,46 +35,51 @@ class TestMsgVerifymessage(TrezorTest): def test_message_testnet(self): self.setup_mnemonic_nopin_nopassphrase() - ret = self.client.verify_message( + ret = btc.verify_message( + self.client, 'Testnet', 'mirio8q3gtv7fhdnmb3TpZ4EuafdzSs7zL', unhexlify('209e23edf0e4e47ff1dec27f32cd78c50e74ef018ee8a6adf35ae17c7a9b0dd96f48b493fd7dbab03efb6f439c6383c9523b3bbc5f1a7d158a6af90ab154e9be80'), 'This is an example of a signed message.' - ) + ) assert ret is True def test_message_verify(self): self.setup_mnemonic_nopin_nopassphrase() # uncompressed pubkey - OK - res = self.client.verify_message( + res = btc.verify_message( + self.client, 'Bitcoin', '1JwSSubhmg6iPtRjtyqhUYYH7bZg3Lfy1T', unhexlify('1ba77e01a9e17ba158b962cfef5f13dfed676ffc2b4bada24e58f784458b52b97421470d001d53d5880cf5e10e76f02be3e80bf21e18398cbd41e8c3b4af74c8c2'), 'This is an example of a signed message.' - ) + ) assert res is True # uncompressed pubkey - FAIL - wrong sig - res = self.client.verify_message( + res = btc.verify_message( + self.client, 'Bitcoin', '1JwSSubhmg6iPtRjtyqhUYYH7bZg3Lfy1T', unhexlify('1ba77e01a9e17ba158b962cfef5f13dfed676ffc2b4bada24e58f784458b52b97421470d001d53d5880cf5e10e76f02be3e80bf21e18398cbd41e8c3b4af74c800'), 'This is an example of a signed message.' - ) + ) assert res is False # uncompressed pubkey - FAIL - wrong msg - res = self.client.verify_message( + res = btc.verify_message( + self.client, 'Bitcoin', '1JwSSubhmg6iPtRjtyqhUYYH7bZg3Lfy1T', unhexlify('1ba77e01a9e17ba158b962cfef5f13dfed676ffc2b4bada24e58f784458b52b97421470d001d53d5880cf5e10e76f02be3e80bf21e18398cbd41e8c3b4af74c8c2'), 'This is an example of a signed message!' - ) + ) assert res is False # compressed pubkey - OK - res = self.client.verify_message( + res = btc.verify_message( + self.client, 'Bitcoin', '1C7zdTfnkzmr13HfA2vNm5SJYRK6nEKyq8', unhexlify('1f44e3e461f7ca9f57c472ce1a28214df1de1dadefb6551a32d1907b80c74d5a1fbfd6daaba12dd8cb06699ce3f6941fbe0f3957b5802d13076181046e741eaaaf'), @@ -80,16 +87,18 @@ class TestMsgVerifymessage(TrezorTest): assert res is True # compressed pubkey - FAIL - wrong sig - res = self.client.verify_message( + res = btc.verify_message( + self.client, 'Bitcoin', '1C7zdTfnkzmr13HfA2vNm5SJYRK6nEKyq8', unhexlify('1f44e3e461f7ca9f57c472ce1a28214df1de1dadefb6551a32d1907b80c74d5a1fbfd6daaba12dd8cb06699ce3f6941fbe0f3957b5802d13076181046e741eaa00'), 'This is an example of a signed message.' - ) + ) assert res is False # compressed pubkey - FAIL - wrong msg - res = self.client.verify_message( + res = btc.verify_message( + self.client, 'Bitcoin', '1C7zdTfnkzmr13HfA2vNm5SJYRK6nEKyq8', unhexlify('1f44e3e461f7ca9f57c472ce1a28214df1de1dadefb6551a32d1907b80c74d5a1fbfd6daaba12dd8cb06699ce3f6941fbe0f3957b5802d13076181046e741eaaaf'), @@ -97,51 +106,56 @@ class TestMsgVerifymessage(TrezorTest): assert res is False # trezor pubkey - OK - res = self.client.verify_message( + res = btc.verify_message( + self.client, 'Bitcoin', '14LmW5k4ssUrtbAB4255zdqv3b4w1TuX9e', unhexlify('209e23edf0e4e47ff1dec27f32cd78c50e74ef018ee8a6adf35ae17c7a9b0dd96f48b493fd7dbab03efb6f439c6383c9523b3bbc5f1a7d158a6af90ab154e9be80'), 'This is an example of a signed message.' - ) + ) assert res is True # trezor pubkey - FAIL - wrong sig - res = self.client.verify_message( + res = btc.verify_message( + self.client, 'Bitcoin', '14LmW5k4ssUrtbAB4255zdqv3b4w1TuX9e', unhexlify('209e23edf0e4e47ff1dec27f32cd78c50e74ef018ee8a6adf35ae17c7a9b0dd96f48b493fd7dbab03efb6f439c6383c9523b3bbc5f1a7d158a6af90ab154e9be00'), 'This is an example of a signed message.' - ) + ) assert res is False # trezor pubkey - FAIL - wrong msg - res = self.client.verify_message( + res = btc.verify_message( + self.client, 'Bitcoin', '14LmW5k4ssUrtbAB4255zdqv3b4w1TuX9e', unhexlify('209e23edf0e4e47ff1dec27f32cd78c50e74ef018ee8a6adf35ae17c7a9b0dd96f48b493fd7dbab03efb6f439c6383c9523b3bbc5f1a7d158a6af90ab154e9be80'), 'This is an example of a signed message!' - ) + ) assert res is False def test_message_verify_bcash(self): self.setup_mnemonic_nopin_nopassphrase() - res = self.client.verify_message( + res = btc.verify_message( + self.client, 'Bcash', 'bitcoincash:qqj22md58nm09vpwsw82fyletkxkq36zxyxh322pru', unhexlify('209e23edf0e4e47ff1dec27f32cd78c50e74ef018ee8a6adf35ae17c7a9b0dd96f48b493fd7dbab03efb6f439c6383c9523b3bbc5f1a7d158a6af90ab154e9be80'), 'This is an example of a signed message.' - ) + ) assert res is True def test_verify_bitcoind(self): self.setup_mnemonic_nopin_nopassphrase() - res = self.client.verify_message( + res = btc.verify_message( + self.client, 'Bitcoin', '1KzXE97kV7DrpxCViCN3HbGbiKhzzPM7TQ', unhexlify('1cc694f0f23901dfe3603789142f36a3fc582d0d5c0ec7215cf2ccd641e4e37228504f3d4dc3eea28bbdbf5da27c49d4635c097004d9f228750ccd836a8e1460c0'), u'\u017elu\u0165ou\u010dk\xfd k\u016f\u0148 \xfap\u011bl \u010f\xe1belsk\xe9 \xf3dy' - ) + ) assert res is True @@ -151,14 +165,16 @@ class TestMsgVerifymessage(TrezorTest): words_nfkd = u'Pr\u030ci\u0301s\u030cerne\u030c z\u030clut\u030couc\u030cky\u0301 ku\u030an\u030c u\u0301pe\u030cl d\u030ca\u0301belske\u0301 o\u0301dy za\u0301ker\u030cny\u0301 uc\u030cen\u030c be\u030cz\u030ci\u0301 pode\u0301l zo\u0301ny u\u0301lu\u030a' words_nfc = u'P\u0159\xed\u0161ern\u011b \u017elu\u0165ou\u010dk\xfd k\u016f\u0148 \xfap\u011bl \u010f\xe1belsk\xe9 \xf3dy z\xe1ke\u0159n\xfd u\u010de\u0148 b\u011b\u017e\xed pod\xe9l z\xf3ny \xfal\u016f' - res_nfkd = self.client.verify_message( + res_nfkd = btc.verify_message( + self.client, 'Bitcoin', '14LmW5k4ssUrtbAB4255zdqv3b4w1TuX9e', unhexlify('20d0ec02ed8da8df23e7fe9e680e7867cc290312fe1c970749d8306ddad1a1eda41c6a771b13d495dd225b13b0a9d0f915a984ee3d0703f92287bf8009fbb9f7d6'), words_nfkd ) - res_nfc = self.client.verify_message( + res_nfc = btc.verify_message( + self.client, 'Bitcoin', '14LmW5k4ssUrtbAB4255zdqv3b4w1TuX9e', unhexlify('20d0ec02ed8da8df23e7fe9e680e7867cc290312fe1c970749d8306ddad1a1eda41c6a771b13d495dd225b13b0a9d0f915a984ee3d0703f92287bf8009fbb9f7d6'), diff --git a/trezorlib/tests/device_tests/test_msg_verifymessage_segwit.py b/trezorlib/tests/device_tests/test_msg_verifymessage_segwit.py index ff0bdf78ef..142a132d9b 100644 --- a/trezorlib/tests/device_tests/test_msg_verifymessage_segwit.py +++ b/trezorlib/tests/device_tests/test_msg_verifymessage_segwit.py @@ -17,13 +17,15 @@ from binascii import unhexlify from .common import TrezorTest +from trezorlib import btc class TestMsgVerifymessageSegwit(TrezorTest): def test_message_long(self): self.setup_mnemonic_nopin_nopassphrase() - ret = self.client.verify_message( + ret = btc.verify_message( + self.client, 'Bitcoin', '3CwYaeWxhpXXiHue3ciQez1DLaTEAXcKa1', unhexlify('245ff795c29aef7538f8b3bdb2e8add0d0722ad630a140b6aefd504a5a895cbd867cbb00981afc50edd0398211e8d7c304bb8efa461181bc0afa67ea4a720a89ed'), @@ -33,42 +35,46 @@ class TestMsgVerifymessageSegwit(TrezorTest): def test_message_testnet(self): self.setup_mnemonic_nopin_nopassphrase() - ret = self.client.verify_message( + ret = btc.verify_message( + self.client, 'Testnet', '2N4VkePSzKH2sv5YBikLHGvzUYvfPxV6zS9', unhexlify('249e23edf0e4e47ff1dec27f32cd78c50e74ef018ee8a6adf35ae17c7a9b0dd96f48b493fd7dbab03efb6f439c6383c9523b3bbc5f1a7d158a6af90ab154e9be80'), 'This is an example of a signed message.' - ) + ) assert ret is True def test_message_verify(self): self.setup_mnemonic_nopin_nopassphrase() # trezor pubkey - OK - res = self.client.verify_message( + res = btc.verify_message( + self.client, 'Bitcoin', '3CwYaeWxhpXXiHue3ciQez1DLaTEAXcKa1', unhexlify('249e23edf0e4e47ff1dec27f32cd78c50e74ef018ee8a6adf35ae17c7a9b0dd96f48b493fd7dbab03efb6f439c6383c9523b3bbc5f1a7d158a6af90ab154e9be80'), 'This is an example of a signed message.' - ) + ) assert res is True # trezor pubkey - FAIL - wrong sig - res = self.client.verify_message( + res = btc.verify_message( + self.client, 'Bitcoin', '3CwYaeWxhpXXiHue3ciQez1DLaTEAXcKa1', unhexlify('249e23edf0e4e47ff1dec27f32cd78c50e74ef018ee8a6adf35ae17c7a9b0dd96f48b493fd7dbab03efb6f439c6383c9523b3bbc5f1a7d158a6af90ab154e9be00'), 'This is an example of a signed message.' - ) + ) assert res is False # trezor pubkey - FAIL - wrong msg - res = self.client.verify_message( + res = btc.verify_message( + self.client, 'Bitcoin', '3CwYaeWxhpXXiHue3ciQez1DLaTEAXcKa1', unhexlify('249e23edf0e4e47ff1dec27f32cd78c50e74ef018ee8a6adf35ae17c7a9b0dd96f48b493fd7dbab03efb6f439c6383c9523b3bbc5f1a7d158a6af90ab154e9be80'), 'This is an example of a signed message!' - ) + ) assert res is False def test_verify_utf(self): @@ -77,14 +83,16 @@ class TestMsgVerifymessageSegwit(TrezorTest): words_nfkd = u'Pr\u030ci\u0301s\u030cerne\u030c z\u030clut\u030couc\u030cky\u0301 ku\u030an\u030c u\u0301pe\u030cl d\u030ca\u0301belske\u0301 o\u0301dy za\u0301ker\u030cny\u0301 uc\u030cen\u030c be\u030cz\u030ci\u0301 pode\u0301l zo\u0301ny u\u0301lu\u030a' words_nfc = u'P\u0159\xed\u0161ern\u011b \u017elu\u0165ou\u010dk\xfd k\u016f\u0148 \xfap\u011bl \u010f\xe1belsk\xe9 \xf3dy z\xe1ke\u0159n\xfd u\u010de\u0148 b\u011b\u017e\xed pod\xe9l z\xf3ny \xfal\u016f' - res_nfkd = self.client.verify_message( + res_nfkd = btc.verify_message( + self.client, 'Bitcoin', '3CwYaeWxhpXXiHue3ciQez1DLaTEAXcKa1', unhexlify('24d0ec02ed8da8df23e7fe9e680e7867cc290312fe1c970749d8306ddad1a1eda41c6a771b13d495dd225b13b0a9d0f915a984ee3d0703f92287bf8009fbb9f7d6'), words_nfkd ) - res_nfc = self.client.verify_message( + res_nfc = btc.verify_message( + self.client, 'Bitcoin', '3CwYaeWxhpXXiHue3ciQez1DLaTEAXcKa1', unhexlify('24d0ec02ed8da8df23e7fe9e680e7867cc290312fe1c970749d8306ddad1a1eda41c6a771b13d495dd225b13b0a9d0f915a984ee3d0703f92287bf8009fbb9f7d6'), diff --git a/trezorlib/tests/device_tests/test_msg_verifymessage_segwit_native.py b/trezorlib/tests/device_tests/test_msg_verifymessage_segwit_native.py index 750019339f..e091e0a5c8 100644 --- a/trezorlib/tests/device_tests/test_msg_verifymessage_segwit_native.py +++ b/trezorlib/tests/device_tests/test_msg_verifymessage_segwit_native.py @@ -17,13 +17,15 @@ from binascii import unhexlify from .common import TrezorTest +from trezorlib import btc class TestMsgVerifymessageSegwitNative(TrezorTest): def test_message_long(self): self.setup_mnemonic_nopin_nopassphrase() - ret = self.client.verify_message( + ret = btc.verify_message( + self.client, 'Bitcoin', 'bc1qyjjkmdpu7metqt5r36jf872a34syws33s82q2j', unhexlify('285ff795c29aef7538f8b3bdb2e8add0d0722ad630a140b6aefd504a5a895cbd867cbb00981afc50edd0398211e8d7c304bb8efa461181bc0afa67ea4a720a89ed'), @@ -33,42 +35,46 @@ class TestMsgVerifymessageSegwitNative(TrezorTest): def test_message_testnet(self): self.setup_mnemonic_nopin_nopassphrase() - ret = self.client.verify_message( + ret = btc.verify_message( + self.client, 'Testnet', 'tb1qyjjkmdpu7metqt5r36jf872a34syws336p3n3p', unhexlify('289e23edf0e4e47ff1dec27f32cd78c50e74ef018ee8a6adf35ae17c7a9b0dd96f48b493fd7dbab03efb6f439c6383c9523b3bbc5f1a7d158a6af90ab154e9be80'), 'This is an example of a signed message.' - ) + ) assert ret is True def test_message_verify(self): self.setup_mnemonic_nopin_nopassphrase() # trezor pubkey - OK - res = self.client.verify_message( + res = btc.verify_message( + self.client, 'Bitcoin', 'bc1qyjjkmdpu7metqt5r36jf872a34syws33s82q2j', unhexlify('289e23edf0e4e47ff1dec27f32cd78c50e74ef018ee8a6adf35ae17c7a9b0dd96f48b493fd7dbab03efb6f439c6383c9523b3bbc5f1a7d158a6af90ab154e9be80'), 'This is an example of a signed message.' - ) + ) assert res is True # trezor pubkey - FAIL - wrong sig - res = self.client.verify_message( + res = btc.verify_message( + self.client, 'Bitcoin', 'bc1qyjjkmdpu7metqt5r36jf872a34syws33s82q2j', unhexlify('289e23edf0e4e47ff1dec27f32cd78c50e74ef018ee8a6adf35ae17c7a9b0dd96f48b493fd7dbab03efb6f439c6383c9523b3bbc5f1a7d158a6af90ab154e9be00'), 'This is an example of a signed message.' - ) + ) assert res is False # trezor pubkey - FAIL - wrong msg - res = self.client.verify_message( + res = btc.verify_message( + self.client, 'Bitcoin', 'bc1qyjjkmdpu7metqt5r36jf872a34syws33s82q2j', unhexlify('289e23edf0e4e47ff1dec27f32cd78c50e74ef018ee8a6adf35ae17c7a9b0dd96f48b493fd7dbab03efb6f439c6383c9523b3bbc5f1a7d158a6af90ab154e9be80'), 'This is an example of a signed message!' - ) + ) assert res is False def test_verify_utf(self): @@ -77,14 +83,16 @@ class TestMsgVerifymessageSegwitNative(TrezorTest): words_nfkd = u'Pr\u030ci\u0301s\u030cerne\u030c z\u030clut\u030couc\u030cky\u0301 ku\u030an\u030c u\u0301pe\u030cl d\u030ca\u0301belske\u0301 o\u0301dy za\u0301ker\u030cny\u0301 uc\u030cen\u030c be\u030cz\u030ci\u0301 pode\u0301l zo\u0301ny u\u0301lu\u030a' words_nfc = u'P\u0159\xed\u0161ern\u011b \u017elu\u0165ou\u010dk\xfd k\u016f\u0148 \xfap\u011bl \u010f\xe1belsk\xe9 \xf3dy z\xe1ke\u0159n\xfd u\u010de\u0148 b\u011b\u017e\xed pod\xe9l z\xf3ny \xfal\u016f' - res_nfkd = self.client.verify_message( + res_nfkd = btc.verify_message( + self.client, 'Bitcoin', 'bc1qyjjkmdpu7metqt5r36jf872a34syws33s82q2j', unhexlify('28d0ec02ed8da8df23e7fe9e680e7867cc290312fe1c970749d8306ddad1a1eda41c6a771b13d495dd225b13b0a9d0f915a984ee3d0703f92287bf8009fbb9f7d6'), words_nfkd ) - res_nfc = self.client.verify_message( + res_nfc = btc.verify_message( + self.client, 'Bitcoin', 'bc1qyjjkmdpu7metqt5r36jf872a34syws33s82q2j', unhexlify('28d0ec02ed8da8df23e7fe9e680e7867cc290312fe1c970749d8306ddad1a1eda41c6a771b13d495dd225b13b0a9d0f915a984ee3d0703f92287bf8009fbb9f7d6'), diff --git a/trezorlib/tests/device_tests/test_msg_wipedevice.py b/trezorlib/tests/device_tests/test_msg_wipedevice.py index 2b428dd919..ef727e7790 100644 --- a/trezorlib/tests/device_tests/test_msg_wipedevice.py +++ b/trezorlib/tests/device_tests/test_msg_wipedevice.py @@ -17,6 +17,7 @@ from .common import TrezorTest from trezorlib import messages as proto +from trezorlib import device class TestMsgWipedevice(TrezorTest): @@ -30,7 +31,7 @@ class TestMsgWipedevice(TrezorTest): assert features.passphrase_protection is True device_id = features.device_id - self.client.wipe_device() + device.wipe(self.client) features = self.client.call_raw(proto.Initialize()) assert features.initialized is False diff --git a/trezorlib/tests/device_tests/test_multisig.py b/trezorlib/tests/device_tests/test_multisig.py index 608d20925a..b9b2e43951 100644 --- a/trezorlib/tests/device_tests/test_multisig.py +++ b/trezorlib/tests/device_tests/test_multisig.py @@ -21,6 +21,7 @@ from .common import TrezorTest from ..support import ckd_public as bip32 from trezorlib import messages as proto from trezorlib.tools import CallException +from trezorlib import btc TXHASH_c6091a = unhexlify('c6091adf4c0c23982a35899a6e58ae11e703eacd7954f588ed4b9cdefc4dba52') @@ -101,7 +102,7 @@ class TestMultisig(TrezorTest): ]) # Now we have first signature - (signatures1, _) = self.client.sign_tx('Bitcoin', [inp1, ], [out1, ]) + (signatures1, _) = btc.sign_tx(self.client, 'Bitcoin', [inp1, ], [out1, ]) assert hexlify(signatures1[0]) == b'3045022100985cc1ba316d140eb4b2d4028d8cd1c451f87bff8ff679858732e516ad04cd3402207af6edda99972af0baa7702a3b7448517c8242e7bca669f6861771cdd16ee058' @@ -142,7 +143,7 @@ class TestMultisig(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXOUTPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures2, serialized_tx) = self.client.sign_tx('Bitcoin', [inp3, ], [out1, ]) + (signatures2, serialized_tx) = btc.sign_tx(self.client, 'Bitcoin', [inp3, ], [out1, ]) assert hexlify(signatures2[0]) == b'3045022100f5428fe0531b3095675b40d87cab607ee036fac823b22e8dcec35b65aff6e52b022032129b4577ff923d321a1c70db5a6cec5bcc142cb2c51901af8b989cced23e0d' @@ -197,7 +198,7 @@ class TestMultisig(TrezorTest): ) with self.client: - (sig, serialized_tx) = self.client.sign_tx('Bitcoin', [inp1, ], [out1, ]) + (sig, serialized_tx) = btc.sign_tx(self.client, 'Bitcoin', [inp1, ], [out1, ]) signatures[x] = sig[0] # Accepted as tx id dd320786d1f58c095be0509dc56b277b6de8f2fb5517f519c6e6708414e3300b @@ -248,7 +249,7 @@ class TestMultisig(TrezorTest): ) with pytest.raises(CallException) as exc: - self.client.sign_tx('Bitcoin', [inp1, ], [out1, ]) + btc.sign_tx(self.client, 'Bitcoin', [inp1, ], [out1, ]) assert exc.value.args[0] == proto.FailureType.DataError assert exc.value.args[1].endswith('Pubkey not found in multisig script') diff --git a/trezorlib/tests/device_tests/test_multisig_change.py b/trezorlib/tests/device_tests/test_multisig_change.py index f41f121659..5a6c205c26 100644 --- a/trezorlib/tests/device_tests/test_multisig_change.py +++ b/trezorlib/tests/device_tests/test_multisig_change.py @@ -21,6 +21,7 @@ from ..support import ckd_public as bip32 from trezorlib import messages as proto from trezorlib.tools import parse_path from trezorlib.tx_api import TxApiInsight +from trezorlib import btc TxApiTestnet = TxApiInsight("insight_testnet") @@ -181,7 +182,7 @@ class TestMultisigChange(TrezorTest): with self.client: self.client.set_expected_responses(self._responses(self.inp1, self.inp2)) - (_, serialized_tx) = self.client.sign_tx('Testnet', [self.inp1, self.inp2, ], [out1, out2, ]) + (_, serialized_tx) = btc.sign_tx(self.client, 'Testnet', [self.inp1, self.inp2, ], [out1, out2, ]) assert hexlify(serialized_tx) == b'0100000002e53cf4e3fcd37f8c439286ce636476e1faeebf86bbb2f228a6b78d1b47c8c61601000000b400473044022064f13801744a6c21b694f62cdb5d834e852f13ecf85ed4d0a56ba279571c24e3022010fab4cb05bdd7b24c8376dda4f62a418548eea6eb483e58675fa06e0d5c642c014c69522103dc07026aacb5918dac4e09f9da8290d0ae22161699636c22cace78082116a7792103e70db185fad69c2971f0107a42930e5d82a9ed3a11b922a96fdfc4124b63e54c2103f3fe007a1e34ac76c1a2528e9149f90f9f93739929797afab6a8e18d682fa71053aeffffffff185315ae8050e18efa70d6ca96378a1194f57e2b102511f68b3a1414ee340cd800000000b4004730440220727b2522268f913acd213c507d7801b146e5b6cef666ad44b769c26d6c762e4d022021c0c2e9e8298dee2a490d956f7ab1b2d3160c1e37a50cc6d19a5e62eb484fc9014c6952210297ad8a5df42f9e362ef37d9a4ddced89d8f7a143690649aa0d0ff049c7daca842103ed1fd93989595d7ad4b488efd05a22c0239482c9a20923f2f214a38e54f6c41a2103f91460d79e4e463d7d90cb75254bcd62b515a99a950574c721efdc5f711dff3553aeffffffff02005a6202000000001976a9149b139230e4fe91c05a37ec334dc8378f3dbe377088ac00639f02000000001976a914b0d05a10926a7925508febdbab9a5bd4cda8c8f688ac00000000' @@ -203,7 +204,7 @@ class TestMultisigChange(TrezorTest): with self.client: self.client.set_expected_responses(self._responses(self.inp1, self.inp2, change=2)) - (_, serialized_tx) = self.client.sign_tx('Testnet', [self.inp1, self.inp2, ], [out1, out2, ]) + (_, serialized_tx) = btc.sign_tx(self.client, 'Testnet', [self.inp1, self.inp2, ], [out1, out2, ]) assert hexlify(serialized_tx) == b'0100000002e53cf4e3fcd37f8c439286ce636476e1faeebf86bbb2f228a6b78d1b47c8c61601000000b400473044022064f13801744a6c21b694f62cdb5d834e852f13ecf85ed4d0a56ba279571c24e3022010fab4cb05bdd7b24c8376dda4f62a418548eea6eb483e58675fa06e0d5c642c014c69522103dc07026aacb5918dac4e09f9da8290d0ae22161699636c22cace78082116a7792103e70db185fad69c2971f0107a42930e5d82a9ed3a11b922a96fdfc4124b63e54c2103f3fe007a1e34ac76c1a2528e9149f90f9f93739929797afab6a8e18d682fa71053aeffffffff185315ae8050e18efa70d6ca96378a1194f57e2b102511f68b3a1414ee340cd800000000b4004730440220727b2522268f913acd213c507d7801b146e5b6cef666ad44b769c26d6c762e4d022021c0c2e9e8298dee2a490d956f7ab1b2d3160c1e37a50cc6d19a5e62eb484fc9014c6952210297ad8a5df42f9e362ef37d9a4ddced89d8f7a143690649aa0d0ff049c7daca842103ed1fd93989595d7ad4b488efd05a22c0239482c9a20923f2f214a38e54f6c41a2103f91460d79e4e463d7d90cb75254bcd62b515a99a950574c721efdc5f711dff3553aeffffffff02005a6202000000001976a9149b139230e4fe91c05a37ec334dc8378f3dbe377088ac00639f02000000001976a914b0d05a10926a7925508febdbab9a5bd4cda8c8f688ac00000000' @@ -225,7 +226,7 @@ class TestMultisigChange(TrezorTest): with self.client: self.client.set_expected_responses(self._responses(self.inp1, self.inp2, change=1)) - (_, serialized_tx) = self.client.sign_tx('Testnet', [self.inp1, self.inp2, ], [out1, out2, ]) + (_, serialized_tx) = btc.sign_tx(self.client, 'Testnet', [self.inp1, self.inp2, ], [out1, out2, ]) assert hexlify(serialized_tx) == b'0100000002e53cf4e3fcd37f8c439286ce636476e1faeebf86bbb2f228a6b78d1b47c8c61601000000b400473044022064f13801744a6c21b694f62cdb5d834e852f13ecf85ed4d0a56ba279571c24e3022010fab4cb05bdd7b24c8376dda4f62a418548eea6eb483e58675fa06e0d5c642c014c69522103dc07026aacb5918dac4e09f9da8290d0ae22161699636c22cace78082116a7792103e70db185fad69c2971f0107a42930e5d82a9ed3a11b922a96fdfc4124b63e54c2103f3fe007a1e34ac76c1a2528e9149f90f9f93739929797afab6a8e18d682fa71053aeffffffff185315ae8050e18efa70d6ca96378a1194f57e2b102511f68b3a1414ee340cd800000000b4004730440220727b2522268f913acd213c507d7801b146e5b6cef666ad44b769c26d6c762e4d022021c0c2e9e8298dee2a490d956f7ab1b2d3160c1e37a50cc6d19a5e62eb484fc9014c6952210297ad8a5df42f9e362ef37d9a4ddced89d8f7a143690649aa0d0ff049c7daca842103ed1fd93989595d7ad4b488efd05a22c0239482c9a20923f2f214a38e54f6c41a2103f91460d79e4e463d7d90cb75254bcd62b515a99a950574c721efdc5f711dff3553aeffffffff02005a6202000000001976a9149b139230e4fe91c05a37ec334dc8378f3dbe377088ac00639f02000000001976a914b0d05a10926a7925508febdbab9a5bd4cda8c8f688ac00000000' @@ -247,7 +248,7 @@ class TestMultisigChange(TrezorTest): with self.client: self.client.set_expected_responses(self._responses(self.inp1, self.inp2)) - (_, serialized_tx) = self.client.sign_tx('Testnet', [self.inp1, self.inp2, ], [out1, out2, ]) + (_, serialized_tx) = btc.sign_tx(self.client, 'Testnet', [self.inp1, self.inp2, ], [out1, out2, ]) assert hexlify(serialized_tx) == b'0100000002e53cf4e3fcd37f8c439286ce636476e1faeebf86bbb2f228a6b78d1b47c8c61601000000b400473044022059394e0dfcb2d2f4a6108703f801545ca5a820c0ac6a1859d0a3854813de55fa02207b6a57d70b82932ff58163336c461653a2dc82c78ed8157159e5178ac7325390014c69522103dc07026aacb5918dac4e09f9da8290d0ae22161699636c22cace78082116a7792103e70db185fad69c2971f0107a42930e5d82a9ed3a11b922a96fdfc4124b63e54c2103f3fe007a1e34ac76c1a2528e9149f90f9f93739929797afab6a8e18d682fa71053aeffffffff185315ae8050e18efa70d6ca96378a1194f57e2b102511f68b3a1414ee340cd800000000b40047304402205a911685f5b974b2fc4a19d5ce056218773a4d20b5eaae2c2f9594929308182002201e03449f5a8813ec19f408bf1b6f4f334886d6fcf9920e300fd7678ef0724f81014c6952210297ad8a5df42f9e362ef37d9a4ddced89d8f7a143690649aa0d0ff049c7daca842103ed1fd93989595d7ad4b488efd05a22c0239482c9a20923f2f214a38e54f6c41a2103f91460d79e4e463d7d90cb75254bcd62b515a99a950574c721efdc5f711dff3553aeffffffff02005a62020000000017a91466528dd543f94d162c8111d2ec248d25ba9b90948700639f020000000017a914f1fc92c0aed1712911c70a2e09ac15ff0922652f8700000000' @@ -280,7 +281,7 @@ class TestMultisigChange(TrezorTest): with self.client: self.client.set_expected_responses(self._responses(self.inp1, self.inp2, change=1)) - (_, serialized_tx) = self.client.sign_tx('Testnet', [self.inp1, self.inp2, ], [out1, out2, ]) + (_, serialized_tx) = btc.sign_tx(self.client, 'Testnet', [self.inp1, self.inp2, ], [out1, out2, ]) assert hexlify(serialized_tx) == b'0100000002e53cf4e3fcd37f8c439286ce636476e1faeebf86bbb2f228a6b78d1b47c8c61601000000b400473044022059394e0dfcb2d2f4a6108703f801545ca5a820c0ac6a1859d0a3854813de55fa02207b6a57d70b82932ff58163336c461653a2dc82c78ed8157159e5178ac7325390014c69522103dc07026aacb5918dac4e09f9da8290d0ae22161699636c22cace78082116a7792103e70db185fad69c2971f0107a42930e5d82a9ed3a11b922a96fdfc4124b63e54c2103f3fe007a1e34ac76c1a2528e9149f90f9f93739929797afab6a8e18d682fa71053aeffffffff185315ae8050e18efa70d6ca96378a1194f57e2b102511f68b3a1414ee340cd800000000b40047304402205a911685f5b974b2fc4a19d5ce056218773a4d20b5eaae2c2f9594929308182002201e03449f5a8813ec19f408bf1b6f4f334886d6fcf9920e300fd7678ef0724f81014c6952210297ad8a5df42f9e362ef37d9a4ddced89d8f7a143690649aa0d0ff049c7daca842103ed1fd93989595d7ad4b488efd05a22c0239482c9a20923f2f214a38e54f6c41a2103f91460d79e4e463d7d90cb75254bcd62b515a99a950574c721efdc5f711dff3553aeffffffff02005a62020000000017a91466528dd543f94d162c8111d2ec248d25ba9b90948700639f020000000017a914f1fc92c0aed1712911c70a2e09ac15ff0922652f8700000000' @@ -313,7 +314,7 @@ class TestMultisigChange(TrezorTest): with self.client: self.client.set_expected_responses(self._responses(self.inp1, self.inp2, change=2)) - (_, serialized_tx) = self.client.sign_tx('Testnet', [self.inp1, self.inp2, ], [out1, out2, ]) + (_, serialized_tx) = btc.sign_tx(self.client, 'Testnet', [self.inp1, self.inp2, ], [out1, out2, ]) assert hexlify(serialized_tx) == b'0100000002e53cf4e3fcd37f8c439286ce636476e1faeebf86bbb2f228a6b78d1b47c8c61601000000b400473044022059394e0dfcb2d2f4a6108703f801545ca5a820c0ac6a1859d0a3854813de55fa02207b6a57d70b82932ff58163336c461653a2dc82c78ed8157159e5178ac7325390014c69522103dc07026aacb5918dac4e09f9da8290d0ae22161699636c22cace78082116a7792103e70db185fad69c2971f0107a42930e5d82a9ed3a11b922a96fdfc4124b63e54c2103f3fe007a1e34ac76c1a2528e9149f90f9f93739929797afab6a8e18d682fa71053aeffffffff185315ae8050e18efa70d6ca96378a1194f57e2b102511f68b3a1414ee340cd800000000b40047304402205a911685f5b974b2fc4a19d5ce056218773a4d20b5eaae2c2f9594929308182002201e03449f5a8813ec19f408bf1b6f4f334886d6fcf9920e300fd7678ef0724f81014c6952210297ad8a5df42f9e362ef37d9a4ddced89d8f7a143690649aa0d0ff049c7daca842103ed1fd93989595d7ad4b488efd05a22c0239482c9a20923f2f214a38e54f6c41a2103f91460d79e4e463d7d90cb75254bcd62b515a99a950574c721efdc5f711dff3553aeffffffff02005a62020000000017a91466528dd543f94d162c8111d2ec248d25ba9b90948700639f020000000017a914f1fc92c0aed1712911c70a2e09ac15ff0922652f8700000000' @@ -346,7 +347,7 @@ class TestMultisigChange(TrezorTest): with self.client: self.client.set_expected_responses(self._responses(self.inp1, self.inp2)) - (_, serialized_tx) = self.client.sign_tx('Testnet', [self.inp1, self.inp2, ], [out1, out2, ]) + (_, serialized_tx) = btc.sign_tx(self.client, 'Testnet', [self.inp1, self.inp2, ], [out1, out2, ]) assert hexlify(serialized_tx) == b'0100000002e53cf4e3fcd37f8c439286ce636476e1faeebf86bbb2f228a6b78d1b47c8c61601000000b40047304402207f9992cc0230527faf54ec6bd233307db82bc8fac039dcee418bc6feb4e96a3a02206bb4cb157ad27c123277328a877572563a45d70b844d9ab07cc42238112f8c2a014c69522103dc07026aacb5918dac4e09f9da8290d0ae22161699636c22cace78082116a7792103e70db185fad69c2971f0107a42930e5d82a9ed3a11b922a96fdfc4124b63e54c2103f3fe007a1e34ac76c1a2528e9149f90f9f93739929797afab6a8e18d682fa71053aeffffffff185315ae8050e18efa70d6ca96378a1194f57e2b102511f68b3a1414ee340cd800000000b400473044022078a41bfa87d72d6ba810d84bf568b5a29acf8b851ba6c3a8dbff079b34a7feb0022037b770c776db0b6c883c38a684a121b90a59ed1958774cbf64de70e53e29639f014c6952210297ad8a5df42f9e362ef37d9a4ddced89d8f7a143690649aa0d0ff049c7daca842103ed1fd93989595d7ad4b488efd05a22c0239482c9a20923f2f214a38e54f6c41a2103f91460d79e4e463d7d90cb75254bcd62b515a99a950574c721efdc5f711dff3553aeffffffff02005a62020000000017a91466528dd543f94d162c8111d2ec248d25ba9b90948700639f020000000017a914e6a3e2fbadb7f559f8d20c46aceae78c96fcf1d18700000000' @@ -379,6 +380,6 @@ class TestMultisigChange(TrezorTest): with self.client: self.client.set_expected_responses(self._responses(self.inp1, self.inp3)) - (_, serialized_tx) = self.client.sign_tx('Testnet', [self.inp1, self.inp3, ], [out1, out2, ]) + (_, serialized_tx) = btc.sign_tx(self.client, 'Testnet', [self.inp1, self.inp3, ], [out1, out2, ]) assert hexlify(serialized_tx) == b'0100000002e53cf4e3fcd37f8c439286ce636476e1faeebf86bbb2f228a6b78d1b47c8c61601000000b500483045022100d907b9339951c96ef4515ef7aff8b3c28c4c8c5875d7421aa1de9f3a94e3508302205cdc311a6c91dfbb74f1a9a940a994a65dbfb0cf6dedcaaaeee839e0b8fd016d014c69522103dc07026aacb5918dac4e09f9da8290d0ae22161699636c22cace78082116a7792103e70db185fad69c2971f0107a42930e5d82a9ed3a11b922a96fdfc4124b63e54c2103f3fe007a1e34ac76c1a2528e9149f90f9f93739929797afab6a8e18d682fa71053aeffffffff39f756d82082b580b0d69ae8798ff10a981820ccfe1ab149a708a37bc26d94b000000000b500483045022100fdad4a47d15f47cc364fe0cbed11b1ced1f9ef210bc1bd413ec4384f630c63720220752e4f09ea4e5e6623f5ebe89b3983ec6e5702f63f9bce696f10b2d594d23532014c6952210297ad8a5df42f9e362ef37d9a4ddced89d8f7a143690649aa0d0ff049c7daca842103b6321a1194e5cc47b6b7edc3f67a096e6f71ccb72440f84f390b6e98df0ea8ec2103f91460d79e4e463d7d90cb75254bcd62b515a99a950574c721efdc5f711dff3553aeffffffff02005a62020000000017a91466528dd543f94d162c8111d2ec248d25ba9b90948740d2df030000000017a914f1fc92c0aed1712911c70a2e09ac15ff0922652f8700000000' diff --git a/trezorlib/tests/device_tests/test_op_return.py b/trezorlib/tests/device_tests/test_op_return.py index db13733946..5247a027cc 100644 --- a/trezorlib/tests/device_tests/test_op_return.py +++ b/trezorlib/tests/device_tests/test_op_return.py @@ -21,6 +21,7 @@ from .common import TrezorTest from .conftest import TREZOR_VERSION from trezorlib import messages as proto from trezorlib.tools import CallException +from trezorlib import btc TXHASH_d5f65e = unhexlify('d5f65ee80147b4bcc70b75e4bbf2d7382021b871bd8867ef8fa525ef50864882') @@ -71,7 +72,7 @@ class TestOpReturn(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXOUTPUT, details=proto.TxRequestDetailsType(request_index=1)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - (signatures, serialized_tx) = self.client.sign_tx('Bitcoin', [inp1, ], [out1, out2]) + (signatures, serialized_tx) = btc.sign_tx(self.client, 'Bitcoin', [inp1, ], [out1, out2]) assert hexlify(serialized_tx) == b'010000000182488650ef25a58fef6788bd71b8212038d7f2bbe4750bc7bcb44701e85ef6d5000000006a4730440220187b7b9c340a32fc8445418ad11fb3827d2e8bac7d730e1c9ad800353e7ba62f02206c0c5820ba8882c82923a39aee8d36d6d32e13daed73f7a3d6199de5f8e7ddfd0121023230848585885f63803a0a8aecdd6538792d5c539215c91698e315bf0253b43dffffffff0260cc0500000000001976a914de9b2a8da088824e8fe51debea566617d851537888ac00000000000000001c6a1a74657374206f6620746865206f705f72657475726e206461746100000000' @@ -106,7 +107,7 @@ class TestOpReturn(TrezorTest): ]) with pytest.raises(CallException) as exc: - self.client.sign_tx('Bitcoin', [inp1], [out1]) + btc.sign_tx(self.client, 'Bitcoin', [inp1], [out1]) if TREZOR_VERSION == 1: assert exc.value.args[0] == proto.FailureType.ProcessError diff --git a/trezorlib/tests/device_tests/test_protection_levels.py b/trezorlib/tests/device_tests/test_protection_levels.py index b6ff5a4d5e..1ec34f81a1 100644 --- a/trezorlib/tests/device_tests/test_protection_levels.py +++ b/trezorlib/tests/device_tests/test_protection_levels.py @@ -19,6 +19,10 @@ import pytest from .common import TrezorTest from trezorlib import messages as proto +from trezorlib import btc +from trezorlib import debuglink +from trezorlib import device +from trezorlib import misc TXHASH_d5f65e = unhexlify('d5f65ee80147b4bcc70b75e4bbf2d7382021b871bd8867ef8fa525ef50864882') @@ -42,7 +46,7 @@ class TestProtectionLevels(TrezorTest): proto.Success(), proto.Features() ]) # TrezorClient reinitializes device - self.client.apply_settings(label='nazdar') + device.apply_settings(self.client, label='nazdar') def test_change_pin(self): with self.client: @@ -55,7 +59,7 @@ class TestProtectionLevels(TrezorTest): proto.Success(), proto.Features() ]) - self.client.change_pin() + device.change_pin(self.client) def test_ping(self): with self.client: @@ -75,7 +79,7 @@ class TestProtectionLevels(TrezorTest): proto.ButtonRequest(), proto.Entropy() ]) - self.client.get_entropy(10) + misc.get_entropy(self.client, 10) def test_get_public_key(self): with self.client: @@ -85,7 +89,7 @@ class TestProtectionLevels(TrezorTest): proto.PassphraseRequest(), proto.PublicKey() ]) - self.client.get_public_node([]) + btc.get_public_node(self.client, []) def test_get_address(self): with self.client: @@ -95,7 +99,7 @@ class TestProtectionLevels(TrezorTest): proto.PassphraseRequest(), proto.Address() ]) - self.client.get_address('Bitcoin', []) + btc.get_address(self.client, 'Bitcoin', []) def test_wipe_device(self): with self.client: @@ -105,27 +109,27 @@ class TestProtectionLevels(TrezorTest): proto.Success(), proto.Features() ]) - self.client.wipe_device() + device.wipe(self.client) def test_load_device(self): with self.client: self.client.set_expected_responses([proto.ButtonRequest(), proto.Success(), proto.Features()]) - self.client.load_device_by_mnemonic('this is mnemonic', '1234', True, 'label', 'english', skip_checksum=True) + debuglink.load_device_by_mnemonic(self.client, 'this is mnemonic', '1234', True, 'label', 'english', skip_checksum=True) # This must fail, because device is already initialized with pytest.raises(Exception): - self.client.load_device_by_mnemonic('this is mnemonic', '1234', True, 'label', 'english', skip_checksum=True) + debuglink.load_device_by_mnemonic(self.client, 'this is mnemonic', '1234', True, 'label', 'english', skip_checksum=True) def test_reset_device(self): with self.client: self.client.set_expected_responses([proto.EntropyRequest()] + [proto.ButtonRequest()] * 24 + [proto.Success(), proto.Features()]) - self.client.reset_device(False, 128, True, False, 'label', 'english') + device.reset(self.client, False, 128, True, False, 'label', 'english') # This must fail, because device is already initialized with pytest.raises(Exception): - self.client.reset_device(False, 128, True, False, 'label', 'english') + device.reset(self.client, False, 128, True, False, 'label', 'english') def test_recovery_device(self): with self.client: @@ -134,11 +138,11 @@ class TestProtectionLevels(TrezorTest): [proto.ButtonRequest()] + [proto.WordRequest()] * 24 + [proto.Success(), proto.Features()]) - self.client.recovery_device(12, False, False, 'label', 'english') + device.recover(self.client, 12, False, False, 'label', 'english') # This must fail, because device is already initialized with pytest.raises(Exception): - self.client.recovery_device(12, False, False, 'label', 'english') + device.recover(self.client, 12, False, False, 'label', 'english') def test_sign_message(self): with self.client: @@ -149,13 +153,14 @@ class TestProtectionLevels(TrezorTest): proto.PassphraseRequest(), proto.MessageSignature() ]) - self.client.sign_message('Bitcoin', [], 'testing message') + btc.sign_message(self.client, 'Bitcoin', [], 'testing message') def test_verify_message(self): with self.client: self.setup_mnemonic_pin_passphrase() self.client.set_expected_responses([proto.ButtonRequest(), proto.ButtonRequest(), proto.Success()]) - self.client.verify_message( + btc.verify_message( + self.client, 'Bitcoin', '14LmW5k4ssUrtbAB4255zdqv3b4w1TuX9e', unhexlify('209e23edf0e4e47ff1dec27f32cd78c50e74ef018ee8a6adf35ae17c7a9b0dd96f48b493fd7dbab03efb6f439c6383c9523b3bbc5f1a7d158a6af90ab154e9be80'), @@ -194,7 +199,7 @@ class TestProtectionLevels(TrezorTest): proto.TxRequest(request_type=proto.RequestType.TXOUTPUT, details=proto.TxRequestDetailsType(request_index=0)), proto.TxRequest(request_type=proto.RequestType.TXFINISHED), ]) - self.client.sign_tx('Bitcoin', [inp1, ], [out1, ]) + btc.sign_tx(self.client, 'Bitcoin', [inp1, ], [out1, ]) # def test_firmware_erase(self): # pass diff --git a/trezorlib/tests/device_tests/test_zerosig.py b/trezorlib/tests/device_tests/test_zerosig.py index 3e18727bce..32456862db 100644 --- a/trezorlib/tests/device_tests/test_zerosig.py +++ b/trezorlib/tests/device_tests/test_zerosig.py @@ -18,6 +18,7 @@ from binascii import unhexlify from .common import TrezorTest from trezorlib import messages as proto +from trezorlib import btc TXHASH_d5f65e = unhexlify('d5f65ee80147b4bcc70b75e4bbf2d7382021b871bd8867ef8fa525ef50864882') @@ -75,7 +76,7 @@ class TestZerosig(TrezorTest): script_type=proto.OutputScriptType.PAYTOADDRESS, ) - (signatures, serialized_tx) = self.client.sign_tx('Bitcoin', [inp1, ], [out1, ]) + (signatures, serialized_tx) = btc.sign_tx(self.client, 'Bitcoin', [inp1, ], [out1, ]) siglen = serialized_tx[44] # TREZOR must strip leading zero from signature @@ -98,7 +99,7 @@ class TestZerosig(TrezorTest): script_type=proto.OutputScriptType.PAYTOADDRESS, ) - (signatures, serialized_tx) = self.client.sign_tx('Bitcoin', [inp1, ], [out1, ]) + (signatures, serialized_tx) = btc.sign_tx(self.client, 'Bitcoin', [inp1, ], [out1, ]) siglen = serialized_tx[44] # TREZOR must strip leading zero from signature