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

nem: refactored to have a common message as an argument

Browse Source
pull/25/head
Tomas Susanka 6 years ago committed by Jan Pochyla
parent 1355b19c77
commit a45ac4ad4b
20 changed files with 168 additions and 161 deletions
Show Stats Download Patch File Download Diff File

2
src/apps/nem/layout.py
Unescape View File

@ -27,7 +27,7 @@ async def require_confirm_final(ctx, fee: int):
content = Text('Final confirm', ui.ICON_SEND,
ui.NORMAL, 'Sign this transaction',
ui.BOLD, 'and pay ' + format_amount(fee, NEM_MAX_DIVISIBILITY) + ' XEM',
ui.NORMAL, 'for transaction fee?',
ui.NORMAL, 'for network fee?',
icon_color=ui.GREEN)
await require_hold_to_confirm(ctx, content, ButtonRequestType.SignTx) # we use SignTx, not ConfirmOutput, for compatibility with T1

12
src/apps/nem/mosaic/__init__.py
Unescape View File

@ -2,11 +2,11 @@ from .layout import *
from .serialize import *
async def mosaic_creation(ctx, public_key: bytes, msg: NEMSignTx) -> bytearray:
await ask_mosaic_creation(ctx, msg)
return serialize_mosaic_creation(msg, public_key)
async def mosaic_creation(ctx, public_key: bytes, common: NEMTransactionCommon, creation: NEMMosaicCreation) -> bytearray:
await ask_mosaic_creation(ctx, common, creation)
return serialize_mosaic_creation(common, creation, public_key)
async def supply_change(ctx, public_key: bytes, msg: NEMSignTx):
await ask_supply_change(ctx, msg)
return serialize_mosaic_supply_change(msg, public_key)
async def supply_change(ctx, public_key: bytes, common: NEMTransactionCommon, change: NEMMosaicSupplyChange):
await ask_supply_change(ctx, common, change)
return serialize_mosaic_supply_change(common, change, public_key)

30
src/apps/nem/mosaic/layout.py
Unescape View File

@ -1,30 +1,32 @@
from apps.nem.layout import *
from trezor.messages import NEMSignTx
from trezor.messages import NEMTransactionCommon
from trezor.messages import NEMSupplyChangeType
from trezor.messages import NEMMosaicDefinition
from trezor.messages import NEMMosaicCreation
from trezor.messages import NEMMosaicSupplyChange
from trezor.messages import NEMMosaicLevy
from trezor.ui.scroll import Scrollpage, animate_swipe, paginate
async def ask_mosaic_creation(ctx, msg: NEMSignTx):
await require_confirm_content(ctx, 'Create mosaic', _creation_message(msg.mosaic_creation))
await _require_confirm_properties(ctx, msg.mosaic_creation.definition)
await require_confirm_fee(ctx, 'Confirm creation fee', msg.mosaic_creation.fee)
async def ask_mosaic_creation(ctx, common: NEMTransactionCommon, creation: NEMMosaicCreation):
await require_confirm_content(ctx, 'Create mosaic', _creation_message(creation))
await _require_confirm_properties(ctx, creation.definition)
await require_confirm_fee(ctx, 'Confirm creation fee', creation.fee)
await require_confirm_final(ctx, msg.transaction.fee)
await require_confirm_final(ctx, common.fee)
async def ask_supply_change(ctx, msg: NEMSignTx):
await require_confirm_content(ctx, 'Supply change', _supply_message(msg.supply_change))
if msg.supply_change.type == NEMSupplyChangeType.SupplyChange_Decrease:
ask_msg = 'Decrease supply by ' + str(msg.supply_change.delta) + ' whole units?'
elif msg.supply_change.type == NEMSupplyChangeType.SupplyChange_Increase:
ask_msg = 'Increase supply by ' + str(msg.supply_change.delta) + ' whole units?'
async def ask_supply_change(ctx, common: NEMTransactionCommon, change: NEMMosaicSupplyChange):
await require_confirm_content(ctx, 'Supply change', _supply_message(change))
if change.type == NEMSupplyChangeType.SupplyChange_Decrease:
msg = 'Decrease supply by ' + str(change.delta) + ' whole units?'
elif change.type == NEMSupplyChangeType.SupplyChange_Increase:
msg = 'Increase supply by ' + str(change.delta) + ' whole units?'
else:
raise ValueError('Invalid supply change type')
await require_confirm_text(ctx, ask_msg)
await require_confirm_text(ctx, msg)
await require_confirm_final(ctx, msg.transaction.fee)
await require_confirm_final(ctx, common.fee)
def _creation_message(mosaic_creation):

60
src/apps/nem/mosaic/serialize.py
Unescape View File

@ -1,62 +1,58 @@
from apps.nem.writers import *
from apps.nem.helpers import *
from trezor.messages.NEMSignTx import NEMSignTx
from trezor.messages.NEMTransactionCommon import NEMTransactionCommon
from trezor.messages.NEMMosaicSupplyChange import NEMMosaicSupplyChange
from trezor.messages.NEMMosaicCreation import NEMMosaicCreation
def serialize_mosaic_creation(msg: NEMSignTx, public_key: bytes):
common = msg.transaction
if msg.multisig:
common = msg.multisig
def serialize_mosaic_creation(common: NEMTransactionCommon, creation: NEMMosaicCreation, public_key: bytes):
w = write_common(common, bytearray(public_key), NEM_TRANSACTION_TYPE_MOSAIC_CREATION)
mosaics_w = bytearray()
write_bytes_with_length(mosaics_w, bytearray(public_key))
identifier_length = 4 + len(msg.mosaic_creation.definition.namespace) + 4 + len(msg.mosaic_creation.definition.mosaic)
identifier_length = 4 + len(creation.definition.namespace) + 4 + len(creation.definition.mosaic)
write_uint32(mosaics_w, identifier_length)
write_bytes_with_length(mosaics_w, bytearray(msg.mosaic_creation.definition.namespace))
write_bytes_with_length(mosaics_w, bytearray(msg.mosaic_creation.definition.mosaic))
write_bytes_with_length(mosaics_w, bytearray(msg.mosaic_creation.definition.description))
write_bytes_with_length(mosaics_w, bytearray(creation.definition.namespace))
write_bytes_with_length(mosaics_w, bytearray(creation.definition.mosaic))
write_bytes_with_length(mosaics_w, bytearray(creation.definition.description))
write_uint32(mosaics_w, 4) # number of properties
_write_property(mosaics_w, "divisibility", msg.mosaic_creation.definition.divisibility)
_write_property(mosaics_w, "initialSupply", msg.mosaic_creation.definition.supply)
_write_property(mosaics_w, "supplyMutable", msg.mosaic_creation.definition.mutable_supply)
_write_property(mosaics_w, "transferable", msg.mosaic_creation.definition.transferable)
_write_property(mosaics_w, "divisibility", creation.definition.divisibility)
_write_property(mosaics_w, "initialSupply", creation.definition.supply)
_write_property(mosaics_w, "supplyMutable", creation.definition.mutable_supply)
_write_property(mosaics_w, "transferable", creation.definition.transferable)
if msg.mosaic_creation.definition.levy:
levy_identifier_length = 4 + len(msg.mosaic_creation.definition.levy_namespace) + 4 + len(msg.mosaic_creation.definition.levy_mosaic)
write_uint32(mosaics_w, 4 + 4 + len(msg.mosaic_creation.definition.levy_address) + 4 + levy_identifier_length + 8)
write_uint32(mosaics_w, msg.mosaic_creation.definition.levy)
write_bytes_with_length(mosaics_w, bytearray(msg.mosaic_creation.definition.levy_address))
if creation.definition.levy:
levy_identifier_length = 4 + len(creation.definition.levy_namespace) + 4 + len(creation.definition.levy_mosaic)
write_uint32(mosaics_w, 4 + 4 + len(creation.definition.levy_address) + 4 + levy_identifier_length + 8)
write_uint32(mosaics_w, creation.definition.levy)
write_bytes_with_length(mosaics_w, bytearray(creation.definition.levy_address))
write_uint32(mosaics_w, levy_identifier_length)
write_bytes_with_length(mosaics_w, bytearray(msg.mosaic_creation.definition.levy_namespace))
write_bytes_with_length(mosaics_w, bytearray(msg.mosaic_creation.definition.levy_mosaic))
write_uint64(mosaics_w, msg.mosaic_creation.definition.fee)
write_bytes_with_length(mosaics_w, bytearray(creation.definition.levy_namespace))
write_bytes_with_length(mosaics_w, bytearray(creation.definition.levy_mosaic))
write_uint64(mosaics_w, creation.definition.fee)
else:
write_uint32(mosaics_w, 0)
# write mosaic bytes with length
write_bytes_with_length(w, mosaics_w)
write_bytes_with_length(w, bytearray(msg.mosaic_creation.sink))
write_uint64(w, msg.mosaic_creation.fee)
write_bytes_with_length(w, bytearray(creation.sink))
write_uint64(w, creation.fee)
return w
def serialize_mosaic_supply_change(msg: NEMSignTx, public_key: bytes):
common = msg.transaction
if msg.multisig:
common = msg.multisig
def serialize_mosaic_supply_change(common: NEMTransactionCommon, change: NEMMosaicSupplyChange, public_key: bytes):
w = write_common(common, bytearray(public_key), NEM_TRANSACTION_TYPE_MOSAIC_SUPPLY_CHANGE)
identifier_length = 4 + len(msg.supply_change.namespace) + 4 + len(msg.supply_change.mosaic)
identifier_length = 4 + len(change.namespace) + 4 + len(change.mosaic)
write_uint32(w, identifier_length)
write_bytes_with_length(w, bytearray(msg.supply_change.namespace))
write_bytes_with_length(w, bytearray(msg.supply_change.mosaic))
write_bytes_with_length(w, bytearray(change.namespace))
write_bytes_with_length(w, bytearray(change.mosaic))
write_uint32(w, msg.supply_change.type)
write_uint64(w, msg.supply_change.delta)
write_uint32(w, change.type)
write_uint64(w, change.delta)
return w

17
src/apps/nem/multisig/__init__.py
Unescape View File

@ -1,5 +1,6 @@
from .serialize import *
from .layout import *
from trezor.messages.NEMAggregateModification import NEMAggregateModification
async def ask(ctx, msg: NEMSignTx):
@ -17,13 +18,17 @@ def cosign(public_key, common: NEMTransactionCommon, inner_tx: bytes, signer: by
signer)
async def aggregate_modification(ctx, public_key: bytes, msg: NEMSignTx):
await ask_aggregate_modification(ctx, msg)
w = serialize_aggregate_modification(msg, public_key)
async def aggregate_modification(ctx,
public_key: bytes,
common: NEMTransactionCommon,
aggr: NEMAggregateModification,
multisig: bool):
await ask_aggregate_modification(ctx, common, aggr, multisig)
w = serialize_aggregate_modification(common, aggr, public_key)
for m in msg.aggregate_modification.modifications:
for m in aggr.modifications:
serialize_cosignatory_modification(w, m.type, m.public_key)
if msg.aggregate_modification.relative_change:
serialize_minimum_cosignatories(w, msg.aggregate_modification.relative_change)
if aggr.relative_change:
serialize_minimum_cosignatories(w, aggr.relative_change)
return w

22
src/apps/nem/multisig/layout.py
Unescape View File

@ -1,6 +1,8 @@
from apps.nem.layout import *
from trezor.messages import NEMAggregateModification
from trezor.messages import NEMModificationType
from trezor.messages import NEMSignTx
from trezor.messages import NEMTransactionCommon
from trezor.crypto import nem
@ -13,26 +15,26 @@ async def ask_multisig(ctx, msg: NEMSignTx):
await require_confirm_fee(ctx, 'Confirm multisig fee', msg.transaction.fee)
async def ask_aggregate_modification(ctx, msg: NEMSignTx):
if not msg.multisig:
async def ask_aggregate_modification(ctx, common: NEMTransactionCommon, mod: NEMAggregateModification, multisig: bool):
if not multisig:
await require_confirm_text(ctx, 'Convert account to multisig account?')
for m in msg.aggregate_modification.modifications:
for m in mod.modifications:
if m.type == NEMModificationType.CosignatoryModification_Add:
action = 'Add'
else:
action = 'Remove'
address = nem.compute_address(m.public_key, msg.transaction.network)
address = nem.compute_address(m.public_key, common.network)
await _require_confirm_address(ctx, action + ' cosignatory', address)
if msg.aggregate_modification.relative_change:
if not msg.multisig:
action = 'Set minimum cosignatories to '
else:
if mod.relative_change:
if multisig:
action = 'Modify the number of cosignatories by '
await require_confirm_text(ctx, action + str(msg.aggregate_modification.relative_change) + '?')
else:
action = 'Set minimum cosignatories to '
await require_confirm_text(ctx, action + str(mod.relative_change) + '?')
await require_confirm_final(ctx, msg.transaction.fee)
await require_confirm_final(ctx, common.fee)
async def _require_confirm_address(ctx, action: str, address: str):

11
src/apps/nem/multisig/serialize.py
Unescape View File

@ -3,6 +3,8 @@ from apps.nem.helpers import *
from trezor.messages.NEMSignTx import NEMSignTx
from trezor.crypto import hashlib
from trezor.crypto import nem
from trezor.messages.NEMTransactionCommon import NEMTransactionCommon
from trezor.messages.NEMAggregateModification import NEMAggregateModification
def serialize_multisig(common: NEMTransactionCommon, public_key: bytes, inner: bytes):
@ -23,19 +25,16 @@ def serialize_multisig_signature(common: NEMTransactionCommon, public_key: bytes
return w
def serialize_aggregate_modification(msg: NEMSignTx, public_key: bytes):
common = msg.transaction
if msg.multisig:
common = msg.multisig
def serialize_aggregate_modification(common: NEMTransactionCommon, mod: NEMAggregateModification, public_key: bytes):
version = common.network << 24 | 1
if msg.aggregate_modification.relative_change:
if mod.relative_change:
version = common.network << 24 | 2
w = write_common(common,
bytearray(public_key),
NEM_TRANSACTION_TYPE_AGGREGATE_MODIFICATION,
version)
write_uint32(w, len(msg.aggregate_modification.modifications))
write_uint32(w, len(mod.modifications))
return w

6
src/apps/nem/namespace/__init__.py
Unescape View File

@ -2,6 +2,6 @@ from .layout import *
from .serialize import *
async def namespace(ctx, public_key: bytes, msg: NEMSignTx) -> bytearray:
await ask_provision_namespace(ctx, msg)
return serialize_provision_namespace(msg, public_key)
async def namespace(ctx, public_key: bytes, common: NEMTransactionCommon, namespace: NEMProvisionNamespace) -> bytearray:
await ask_provision_namespace(ctx, common, namespace)
return serialize_provision_namespace(common, namespace, public_key)

17
src/apps/nem/namespace/layout.py
Unescape View File

@ -1,19 +1,20 @@
from apps.nem.layout import *
from trezor.messages import NEMSignTx
from trezor.messages import NEMTransactionCommon
from trezor.messages import NEMProvisionNamespace
async def ask_provision_namespace(ctx, msg: NEMSignTx):
if msg.provision_namespace.parent:
async def ask_provision_namespace(ctx, common: NEMTransactionCommon, namespace: NEMProvisionNamespace):
if namespace.parent:
content = [ui.NORMAL, 'Create namespace',
ui.BOLD, msg.provision_namespace.namespace,
ui.BOLD, namespace.namespace,
ui.NORMAL, 'under namespace',
ui.BOLD, msg.provision_namespace.parent]
ui.BOLD, namespace.parent]
await require_confirm_content(ctx, 'Confirm namespace', content)
else:
content = [ui.NORMAL, 'Create namespace',
ui.BOLD, msg.provision_namespace.namespace]
ui.BOLD, namespace.namespace]
await require_confirm_content(ctx, 'Confirm namespace', content)
await require_confirm_fee(ctx, 'Confirm rental fee', msg.provision_namespace.fee)
await require_confirm_fee(ctx, 'Confirm rental fee', namespace.fee)
await require_confirm_final(ctx, msg.transaction.fee)
await require_confirm_final(ctx, common.fee)

18
src/apps/nem/namespace/serialize.py
Unescape View File

@ -1,21 +1,19 @@
from apps.nem.helpers import *
from apps.nem.writers import *
from trezor.messages.NEMSignTx import NEMSignTx
from trezor.messages.NEMTransactionCommon import NEMTransactionCommon
from trezor.messages.NEMProvisionNamespace import NEMProvisionNamespace
def serialize_provision_namespace(msg: NEMSignTx, public_key: bytes) -> bytearray:
common = msg.transaction
if msg.multisig:
common = msg.multisig
def serialize_provision_namespace(common: NEMTransactionCommon, namespace: NEMProvisionNamespace, public_key: bytes) -> bytearray:
tx = write_common(common,
bytearray(public_key),
NEM_TRANSACTION_TYPE_PROVISION_NAMESPACE)
write_bytes_with_length(tx, bytearray(msg.provision_namespace.sink))
write_uint64(tx, msg.provision_namespace.fee)
write_bytes_with_length(tx, bytearray(msg.provision_namespace.namespace))
if msg.provision_namespace.parent:
write_bytes_with_length(tx, bytearray(msg.provision_namespace.parent))
write_bytes_with_length(tx, bytearray(namespace.sink))
write_uint64(tx, namespace.fee)
write_bytes_with_length(tx, bytearray(namespace.namespace))
if namespace.parent:
write_bytes_with_length(tx, bytearray(namespace.parent))
else:
write_uint32(tx, 0xffffffff)

14
src/apps/nem/signing.py
Unescape View File

@ -17,21 +17,23 @@ async def sign_tx(ctx, msg: NEMSignTx):
if msg.multisig:
public_key = msg.multisig.signer
await multisig.ask(ctx, msg)
common = msg.multisig
else:
public_key = _get_public_key(node)
common = msg.transaction
if msg.transfer:
tx = await transfer.transfer(ctx, public_key, msg, node)
tx = await transfer.transfer(ctx, public_key, common, msg.transfer, node)
elif msg.provision_namespace:
tx = await namespace.namespace(ctx, public_key, msg)
tx = await namespace.namespace(ctx, public_key, common, msg.provision_namespace)
elif msg.mosaic_creation:
tx = await mosaic.mosaic_creation(ctx, public_key, msg)
tx = await mosaic.mosaic_creation(ctx, public_key, common, msg.mosaic_creation)
elif msg.supply_change:
tx = await mosaic.supply_change(ctx, public_key, msg)
tx = await mosaic.supply_change(ctx, public_key, common, msg.supply_change)
elif msg.aggregate_modification:
tx = await multisig.aggregate_modification(ctx, public_key, msg)
tx = await multisig.aggregate_modification(ctx, public_key, common, msg.aggregate_modification, msg.multisig is not None)
elif msg.importance_transfer:
tx = await transfer.importance_transfer(ctx, public_key, msg)
tx = await transfer.importance_transfer(ctx, public_key, common, msg.importance_transfer)
else:
raise ValueError('No transaction provided')

19
src/apps/nem/transfer/__init__.py
Unescape View File

@ -1,19 +1,20 @@
from .layout import *
from .serialize import *
from trezor.messages.NEMSignTx import NEMTransfer
async def transfer(ctx, public_key: bytes, msg: NEMSignTx, node):
msg.transfer.mosaics = canonicalize_mosaics(msg.transfer.mosaics)
async def transfer(ctx, public_key: bytes, common: NEMTransactionCommon, transfer: NEMTransfer, node):
transfer.mosaics = canonicalize_mosaics(transfer.mosaics)
payload, encrypted = get_transfer_payload(msg, node)
await ask_transfer(ctx, msg, payload, encrypted)
payload, encrypted = get_transfer_payload(transfer, node)
await ask_transfer(ctx, common, transfer, payload, encrypted)
w = serialize_transfer(msg, public_key, payload, encrypted)
for mosaic in msg.transfer.mosaics:
w = serialize_transfer(common, transfer, public_key, payload, encrypted)
for mosaic in transfer.mosaics:
serialize_mosaic(w, mosaic.namespace, mosaic.mosaic, mosaic.quantity)
return w
async def importance_transfer(ctx, public_key: bytes, msg: NEMSignTx):
await ask_importance_transfer(ctx, msg)
return serialize_importance_transfer(msg, public_key)
async def importance_transfer(ctx, public_key: bytes, common: NEMTransactionCommon, imp: NEMImportanceTransfer):
await ask_importance_transfer(ctx, common, imp)
return serialize_importance_transfer(common, imp, public_key)

20
src/apps/nem/transfer/layout.py
Unescape View File

@ -1,27 +1,29 @@
from apps.nem.layout import *
from trezor.messages import NEMImportanceTransferMode
from trezor.messages import NEMSignTx
from trezor.messages import NEMTransfer
from trezor.messages import NEMImportanceTransfer
from trezor.messages import NEMTransactionCommon
async def ask_transfer(ctx, msg: NEMSignTx, payload, encrypted):
async def ask_transfer(ctx, common: NEMTransactionCommon, transfer: NEMTransfer, payload, encrypted):
if payload:
await _require_confirm_payload(ctx, msg.transfer.payload, encrypted)
await _require_confirm_payload(ctx, transfer.payload, encrypted)
for mosaic in msg.transfer.mosaics:
for mosaic in transfer.mosaics:
await require_confirm_content(ctx, 'Confirm mosaic', _mosaics_message(mosaic))
await _require_confirm_transfer(ctx, msg.transfer.recipient, msg.transfer.amount)
await _require_confirm_transfer(ctx, transfer.recipient, transfer.amount)
await require_confirm_final(ctx, msg.transaction.fee)
await require_confirm_final(ctx, common.fee)
async def ask_importance_transfer(ctx, msg: NEMSignTx):
if msg.importance_transfer.mode == NEMImportanceTransferMode.ImportanceTransfer_Activate:
async def ask_importance_transfer(ctx, common: NEMTransactionCommon, imp: NEMImportanceTransfer):
if imp.mode == NEMImportanceTransferMode.ImportanceTransfer_Activate:
m = 'Activate'
else:
m = 'Deactivate'
await require_confirm_text(ctx, m + ' remote harvesting?')
await require_confirm_final(ctx, msg.transaction.fee)
await require_confirm_final(ctx, common.fee)
async def _require_confirm_transfer(ctx, recipient, value):

36
src/apps/nem/transfer/serialize.py
Unescape View File

@ -1,21 +1,20 @@
from apps.nem.writers import *
from apps.nem.helpers import *
from trezor.messages.NEMMosaic import NEMMosaic
from trezor.messages.NEMSignTx import NEMSignTx
from trezor.messages.NEMImportanceTransfer import NEMImportanceTransfer
from trezor.messages.NEMTransfer import NEMTransfer
from trezor.crypto import random
def serialize_transfer(msg: NEMSignTx, public_key: bytes, payload: bytes=None, encrypted: bool=False) -> bytearray:
common = msg.transaction
if msg.multisig:
common = msg.multisig
def serialize_transfer(common: NEMTransactionCommon, transfer: NEMTransfer,
public_key: bytes, payload: bytes=None, encrypted: bool=False) -> bytearray:
tx = write_common(common,
bytearray(public_key),
NEM_TRANSACTION_TYPE_TRANSFER,
_get_version(common.network, msg.transfer.mosaics))
_get_version(common.network, transfer.mosaics))
write_bytes_with_length(tx, bytearray(msg.transfer.recipient))
write_uint64(tx, msg.transfer.amount)
write_bytes_with_length(tx, bytearray(transfer.recipient))
write_uint64(tx, transfer.amount)
if payload:
# payload + payload size (u32) + encryption flag (u32)
@ -28,8 +27,8 @@ def serialize_transfer(msg: NEMSignTx, public_key: bytes, payload: bytes=None, e
else:
write_uint32(tx, 0)
if msg.transfer.mosaics:
write_uint32(tx, len(msg.transfer.mosaics))
if transfer.mosaics:
write_uint32(tx, len(transfer.mosaics))
return tx
@ -44,24 +43,21 @@ def serialize_mosaic(w: bytearray, namespace: str, mosaic: str, quantity: int):
write_uint64(w, quantity)
def serialize_importance_transfer(msg: NEMSignTx, public_key: bytes) -> bytearray:
common = msg.transaction
if msg.multisig:
common = msg.multisig
def serialize_importance_transfer(common: NEMTransactionCommon, imp: NEMImportanceTransfer, public_key: bytes)-> bytearray:
w = write_common(common, bytearray(public_key), NEM_TRANSACTION_TYPE_IMPORTANCE_TRANSFER)
write_uint32(w, msg.importance_transfer.mode)
write_bytes_with_length(w, bytearray(msg.importance_transfer.public_key))
write_uint32(w, imp.mode)
write_bytes_with_length(w, bytearray(imp.public_key))
return w
def get_transfer_payload(msg: NEMSignTx, node) -> [bytes, bool]:
payload = msg.transfer.payload
def get_transfer_payload(transfer: NEMTransfer, node) -> [bytes, bool]:
payload = transfer.payload
encrypted = False
if msg.transfer.public_key is not None:
if transfer.public_key is not None:
if payload is None:
raise ValueError("Public key provided but no payload to encrypt")
payload = _encrypt(node, msg.transfer.public_key, msg.transfer.payload)
payload = _encrypt(node, transfer.public_key, transfer.payload)
encrypted = True
return payload, encrypted

9
tests/test_apps.nem.mosaic_creation.py
Unescape View File

@ -2,6 +2,7 @@ from common import *
from apps.nem.mosaic import *
from trezor.crypto import hashlib
from trezor.messages.NEMSignTx import NEMSignTx
from trezor.messages.NEMMosaicCreation import NEMMosaicCreation
from trezor.messages.NEMMosaicDefinition import NEMMosaicDefinition
@ -30,7 +31,7 @@ class TestNemMosaicCreation(unittest.TestCase):
'TBMOSAICOD4F54EE5CDMR23CCBGOAM2XSJBR5OLC',
50000000000)
t = serialize_mosaic_creation(m, unhexlify('994793ba1c789fa9bdea918afc9b06e2d0309beb1081ac5b6952991e4defd324'))
t = serialize_mosaic_creation(m.transaction, m.mosaic_creation, unhexlify('994793ba1c789fa9bdea918afc9b06e2d0309beb1081ac5b6952991e4defd324'))
self.assertEqual(t, unhexlify('014000000100009870b4d60020000000994793ba1c789fa9bdea918afc9b06e2d0309beb1081ac5b6952991e4defd32400f36f060000000080c2d600de00000020000000994793ba1c789fa9bdea918afc9b06e2d0309beb1081ac5b6952991e4defd3241f0000001000000067696d72652e67616d65732e706f6e6707000000706164646c65731b000000506164646c657320666f722074686520626f6e672067616d652e0a04000000150000000c00000064697669736962696c69747901000000301a0000000d000000696e697469616c537570706c79050000003130303030190000000d000000737570706c794d757461626c650400000074727565180000000c0000007472616e7366657261626c650400000074727565000000002800000054424d4f534149434f443446353445453543444d523233434342474f414d3258534a4252354f4c4300743ba40b000000'))
self.assertEqual(hashlib.sha3_256(t).digest(True), unhexlify('68364353c29105e6d361ad1a42abbccbf419cfc7adb8b74c8f35d8f8bdaca3fa'))
@ -56,7 +57,7 @@ class TestNemMosaicCreation(unittest.TestCase):
"TBMOSAICOD4F54EE5CDMR23CCBGOAM2XSJBR5OLC",
50000000000)
t = serialize_mosaic_creation(m, unhexlify("244fa194e2509ac0d2fbc18779c2618d8c2ebb61c16a3bcbebcf448c661ba8dc"),)
t = serialize_mosaic_creation(m.transaction, m.mosaic_creation, unhexlify("244fa194e2509ac0d2fbc18779c2618d8c2ebb61c16a3bcbebcf448c661ba8dc"),)
self.assertEqual(hashlib.sha3_256(t).digest(True), unhexlify('b2f4a98113ff1f3a8f1e9d7197aa982545297fe0aa3fa6094af8031569953a55'))
@ -80,7 +81,7 @@ class TestNemMosaicCreation(unittest.TestCase):
"NBMOSAICOD4F54EE5CDMR23CCBGOAM2XSIUX6TRS",
500000000)
t = serialize_mosaic_creation(m, unhexlify("a1df5306355766bd2f9a64efdc089eb294be265987b3359093ae474c051d7d5a"))
t = serialize_mosaic_creation(m.transaction, m.mosaic_creation, unhexlify("a1df5306355766bd2f9a64efdc089eb294be265987b3359093ae474c051d7d5a"))
self.assertEqual(t, unhexlify('0140000001000068ccaf200420000000a1df5306355766bd2f9a64efdc089eb294be265987b3359093ae474c051d7d5a002d3101000000004c0122040c01000020000000a1df5306355766bd2f9a64efdc089eb294be265987b3359093ae474c051d7d5a0f0000000300000064696d04000000636f696e0800000044494d20434f494e04000000150000000c00000064697669736962696c69747901000000361f0000000d000000696e697469616c537570706c790a000000393030303030303030301a0000000d000000737570706c794d757461626c650500000066616c7365180000000c0000007472616e7366657261626c6504000000747275654b00000002000000280000004e4347474c564f32473343554143564935474e58324b52424a5351434e3452444c325a574a3444500f0000000300000064696d04000000636f696e0a00000000000000280000004e424d4f534149434f443446353445453543444d523233434342474f414d325853495558365452530065cd1d00000000'))
self.assertEqual(hashlib.sha3_256(t).digest(True), unhexlify('e8dc14821dbea4831d9051f86158ef348001447968fc22c01644fdaf2bda75c6'))
@ -108,7 +109,7 @@ class TestNemMosaicCreation(unittest.TestCase):
"",
"NBMOSAICOD4F54EE5CDMR23CCBGOAM2XSIUX6TRS",
50000000000)
t = serialize_mosaic_creation(m, unhexlify("58956ac77951622dc5f1c938affbf017c458e30e6b21ddb5783d38b302531f23"))
t = serialize_mosaic_creation(m.transaction, m.mosaic_creation, unhexlify("58956ac77951622dc5f1c938affbf017c458e30e6b21ddb5783d38b302531f23"))
self.assertEqual(t, unhexlify('0140000001000068d2dd97012000000058956ac77951622dc5f1c938affbf017c458e30e6b21ddb5783d38b302531f2300f36f0600000000e2eb9701c80100002000000058956ac77951622dc5f1c938affbf017c458e30e6b21ddb5783d38b302531f2317000000060000006a61626f3338090000007265645f746f6b656e0c0100005468697320746f6b656e20697320746f2063656c656272617465207468652072656c65617365206f66204e616d6573706163657320616e64204d6f7361696373206f6e20746865204e454d2073797374656d2e205468697320746f6b656e207761732074686520666973742065766572206d6f736169632063726561746564206f74686572207468616e206e656d2e78656d2e20546865726520617265206f6e6c792031302c3030302052656420546f6b656e7320746861742077696c6c206576657220626520637265617465642e20497420686173206e6f206c65767920616e642063616e2062652074726164656420667265656c7920616d6f6e6720746869726420706172746965732e04000000150000000c00000064697669736962696c69747901000000321a0000000d000000696e697469616c537570706c790500000031303030301a0000000d000000737570706c794d757461626c650500000066616c7365180000000c0000007472616e7366657261626c65040000007472756500000000280000004e424d4f534149434f443446353445453543444d523233434342474f414d3258534955583654525300743ba40b000000'))
self.assertEqual(hashlib.sha3_256(t).digest(True), unhexlify('269c6fda657aba3053a0e5b138c075808cc20e244e1182d9b730798b60a1f77b'))

9
tests/test_apps.nem.mosaic_supply_change.py
Unescape View File

@ -2,6 +2,7 @@ from common import *
from apps.nem.mosaic import *
from trezor.crypto import hashlib
from trezor.messages.NEMSignTx import NEMSignTx
from trezor.messages.NEMMosaicSupplyChange import NEMMosaicSupplyChange
@ -18,7 +19,7 @@ class TestNemMosaicSupplyChange(unittest.TestCase):
"paddles",
1,
1234)
t = serialize_mosaic_supply_change(m, unhexlify("994793ba1c789fa9bdea918afc9b06e2d0309beb1081ac5b6952991e4defd324"))
t = serialize_mosaic_supply_change(m.transaction, m.supply_change, unhexlify("994793ba1c789fa9bdea918afc9b06e2d0309beb1081ac5b6952991e4defd324"))
self.assertEqual(hashlib.sha3_256(t).digest(True),
unhexlify('33a50fdd4a54913643a580b2af08b9a5b51b7cee922bde380e84c573a7969c50'))
@ -32,7 +33,7 @@ class TestNemMosaicSupplyChange(unittest.TestCase):
"coupons",
2,
1)
t = serialize_mosaic_supply_change(m, unhexlify("84afa1bbc993b7f5536344914dde86141e61f8cbecaf8c9cefc07391f3287cf5"))
t = serialize_mosaic_supply_change(m.transaction, m.supply_change, unhexlify("84afa1bbc993b7f5536344914dde86141e61f8cbecaf8c9cefc07391f3287cf5"))
self.assertEqual(hashlib.sha3_256(t).digest(True),
unhexlify('1ce8e8894d077a66ff22294b000825d090a60742ec407efd80eb8b19657704f2'))
@ -46,7 +47,7 @@ class TestNemMosaicSupplyChange(unittest.TestCase):
"abv",
1,
9000000)
t = serialize_mosaic_supply_change(m, unhexlify("b7ccc27b21ba6cf5c699a8dc86ba6ba98950442597ff9fa30e0abe0f5f4dd05d"))
t = serialize_mosaic_supply_change(m.transaction, m.supply_change, unhexlify("b7ccc27b21ba6cf5c699a8dc86ba6ba98950442597ff9fa30e0abe0f5f4dd05d"))
self.assertEqual(hashlib.sha3_256(t).digest(True),
unhexlify('694e493e9576d2bcf60d85747e302ac2e1cc27783187947180d4275a713ff1ff'))
@ -60,7 +61,7 @@ class TestNemMosaicSupplyChange(unittest.TestCase):
"wasabi",
2,
20)
t = serialize_mosaic_supply_change(m, unhexlify("75f001a8641e2ce5c4386883dda561399ed346177411b492a677b73899502f13"))
t = serialize_mosaic_supply_change(m.transaction, m.supply_change, unhexlify("75f001a8641e2ce5c4386883dda561399ed346177411b492a677b73899502f13"))
self.assertEqual(hashlib.sha3_256(t).digest(True),
unhexlify('09836334e123970e068d5b411e4d1df54a3ead10acf1ad5935a2cdd9f9680185'))

7
tests/test_apps.nem.multisig.aggregate_modification.py
Unescape View File

@ -5,6 +5,7 @@ from trezor.crypto import hashlib
from trezor.messages.NEMSignTx import NEMSignTx
from trezor.messages.NEMAggregateModification import NEMAggregateModification
from trezor.messages.NEMCosignatoryModification import NEMCosignatoryModification
from trezor.messages.NEMTransactionCommon import NEMTransactionCommon
class TestNemMultisigAggregateModification(unittest.TestCase):
@ -17,7 +18,7 @@ class TestNemMultisigAggregateModification(unittest.TestCase):
0,
2,
0)
t = serialize_aggregate_modification(m, unhexlify("462ee976890916e54fa825d26bdd0235f5eb5b6a143c199ab0ae5ee9328e08ce"))
t = serialize_aggregate_modification(m.transaction, m.aggregate_modification, unhexlify("462ee976890916e54fa825d26bdd0235f5eb5b6a143c199ab0ae5ee9328e08ce"))
serialize_cosignatory_modification(t, 1, unhexlify(
"994793ba1c789fa9bdea918afc9b06e2d0309beb1081ac5b6952991e4defd324"))
@ -34,7 +35,7 @@ class TestNemMultisigAggregateModification(unittest.TestCase):
0,
5,
0)
t = serialize_aggregate_modification(m, unhexlify("f41b99320549741c5cce42d9e4bb836d98c50ed5415d0c3c2912d1bb50e6a0e5"))
t = serialize_aggregate_modification(m.transaction, m.aggregate_modification, unhexlify("f41b99320549741c5cce42d9e4bb836d98c50ed5415d0c3c2912d1bb50e6a0e5"))
serialize_cosignatory_modification(t, 1, unhexlify(
"1fbdbdde28daf828245e4533765726f0b7790e0b7146e2ce205df3e86366980b"))
@ -58,7 +59,7 @@ class TestNemMultisigAggregateModification(unittest.TestCase):
6545854,
4,
2)
t = serialize_aggregate_modification(m, unhexlify("6bf7849c1eec6a2002995cc457dc00c4e29bad5c88de63f51e42dfdcd7b2131d"))
t = serialize_aggregate_modification(m.transaction, m.aggregate_modification, unhexlify("6bf7849c1eec6a2002995cc457dc00c4e29bad5c88de63f51e42dfdcd7b2131d"))
serialize_cosignatory_modification(t, 1, unhexlify(
"5f53d076c8c3ec3110b98364bc423092c3ec2be2b1b3c40fd8ab68d54fa39295"))

4
tests/test_apps.nem.multisig.py
Unescape View File

@ -18,7 +18,7 @@ class TestNemMultisig(unittest.TestCase):
3960639,
1,
0)
base_tx = serialize_aggregate_modification(m, unhexlify("abac2ee3d4aaa7a3bfb65261a00cc04c761521527dd3f2cf741e2815cbba83ac"))
base_tx = serialize_aggregate_modification(m.transaction, m.aggregate_modification, unhexlify("abac2ee3d4aaa7a3bfb65261a00cc04c761521527dd3f2cf741e2815cbba83ac"))
base_tx = serialize_cosignatory_modification(base_tx, 2, unhexlify("e6cff9b3725a91f31089c3acca0fac3e341c00b1c8c6e9578f66c4514509c3b3"))
m = _create_common_msg(NEM_NETWORK_TESTNET,
@ -48,7 +48,7 @@ class TestNemMultisig(unittest.TestCase):
"",
"NAMESPACEWH4MKFMBCVFERDPOOP4FK7MTBXDPZZA",
5000000000)
base_tx = serialize_provision_namespace(m, unhexlify("a1df5306355766bd2f9a64efdc089eb294be265987b3359093ae474c051d7d5a"))
base_tx = serialize_provision_namespace(m.transaction, m.provision_namespace, unhexlify("a1df5306355766bd2f9a64efdc089eb294be265987b3359093ae474c051d7d5a"))
m = _create_common_msg(NEM_NETWORK_MAINNET,
59414272,

6
tests/test_apps.nem.namespace.py
Unescape View File

@ -19,7 +19,7 @@ class TestNemNamespace(unittest.TestCase):
'',
'TAMESPACEWH4MKFMBCVFERDPOOP4FK7MTDJEYP35',
5000000000)
t = serialize_provision_namespace(m, unhexlify('84afa1bbc993b7f5536344914dde86141e61f8cbecaf8c9cefc07391f3287cf5'))
t = serialize_provision_namespace(m.transaction, m.provision_namespace, unhexlify('84afa1bbc993b7f5536344914dde86141e61f8cbecaf8c9cefc07391f3287cf5'))
self.assertEqual(hashlib.sha3_256(t).digest(True), unhexlify('f7cab28da57204d01a907c697836577a4ae755e6c9bac60dcc318494a22debb3'))
# http://bob.nem.ninja:8765/#/namespace/7ddd5fe607e1bfb5606e0ac576024c318c8300d237273117d4db32a60c49524d
@ -31,7 +31,7 @@ class TestNemNamespace(unittest.TestCase):
'alice',
'TAMESPACEWH4MKFMBCVFERDPOOP4FK7MTDJEYP35',
5000000000)
t = serialize_provision_namespace(m, unhexlify('244fa194e2509ac0d2fbc18779c2618d8c2ebb61c16a3bcbebcf448c661ba8dc'))
t = serialize_provision_namespace(m.transaction, m.provision_namespace, unhexlify('244fa194e2509ac0d2fbc18779c2618d8c2ebb61c16a3bcbebcf448c661ba8dc'))
self.assertEqual(hashlib.sha3_256(t).digest(True), unhexlify('7ddd5fe607e1bfb5606e0ac576024c318c8300d237273117d4db32a60c49524d'))
@ -44,7 +44,7 @@ class TestNemNamespace(unittest.TestCase):
'',
'NAMESPACEWH4MKFMBCVFERDPOOP4FK7MTBXDPZZA',
50000000000)
t = serialize_provision_namespace(m, unhexlify('9f3c14f304309c8b72b2821339c4428793b1518bea72d58dd01f19d523518614'))
t = serialize_provision_namespace(m.transaction, m.provision_namespace, unhexlify('9f3c14f304309c8b72b2821339c4428793b1518bea72d58dd01f19d523518614'))
self.assertEqual(hashlib.sha3_256(t).digest(True), unhexlify('57071aad93ca125dc231dc02c07ad8610cd243d35068f9b36a7d231383907569'))

10
tests/test_apps.nem.transfer.py
Unescape View File

@ -19,7 +19,7 @@ class TestNemTransfer(unittest.TestCase):
'TBGIMRE4SBFRUJXMH7DVF2IBY36L2EDWZ37GVSC4',
50000000000000)
t = serialize_transfer(m, unhexlify('e59ef184a612d4c3c4d89b5950eb57262c69862b2f96e59c5043bf41765c482f'))
t = serialize_transfer(m.transaction, m.transfer, unhexlify('e59ef184a612d4c3c4d89b5950eb57262c69862b2f96e59c5043bf41765c482f'))
self.assertEqual(t, unhexlify('01010000010000980000000020000000e59ef184a612d4c3c4d89b5950eb57262c69862b2f96e59c5043bf41765c482f00000000000000000000000028000000544247494d52453453424652554a584d48374456463249425933364c324544575a3337475653433400203d88792d000000000000'))
self.assertEqual(hashlib.sha3_256(t).digest(True), unhexlify('0acbf8df91e6a65dc56c56c43d65f31ff2a6a48d06fc66e78c7f3436faf3e74f'))
@ -33,7 +33,7 @@ class TestNemTransfer(unittest.TestCase):
'NBT3WHA2YXG2IR4PWKFFMO772JWOITTD2V4PECSB',
5175000000000)
t = serialize_transfer(m,
t = serialize_transfer(m.transaction, m.transfer,
unhexlify('8d07f90fb4bbe7715fa327c926770166a11be2e494a970605f2e12557f66c9b9'),
bytearray('Good luck!'))
self.assertEqual(hashlib.sha3_256(t).digest(True), unhexlify('e90e98614c7598fbfa4db5411db1b331d157c2f86b558fb7c943d013ed9f71cb'))
@ -48,7 +48,7 @@ class TestNemTransfer(unittest.TestCase):
'NALICEPFLZQRZGPRIJTMJOCPWDNECXTNNG7QLSG3',
30000000)
t = serialize_transfer(m,
t = serialize_transfer(m.transaction, m.transfer,
unhexlify('f85ab43dad059b9d2331ddacc384ad925d3467f03207182e01296bacfb242d01'),
unhexlify('4d9dcf9186967d30be93d6d5404ded22812dbbae7c3f0de501bcd7228cba45bded13000eec7b4c6215fc4d3588168c9218167cec98e6977359153a4132e050f594548e61e0dc61c153f0f53c5e65c595239c9eb7c4e7d48e0f4bb8b1dd2f5ddc'),
True)
@ -65,7 +65,7 @@ class TestNemTransfer(unittest.TestCase):
3000000,
2)
t = serialize_transfer(m,
t = serialize_transfer(m.transaction, m.transfer,
unhexlify('994793ba1c789fa9bdea918afc9b06e2d0309beb1081ac5b6952991e4defd324'),
bytearray('sending you 3 pairs of paddles\n'),
False)
@ -86,7 +86,7 @@ class TestNemTransfer(unittest.TestCase):
1000000,
1)
t = serialize_transfer(m,
t = serialize_transfer(m.transaction, m.transfer,
unhexlify('f85ab43dad059b9d2331ddacc384ad925d3467f03207182e01296bacfb242d01'),
bytearray('enjoy! :)'),
False)

Write Preview
Loading…
Cancel
Save