nem: refactored to have a common message as an argument

src/apps/nem/layout.py

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

src/apps/nem/mosaic/__init__.py

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

src/apps/nem/mosaic/layout.py

@@ -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):
+async def ask_mosaic_creation(ctx, common: NEMTransactionCommon, creation: NEMMosaicCreation):
-    await require_confirm_content(ctx, 'Create mosaic', _creation_message(msg.mosaic_creation))
+    await require_confirm_content(ctx, 'Create mosaic', _creation_message(creation))
-    await _require_confirm_properties(ctx, msg.mosaic_creation.definition)
+    await _require_confirm_properties(ctx, creation.definition)
-    await require_confirm_fee(ctx, 'Confirm creation fee', msg.mosaic_creation.fee)
+    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):
+async def ask_supply_change(ctx, common: NEMTransactionCommon, change: NEMMosaicSupplyChange):
-    await require_confirm_content(ctx, 'Supply change', _supply_message(msg.supply_change))
+    await require_confirm_content(ctx, 'Supply change', _supply_message(change))
-    if msg.supply_change.type == NEMSupplyChangeType.SupplyChange_Decrease:
+    if change.type == NEMSupplyChangeType.SupplyChange_Decrease:
-        ask_msg = 'Decrease supply by ' + str(msg.supply_change.delta) + ' whole units?'
+        msg = 'Decrease supply by ' + str(change.delta) + ' whole units?'
-    elif msg.supply_change.type == NEMSupplyChangeType.SupplyChange_Increase:
+    elif change.type == NEMSupplyChangeType.SupplyChange_Increase:
-        ask_msg = 'Increase supply by ' + str(msg.supply_change.delta) + ' whole units?'
+        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):

src/apps/nem/mosaic/serialize.py

@@ -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):
+def serialize_mosaic_creation(common: NEMTransactionCommon, creation: NEMMosaicCreation, public_key: bytes):
-    common = msg.transaction
-    if msg.multisig:
-        common = msg.multisig
     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(creation.definition.namespace))
-    write_bytes_with_length(mosaics_w, bytearray(msg.mosaic_creation.definition.mosaic))
+    write_bytes_with_length(mosaics_w, bytearray(creation.definition.mosaic))
-    write_bytes_with_length(mosaics_w, bytearray(msg.mosaic_creation.definition.description))
+    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, "divisibility", creation.definition.divisibility)
-    _write_property(mosaics_w, "initialSupply", msg.mosaic_creation.definition.supply)
+    _write_property(mosaics_w, "initialSupply", creation.definition.supply)
-    _write_property(mosaics_w, "supplyMutable", msg.mosaic_creation.definition.mutable_supply)
+    _write_property(mosaics_w, "supplyMutable", creation.definition.mutable_supply)
-    _write_property(mosaics_w, "transferable", msg.mosaic_creation.definition.transferable)
+    _write_property(mosaics_w, "transferable", creation.definition.transferable)
 
-    if msg.mosaic_creation.definition.levy:
+    if creation.definition.levy:
-        levy_identifier_length = 4 + len(msg.mosaic_creation.definition.levy_namespace) + 4 + len(msg.mosaic_creation.definition.levy_mosaic)
+        levy_identifier_length = 4 + len(creation.definition.levy_namespace) + 4 + len(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, 4 + 4 + len(creation.definition.levy_address) + 4 + levy_identifier_length + 8)
-        write_uint32(mosaics_w, msg.mosaic_creation.definition.levy)
+        write_uint32(mosaics_w, creation.definition.levy)
-        write_bytes_with_length(mosaics_w, bytearray(msg.mosaic_creation.definition.levy_address))
+        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(creation.definition.levy_namespace))
-        write_bytes_with_length(mosaics_w, bytearray(msg.mosaic_creation.definition.levy_mosaic))
+        write_bytes_with_length(mosaics_w, bytearray(creation.definition.levy_mosaic))
-        write_uint64(mosaics_w, msg.mosaic_creation.definition.fee)
+        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_bytes_with_length(w, bytearray(creation.sink))
-    write_uint64(w, msg.mosaic_creation.fee)
+    write_uint64(w, creation.fee)
 
     return w
 
 
-def serialize_mosaic_supply_change(msg: NEMSignTx, public_key: bytes):
+def serialize_mosaic_supply_change(common: NEMTransactionCommon, change: NEMMosaicSupplyChange, public_key: bytes):
-    common = msg.transaction
-    if msg.multisig:
-        common = msg.multisig
     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(change.namespace))
-    write_bytes_with_length(w, bytearray(msg.supply_change.mosaic))
+    write_bytes_with_length(w, bytearray(change.mosaic))
 
-    write_uint32(w, msg.supply_change.type)
+    write_uint32(w, change.type)
-    write_uint64(w, msg.supply_change.delta)
+    write_uint64(w, change.delta)
     return w
 
 

src/apps/nem/multisig/__init__.py

@@ -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):
+async def aggregate_modification(ctx,
-    await ask_aggregate_modification(ctx, msg)
+                                 public_key: bytes,
-    w = serialize_aggregate_modification(msg, public_key)
+                                 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:
+    if aggr.relative_change:
-        serialize_minimum_cosignatories(w, msg.aggregate_modification.relative_change)
+        serialize_minimum_cosignatories(w, aggr.relative_change)
     return w

src/apps/nem/multisig/layout.py

@@ -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):
+async def ask_aggregate_modification(ctx, common: NEMTransactionCommon, mod: NEMAggregateModification, multisig: bool):
-    if not msg.multisig:
+    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 mod.relative_change:
-        if not msg.multisig:
+        if multisig:
-            action = 'Set minimum cosignatories to '
-        else:
             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):

src/apps/nem/multisig/serialize.py

@@ -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):
+def serialize_aggregate_modification(common: NEMTransactionCommon, mod: NEMAggregateModification, public_key: bytes):
-    common = msg.transaction
-    if msg.multisig:
-        common = msg.multisig
     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
 
 

src/apps/nem/namespace/__init__.py

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

src/apps/nem/namespace/layout.py

@@ -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):
+async def ask_provision_namespace(ctx, common: NEMTransactionCommon, namespace: NEMProvisionNamespace):
-    if msg.provision_namespace.parent:
+    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)

src/apps/nem/namespace/serialize.py

@@ -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:
+def serialize_provision_namespace(common: NEMTransactionCommon, namespace: NEMProvisionNamespace, public_key: bytes) -> bytearray:
-    common = msg.transaction
-    if msg.multisig:
-        common = msg.multisig
     tx = write_common(common,
                       bytearray(public_key),
                       NEM_TRANSACTION_TYPE_PROVISION_NAMESPACE)
 
-    write_bytes_with_length(tx, bytearray(msg.provision_namespace.sink))
+    write_bytes_with_length(tx, bytearray(namespace.sink))
-    write_uint64(tx, msg.provision_namespace.fee)
+    write_uint64(tx, namespace.fee)
-    write_bytes_with_length(tx, bytearray(msg.provision_namespace.namespace))
+    write_bytes_with_length(tx, bytearray(namespace.namespace))
-    if msg.provision_namespace.parent:
+    if namespace.parent:
-        write_bytes_with_length(tx, bytearray(msg.provision_namespace.parent))
+        write_bytes_with_length(tx, bytearray(namespace.parent))
     else:
         write_uint32(tx, 0xffffffff)
 

src/apps/nem/signing.py

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

src/apps/nem/transfer/__init__.py

@@ -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):
+async def transfer(ctx, public_key: bytes, common: NEMTransactionCommon, transfer: NEMTransfer, node):
-    msg.transfer.mosaics = canonicalize_mosaics(msg.transfer.mosaics)
+    transfer.mosaics = canonicalize_mosaics(transfer.mosaics)
 
-    payload, encrypted = get_transfer_payload(msg, node)
+    payload, encrypted = get_transfer_payload(transfer, node)
-    await ask_transfer(ctx, msg, payload, encrypted)
+    await ask_transfer(ctx, common, transfer, payload, encrypted)
 
-    w = serialize_transfer(msg, public_key, payload, encrypted)
+    w = serialize_transfer(common, transfer, public_key, payload, encrypted)
-    for mosaic in msg.transfer.mosaics:
+    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):
+async def importance_transfer(ctx, public_key: bytes, common: NEMTransactionCommon, imp: NEMImportanceTransfer):
-    await ask_importance_transfer(ctx, msg)
+    await ask_importance_transfer(ctx, common, imp)
-    return serialize_importance_transfer(msg, public_key)
+    return serialize_importance_transfer(common, imp, public_key)

src/apps/nem/transfer/layout.py

@@ -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):
+async def ask_importance_transfer(ctx, common: NEMTransactionCommon, imp: NEMImportanceTransfer):
-    if msg.importance_transfer.mode == NEMImportanceTransferMode.ImportanceTransfer_Activate:
+    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):

src/apps/nem/transfer/serialize.py

@@ -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:
+def serialize_transfer(common: NEMTransactionCommon, transfer: NEMTransfer,
-    common = msg.transaction
+                       public_key: bytes, payload: bytes=None, encrypted: bool=False) -> bytearray:
-    if msg.multisig:
-        common = msg.multisig
     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_bytes_with_length(tx, bytearray(transfer.recipient))
-    write_uint64(tx, msg.transfer.amount)
+    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:
+    if transfer.mosaics:
-        write_uint32(tx, len(msg.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:
+def serialize_importance_transfer(common: NEMTransactionCommon, imp: NEMImportanceTransfer, public_key: bytes)-> bytearray:
-    common = msg.transaction
-    if msg.multisig:
-        common = msg.multisig
     w = write_common(common, bytearray(public_key), NEM_TRANSACTION_TYPE_IMPORTANCE_TRANSFER)
 
-    write_uint32(w, msg.importance_transfer.mode)
+    write_uint32(w, imp.mode)
-    write_bytes_with_length(w, bytearray(msg.importance_transfer.public_key))
+    write_bytes_with_length(w, bytearray(imp.public_key))
     return w
 
 
-def get_transfer_payload(msg: NEMSignTx, node) -> [bytes, bool]:
+def get_transfer_payload(transfer: NEMTransfer, node) -> [bytes, bool]:
-    payload = msg.transfer.payload
+    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

tests/test_apps.nem.mosaic_creation.py

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

tests/test_apps.nem.mosaic_supply_change.py

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

tests/test_apps.nem.multisig.aggregate_modification.py

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

tests/test_apps.nem.multisig.py

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

tests/test_apps.nem.namespace.py

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

tests/test_apps.nem.transfer.py

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