use primitive conversions

Author: OBorce

wallet/src/signer/ledger_signer/ledger_messages.rs

@@ -16,38 +16,27 @@
 use std::{collections::BTreeMap, mem::size_of_val, time::Duration};
 
 use crate::signer::{ledger_signer::LedgerError, SignerError, SignerResult};
-use common::{
-    chain::{self},
-    primitives,
-    primitives_converters::TryConvertInto as _,
-};
 use crypto::key::{
     extended::ExtendedPublicKey,
     hdkd::{chain_code::ChainCode, derivation_path::DerivationPath},
     secp256k1::{extended_keys::Secp256k1ExtendedPublicKey, Secp256k1PublicKey},
 };
-use serialization::Encode;
 use utils::ensure;
 
 use ledger_lib::{Device, Exchange};
 use ledger_proto::StatusCode;
 use mintlayer_ledger_messages::{
-    decode_all as ledger_decode_all, encode as ledger_encode, AccountCommand as LAccountCommand,
-    AccountNonce as LAccountNonce, AccountOutPoint as LAccountOutPoint, AdditionalOrderInfo,
-    AddrType, Amount as LAmount, Apdu, Bip32Path as LedgerBip32Path, CoinType,
-    GetPublicKeyRespones, Id as LId, Ins, MsgSignature,
-    OrderAccountCommand as LOrderAccountCommand, OutputValue as LOutputValue, PubKeyP1,
-    PublicKeyReq, SighashInputCommitment as LSighashInputCommitment, SignMessageReq, SignP1,
-    SignTxReq, Signature as LedgerSignature, TxInputReq, TxMetadataReq, TxOutput as LTxOutput,
-    TxOutputReq, UtxoOutPoint as LUtxoOutPoint, APDU_CLASS, H256 as LH256, P2_DONE, P2_MORE,
+    decode_all as ledger_decode_all, encode as ledger_encode, AddrType, Apdu,
+    Bip32Path as LedgerBip32Path, CoinType, GetPublicKeyRespones, Ins, MsgSignature, PubKeyP1,
+    PublicKeyReq, SighashInputCommitment, SignMessageReq, SignP1, SignTxReq, Signature, TxInputReq,
+    TxMetadataReq, TxOutputReq, APDU_CLASS, P2_DONE, P2_MORE,
 };
-use wallet_types::partially_signed_transaction::OrderAdditionalInfo;
 
 const TIMEOUT_DUR: Duration = Duration::from_secs(100);
 const TX_VERSION: u8 = 1;
 
 struct SignatureResult {
-    sig: LedgerSignature,
+    sig: Signature,
     input_idx: usize,
     has_more_signatures: bool,
 }
@@ -217,9 +206,9 @@ pub async fn sign_tx<L: Exchange>(
     ledger: &mut L,
     chain_type: CoinType,
     inputs: Vec<TxInputReq>,
-    input_commitments: Vec<LSighashInputCommitment>,
+    input_commitments: Vec<SighashInputCommitment>,
     outputs: Vec<TxOutputReq>,
-) -> SignerResult<BTreeMap<usize, Vec<LedgerSignature>>> {
+) -> SignerResult<BTreeMap<usize, Vec<Signature>>> {
     let metadata = ledger_encode(TxMetadataReq {
         coin: chain_type,
         version: TX_VERSION,
@@ -301,7 +290,7 @@ fn decode_signature_response(resp: &[u8]) -> Result<SignatureResult, LedgerError
     let input_idx = *resp.first().ok_or(LedgerError::InvalidResponse)? as usize;
     let has_more_signatures = *resp.last().ok_or(LedgerError::InvalidResponse)? == P2_MORE;
 
-    let sig: LedgerSignature =
+    let sig =
         ledger_decode_all(&resp[..resp.len() - 1][1..]).ok_or(LedgerError::InvalidResponse)?;
 
     Ok(SignatureResult {
@@ -310,57 +299,3 @@ fn decode_signature_response(resp: &[u8]) -> Result<SignatureResult, LedgerError
         has_more_signatures,
     })
 }
-
-pub fn to_ledger_tx_output(value: &chain::TxOutput) -> LTxOutput {
-    ledger_decode_all(value.encode().as_slice()).expect("ok")
-}
-
-pub fn to_ledger_amount(value: &primitives::Amount) -> LAmount {
-    LAmount::from_atoms(value.into_atoms())
-}
-
-pub fn to_ledger_outpoint(value: &chain::UtxoOutPoint) -> LUtxoOutPoint {
-    ledger_decode_all(value.encode().as_slice()).expect("ok")
-}
-
-pub fn to_ledger_account_outpoint(value: &chain::AccountOutPoint) -> LAccountOutPoint {
-    ledger_decode_all(value.encode().as_slice()).expect("ok")
-}
-
-pub fn to_ledger_account_nonce(value: &chain::AccountNonce) -> LAccountNonce {
-    ledger_decode_all(value.encode().as_slice()).expect("ok")
-}
-
-pub fn to_ledger_account_command(value: &chain::AccountCommand) -> LAccountCommand {
-    ledger_decode_all(value.encode().as_slice()).expect("ok")
-}
-
-pub fn to_ledger_order_account_command(value: &chain::OrderAccountCommand) -> LOrderAccountCommand {
-    ledger_decode_all(value.encode().as_slice()).expect("ok")
-}
-
-pub fn to_ledger_additional_order_info(
-    info: &OrderAdditionalInfo,
-) -> SignerResult<AdditionalOrderInfo> {
-    Ok(AdditionalOrderInfo {
-        initially_asked: to_ledger_output_value(&info.initially_asked)?,
-        initially_given: to_ledger_output_value(&info.initially_given)?,
-        ask_balance: info.ask_balance.try_convert_into()?,
-        give_balance: to_ledger_amount(&info.give_balance),
-    })
-}
-
-pub fn to_ledger_output_value(
-    value: &chain::output_value::OutputValue,
-) -> SignerResult<LOutputValue> {
-    match value {
-        chain::output_value::OutputValue::Coin(amount) => {
-            Ok(LOutputValue::Coin(to_ledger_amount(amount)))
-        }
-        chain::output_value::OutputValue::TokenV0(_) => Err(SignerError::UnsupportedTokensV0),
-        chain::output_value::OutputValue::TokenV1(token_id, amount) => Ok(LOutputValue::TokenV1(
-            LId::new(LH256(token_id.to_hash().into())),
-            to_ledger_amount(amount),
-        )),
-    }
-}

wallet/src/signer/ledger_signer/mod.rs

@@ -22,10 +22,7 @@ use crate::{
     signer::{
         ledger_signer::ledger_messages::{
             check_current_app, get_extended_public_key, get_extended_public_key_raw,
-            sign_challenge, sign_tx, to_ledger_account_command, to_ledger_account_nonce,
-            to_ledger_account_outpoint, to_ledger_additional_order_info, to_ledger_amount,
-            to_ledger_order_account_command, to_ledger_outpoint, to_ledger_output_value,
-            to_ledger_tx_output,
+            sign_challenge, sign_tx,
         },
         utils::{is_htlc_utxo, produce_uniparty_signature_for_input},
         Signer, SignerError, SignerProvider, SignerResult,
@@ -58,6 +55,7 @@ use common::{
         Transaction, TxInput, TxOutput,
     },
     primitives::{BlockHeight, Idable, H256},
+    primitives_converters::TryConvertInto as _,
 };
 use crypto::key::{
     extended::ExtendedPublicKey,
@@ -84,7 +82,7 @@ use async_trait::async_trait;
 use itertools::{izip, Itertools};
 use ledger_lib::{info::Model, Exchange, Filters, LedgerHandle, LedgerProvider, Transport};
 use mintlayer_ledger_messages::{
-    AdditionalUtxoInfo, AddrType, Bip32Path as LedgerBip32Path, CoinType,
+    AdditionalOrderInfo, AdditionalUtxoInfo, AddrType, Bip32Path as LedgerBip32Path, CoinType,
     InputAddressPath as LedgerInputAddressPath, SighashInputCommitment as LSighashInputCommitment,
     Signature as LedgerSignature, TxInputReq, TxInputWithAdditionalInfo, TxOutputReq,
 };
@@ -378,12 +376,17 @@ where
         }
     }
 
-    fn to_ledger_output_msgs(&self, ptx: &PartiallySignedTransaction) -> Vec<TxOutputReq> {
+    fn to_ledger_output_msgs(
+        &self,
+        ptx: &PartiallySignedTransaction,
+    ) -> SignerResult<Vec<TxOutputReq>> {
         ptx.tx()
             .outputs()
             .iter()
-            .map(|out| TxOutputReq {
-                out: to_ledger_tx_output(out),
+            .map(|out| {
+                Ok(TxOutputReq {
+                    out: out.clone().try_convert_into()?,
+                })
             })
             .collect()
     }
@@ -504,7 +507,7 @@ where
     )> {
         let (inputs, standalone_inputs) = to_ledger_input_msgs(&ptx, key_chain, &db_tx)?;
         let input_commitments = to_ledger_input_commitments_reqs(&ptx)?;
-        let outputs = self.to_ledger_output_msgs(&ptx);
+        let outputs = self.to_ledger_output_msgs(&ptx)?;
         let coin_type = to_ledger_chain_type(&self.chain_config);
 
         let input_commitment_version = self
@@ -898,29 +901,34 @@ fn to_ledger_tx_input_with_additional_info(
                         .get_pool_info(pool_id)
                         .ok_or(SignerError::MissingTxExtraInfo)?;
                     AdditionalUtxoInfo::PoolData {
-                        utxo: to_ledger_tx_output(utxo),
-                        staker_balance: to_ledger_amount(&pool_info.staker_balance),
+                        utxo: utxo.clone().try_convert_into()?,
+                        staker_balance: pool_info.staker_balance.try_convert_into()?,
                     }
                 }
-                _ => AdditionalUtxoInfo::Utxo(to_ledger_tx_output(utxo)),
+                _ => AdditionalUtxoInfo::Utxo(utxo.clone().try_convert_into()?),
             };
-            TxInputWithAdditionalInfo::Utxo(to_ledger_outpoint(outpoint), info)
+            TxInputWithAdditionalInfo::Utxo(outpoint.clone().try_convert_into()?, info)
         }
         TxInput::Account(acc) => {
-            TxInputWithAdditionalInfo::Account(to_ledger_account_outpoint(acc))
+            TxInputWithAdditionalInfo::Account(acc.clone().try_convert_into()?)
         }
         TxInput::AccountCommand(nonce, cmd) => TxInputWithAdditionalInfo::AccountCommand(
-            to_ledger_account_nonce(nonce),
-            to_ledger_account_command(cmd),
+            (*nonce).try_convert_into()?,
+            cmd.clone().try_convert_into()?,
         ),
         TxInput::OrderAccountCommand(cmd) => {
             let info = additional_info
                 .get_order_info(cmd.order_id())
                 .ok_or(SignerError::MissingTxExtraInfo)?;
 
             TxInputWithAdditionalInfo::OrderAccountCommand(
-                to_ledger_order_account_command(cmd),
-                to_ledger_additional_order_info(info)?,
+                cmd.clone().try_convert_into()?,
+                AdditionalOrderInfo {
+                    initially_asked: info.initially_asked.clone().try_convert_into()?,
+                    initially_given: info.initially_given.clone().try_convert_into()?,
+                    ask_balance: info.ask_balance.try_convert_into()?,
+                    give_balance: info.give_balance.try_convert_into()?,
+                },
             )
         }
     };
@@ -1011,11 +1019,11 @@ fn to_ledger_input_commitments_reqs(
                                 .get_pool_info(pool_id)
                                 .ok_or(SignerError::MissingTxExtraInfo)?;
                             LSighashInputCommitment::ProduceBlockFromStakeUtxo {
-                                utxo: to_ledger_tx_output(utxo),
-                                staker_balance: to_ledger_amount(&pool_info.staker_balance),
+                                utxo: utxo.clone().try_convert_into()?,
+                                staker_balance: pool_info.staker_balance.try_convert_into()?,
                             }
                         }
-                        _ => LSighashInputCommitment::Utxo(to_ledger_tx_output(utxo)),
+                        _ => LSighashInputCommitment::Utxo(utxo.clone().try_convert_into()?),
                     }
                 }
                 TxInput::Account(_) => LSighashInputCommitment::None,
@@ -1033,8 +1041,14 @@ fn to_ledger_input_commitments_reqs(
                             .get_order_info(order_id)
                             .ok_or(SignerError::MissingTxExtraInfo)?;
                         LSighashInputCommitment::FillOrderAccountCommand {
-                            initially_asked: to_ledger_output_value(&order_info.initially_asked)?,
-                            initially_given: to_ledger_output_value(&order_info.initially_given)?,
+                            initially_asked: order_info
+                                .initially_asked
+                                .clone()
+                                .try_convert_into()?,
+                            initially_given: order_info
+                                .initially_given
+                                .clone()
+                                .try_convert_into()?,
                         }
                     }
                     AccountCommand::ConcludeOrder(order_id) => {
@@ -1043,10 +1057,16 @@ fn to_ledger_input_commitments_reqs(
                             .get_order_info(order_id)
                             .ok_or(SignerError::MissingTxExtraInfo)?;
                         LSighashInputCommitment::ConcludeOrderAccountCommand {
-                            initially_asked: to_ledger_output_value(&order_info.initially_asked)?,
-                            initially_given: to_ledger_output_value(&order_info.initially_given)?,
-                            ask_balance: to_ledger_amount(&order_info.ask_balance),
-                            give_balance: to_ledger_amount(&order_info.give_balance),
+                            initially_asked: order_info
+                                .initially_asked
+                                .clone()
+                                .try_convert_into()?,
+                            initially_given: order_info
+                                .initially_given
+                                .clone()
+                                .try_convert_into()?,
+                            ask_balance: order_info.ask_balance.try_convert_into()?,
+                            give_balance: order_info.give_balance.try_convert_into()?,
                         }
                     }
                 },
@@ -1057,8 +1077,14 @@ fn to_ledger_input_commitments_reqs(
                             .get_order_info(order_id)
                             .ok_or(SignerError::MissingTxExtraInfo)?;
                         LSighashInputCommitment::FillOrderAccountCommand {
-                            initially_asked: to_ledger_output_value(&order_info.initially_asked)?,
-                            initially_given: to_ledger_output_value(&order_info.initially_given)?,
+                            initially_asked: order_info
+                                .initially_asked
+                                .clone()
+                                .try_convert_into()?,
+                            initially_given: order_info
+                                .initially_given
+                                .clone()
+                                .try_convert_into()?,
                         }
                     }
                     OrderAccountCommand::ConcludeOrder(order_id) => {
@@ -1067,10 +1093,16 @@ fn to_ledger_input_commitments_reqs(
                             .get_order_info(order_id)
                             .ok_or(SignerError::MissingTxExtraInfo)?;
                         LSighashInputCommitment::ConcludeOrderAccountCommand {
-                            initially_asked: to_ledger_output_value(&order_info.initially_asked)?,
-                            initially_given: to_ledger_output_value(&order_info.initially_given)?,
-                            ask_balance: to_ledger_amount(&order_info.ask_balance),
-                            give_balance: to_ledger_amount(&order_info.give_balance),
+                            initially_asked: order_info
+                                .initially_asked
+                                .clone()
+                                .try_convert_into()?,
+                            initially_given: order_info
+                                .initially_given
+                                .clone()
+                                .try_convert_into()?,
+                            ask_balance: order_info.ask_balance.try_convert_into()?,
+                            give_balance: order_info.give_balance.try_convert_into()?,
                         }
                     }
                     OrderAccountCommand::FreezeOrder(_) => LSighashInputCommitment::None,