arno
/
trezor-firmware
mirror of https://github.com/trezor/trezor-firmware.git
1
0
Fork 0
Code Issues Releases Wiki Activity

tests: adapt tests to new APIs

Browse Source
pull/25/head
matejcik 6 years ago
parent 9caea6d413
commit 620e48e4d0
15 changed files with 342 additions and 370 deletions
Show Stats Download Patch File Download Diff File

6
trezorlib/tests/device_tests/common.py
Unescape View File

@ -16,15 +16,12 @@
import os
from trezorlib import coins, debuglink, device, tx_api
from trezorlib import coins, debuglink, device
from trezorlib.debuglink import TrezorClientDebugLink
from trezorlib.messages.PassphraseSourceType import HOST as PASSPHRASE_ON_HOST
from . import conftest
tests_dir = os.path.dirname(os.path.abspath(__file__))
tx_api.cache_dir = os.path.join(tests_dir, "../txcache")
class TrezorTest:
# fmt: off
@ -42,7 +39,6 @@ class TrezorTest:
def setup_method(self, method):
wirelink = conftest.get_device()
self.client = TrezorClientDebugLink(wirelink)
self.client.set_tx_api(coins.tx_api["Bitcoin"])
# self.client.set_buttonwait(3)
device.wipe(self.client)

3
trezorlib/tests/device_tests/conftest.py
Unescape View File

@ -19,7 +19,7 @@ import os
import pytest
from trezorlib import coins, debuglink, log
from trezorlib import debuglink, log
from trezorlib.debuglink import TrezorClientDebugLink
from trezorlib.device import wipe as wipe_device
from trezorlib.transport import enumerate_devices, get_transport
@ -54,7 +54,6 @@ def device_version():
def client():
wirelink = get_device()
client = TrezorClientDebugLink(wirelink)
client.set_tx_api(coins.tx_api["Bitcoin"])
wipe_device(client)
client.transport.session_begin()

136
trezorlib/tests/device_tests/test_msg_signtx.py
Unescape View File

@ -18,10 +18,11 @@ import pytest
from trezorlib import btc, messages as proto
from trezorlib.coins import tx_api
from trezorlib.tools import H_, CallException, parse_path
from trezorlib.tools import H_, CallException, parse_path, btc_hash
from .common import TrezorTest
from .conftest import TREZOR_VERSION
from ..support.tx_cache import tx_cache
TXHASH_157041 = bytes.fromhex(
"1570416eb4302cf52979afd5e6909e37d8fdd874301f7cc87e547e509cb1caa6"
@ -68,7 +69,7 @@ def check_sign_tx(client, coin_name, inputs, outputs, fee_too_high=False, failur
__tracebackhide__ = True
expected_responses = []
txes = tx_api[coin_name]
txes = tx_cache(coin_name)
t = proto.RequestType
b = proto.ButtonRequestType
@ -95,8 +96,7 @@ def check_sign_tx(client, coin_name, inputs, outputs, fee_too_high=False, failur
):
continue
prev_hash = inp.prev_hash.hex()
prev_tx = txes.get_tx(prev_hash)
prev_tx = txes[inp.prev_hash]
for pi in range(len(prev_tx.inputs)):
r = tx_request(t.TXINPUT, request_index=pi, tx_hash=inp.prev_hash)
expected_responses.append(r)
@ -138,7 +138,7 @@ def check_sign_tx(client, coin_name, inputs, outputs, fee_too_high=False, failur
with client:
client.set_expected_responses(expected_responses)
return btc.sign_tx(client, coin_name, inputs, outputs)
return btc.sign_tx(client, coin_name, inputs, outputs, prev_txes=txes)
class TestMsgSigntx(TrezorTest):
@ -171,7 +171,6 @@ class TestMsgSigntx(TrezorTest):
def test_testnet_one_two_fee(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(tx_api["Testnet"])
# see 87be0736f202f7c2bff0781b42bad3e0cdcb54761939da69ea793a3735552c56
# tx: e5040e1bc1ae7667ffb9e5248e90b2fb93cd9150234151ce90e14ab2f5933bcd
@ -204,8 +203,6 @@ class TestMsgSigntx(TrezorTest):
def test_testnet_fee_too_high(self):
self.setup_mnemonic_nopin_nopassphrase()
self.client.set_tx_api(tx_api["Testnet"])
# tx: 6f90f3c7cbec2258b0971056ef3fe34128dbde30daa9c0639a898f9977299d54
# input 1: 10.00000000 BTC
inp1 = proto.TxInputType(
@ -354,29 +351,38 @@ class TestMsgSigntx(TrezorTest):
)
# Accepted by network: tx c63e24ed820c5851b60c54613fbc4bcb37df6cd49b4c96143e99580a472f79fb
# The transaction was produced before Trezor implemented BIP-66, so the signature
# is now different and txhash doesn't match what is on the blockchain.
assert (
serialized_tx.hex()
== "01000000021c032e5715d1da8115a2fe4f57699e15742fe113b0d2d1ca3b594649d322bec6010000006b483045022100f773c403b2f85a5c1d6c9c4ad69c43de66930fff4b1bc818eb257af98305546a0220443bde4be439f276a6ce793664b463580e210ec6c9255d68354449ac0443c76501210338d78612e990f2eea0c426b5e48a8db70b9d7ed66282b3b26511e0b1c75515a6ffffffff6ea42cd8d9c8e5441c4c5f85bfe50311078730d2881494f11f4d2257777a4958010000006b48304502210090cff1c1911e771605358a8cddd5ae94c7b60cc96e50275908d9bf9d6367c79f02202bfa72e10260a146abd59d0526e1335bacfbb2b4401780e9e3a7441b0480c8da0121038caebd6f753bbbd2bb1f3346a43cd32140648583673a31d62f2dfb56ad0ab9e3ffffffff02a0860100000000001976a9142f4490d5263906e4887ca2996b9e207af3e7824088aca0860100000000001976a914812c13d97f9159e54e326b481b8f88a73df8507a88ac00000000"
)
"""
def test_lots_of_inputs(self):
self.setup_mnemonic_nopin_nopassphrase()
# Tests if device implements serialization of len(inputs) correctly
# tx 4a7b7e0403ae5607e473949cfa03f09f2cd8b0f404bf99ce10b7303d86280bf7 : 100 UTXO for spending for unit tests
inputs = []
for i in range(100):
inputs.append( proto.TxInputType(address_n=[4], # 1NwN6UduuVkJi6sw3gSiKZaCY5rHgVXC2h
prev_hash=TXHASH_4a7b7e,
prev_index=i) )
out = proto.TxOutputType(address='19dvDdyxxptP9dGvozYe8BP6tgFV9L4jg5',
amount=100 * 26000 - 15 * 10000,
script_type=proto.OutputScriptType.PAYTOADDRESS)
with self.client:
(signatures, serialized_tx) = self.client.sign_tx('Bitcoin', inputs, [out])
inputs.append(
proto.TxInputType(
address_n=[4], # 1NwN6UduuVkJi6sw3gSiKZaCY5rHgVXC2h
prev_hash=TXHASH_4a7b7e,
prev_index=i,
)
)
out = proto.TxOutputType(
address="19dvDdyxxptP9dGvozYe8BP6tgFV9L4jg5",
amount=100 * 26000 - 15 * 10000,
script_type=proto.OutputScriptType.PAYTOADDRESS,
)
_, serialized_tx = check_sign_tx(self.client, "Bitcoin", inputs, [out])
# Accepted by network: tx 23d9d8eecf3abf6c0f0f3f8b0976a04792d7f1c9a4ea9b0a8931734949e27c92
# too big put in unit test
"""
# too big put in unit test, only check hash
assert (
btc_hash(serialized_tx)[::-1].hex()
== "23d9d8eecf3abf6c0f0f3f8b0976a04792d7f1c9a4ea9b0a8931734949e27c92"
)
def test_lots_of_outputs(self):
self.setup_mnemonic_nopin_nopassphrase()
@ -540,30 +546,9 @@ class TestMsgSigntx(TrezorTest):
script_type=proto.OutputScriptType.PAYTOADDRESS,
)
global run_attack
run_attack = False
def attack_processor(req, msg):
global run_attack
if req.details.tx_hash is not None:
return msg
if req.details.request_index != 1:
return msg
if req.request_type != proto.RequestType.TXOUTPUT:
return msg
if not run_attack:
run_attack = True
return msg
msg.outputs[0].amount = 9999999 # Sign output with another amount
return msg
out2.force_confirm = True
# Test if the transaction can be signed normally
(_, serialized_tx) = btc.sign_tx(
_, serialized_tx = check_sign_tx(
self.client, "Bitcoin", [inp1, inp2], [out1, out2]
)
@ -573,14 +558,29 @@ class TestMsgSigntx(TrezorTest):
== "01000000021c032e5715d1da8115a2fe4f57699e15742fe113b0d2d1ca3b594649d322bec6010000006b483045022100f773c403b2f85a5c1d6c9c4ad69c43de66930fff4b1bc818eb257af98305546a0220443bde4be439f276a6ce793664b463580e210ec6c9255d68354449ac0443c76501210338d78612e990f2eea0c426b5e48a8db70b9d7ed66282b3b26511e0b1c75515a6ffffffff6ea42cd8d9c8e5441c4c5f85bfe50311078730d2881494f11f4d2257777a4958010000006b48304502210090cff1c1911e771605358a8cddd5ae94c7b60cc96e50275908d9bf9d6367c79f02202bfa72e10260a146abd59d0526e1335bacfbb2b4401780e9e3a7441b0480c8da0121038caebd6f753bbbd2bb1f3346a43cd32140648583673a31d62f2dfb56ad0ab9e3ffffffff02a0860100000000001976a9142f4490d5263906e4887ca2996b9e207af3e7824088aca0860100000000001976a914812c13d97f9159e54e326b481b8f88a73df8507a88ac00000000"
)
# Now run the attack, must trigger the exception
run_attack = False
def attack_processor(msg):
nonlocal run_attack
if msg.tx.outputs and msg.tx.outputs[0] == out2:
if not run_attack:
run_attack = True
else:
# Sign output with another amount
msg.tx.outputs[0].amount = 9999999
return msg
# Set up attack processors
self.client.set_filter(proto.TxAck, attack_processor)
with pytest.raises(CallException) as exc:
btc.sign_tx(
self.client,
"Bitcoin",
[inp1, inp2],
[out1, out2],
debug_processor=attack_processor,
prev_txes=tx_cache("Bitcoin"),
)
assert exc.value.args[0] in (
proto.FailureType.ProcessError,
@ -591,9 +591,7 @@ class TestMsgSigntx(TrezorTest):
def test_attack_change_input_address(self):
# This unit test attempts to modify input address after the Trezor checked
# that it matches the change output
self.setup_mnemonic_allallall()
self.client.set_tx_api(tx_api["Testnet"])
inp1 = proto.TxInputType(
address_n=parse_path("44'/1'/4'/0/0"),
@ -610,41 +608,32 @@ class TestMsgSigntx(TrezorTest):
)
out2 = proto.TxOutputType(
address_n=parse_path("44'/1'/12345'/1/0"),
address_n=parse_path("44'/1'/4'/1/0"),
amount=123400000 - 5000 - 100000,
script_type=proto.OutputScriptType.PAYTOADDRESS,
)
global run_attack
run_attack = True
def attack_processor(req, msg):
global run_attack
if req.details.tx_hash is not None:
return msg
if req.request_type != proto.RequestType.TXINPUT:
return msg
if req.details.request_index != 0:
return msg
if not run_attack:
return msg
msg.inputs[0].address_n[2] = H_(12345)
run_attack = False
return msg
# Test if the transaction can be signed normally
(_, serialized_tx) = btc.sign_tx(self.client, "Testnet", [inp1], [out1, out2])
_, serialized_tx = check_sign_tx(self.client, "Testnet", [inp1], [out1, out2])
assert (
serialized_tx.hex()
== "0100000001243e15b53cc553d93ec4e27e16984adc3d885ef107c613a7577fea47f5dadcd2010000006a47304402207d517dcb6b823bba4d252da096795a7f914d0c477aee26e554ba61653c45608a02202cba1e805c586c830472f399510be5d42c2fcfd67b8a6b0690cbe8a3e6e475e801210364430c9122948e525e2f1c6d88f00f47679274f0810fd8c63754954f310995c1ffffffff02a0860100000000001976a914b3cc67f3349974d0f1b50e9bb5dfdf226f888fa088ac18555907000000001976a91485a3f5b0d23cdd61f5f8e1eb8c9ca0890dd15a9788ac00000000"
== "0100000001243e15b53cc553d93ec4e27e16984adc3d885ef107c613a7577fea47f5dadcd2010000006b483045022100eedaadde3a771967beee39f1daa9e9450f72fccdec63488a96d71eeae4224b4002203a22be3c1677d3451c93a49550b69e8f8fc06328823c7e0f633dde13d67ef96b01210364430c9122948e525e2f1c6d88f00f47679274f0810fd8c63754954f310995c1ffffffff02a0860100000000001976a914b3cc67f3349974d0f1b50e9bb5dfdf226f888fa088ac18555907000000001976a914f80fb232a1e54b1fa732bc120cae72eabd7fcf6888ac00000000"
)
run_attack = False
def attack_processor(msg):
nonlocal run_attack
if msg.tx.inputs and msg.tx.inputs[0] == inp1:
if not run_attack:
run_attack = True
else:
msg.tx.inputs[0].address_n[2] = H_(12345)
return msg
self.client.set_filter(proto.TxAck, attack_processor)
# Now run the attack, must trigger the exception
with self.client:
self.client.set_expected_responses(
@ -699,7 +688,7 @@ class TestMsgSigntx(TrezorTest):
"Testnet",
[inp1],
[out1, out2],
debug_processor=attack_processor,
prev_txes=tx_cache("Testnet"),
)
assert exc.value.args[0] == proto.FailureType.ProcessError
@ -716,7 +705,6 @@ class TestMsgSigntx(TrezorTest):
# input 0: 25.0027823 BTC
self.setup_mnemonic_nopin_nopassphrase()
self.client.set_tx_api(tx_api["Testnet"])
inp1 = proto.TxInputType(
address_n=[1], # mfiGQVPcRcaEvQPYDErR34DcCovtxYvUUV
@ -741,7 +729,6 @@ class TestMsgSigntx(TrezorTest):
def test_two_changes(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(tx_api["Testnet"])
# see 87be0736f202f7c2bff0781b42bad3e0cdcb54761939da69ea793a3735552c56
# tx: e5040e1bc1ae7667ffb9e5248e90b2fb93cd9150234151ce90e14ab2f5933bcd
@ -777,7 +764,6 @@ class TestMsgSigntx(TrezorTest):
def test_change_on_main_chain_allowed(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(tx_api["Testnet"])
# see 87be0736f202f7c2bff0781b42bad3e0cdcb54761939da69ea793a3735552c56
# tx: e5040e1bc1ae7667ffb9e5248e90b2fb93cd9150234151ce90e14ab2f5933bcd

106
trezorlib/tests/device_tests/test_msg_signtx_bcash.py
Unescape View File

@ -20,15 +20,15 @@ from trezorlib import btc, coins, messages as proto
from trezorlib.tools import H_, CallException, parse_path
from ..support.ckd_public import deserialize
from ..support.tx_cache import tx_cache
from .common import TrezorTest
TxApiBcash = coins.tx_api["Bcash"]
TX_API = tx_cache("Bcash")
class TestMsgSigntxBch(TrezorTest):
def test_send_bch_change(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiBcash)
inp1 = proto.TxInputType(
address_n=parse_path("44'/145'/0'/0/0"),
# bitcoincash:qr08q88p9etk89wgv05nwlrkm4l0urz4cyl36hh9sv
@ -81,8 +81,8 @@ class TestMsgSigntxBch(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures, serialized_tx) = btc.sign_tx(
self.client, "Bcash", [inp1], [out1, out2]
_, serialized_tx = btc.sign_tx(
self.client, "Bcash", [inp1], [out1, out2], prev_txes=TX_API
)
assert (
@ -92,7 +92,6 @@ class TestMsgSigntxBch(TrezorTest):
def test_send_bch_nochange(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiBcash)
inp1 = proto.TxInputType(
address_n=parse_path("44'/145'/0'/1/0"),
# bitcoincash:qzc5q87w069lzg7g3gzx0c8dz83mn7l02scej5aluw
@ -150,8 +149,8 @@ class TestMsgSigntxBch(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures, serialized_tx) = btc.sign_tx(
self.client, "Bcash", [inp1, inp2], [out1]
_, serialized_tx = btc.sign_tx(
self.client, "Bcash", [inp1, inp2], [out1], prev_txes=TX_API
)
assert (
@ -161,7 +160,6 @@ class TestMsgSigntxBch(TrezorTest):
def test_send_bch_oldaddr(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiBcash)
inp1 = proto.TxInputType(
address_n=parse_path("44'/145'/0'/1/0"),
# bitcoincash:qzc5q87w069lzg7g3gzx0c8dz83mn7l02scej5aluw
@ -219,8 +217,8 @@ class TestMsgSigntxBch(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures, serialized_tx) = btc.sign_tx(
self.client, "Bcash", [inp1, inp2], [out1]
_, serialized_tx = btc.sign_tx(
self.client, "Bcash", [inp1, inp2], [out1], prev_txes=TX_API
)
assert (
@ -230,7 +228,6 @@ class TestMsgSigntxBch(TrezorTest):
def test_attack_amount(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiBcash)
inp1 = proto.TxInputType(
address_n=parse_path("44'/145'/0'/1/0"),
# bitcoincash:qzc5q87w069lzg7g3gzx0c8dz83mn7l02scej5aluw
@ -257,31 +254,6 @@ class TestMsgSigntxBch(TrezorTest):
script_type=proto.OutputScriptType.PAYTOADDRESS,
)
global run_attack
run_attack = True
def attack_processor(req, msg):
global run_attack
if req.details.tx_hash is not None:
return msg
if req.request_type != proto.RequestType.TXINPUT:
return msg
if req.details.request_index != 0:
return msg
if not run_attack:
return msg
# 300 is lowered to 280 at the first run
# the user confirms 280 but the transaction
# is spending 300 => larger fee without the user knowing
msg.inputs[0].amount = 280
run_attack = False
return msg
# test if passes without modifications
with self.client:
self.client.set_expected_responses(
@ -315,9 +287,24 @@ class TestMsgSigntxBch(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
btc.sign_tx(self.client, "Bcash", [inp1, inp2], [out1])
btc.sign_tx(self.client, "Bcash", [inp1, inp2], [out1], prev_txes=TX_API)
run_attack = True
def attack_processor(msg):
nonlocal run_attack
if run_attack and msg.tx.inputs and msg.tx.inputs[0] == inp1:
# 300 is lowered to 280 at the first run
# the user confirms 280 but the transaction
# is spending 300 => larger fee without the user knowing
msg.tx.inputs[0].amount = 280
run_attack = False
return msg
# now fails
self.client.set_filter(proto.TxAck, attack_processor)
with self.client:
self.client.set_expected_responses(
[
@ -349,11 +336,7 @@ class TestMsgSigntxBch(TrezorTest):
with pytest.raises(CallException) as exc:
btc.sign_tx(
self.client,
"Bcash",
[inp1, inp2],
[out1],
debug_processor=attack_processor,
self.client, "Bcash", [inp1, inp2], [out1], prev_txes=TX_API
)
assert exc.value.args[0] in (
@ -364,7 +347,6 @@ class TestMsgSigntxBch(TrezorTest):
def test_attack_change_input(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiBcash)
inp1 = proto.TxInputType(
address_n=parse_path("44'/145'/1000'/0/0"),
# bitcoincash:qr08q88p9etk89wgv05nwlrkm4l0urz4cyl36hh9sv
@ -386,25 +368,21 @@ class TestMsgSigntxBch(TrezorTest):
script_type=proto.OutputScriptType.PAYTOADDRESS,
)
global attack_ctr
attack_ctr = 0
def attack_processor(req, msg):
global attack_ctr
run_attack = False
if req.details.tx_hash is not None:
return msg
def attack_processor(msg):
nonlocal run_attack
if req.request_type != proto.RequestType.TXINPUT:
return msg
if msg.tx.inputs and msg.tx.inputs[0] == inp1:
if not run_attack:
run_attack = True
else:
msg.tx.inputs[0].address_n[2] = H_(1)
attack_ctr += 1
if attack_ctr <= 1:
return msg
msg.inputs[0].address_n[2] = H_(1)
return msg
self.client.set_filter(proto.TxAck, attack_processor)
with self.client:
self.client.set_expected_responses(
[
@ -431,16 +409,11 @@ class TestMsgSigntxBch(TrezorTest):
)
with pytest.raises(CallException):
btc.sign_tx(
self.client,
"Bcash",
[inp1],
[out1, out2],
debug_processor=attack_processor,
self.client, "Bcash", [inp1], [out1, out2], prev_txes=TX_API
)
def test_send_bch_multisig_wrongchange(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiBcash)
xpubs = []
for n in map(
lambda index: btc.get_public_node(
@ -528,7 +501,7 @@ class TestMsgSigntxBch(TrezorTest):
]
)
(signatures1, serialized_tx) = btc.sign_tx(
self.client, "Bcash", [inp1], [out1]
self.client, "Bcash", [inp1], [out1], prev_txes=TX_API
)
assert (
signatures1[0].hex()
@ -541,7 +514,6 @@ class TestMsgSigntxBch(TrezorTest):
def test_send_bch_multisig_change(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiBcash)
xpubs = []
for n in map(
lambda index: btc.get_public_node(
@ -620,7 +592,7 @@ class TestMsgSigntxBch(TrezorTest):
]
)
(signatures1, serialized_tx) = btc.sign_tx(
self.client, "Bcash", [inp1], [out1, out2]
self.client, "Bcash", [inp1], [out1, out2], prev_txes=TX_API
)
assert (
@ -674,7 +646,7 @@ class TestMsgSigntxBch(TrezorTest):
]
)
(signatures1, serialized_tx) = btc.sign_tx(
self.client, "Bcash", [inp1], [out1, out2]
self.client, "Bcash", [inp1], [out1, out2], prev_txes=TX_API
)
assert (

79
trezorlib/tests/device_tests/test_msg_signtx_bgold.py
Unescape View File

@ -20,16 +20,16 @@ from trezorlib import btc, coins, messages as proto
from trezorlib.tools import H_, CallException, parse_path
from ..support.ckd_public import deserialize
from ..support.tx_cache import tx_cache
from .common import TrezorTest
TxApiBitcoinGold = coins.tx_api["Bgold"]
TX_API = tx_cache("Bgold")
# All data taken from T1
class TestMsgSigntxBitcoinGold(TrezorTest):
def test_send_bitcoin_gold_change(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiBitcoinGold)
inp1 = proto.TxInputType(
address_n=parse_path("44'/156'/0'/0/0"),
amount=1995344,
@ -81,8 +81,8 @@ class TestMsgSigntxBitcoinGold(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures, serialized_tx) = btc.sign_tx(
self.client, "Bgold", [inp1], [out1, out2]
_, serialized_tx = btc.sign_tx(
self.client, "Bgold", [inp1], [out1, out2], prev_txes=TX_API
)
assert (
@ -92,7 +92,6 @@ class TestMsgSigntxBitcoinGold(TrezorTest):
def test_send_bitcoin_gold_nochange(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiBitcoinGold)
inp1 = proto.TxInputType(
address_n=parse_path("44'/156'/0'/1/0"),
amount=1896050,
@ -149,8 +148,8 @@ class TestMsgSigntxBitcoinGold(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures, serialized_tx) = btc.sign_tx(
self.client, "Bgold", [inp1, inp2], [out1]
_, serialized_tx = btc.sign_tx(
self.client, "Bgold", [inp1, inp2], [out1], prev_txes=TX_API
)
assert (
@ -160,7 +159,6 @@ class TestMsgSigntxBitcoinGold(TrezorTest):
def test_attack_change_input(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiBitcoinGold)
inp1 = proto.TxInputType(
address_n=parse_path("44'/156'/1000'/0/0"),
# 1MH9KKcvdCTY44xVDC2k3fjBbX5Cz29N1q
@ -182,25 +180,20 @@ class TestMsgSigntxBitcoinGold(TrezorTest):
script_type=proto.OutputScriptType.PAYTOADDRESS,
)
global attack_ctr
attack_ctr = 0
run_attack = False
def attack_processor(req, msg):
global attack_ctr
def attack_processor(msg):
nonlocal run_attack
if req.details.tx_hash is not None:
return msg
if msg.tx.inputs and msg.tx.inputs[0] == inp1:
if run_attack:
msg.tx.inputs[0].address_n[2] = H_(1)
else:
run_attack = True
if req.request_type != proto.RequestType.TXINPUT:
return msg
attack_ctr += 1
if attack_ctr <= 1:
return msg
msg.inputs[0].address_n[2] = H_(1)
return msg
self.client.set_filter(proto.TxAck, attack_processor)
with self.client:
self.client.set_expected_responses(
[
@ -227,16 +220,11 @@ class TestMsgSigntxBitcoinGold(TrezorTest):
)
with pytest.raises(CallException):
btc.sign_tx(
self.client,
"Bgold",
[inp1],
[out1, out2],
debug_processor=attack_processor,
self.client, "Bgold", [inp1], [out1, out2], prev_txes=TX_API
)
def test_send_btg_multisig_change(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiBitcoinGold)
xpubs = []
for n in map(
lambda index: btc.get_public_node(
@ -314,18 +302,18 @@ class TestMsgSigntxBitcoinGold(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures1, serialized_tx) = btc.sign_tx(
self.client, "Bgold", [inp1], [out1, out2]
signatures, serialized_tx = btc.sign_tx(
self.client, "Bgold", [inp1], [out1, out2], prev_txes=TX_API
)
assert (
signatures1[0].hex()
signatures[0].hex()
== "3045022100b1594f3b186d0dedbf61e53a1c407b1e0747098b7375941df85af045040f578e022013ba1893eb9e2fd854dd07073a83b261cf4beba76f66b07742e462b4088a7e4a"
)
inp1 = proto.TxInputType(
address_n=parse_path("44'/156'/1'/0/0"),
multisig=getmultisig(0, 0, [b"", b"", signatures1[0]]),
multisig=getmultisig(0, 0, [b"", b"", signatures[0]]),
# 33Ju286QvonBz5N1V754ZekQv4GLJqcc5R
amount=48490,
prev_hash=bytes.fromhex(
@ -368,12 +356,12 @@ class TestMsgSigntxBitcoinGold(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures1, serialized_tx) = btc.sign_tx(
self.client, "Bgold", [inp1], [out1, out2]
signatures, serialized_tx = btc.sign_tx(
self.client, "Bgold", [inp1], [out1, out2], prev_txes=TX_API
)
assert (
signatures1[0].hex()
signatures[0].hex()
== "3044022006da8dbd14e6656ac8dcb956f4c0498574e88680eaeceb2cbafd8d2b2329d8cc02200972d076d444c5ff8f2ab18e14d8249ab661cb9c53335039bedcde037a40d747"
)
assert (
@ -383,7 +371,6 @@ class TestMsgSigntxBitcoinGold(TrezorTest):
def test_send_p2sh(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiBitcoinGold)
inp1 = proto.TxInputType(
address_n=parse_path("49'/156'/0'/1/0"),
amount=123456789,
@ -440,8 +427,8 @@ class TestMsgSigntxBitcoinGold(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures, serialized_tx) = btc.sign_tx(
self.client, "Bgold", [inp1], [out1, out2]
_, serialized_tx = btc.sign_tx(
self.client, "Bgold", [inp1], [out1, out2], prev_txes=TX_API
)
assert (
@ -451,7 +438,6 @@ class TestMsgSigntxBitcoinGold(TrezorTest):
def test_send_p2sh_witness_change(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiBitcoinGold)
inp1 = proto.TxInputType(
address_n=parse_path("49'/156'/0'/1/0"),
amount=123456789,
@ -507,8 +493,8 @@ class TestMsgSigntxBitcoinGold(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures, serialized_tx) = btc.sign_tx(
self.client, "Bgold", [inp1], [out1, out2]
_, serialized_tx = btc.sign_tx(
self.client, "Bgold", [inp1], [out1, out2], prev_txes=TX_API
)
assert (
@ -518,7 +504,6 @@ class TestMsgSigntxBitcoinGold(TrezorTest):
def test_send_multisig_1(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiBitcoinGold)
nodes = map(
lambda index: btc.get_public_node(
self.client, parse_path("999'/1'/%d'" % index)
@ -583,9 +568,11 @@ class TestMsgSigntxBitcoinGold(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures1, _) = btc.sign_tx(self.client, "Bgold", [inp1], [out1])
signatures, _ = btc.sign_tx(
self.client, "Bgold", [inp1], [out1], prev_txes=TX_API
)
# store signature
inp1.multisig.signatures[0] = signatures1[0]
inp1.multisig.signatures[0] = signatures[0]
# sign with third key
inp1.address_n[2] = H_(3)
self.client.set_expected_responses(
@ -615,8 +602,8 @@ class TestMsgSigntxBitcoinGold(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures2, serialized_tx) = btc.sign_tx(
self.client, "Bgold", [inp1], [out1]
_, serialized_tx = btc.sign_tx(
self.client, "Bgold", [inp1], [out1], prev_txes=TX_API
)
assert (

69
trezorlib/tests/device_tests/test_msg_signtx_capricoin.py
Unescape View File

@ -16,10 +16,11 @@
import pytest
from trezorlib import btc, coins, messages as proto
from trezorlib import btc, messages
from trezorlib.tools import parse_path
from .common import TrezorTest
from .conftest import setup_client
from ..support.tx_cache import tx_cache
TXHASH_3bf506 = bytes.fromhex(
"3bf506c81ce84eda891679ddc797d162c17c60b15d6c0ac23be5e31369e7235f"
@ -32,44 +33,38 @@ TXHASH_f3a6e6 = bytes.fromhex(
@pytest.mark.xfail
@pytest.mark.capricoin
class TestMsgSigntx(TrezorTest):
def test_timestamp_included(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(coins.tx_api["Capricoin"])
@setup_client()
def test_timestamp_included(client):
# tx: 3bf506c81ce84eda891679ddc797d162c17c60b15d6c0ac23be5e31369e7235f
# input 0: 0.01 CPC
# tx: f3a6e6411f1b2dffd76d2729bae8e056f8f9ecf8996d3f428e75a6f23f2c5e8c
# input 0: 0.02 CPC
# tx: 3bf506c81ce84eda891679ddc797d162c17c60b15d6c0ac23be5e31369e7235f
# input 0: 0.01 CPC
# tx: f3a6e6411f1b2dffd76d2729bae8e056f8f9ecf8996d3f428e75a6f23f2c5e8c
# input 0: 0.02 CPC
inp1 = messages.TxInputType(
address_n=parse_path("m/44'/289'/0'/0/0"), prev_hash=TXHASH_3bf506, prev_index=0
)
inp1 = proto.TxInputType(
address_n=parse_path("m/44'/289'/0'/0/0"),
prev_hash=TXHASH_3bf506,
prev_index=0,
)
inp2 = messages.TxInputType(
address_n=parse_path("m/44'/289'/0'/0/0"), prev_hash=TXHASH_f3a6e6, prev_index=1
)
inp2 = proto.TxInputType(
address_n=parse_path("m/44'/289'/0'/0/0"),
prev_hash=TXHASH_f3a6e6,
prev_index=1,
)
out1 = messages.TxOutputType(
address="CUGi8RGPWxbHM6FxF4eMEfqmQ6Bs5VjCdr",
amount=3000000 - 20000,
script_type=messages.OutputScriptType.PAYTOADDRESS,
)
out1 = proto.TxOutputType(
address="CUGi8RGPWxbHM6FxF4eMEfqmQ6Bs5VjCdr",
amount=3000000 - 20000,
script_type=proto.OutputScriptType.PAYTOADDRESS,
with client:
details = messages.SignTx(version=1, timestamp=0x5BCF5C66)
_, timestamp_tx = btc.sign_tx(
client,
"Capricoin",
[inp1, inp2],
[out1],
details=details,
prev_txes=tx_cache("Capricoin"),
)
with self.client:
timestamp_signatures, timestamp_tx = btc.sign_tx(
self.client,
"Capricoin",
[inp1, inp2],
[out1],
version=1,
timestamp=0x5BCF5C66,
)
# Accepted by network https://insight.capricoin.org/tx/1bf227e6e24fe1f8ac98849fe06a2c5b77762e906fcf7e82787675f7f3a10bb8
accepted_txhex = "01000000665ccf5b025f23e76913e3e53bc20a6c5db1607cc162d197c7dd791689da4ee81cc806f53b000000006b483045022100fce7ccbeb9524f36d118ebcfebcb133a05c236c4478e2051cfd5c9632920aee602206921b7be1a81f30cce3d8e7dba4597fc16a2761c42321c49d65eeacdfe3781250121021fcf98aee04939ec7df5762f426dc2d1db8026e3a73c3bbe44749dacfbb61230ffffffff8c5e2c3ff2a6758e423f6d99f8ecf9f856e0e8ba29276dd7ff2d1b1f41e6a6f3010000006a473044022015d967166fe9f89fbed8747328b1c4658aa1d7163e731c5fd5908feafe08e9a6022028af30801098418bd298cc60b143c52c48466f5791256721304b6eba4fdf0b3c0121021fcf98aee04939ec7df5762f426dc2d1db8026e3a73c3bbe44749dacfbb61230ffffffff01a0782d00000000001976a914818437acfd15780debd31f3fd21d4ca678bb36d188ac00000000"
assert timestamp_tx.hex() == accepted_txhex
# Accepted by network https://insight.capricoin.org/tx/1bf227e6e24fe1f8ac98849fe06a2c5b77762e906fcf7e82787675f7f3a10bb8
accepted_txhex = "01000000665ccf5b025f23e76913e3e53bc20a6c5db1607cc162d197c7dd791689da4ee81cc806f53b000000006b483045022100fce7ccbeb9524f36d118ebcfebcb133a05c236c4478e2051cfd5c9632920aee602206921b7be1a81f30cce3d8e7dba4597fc16a2761c42321c49d65eeacdfe3781250121021fcf98aee04939ec7df5762f426dc2d1db8026e3a73c3bbe44749dacfbb61230ffffffff8c5e2c3ff2a6758e423f6d99f8ecf9f856e0e8ba29276dd7ff2d1b1f41e6a6f3010000006a473044022015d967166fe9f89fbed8747328b1c4658aa1d7163e731c5fd5908feafe08e9a6022028af30801098418bd298cc60b143c52c48466f5791256721304b6eba4fdf0b3c0121021fcf98aee04939ec7df5762f426dc2d1db8026e3a73c3bbe44749dacfbb61230ffffffff01a0782d00000000001976a914818437acfd15780debd31f3fd21d4ca678bb36d188ac00000000"
assert timestamp_tx.hex() == accepted_txhex

28
trezorlib/tests/device_tests/test_msg_signtx_decred.py
Unescape View File

@ -16,12 +16,13 @@
import pytest
from trezorlib import btc, coins, messages as proto
from trezorlib import btc, messages as proto
from trezorlib.tools import parse_path
from .common import TrezorTest
from ..support.tx_cache import tx_cache
TxApiDecredTestnet = coins.tx_api["Decred Testnet"]
TX_API = tx_cache("Decred Testnet")
TXHASH_e16248 = bytes.fromhex(
@ -48,7 +49,6 @@ TXHASH_16da18 = bytes.fromhex(
class TestMsgSigntxDecred(TrezorTest):
def test_send_decred(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiDecredTestnet)
inp1 = proto.TxInputType(
# TscqTv1he8MZrV321SfRghw7LFBCJDKB3oz
@ -109,8 +109,8 @@ class TestMsgSigntxDecred(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures, serialized_tx) = btc.sign_tx(
self.client, "Decred Testnet", [inp1], [out1]
_, serialized_tx = btc.sign_tx(
self.client, "Decred Testnet", [inp1], [out1], prev_txes=TX_API
)
assert (
@ -120,7 +120,6 @@ class TestMsgSigntxDecred(TrezorTest):
def test_send_decred_change(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiDecredTestnet)
inp1 = proto.TxInputType(
# TscqTv1he8MZrV321SfRghw7LFBCJDKB3oz
@ -264,8 +263,12 @@ class TestMsgSigntxDecred(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures, serialized_tx) = btc.sign_tx(
self.client, "Decred Testnet", [inp1, inp2, inp3], [out1, out2]
_, serialized_tx = btc.sign_tx(
self.client,
"Decred Testnet",
[inp1, inp2, inp3],
[out1, out2],
prev_txes=TX_API,
)
assert (
@ -275,7 +278,6 @@ class TestMsgSigntxDecred(TrezorTest):
def test_decred_multisig_change(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiDecredTestnet)
paths = [parse_path("m/48'/1'/%d'" % index) for index in range(3)]
nodes = [
@ -414,8 +416,12 @@ class TestMsgSigntxDecred(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signature, serialized_tx) = btc.sign_tx(
self.client, "Decred Testnet", [inp1, inp2], [out1, out2]
signature, serialized_tx = btc.sign_tx(
self.client,
"Decred Testnet",
[inp1, inp2],
[out1, out2],
prev_txes=TX_API,
)
signatures[0][index] = signature[0]

70
trezorlib/tests/device_tests/test_msg_signtx_segwit.py
Unescape View File

@ -18,19 +18,18 @@ import pytest
from trezorlib import btc, messages as proto
from trezorlib.tools import H_, CallException, parse_path
from trezorlib.tx_api import TxApiInsight
from ..support.ckd_public import deserialize
from ..support.tx_cache import tx_cache
from .common import TrezorTest
from .conftest import TREZOR_VERSION
TxApiTestnet = TxApiInsight("insight_testnet")
TX_API = tx_cache("Testnet")
class TestMsgSigntxSegwit(TrezorTest):
def test_send_p2sh(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiTestnet)
inp1 = proto.TxInputType(
address_n=parse_path("49'/1'/0'/1/0"),
# 2N1LGaGg836mqSQqiuUBLfcyGBhyZbremDX
@ -88,8 +87,8 @@ class TestMsgSigntxSegwit(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures, serialized_tx) = btc.sign_tx(
self.client, "Testnet", [inp1], [out1, out2]
_, serialized_tx = btc.sign_tx(
self.client, "Testnet", [inp1], [out1, out2], prev_txes=TX_API
)
assert (
@ -99,7 +98,6 @@ class TestMsgSigntxSegwit(TrezorTest):
def test_send_p2sh_change(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiTestnet)
inp1 = proto.TxInputType(
address_n=parse_path("49'/1'/0'/1/0"),
# 2N1LGaGg836mqSQqiuUBLfcyGBhyZbremDX
@ -156,8 +154,8 @@ class TestMsgSigntxSegwit(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures, serialized_tx) = btc.sign_tx(
self.client, "Testnet", [inp1], [out1, out2]
_, serialized_tx = btc.sign_tx(
self.client, "Testnet", [inp1], [out1, out2], prev_txes=TX_API
)
assert (
@ -167,7 +165,6 @@ class TestMsgSigntxSegwit(TrezorTest):
def test_send_multisig_1(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiTestnet)
nodes = map(
lambda index: btc.get_public_node(
self.client, parse_path("999'/1'/%d'" % index)
@ -232,9 +229,11 @@ class TestMsgSigntxSegwit(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures1, _) = btc.sign_tx(self.client, "Testnet", [inp1], [out1])
signatures, _ = btc.sign_tx(
self.client, "Testnet", [inp1], [out1], prev_txes=TX_API
)
# store signature
inp1.multisig.signatures[0] = signatures1[0]
inp1.multisig.signatures[0] = signatures[0]
# sign with third key
inp1.address_n[2] = H_(3)
self.client.set_expected_responses(
@ -264,8 +263,8 @@ class TestMsgSigntxSegwit(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures2, serialized_tx) = btc.sign_tx(
self.client, "Testnet", [inp1], [out1]
_, serialized_tx = btc.sign_tx(
self.client, "Testnet", [inp1], [out1], prev_txes=TX_API
)
assert (
@ -278,7 +277,6 @@ class TestMsgSigntxSegwit(TrezorTest):
# that it matches the change output
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiTestnet)
inp1 = proto.TxInputType(
address_n=parse_path("49'/1'/0'/1/0"),
# 2N1LGaGg836mqSQqiuUBLfcyGBhyZbremDX
@ -300,28 +298,6 @@ class TestMsgSigntxSegwit(TrezorTest):
amount=123456789 - 11000 - 12300000,
)
global run_attack
run_attack = True
def attack_processor(req, msg):
global run_attack
if req.details.tx_hash is not None:
return msg
if req.request_type != proto.RequestType.TXINPUT:
return msg
if req.details.request_index != 0:
return msg
if not run_attack:
return msg
msg.inputs[0].address_n[2] = H_(12345)
run_attack = False
return msg
# Test if the transaction can be signed normally
with self.client:
self.client.set_expected_responses(
@ -360,8 +336,8 @@ class TestMsgSigntxSegwit(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures, serialized_tx) = btc.sign_tx(
self.client, "Testnet", [inp1], [out1, out2]
_, serialized_tx = btc.sign_tx(
self.client, "Testnet", [inp1], [out1, out2], prev_txes=TX_API
)
assert (
@ -369,7 +345,19 @@ class TestMsgSigntxSegwit(TrezorTest):
== "0100000000010137c361fb8f2d9056ba8c98c5611930fcb48cacfdd0fe2e0449d83eea982f91200000000017160014d16b8c0680c61fc6ed2e407455715055e41052f5ffffffff02e0aebb00000000001976a91414fdede0ddc3be652a0ce1afbc1b509a55b6b94888ac3df39f060000000017a914dae9e09a7fc3bbe5a716fffec1bbb340b82a4fb9870248304502210099b5c4f8fd4402c9c0136fee5f711137d64fc9f14587e01bfa7798f5428f845d0220253e21c98f5b1b64efae69bc2ea9799c5620a43450baa6762a0c3cf4fdc886e5012103e7bfe10708f715e8538c92d46ca50db6f657bbc455b7494e6a0303ccdb868b7900000000"
)
run_attack = True
def attack_processor(msg):
nonlocal run_attack
if run_attack and msg.tx.inputs and msg.tx.inputs[0] == inp1:
run_attack = False
msg.tx.inputs[0].address_n[2] = H_(12345)
return msg
# Now run the attack, must trigger the exception
self.client.set_filter(proto.TxAck, attack_processor)
with self.client:
self.client.set_expected_responses(
[
@ -396,11 +384,7 @@ class TestMsgSigntxSegwit(TrezorTest):
)
with pytest.raises(CallException) as exc:
btc.sign_tx(
self.client,
"Testnet",
[inp1],
[out1, out2],
debug_processor=attack_processor,
self.client, "Testnet", [inp1], [out1, out2], prev_txes=TX_API
)
assert exc.value.args[0] == proto.FailureType.ProcessError
if TREZOR_VERSION == 1:

77
trezorlib/tests/device_tests/test_msg_signtx_segwit_native.py
Unescape View File

@ -16,18 +16,17 @@
from trezorlib import btc, messages as proto
from trezorlib.tools import H_, parse_path
from trezorlib.tx_api import TxApiInsight
from ..support.ckd_public import deserialize
from ..support.tx_cache import tx_cache
from .common import TrezorTest
TxApiTestnet = TxApiInsight("insight_testnet")
TX_API = tx_cache("Testnet")
class TestMsgSigntxSegwitNative(TrezorTest):
def test_send_p2sh(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiTestnet)
inp1 = proto.TxInputType(
address_n=parse_path("49'/1'/0'/1/0"),
# 2N1LGaGg836mqSQqiuUBLfcyGBhyZbremDX
@ -85,8 +84,8 @@ class TestMsgSigntxSegwitNative(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures, serialized_tx) = btc.sign_tx(
self.client, "Testnet", [inp1], [out1, out2]
_, serialized_tx = btc.sign_tx(
self.client, "Testnet", [inp1], [out1, out2], prev_txes=TX_API
)
assert (
@ -96,7 +95,6 @@ class TestMsgSigntxSegwitNative(TrezorTest):
def test_send_p2sh_change(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiTestnet)
inp1 = proto.TxInputType(
address_n=parse_path("49'/1'/0'/1/0"),
# 2N1LGaGg836mqSQqiuUBLfcyGBhyZbremDX
@ -153,8 +151,8 @@ class TestMsgSigntxSegwitNative(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures, serialized_tx) = btc.sign_tx(
self.client, "Testnet", [inp1], [out1, out2]
_, serialized_tx = btc.sign_tx(
self.client, "Testnet", [inp1], [out1, out2], prev_txes=TX_API
)
assert (
@ -164,7 +162,6 @@ class TestMsgSigntxSegwitNative(TrezorTest):
def test_send_native(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiTestnet)
inp1 = proto.TxInputType(
address_n=parse_path("49'/1'/0'/0/0"),
# tb1qqzv60m9ajw8drqulta4ld4gfx0rdh82un5s65s
@ -222,8 +219,8 @@ class TestMsgSigntxSegwitNative(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures, serialized_tx) = btc.sign_tx(
self.client, "Testnet", [inp1], [out1, out2]
_, serialized_tx = btc.sign_tx(
self.client, "Testnet", [inp1], [out1, out2], prev_txes=TX_API
)
assert (
@ -233,7 +230,6 @@ class TestMsgSigntxSegwitNative(TrezorTest):
def test_send_native_change(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiTestnet)
inp1 = proto.TxInputType(
address_n=parse_path("49'/1'/0'/0/0"),
# tb1qqzv60m9ajw8drqulta4ld4gfx0rdh82un5s65s
@ -290,8 +286,8 @@ class TestMsgSigntxSegwitNative(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures, serialized_tx) = btc.sign_tx(
self.client, "Testnet", [inp1], [out1, out2]
_, serialized_tx = btc.sign_tx(
self.client, "Testnet", [inp1], [out1, out2], prev_txes=TX_API
)
assert (
@ -301,7 +297,6 @@ class TestMsgSigntxSegwitNative(TrezorTest):
def test_send_both(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiTestnet)
inp1 = proto.TxInputType(
address_n=parse_path("49'/1'/0'/1/0"),
# 2N1LGaGg836mqSQqiuUBLfcyGBhyZbremDX
@ -398,8 +393,12 @@ class TestMsgSigntxSegwitNative(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures, serialized_tx) = btc.sign_tx(
self.client, "Testnet", [inp1, inp2], [out1, out2, out3]
_, serialized_tx = btc.sign_tx(
self.client,
"Testnet",
[inp1, inp2],
[out1, out2, out3],
prev_txes=TX_API,
)
# 0e480a97c7a545c85e101a2f13c9af0e115d43734e1448f0cac3e55fe8e7399d
@ -410,7 +409,6 @@ class TestMsgSigntxSegwitNative(TrezorTest):
def test_send_multisig_1(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiTestnet)
nodes = [
btc.get_public_node(self.client, parse_path("999'/1'/%d'" % index))
for index in range(1, 4)
@ -473,9 +471,11 @@ class TestMsgSigntxSegwitNative(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures1, _) = btc.sign_tx(self.client, "Testnet", [inp1], [out1])
signatures, _ = btc.sign_tx(
self.client, "Testnet", [inp1], [out1], prev_txes=TX_API
)
# store signature
inp1.multisig.signatures[0] = signatures1[0]
inp1.multisig.signatures[0] = signatures[0]
# sign with third key
inp1.address_n[2] = H_(3)
self.client.set_expected_responses(
@ -505,8 +505,8 @@ class TestMsgSigntxSegwitNative(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures2, serialized_tx) = btc.sign_tx(
self.client, "Testnet", [inp1], [out1]
_, serialized_tx = btc.sign_tx(
self.client, "Testnet", [inp1], [out1], prev_txes=TX_API
)
# f41cbedd8becee05a830f418d13aa665125464547db5c7a6cd28f21639fe1228
@ -517,7 +517,6 @@ class TestMsgSigntxSegwitNative(TrezorTest):
def test_send_multisig_2(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiTestnet)
nodes = [
btc.get_public_node(self.client, parse_path("999'/1'/%d'" % index))
for index in range(1, 4)
@ -580,9 +579,11 @@ class TestMsgSigntxSegwitNative(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures1, _) = btc.sign_tx(self.client, "Testnet", [inp1], [out1])
signatures, _ = btc.sign_tx(
self.client, "Testnet", [inp1], [out1], prev_txes=TX_API
)
# store signature
inp1.multisig.signatures[1] = signatures1[0]
inp1.multisig.signatures[1] = signatures[0]
# sign with first key
inp1.address_n[2] = H_(1)
self.client.set_expected_responses(
@ -612,8 +613,8 @@ class TestMsgSigntxSegwitNative(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures2, serialized_tx) = btc.sign_tx(
self.client, "Testnet", [inp1], [out1]
_, serialized_tx = btc.sign_tx(
self.client, "Testnet", [inp1], [out1], prev_txes=TX_API
)
# c9348040bbc2024e12dcb4a0b4806b0398646b91acf314da028c3f03dd0179fc
@ -624,7 +625,6 @@ class TestMsgSigntxSegwitNative(TrezorTest):
def test_send_multisig_3_change(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiTestnet)
nodes = [
btc.get_public_node(self.client, parse_path("999'/1'/%d'" % index))
for index in range(1, 4)
@ -699,9 +699,11 @@ class TestMsgSigntxSegwitNative(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures1, _) = btc.sign_tx(self.client, "Testnet", [inp1], [out1])
signatures, _ = btc.sign_tx(
self.client, "Testnet", [inp1], [out1], prev_txes=TX_API
)
# store signature
inp1.multisig.signatures[0] = signatures1[0]
inp1.multisig.signatures[0] = signatures[0]
# sign with third key
inp1.address_n[2] = H_(3)
out1.address_n[2] = H_(3)
@ -731,8 +733,8 @@ class TestMsgSigntxSegwitNative(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures2, serialized_tx) = btc.sign_tx(
self.client, "Testnet", [inp1], [out1]
_, serialized_tx = btc.sign_tx(
self.client, "Testnet", [inp1], [out1], prev_txes=TX_API
)
# 31bc1c88ce6ae337a6b3057a16d5bad0b561ad1dfc047d0a7fbb8814668f91e5
@ -743,7 +745,6 @@ class TestMsgSigntxSegwitNative(TrezorTest):
def test_send_multisig_4_change(self):
self.setup_mnemonic_allallall()
self.client.set_tx_api(TxApiTestnet)
nodes = [
btc.get_public_node(self.client, parse_path("999'/1'/%d'" % index))
for index in range(1, 4)
@ -818,9 +819,11 @@ class TestMsgSigntxSegwitNative(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures1, _) = btc.sign_tx(self.client, "Testnet", [inp1], [out1])
signatures, _ = btc.sign_tx(
self.client, "Testnet", [inp1], [out1], prev_txes=TX_API
)
# store signature
inp1.multisig.signatures[0] = signatures1[0]
inp1.multisig.signatures[0] = signatures[0]
# sign with third key
inp1.address_n[2] = H_(3)
out1.address_n[2] = H_(3)
@ -850,8 +853,8 @@ class TestMsgSigntxSegwitNative(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures2, serialized_tx) = btc.sign_tx(
self.client, "Testnet", [inp1], [out1]
_, serialized_tx = btc.sign_tx(
self.client, "Testnet", [inp1], [out1], prev_txes=TX_API
)
# c0bf56060a109624b4635222696d94a7d533cacea1b3f8245417a4348c045829

25
trezorlib/tests/device_tests/test_msg_signtx_zcash.py
Unescape View File

@ -20,8 +20,9 @@ from trezorlib import btc, coins, messages as proto
from trezorlib.tools import parse_path
from .common import TrezorTest
from ..support.tx_cache import tx_cache
TxApiZcashTestnet = coins.tx_api["Zcash Testnet"]
TX_API = tx_cache("Zcash Testnet")
TXHASH_aaf51e = bytes.fromhex(
"aaf51e4606c264e47e5c42c958fe4cf1539c5172684721e38e69f4ef634d75dc"
@ -55,7 +56,6 @@ class TestMsgSigntxZcash(TrezorTest):
)
with self.client:
self.client.set_tx_api(TxApiZcashTestnet)
self.client.set_expected_responses(
[
proto.TxRequest(
@ -80,14 +80,16 @@ class TestMsgSigntxZcash(TrezorTest):
]
)
(signatures, serialized_tx) = btc.sign_tx(
details = proto.SignTx(
version=3, overwintered=True, version_group_id=0x3C48270
)
_, serialized_tx = btc.sign_tx(
self.client,
"Zcash Testnet",
[inp1],
[out1],
version=3,
overwintered=True,
version_group_id=0x3C48270,
details=details,
prev_txes=TX_API,
)
# Accepted by network: tx eda9b772c47f0c29310759960e0081c98707aa67a0a2738bcc71439fcf360675
@ -118,7 +120,6 @@ class TestMsgSigntxZcash(TrezorTest):
)
with self.client:
self.client.set_tx_api(TxApiZcashTestnet)
self.client.set_expected_responses(
[
proto.TxRequest(
@ -143,14 +144,16 @@ class TestMsgSigntxZcash(TrezorTest):
]
)
(signatures, serialized_tx) = btc.sign_tx(
details = proto.SignTx(
version=4, overwintered=True, version_group_id=0x892F2085
)
_, serialized_tx = btc.sign_tx(
self.client,
"Zcash Testnet",
[inp1],
[out1],
version=4,
overwintered=True,
version_group_id=0x892F2085,
details=details,
prev_txes=TX_API,
)
# Accepted by network: tx 0cef132c1d6d67f11cfa48f7fca3209da29cf872ac782354bedb686e61a17a78

17
trezorlib/tests/device_tests/test_multisig.py
Unescape View File

@ -20,8 +20,11 @@ from trezorlib import btc, messages as proto
from trezorlib.tools import CallException
from ..support import ckd_public as bip32
from ..support.tx_cache import tx_cache
from .common import TrezorTest
TX_API = tx_cache("Bitcoin")
TXHASH_c6091a = bytes.fromhex(
"c6091adf4c0c23982a35899a6e58ae11e703eacd7954f588ed4b9cdefc4dba52"
)
@ -139,7 +142,9 @@ class TestMultisig(TrezorTest):
)
# Now we have first signature
(signatures1, _) = btc.sign_tx(self.client, "Bitcoin", [inp1], [out1])
signatures1, _ = btc.sign_tx(
self.client, "Bitcoin", [inp1], [out1], prev_txes=TX_API
)
assert (
signatures1[0].hex()
@ -222,8 +227,8 @@ class TestMultisig(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures2, serialized_tx) = btc.sign_tx(
self.client, "Bitcoin", [inp3], [out1]
signatures2, serialized_tx = btc.sign_tx(
self.client, "Bitcoin", [inp3], [out1], prev_txes=TX_API
)
assert (
@ -287,8 +292,8 @@ class TestMultisig(TrezorTest):
)
with self.client:
(sig, serialized_tx) = btc.sign_tx(
self.client, "Bitcoin", [inp1], [out1]
sig, serialized_tx = btc.sign_tx(
self.client, "Bitcoin", [inp1], [out1], prev_txes=TX_API
)
signatures[x] = sig[0]
@ -345,7 +350,7 @@ class TestMultisig(TrezorTest):
)
with pytest.raises(CallException) as exc:
btc.sign_tx(self.client, "Bitcoin", [inp1], [out1])
btc.sign_tx(self.client, "Bitcoin", [inp1], [out1], prev_txes=TX_API)
assert exc.value.args[0] == proto.FailureType.DataError
assert exc.value.args[1].endswith("Pubkey not found in multisig script")

72
trezorlib/tests/device_tests/test_multisig_change.py
Unescape View File

@ -16,19 +16,15 @@
from trezorlib import btc, messages as proto
from trezorlib.tools import H_, parse_path
from trezorlib.tx_api import TxApiInsight
from ..support import ckd_public as bip32
from ..support.tx_cache import tx_cache
from .common import TrezorTest
TxApiTestnet = TxApiInsight("insight_testnet")
TX_API = tx_cache("Testnet")
class TestMultisigChange(TrezorTest):
def setup_method(self, method):
super(TestMultisigChange, self).setup_method(method)
self.client.set_tx_api(TxApiTestnet)
node_ext1 = bip32.deserialize(
"tpubDADHV9u9Y6gkggintTdMjJE3be58zKNLhpxBQyuEM6Pwx3sN9JVLmMCMN4DNVwL9AKec27z5TaWcWuHzMXiGAtcra5DjwWbvppGX4gaEGVN"
)
@ -267,8 +263,12 @@ class TestMultisigChange(TrezorTest):
with self.client:
self.client.set_expected_responses(self._responses(self.inp1, self.inp2))
(_, serialized_tx) = btc.sign_tx(
self.client, "Testnet", [self.inp1, self.inp2], [out1, out2]
_, serialized_tx = btc.sign_tx(
self.client,
"Testnet",
[self.inp1, self.inp2],
[out1, out2],
prev_txes=TX_API,
)
assert (
@ -296,8 +296,12 @@ class TestMultisigChange(TrezorTest):
self.client.set_expected_responses(
self._responses(self.inp1, self.inp2, change=2)
)
(_, serialized_tx) = btc.sign_tx(
self.client, "Testnet", [self.inp1, self.inp2], [out1, out2]
_, serialized_tx = btc.sign_tx(
self.client,
"Testnet",
[self.inp1, self.inp2],
[out1, out2],
prev_txes=TX_API,
)
assert (
@ -325,8 +329,12 @@ class TestMultisigChange(TrezorTest):
self.client.set_expected_responses(
self._responses(self.inp1, self.inp2, change=1)
)
(_, serialized_tx) = btc.sign_tx(
self.client, "Testnet", [self.inp1, self.inp2], [out1, out2]
_, serialized_tx = btc.sign_tx(
self.client,
"Testnet",
[self.inp1, self.inp2],
[out1, out2],
prev_txes=TX_API,
)
assert (
@ -352,8 +360,12 @@ class TestMultisigChange(TrezorTest):
with self.client:
self.client.set_expected_responses(self._responses(self.inp1, self.inp2))
(_, serialized_tx) = btc.sign_tx(
self.client, "Testnet", [self.inp1, self.inp2], [out1, out2]
_, serialized_tx = btc.sign_tx(
self.client,
"Testnet",
[self.inp1, self.inp2],
[out1, out2],
prev_txes=TX_API,
)
assert (
@ -392,8 +404,12 @@ class TestMultisigChange(TrezorTest):
self.client.set_expected_responses(
self._responses(self.inp1, self.inp2, change=1)
)
(_, serialized_tx) = btc.sign_tx(
self.client, "Testnet", [self.inp1, self.inp2], [out1, out2]
_, serialized_tx = btc.sign_tx(
self.client,
"Testnet",
[self.inp1, self.inp2],
[out1, out2],
prev_txes=TX_API,
)
assert (
@ -432,8 +448,12 @@ class TestMultisigChange(TrezorTest):
self.client.set_expected_responses(
self._responses(self.inp1, self.inp2, change=2)
)
(_, serialized_tx) = btc.sign_tx(
self.client, "Testnet", [self.inp1, self.inp2], [out1, out2]
_, serialized_tx = btc.sign_tx(
self.client,
"Testnet",
[self.inp1, self.inp2],
[out1, out2],
prev_txes=TX_API,
)
assert (
@ -470,8 +490,12 @@ class TestMultisigChange(TrezorTest):
with self.client:
self.client.set_expected_responses(self._responses(self.inp1, self.inp2))
(_, serialized_tx) = btc.sign_tx(
self.client, "Testnet", [self.inp1, self.inp2], [out1, out2]
_, serialized_tx = btc.sign_tx(
self.client,
"Testnet",
[self.inp1, self.inp2],
[out1, out2],
prev_txes=TX_API,
)
assert (
@ -508,8 +532,12 @@ class TestMultisigChange(TrezorTest):
with self.client:
self.client.set_expected_responses(self._responses(self.inp1, self.inp3))
(_, serialized_tx) = btc.sign_tx(
self.client, "Testnet", [self.inp1, self.inp3], [out1, out2]
_, serialized_tx = btc.sign_tx(
self.client,
"Testnet",
[self.inp1, self.inp3],
[out1, out2],
prev_txes=TX_API,
)
assert (

10
trezorlib/tests/device_tests/test_op_return.py
Unescape View File

@ -22,6 +22,10 @@ from trezorlib.tools import CallException
from .common import TrezorTest
from .conftest import TREZOR_VERSION
from ..support.tx_cache import tx_cache
TX_API = tx_cache("Bitcoin")
TXHASH_d5f65e = bytes.fromhex(
"d5f65ee80147b4bcc70b75e4bbf2d7382021b871bd8867ef8fa525ef50864882"
)
@ -116,8 +120,8 @@ class TestOpReturn(TrezorTest):
proto.TxRequest(request_type=proto.RequestType.TXFINISHED),
]
)
(signatures, serialized_tx) = btc.sign_tx(
self.client, "Bitcoin", [inp1], [out1, out2]
_, serialized_tx = btc.sign_tx(
self.client, "Bitcoin", [inp1], [out1, out2], prev_txes=TX_API
)
assert (
@ -182,7 +186,7 @@ class TestOpReturn(TrezorTest):
)
with pytest.raises(CallException) as exc:
btc.sign_tx(self.client, "Bitcoin", [inp1], [out1])
btc.sign_tx(self.client, "Bitcoin", [inp1], [out1], prev_txes=TX_API)
if TREZOR_VERSION == 1:
assert exc.value.args[0] == proto.FailureType.ProcessError

10
trezorlib/tests/device_tests/test_zerosig.py
Unescape View File

@ -18,6 +18,8 @@ from trezorlib import btc, messages as proto
from .common import TrezorTest
from ..support.tx_cache import tx_cache
TXHASH_d5f65e = bytes.fromhex(
"d5f65ee80147b4bcc70b75e4bbf2d7382021b871bd8867ef8fa525ef50864882"
)
@ -75,8 +77,8 @@ class TestZerosig(TrezorTest):
script_type=proto.OutputScriptType.PAYTOADDRESS,
)
(signatures, serialized_tx) = btc.sign_tx(
self.client, "Bitcoin", [inp1], [out1]
_, serialized_tx = btc.sign_tx(
self.client, "Bitcoin", [inp1], [out1], prev_txes=tx_cache("Bitcoin")
)
siglen = serialized_tx[44]
@ -100,8 +102,8 @@ class TestZerosig(TrezorTest):
script_type=proto.OutputScriptType.PAYTOADDRESS,
)
(signatures, serialized_tx) = btc.sign_tx(
self.client, "Bitcoin", [inp1], [out1]
_, serialized_tx = btc.sign_tx(
self.client, "Bitcoin", [inp1], [out1], prev_txes=tx_cache("Bitcoin")
)
siglen = serialized_tx[44]

4
trezorlib/tests/unit_tests/test_tx_api.py
Unescape View File

@ -18,8 +18,10 @@ import os
from trezorlib import coins, tx_api
from ..support.tx_cache import tx_cache
TxApiBitcoin = coins.tx_api["Bitcoin"]
TxApiTestnet = tx_api.TxApiInsight("insight_testnet")
TxApiTestnet = tx_cache("Testnet", allow_fetch=False)
TxApiZencash = coins.tx_api["Zencash"]
tests_dir = os.path.dirname(os.path.abspath(__file__))

Write Preview
Loading…
Cancel
Save