Merge pull request #1926 from mintlayer/feature/account-extended-pk

Add a wallet command to get the account extended public key

Author: OBorce

crypto/src/key/extended.rs

@@ -25,6 +25,8 @@ use crate::key::secp256k1::extended_keys::{
 use crate::key::{PrivateKey, PublicKey};
 use randomness::{make_true_rng, CryptoRng, Rng};
 
+use super::hdkd::chain_code::ChainCode;
+
 #[derive(Debug, PartialEq, Eq, Clone, Decode, Encode)]
 pub enum ExtendedKeyKind {
     #[codec(index = 0)]
@@ -133,6 +135,15 @@ impl ExtendedPublicKey {
             ExtendedPublicKeyHolder::Secp256k1Schnorr(k) => k.into_public_key().into(),
         }
     }
+
+    pub fn into_public_key_and_chain_code(self) -> (PublicKey, ChainCode) {
+        match self.pub_key {
+            ExtendedPublicKeyHolder::Secp256k1Schnorr(k) => {
+                let chain_code = k.chain_code();
+                (k.into_public_key().into(), chain_code)
+            }
+        }
+    }
 }
 
 impl Derivable for ExtendedPrivateKey {

crypto/src/key/secp256k1/extended_keys.rs

@@ -191,6 +191,10 @@ impl Secp256k1ExtendedPublicKey {
         self.public_key
     }
 
+    pub fn chain_code(&self) -> ChainCode {
+        self.chain_code
+    }
+
     pub fn from_private_key(private_key: &Secp256k1ExtendedPrivateKey) -> Self {
         let secp: secp256k1::Secp256k1<secp256k1::All> = secp256k1::Secp256k1::new();
         Secp256k1ExtendedPublicKey {

test/functional/test_framework/wallet_cli_controller.py

@@ -262,6 +262,9 @@ async def new_public_key(self, address: Optional[str] = None) -> bytes:
     async def reveal_public_key_as_address(self, address: str) -> str:
         return await self._write_command(f"address-reveal-public-key-as-address {address}\n")
 
+    async def account_extended_public_key(self) -> str:
+        return await self._write_command(f"account-extended-public-key-as-hex\n")
+
     async def new_address(self) -> str:
         return await self._write_command(f"address-new\n")
 

test/functional/wallet_get_address_usage.py

@@ -81,6 +81,9 @@ async def async_test(self):
             best_block_height = await wallet.get_best_block_height()
             assert_equal(best_block_height, '0')
 
+            result = await wallet.account_extended_public_key()
+            assert_in("The account extended public key is: 00028b42cd4776376c82791b494155151f56c2d7b471e0c7a526a7ce60dd872e38676b22c5123ba10adeaf4bfcbb45d1a02d828f25bf8646957a98d06287c4e2b850", result)
+
             # new address
             for _ in range(4):
                 pub_key_bytes = await wallet.new_public_key()

wallet/src/account/mod.rs

@@ -33,6 +33,7 @@ use common::size_estimation::{
     tx_size_with_num_inputs_and_outputs, DestinationInfoProvider,
 };
 use common::Uint256;
+use crypto::key::extended::ExtendedPublicKey;
 use crypto::key::hdkd::child_number::ChildNumber;
 use mempool::FeeRate;
 use serialization::hex_encoded::HexEncoded;
@@ -1696,6 +1697,10 @@ impl<K: AccountKeyChains> Account<K> {
             .ok_or(WalletError::AddressNotFound)
     }
 
+    pub fn get_extended_public_key(&self) -> &ExtendedPublicKey {
+        self.account_info.account_key()
+    }
+
     pub fn get_all_issued_addresses(
         &self,
         key_purpose: KeyPurpose,

wallet/src/wallet/mod.rs

@@ -59,6 +59,7 @@ use common::primitives::id::{hash_encoded, WithId};
 use common::primitives::{Amount, BlockHeight, Id, H256};
 use common::size_estimation::SizeEstimationError;
 use consensus::PoSGenerateBlockInputData;
+use crypto::key::extended::ExtendedPublicKey;
 use crypto::key::hdkd::child_number::ChildNumber;
 use crypto::key::hdkd::derivable::Derivable;
 use crypto::key::hdkd::u31::U31;
@@ -1441,6 +1442,13 @@ where
         }
     }
 
+    pub fn account_extended_public_key(
+        &self,
+        account_index: U31,
+    ) -> WalletResult<&ExtendedPublicKey> {
+        Ok(self.get_account(account_index)?.get_extended_public_key())
+    }
+
     pub fn get_transaction_list(
         &self,
         account_index: U31,

wallet/src/wallet/tests.rs

@@ -678,6 +678,21 @@ fn wallet_seed_phrase_check_address() {
     .wallet()
     .unwrap();
 
+    let (public_key, chain_code) = wallet
+        .account_extended_public_key(DEFAULT_ACCOUNT_INDEX)
+        .unwrap()
+        .clone()
+        .into_public_key_and_chain_code();
+    // m/44'/19788'/0' for MNEMONIC
+    let expected_pk = "029103888be8638b733d54eba6c5a96ae12583881dfab4b9585366548b54e3f8fd";
+    assert_eq!(
+        expected_pk,
+        public_key.hex_encode().strip_prefix("00").unwrap()
+    );
+    // m/44'/19788'/0' chain code for MNEMONIC
+    let expected_chain_code = "0b71f99e82c97a4c8f75d8d215e7260bcf9e964d437ec252af26877adf7e8683";
+    assert_eq!(expected_chain_code, chain_code.hex_encode());
+
     let address = wallet.get_new_address(DEFAULT_ACCOUNT_INDEX).unwrap();
     let pk = wallet.find_public_key(DEFAULT_ACCOUNT_INDEX, address.1.into_object()).unwrap();
 

wallet/wallet-cli-commands/src/command_handler/mod.rs

@@ -462,6 +462,25 @@ where
                 ))
             }
 
+            ColdWalletCommand::AccountExtendedPublicKey => {
+                let (wallet, selected_account) = wallet_and_selected_acc(&mut self.wallet).await?;
+                let key = wallet.get_account_extended_public_key(selected_account).await?;
+                let hex_public_key = key.public_key.to_string();
+                let hex_chain_code = key.chain_code.to_string();
+
+                let extended_public_key = format!("{hex_public_key}{hex_chain_code}");
+                let qr_code = if !self.no_qr {
+                    let qr_code = qrcode_or_error_string(&extended_public_key);
+                    format!("\nOr contained in the QR code:\n{qr_code}")
+                } else {
+                    String::new()
+                };
+
+                Ok(ConsoleCommand::Print(format!(
+                    "The account extended public key is: {extended_public_key}{qr_code}"
+                )))
+            }
+
             ColdWalletCommand::ShowAddresses { include_change } => {
                 let (wallet, selected_account) = wallet_and_selected_acc(&mut self.wallet).await?;
                 let addresses_with_usage =

wallet/wallet-cli-commands/src/lib.rs

@@ -329,6 +329,9 @@ pub enum ColdWalletCommand {
     #[clap(name = "staking-show-legacy-vrf-key")]
     GetLegacyVrfPublicKey,
 
+    #[clap(name = "account-extended-public-key-as-hex")]
+    AccountExtendedPublicKey,
+
     #[clap(name = "account-sign-raw-transaction")]
     SignRawTransaction {
         /// Hex encoded transaction or PartiallySignedTransaction.

wallet/wallet-controller/src/read.rs

@@ -23,7 +23,10 @@ use common::{
     primitives::{id::WithId, Amount, Id},
 };
 use crypto::{
-    key::hdkd::{child_number::ChildNumber, u31::U31},
+    key::{
+        extended::ExtendedPublicKey,
+        hdkd::{child_number::ChildNumber, u31::U31},
+    },
     vrf::VRFPublicKey,
 };
 use futures::{stream::FuturesUnordered, FutureExt, TryStreamExt};
@@ -88,6 +91,14 @@ where
         self.account_index
     }
 
+    pub fn account_extended_public_key(
+        &mut self,
+    ) -> Result<&ExtendedPublicKey, ControllerError<T>> {
+        self.wallet
+            .account_extended_public_key(self.account_index)
+            .map_err(ControllerError::WalletError)
+    }
+
     pub fn get_balance(
         &self,
         utxo_states: UtxoStates,