ur-registry 1.0.9

Keystone UR registry types and encoders/decoders for multi-chain payloads
Documentation
use crate::cbor::{cbor_array, cbor_map};
use crate::crypto_hd_key::CryptoHDKey;
use crate::error::{URError, URResult};
use crate::registry_types::{RegistryType, CRYPTO_HDKEY, CRYPTO_MULTI_ACCOUNTS};
use crate::traits::{From as FromCbor, RegistryItem, To};
use crate::types::Fingerprint;
use alloc::string::{String, ToString};
use alloc::vec;
use alloc::vec::Vec;
use minicbor::data::{Int, Tag};
use minicbor::encode::Write;
use minicbor::{Decoder, Encoder};

const MASTER_FINGERPRINT: u8 = 1;
const KEYS: u8 = 2;
const DEVICE: u8 = 3;
const DEVICE_ID: u8 = 4;
const DEVICE_VERSION: u8 = 5;

#[derive(Default, Clone, Debug)]
pub struct CryptoMultiAccounts {
    master_fingerprint: Fingerprint,
    keys: Vec<CryptoHDKey>,
    device: Option<String>,
    device_id: Option<String>,
    device_version: Option<String>,
}

impl CryptoMultiAccounts {
    pub fn default() -> Self {
        Default::default()
    }

    pub fn set_master_fingerprint(&mut self, master_fingerprint: Fingerprint) {
        self.master_fingerprint = master_fingerprint;
    }

    pub fn set_keys(&mut self, keys: Vec<CryptoHDKey>) {
        self.keys = keys;
    }

    pub fn add_key(&mut self, key: CryptoHDKey) {
        self.keys.push(key)
    }

    pub fn set_device(&mut self, device: String) {
        self.device = Some(device);
    }

    pub fn set_device_id(&mut self, device_id: String) {
        self.device_id = Some(device_id);
    }

    pub fn set_device_version(&mut self, device_version: String) {
        self.device_version = Some(device_version);
    }

    pub fn new(
        master_fingerprint: Fingerprint,
        keys: Vec<CryptoHDKey>,
        device: Option<String>,
        device_id: Option<String>,
        device_version: Option<String>,
    ) -> CryptoMultiAccounts {
        CryptoMultiAccounts {
            master_fingerprint,
            keys,
            device,
            device_id,
            device_version,
        }
    }

    pub fn get_master_fingerprint(&self) -> Fingerprint {
        self.master_fingerprint
    }
    pub fn get_keys(&self) -> Vec<CryptoHDKey> {
        self.keys.clone()
    }
    pub fn get_device(&self) -> Option<String> {
        self.device.clone()
    }
    pub fn get_device_id(&self) -> Option<String> {
        self.device_id.clone()
    }
    pub fn get_device_version(&self) -> Option<String> {
        self.device_version.clone()
    }
}

impl RegistryItem for CryptoMultiAccounts {
    fn get_registry_type() -> RegistryType<'static> {
        CRYPTO_MULTI_ACCOUNTS
    }
}

impl<C> minicbor::Encode<C> for CryptoMultiAccounts {
    fn encode<W: Write>(
        &self,
        e: &mut Encoder<W>,
        ctx: &mut C,
    ) -> Result<(), minicbor::encode::Error<W::Error>> {
        let mut size = 2;
        if self.device.is_some() {
            size += 1;
        }
        if self.device_id.is_some() {
            size += 1;
        }
        if self.device_version.is_some() {
            size += 1;
        }
        e.map(size)?;

        e.int(Int::from(MASTER_FINGERPRINT))?
            .int(Int::from(u32::from_be_bytes(self.master_fingerprint)))?;

        e.int(Int::from(KEYS))?.array(self.keys.len() as u64)?;
        for key in &self.keys {
            e.tag(Tag::Unassigned(CRYPTO_HDKEY.get_tag()))?;
            CryptoHDKey::encode(key, e, ctx)?;
        }

        if let Some(device) = &self.device {
            e.int(Int::from(DEVICE))?.str(device)?;
        }
        if let Some(device_id) = &self.device_id {
            e.int(Int::from(DEVICE_ID))?.str(device_id)?;
        }
        if let Some(device_version) = &self.device_version {
            e.int(Int::from(DEVICE_VERSION))?.str(device_version)?;
        }

        Ok(())
    }
}

impl<'b, C> minicbor::Decode<'b, C> for CryptoMultiAccounts {
    fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Self, minicbor::decode::Error> {
        let mut result = CryptoMultiAccounts::default();
        cbor_map(d, &mut result, |key, obj, d| {
            let key =
                u8::try_from(key).map_err(|e| minicbor::decode::Error::message(e.to_string()))?;
            match key {
                MASTER_FINGERPRINT => {
                    obj.master_fingerprint = u32::to_be_bytes(
                        u32::try_from(d.int()?)
                            .map_err(|e| minicbor::decode::Error::message(e.to_string()))?,
                    );
                }
                KEYS => {
                    let mut keys: Vec<CryptoHDKey> = vec![];
                    cbor_array(d, obj, |_index, _obj, d| {
                        d.tag()?;
                        keys.push(CryptoHDKey::decode(d, ctx)?);
                        Ok(())
                    })?;
                    obj.keys = keys;
                }
                DEVICE => {
                    obj.device = Some(d.str()?.to_string());
                }
                DEVICE_ID => {
                    obj.device_id = Some(d.str()?.to_string());
                }
                DEVICE_VERSION => {
                    obj.device_version = Some(d.str()?.to_string());
                }
                _ => {}
            }
            Ok(())
        })?;
        Ok(result)
    }
}

impl To for CryptoMultiAccounts {
    fn to_bytes(&self) -> URResult<Vec<u8>> {
        minicbor::to_vec(self.clone()).map_err(|e| URError::CborEncodeError(e.to_string()))
    }
}

impl FromCbor<CryptoMultiAccounts> for CryptoMultiAccounts {
    fn from_cbor(bytes: Vec<u8>) -> URResult<CryptoMultiAccounts> {
        minicbor::decode(&bytes).map_err(|e| URError::CborDecodeError(e.to_string()))
    }
}

#[cfg(test)]
mod tests {
    use crate::crypto_hd_key::CryptoHDKey;
    use crate::crypto_key_path::{CryptoKeyPath, PathComponent};
    use crate::extend::crypto_multi_accounts::CryptoMultiAccounts;
    use crate::traits::{From, To};
    use alloc::string::ToString;
    use alloc::vec;
    use alloc::vec::Vec;
    use hex::FromHex;

    #[test]
    fn test_encode() {
        let crypto_hdkey = CryptoHDKey::new_extended_key(
            None,
            Vec::from_hex("02eae4b876a8696134b868f88cc2f51f715f2dbedb7446b8e6edf3d4541c4eb67b")
                .unwrap(),
            None,
            None,
            Some(CryptoKeyPath::new(
                vec![
                    PathComponent::new(Some(44), true).unwrap(),
                    PathComponent::new(Some(501), true).unwrap(),
                    PathComponent::new(Some(0), true).unwrap(),
                    PathComponent::new(Some(0), true).unwrap(),
                ],
                None,
                None,
            )),
            None,
            None,
            None,
            None,
        );
        let crypto_multi_accounts = CryptoMultiAccounts::new(
            [0xe9, 0x18, 0x1c, 0xf3],
            vec![crypto_hdkey],
            Some("keystone".to_string()),
            Some("28475c8d80f6c06bafbe46a7d1750f3fcf2565f7".to_string()),
            Some("1.0.0".to_string()),
        );
        assert_eq!("a5011ae9181cf30281d9012fa203582102eae4b876a8696134b868f88cc2f51f715f2dbedb7446b8e6edf3d4541c4eb67b06d90130a10188182cf51901f5f500f500f503686b657973746f6e65047828323834373563386438306636633036626166626534366137643137353066336663663235363566370565312e302e30", hex::encode(crypto_multi_accounts.to_bytes().unwrap()));
        // let result = crypto_multi_accounts
        //     .to_ur_encoder(400)
        //     .next_part()
        //     .unwrap();
        // assert_eq!("ur:crypto-multi-accounts/1-1/lpadadcsgtcyeokkkgkthdgtotadcywlcscewfaolytaaddloeaxhdclaowdverokopdinhseeroisyalksaykctjshedprnuyjyfgrovawewftyghceglrpkgamtaaddyoyadlocsdwykcfadykykaeykaeykaxisjeihkkjkjyjljtihutltlrvo", result);
    }

    #[test]
    fn test_decode() {
        let crypto_multi_accounts = CryptoMultiAccounts::from_cbor(Vec::from_hex("a5011ae9181cf30281d9012fa203582102eae4b876a8696134b868f88cc2f51f715f2dbedb7446b8e6edf3d4541c4eb67b06d90130a10188182cf51901f5f500f500f503686b657973746f6e65047828323834373563386438306636633036626166626534366137643137353066336663663235363566370565312e302e30").unwrap()).unwrap();
        assert_eq!(
            crypto_multi_accounts.master_fingerprint,
            [0xe9, 0x18, 0x1c, 0xf3]
        );
        assert_eq!(crypto_multi_accounts.device, Some("keystone".to_string()));
        assert_eq!(crypto_multi_accounts.keys.len(), 1);
        assert_eq!(
            crypto_multi_accounts.device_version,
            Some("1.0.0".to_string())
        );
    }

    #[test]
    fn test_decode_multi_accounts() {
        let part ="UR:CRYPTO-MULTI-ACCOUNTS/OXADCYWMCMJKCTAOLFTAADDLOTAXHDCLAXRSJEQZPETEIMAXTOBSTIJNJKVSIMPRCWFHYTSTWDLYTDNBTDHHYNDMCYJPOEUECSAAHDCXEOTEWFLFMYPLAXWPDTHPFHWNATYAFHMUDPLUAHGSNLVONLBESRGLCHFYJOPDFMHGAMTAADDYOYADLNCSDWYKCSFNYKAEYKTAADDLOEAXHDCXTIDIFEHYSFWTETHESRMYCLKEHPZORHHEJSCYCMZOVDLFPEKGEOPTKICTCHWMSNKKAMTAADDYOYADLNCSDWYKCFADYKYKAEYKAXJTGRIHKKJKJYJLJTIHCXEOCXGDJPJLAHIHEHDMEHDMDYDLEYYLLD";
        // let result = ur::decode(&ur.to_lowercase());
        let decode_data = ur::decode(&part.to_lowercase());
        let crypto_multi_accounts = CryptoMultiAccounts::from_cbor(decode_data.unwrap().1).unwrap();
        //xpub
        let hd_key = crypto_multi_accounts.keys.get(0).unwrap();
        assert_eq!(
            "44'/60'/0'",
            hd_key.get_origin().unwrap().get_path().unwrap()
        );

        // public key
        assert_eq!(
            "03bf6bb4afd36a03ce0fd06d73e86ab21b3ff9c7ea81d2a0d25cf62e1a72a2de18",
            hex::encode(hd_key.get_key())
        );
        // chain code
        assert_eq!(
            "33d3f3828fae03ec295b3ff107f83f932d8b054c99e29910c34e174470a83e57",
            hex::encode(hd_key.get_chain_code().unwrap())
        );
    }

    #[test]
    fn test_decode_multi() {
        let part = "UR:CRYPTO-MULTI-ACCOUNTS/OTADCYCNTIFDWTAOLNTAADDLOXAOWKAXHDCXSPTPFWOEWNLBTSPKRPAYTODMONECOLWLHDURZSCXSGYNINQDFLRHBYSSCHCFIHGUAMTAADDYOTADLOCSDWYKCFADYKYKAEYKAEYKAOCYCNTIFDWTAXAHASISGRIHKKJKJYJLJTIHTAADDLOXAOWKAXHDCXBSMDKOCXPRDERDVORHGSLFUTTYRTMUMKFTIOENGOGORLEMWPKIUOBYCHVACEJPVTAMTAADDYOTADLOCSDWYKCFADYKYKADYKAEYKAOCYCNTIFDWTAXAHASISGRIHKKJKJYJLJTIHTAADDLOXAOWKAXHDCXWZDKVSECEOURRKKEVWWYRDFGAELYNNPYMDPRAATKAYJKTYRFHSTSBANYZMGLGHPMAMTAADDYOTADLOCSDWYKCFADYKYKAOYKAEYKAOCYCNTIFDWTAXAHASISGRIHKKJKJYJLJTIHTAADDLOXAOWKAXHDCXGLAAUECPATIEADBGPKJNUEYKNNTLADOXTIMURTGWCPAYGSZSYABTVLISECSOJYTKAMTAADDYOTADLOCSDWYKCFADYKYKAXYKAEYKAOCYCNTIFDWTAXAHASISGRIHKKJKJYJLJTIHTAADDLOXAOWKAXHDCXMUJLWLCKPYPMKBNEDPIOGRDINYRYIYWLECBAONHDPMSPBGFYTDEHASKEMTLDFZINAMTAADDYOTADLOCSDWYKCFADYKYKAAYKAEYKAOCYCNTIFDWTAXAHASISGRIHKKJKJYJLJTIHTAADDLOXAOWKAXHDCXKEOLGWPEFSRSKEEMGAONWLMWVWKOISTPPEJZFRVEPKFWVDGAAMAHBTTIJSFSGSLDAMTAADDYOTADLOCSDWYKCFADYKYKAHYKAEYKAOCYCNTIFDWTAXAHASISGRIHKKJKJYJLJTIHAXISGRIHKKJKJYJLJTIHLDMEDATK";
        let decode_data = ur::decode(&part.to_lowercase());
        let crypto_multi_accounts = CryptoMultiAccounts::from_cbor(decode_data.unwrap().1).unwrap();
        assert_eq!(
            0,
            crypto_multi_accounts
                .keys
                .get(0)
                .unwrap()
                .get_account_index(3)
                .unwrap()
        );
        assert_eq!(
            "44'/501'/0'/0'".to_string(),
            crypto_multi_accounts
                .keys
                .get(0)
                .unwrap()
                .get_origin()
                .unwrap()
                .get_path()
                .unwrap()
        );
        assert_eq!(
            5,
            crypto_multi_accounts
                .keys
                .get(0)
                .unwrap()
                .get_depth()
                .unwrap()
        );
    }
}