arno/trezor-firmware
1
0
Fork 0
mirror of https://github.com/trezor/trezor-firmware.git synced 2025-03-12 06:06:07 +00:00
Code Issues Releases Wiki Activity

tests: use new API

Browse Source
This commit is contained in:
matejcik 2018-08-10 14:04:58 +02:00
parent d5dee0c897
commit c0ef1ec535
60 changed files with 517 additions and 398 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
trezorlib/tests/device_tests/common.py
View File

@ -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):

3
trezorlib/tests/device_tests/test_basic.py
View File

@ -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

13
trezorlib/tests/device_tests/test_bip32_speed.py
View File

@ -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)

28
trezorlib/tests/device_tests/test_cosi.py
View File

@ -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])

17
trezorlib/tests/device_tests/test_msg_applysettings.py
View File

@ -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:

33
trezorlib/tests/device_tests/test_msg_cipherkeyvalue.py
View File

@ -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")

11
trezorlib/tests/device_tests/test_msg_ethereum_getaddress.py
View File

@ -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'

3
trezorlib/tests/device_tests/test_msg_ethereum_signmessage.py
View File

@ -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

40
trezorlib/tests/device_tests/test_msg_ethereum_signtx.py
View File

@ -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,

4
trezorlib/tests/device_tests/test_msg_ethereum_signtx_eip155.py
View File

@ -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,

4
trezorlib/tests/device_tests/test_msg_ethereum_verifymessage.py
View File

@ -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

41
trezorlib/tests/device_tests/test_msg_getaddress.py
View File

@ -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'

13
trezorlib/tests/device_tests/test_msg_getaddress_segwit.py
View File

@ -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'

15
trezorlib/tests/device_tests/test_msg_getaddress_segwit_native.py
View File

@ -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'

11
trezorlib/tests/device_tests/test_msg_getaddress_show.py
View File

@ -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'

7
trezorlib/tests/device_tests/test_msg_getecdhsessionkey.py
View File

@ -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 <satoshi@bitcoin.org>', 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')

3
trezorlib/tests/device_tests/test_msg_getentropy.py
View File

@ -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))

45
trezorlib/tests/device_tests/test_msg_getpublickey.py
View File

@ -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'

19
trezorlib/tests/device_tests/test_msg_getpublickey_curve.py
View File

@ -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')

9
trezorlib/tests/device_tests/test_msg_lisk_getaddress.py
View File

@ -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'

3
trezorlib/tests/device_tests/test_msg_lisk_getpublickey.py
View File

@ -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'

5
trezorlib/tests/device_tests/test_msg_lisk_signmessage.py
View File

@ -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'

13
trezorlib/tests/device_tests/test_msg_lisk_signtx.py
View File

@ -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,

9
trezorlib/tests/device_tests/test_msg_lisk_verifymessage.py
View File

@ -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

31
trezorlib/tests/device_tests/test_msg_loaddevice.py
View File

@ -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

10
trezorlib/tests/device_tests/test_msg_loaddevice_xprv.py
View File

@ -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'

5
trezorlib/tests/device_tests/test_msg_nem_getaddress.py
View File

@ -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"

8
trezorlib/tests/device_tests/test_msg_nem_signtx_mosaics.py
View File

@ -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,

2
trezorlib/tests/device_tests/test_msg_nem_signtx_mosaics_t2.py
View File

@ -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,

10
trezorlib/tests/device_tests/test_msg_nem_signtx_multisig.py
View File

@ -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,

4
trezorlib/tests/device_tests/test_msg_nem_signtx_others.py
View File

@ -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,

14
trezorlib/tests/device_tests/test_msg_nem_signtx_transfers.py
View File

@ -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,

3
trezorlib/tests/device_tests/test_msg_recoverydevice.py
View File

@ -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')

3
trezorlib/tests/device_tests/test_msg_recoverydevice_t2.py
View File

@ -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')

3
trezorlib/tests/device_tests/test_msg_resetdevice.py
View File

@ -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')

3
trezorlib/tests/device_tests/test_msg_resetdevice_t2.py
View File

@ -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')

4
trezorlib/tests/device_tests/test_msg_ripple_get_address.py
View File

@ -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,

9
trezorlib/tests/device_tests/test_msg_signidentity.py
View File

@ -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'

13
trezorlib/tests/device_tests/test_msg_signmessage.py
View File

@ -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'

11
trezorlib/tests/device_tests/test_msg_signmessage_segwit.py
View File

@ -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'

11
trezorlib/tests/device_tests/test_msg_signmessage_segwit_native.py
View File

@ -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'

35
trezorlib/tests/device_tests/test_msg_signtx.py
View File

@ -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])

23
trezorlib/tests/device_tests/test_msg_signtx_bcash.py
View File

@ -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'

23
trezorlib/tests/device_tests/test_msg_signtx_bgold.py
View File

@ -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'

9
trezorlib/tests/device_tests/test_msg_signtx_decred.py
View File

@ -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]

15
trezorlib/tests/device_tests/test_msg_signtx_segwit.py
View File

@ -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")

35
trezorlib/tests/device_tests/test_msg_signtx_segwit_native.py
View File

@ -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'

3
trezorlib/tests/device_tests/test_msg_signtx_zcash.py
View File

@ -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'

16
trezorlib/tests/device_tests/test_msg_stellar_get_address.py
View File

@ -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

4
trezorlib/tests/device_tests/test_msg_stellar_get_public_key.py
View File

@ -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

14
trezorlib/tests/device_tests/test_msg_stellar_sign_transaction.py
View File

@ -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=='

66
trezorlib/tests/device_tests/test_msg_verifymessage.py
View File

@ -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'),

30
trezorlib/tests/device_tests/test_msg_verifymessage_segwit.py
View File

@ -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'),

30
trezorlib/tests/device_tests/test_msg_verifymessage_segwit_native.py
View File

@ -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'),

3
trezorlib/tests/device_tests/test_msg_wipedevice.py
View File

@ -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

9
trezorlib/tests/device_tests/test_multisig.py
View File

@ -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')

17
trezorlib/tests/device_tests/test_multisig_change.py
View File

@ -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'

5
trezorlib/tests/device_tests/test_op_return.py
View File

@ -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

35
trezorlib/tests/device_tests/test_protection_levels.py
View File

@ -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

5
trezorlib/tests/device_tests/test_zerosig.py
View File

@ -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