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::extend::key_derivation_schema::KeyDerivationSchema;
use crate::impl_template_struct;
use crate::registry_types::{RegistryType, KEY_DERIVATION_CALL, KEY_DERIVATION_SCHEMA};
use crate::traits::{MapSize, RegistryItem};
use alloc::string::ToString;
use alloc::vec;
use alloc::vec::Vec;
use minicbor::data::Int;
use minicbor::data::Tag;
use minicbor::encode::{Error, Write};
use minicbor::{Decoder, Encoder};

const SCHEMAS: u8 = 1;

impl_template_struct!(KeyDerivationCall {
    schemas: Vec<KeyDerivationSchema>
});

impl RegistryItem for KeyDerivationCall {
    fn get_registry_type() -> RegistryType<'static> {
        KEY_DERIVATION_CALL
    }
}

impl MapSize for KeyDerivationCall {
    fn map_size(&self) -> u64 {
        1
    }
}

impl<C> minicbor::Encode<C> for KeyDerivationCall {
    fn encode<W: Write>(&self, e: &mut Encoder<W>, ctx: &mut C) -> Result<(), Error<W::Error>> {
        e.map(self.map_size())?;
        e.int(Int::from(SCHEMAS))?
            .array(self.get_schemas().len() as u64)?;
        for x in self.get_schemas() {
            e.tag(Tag::Unassigned(KEY_DERIVATION_SCHEMA.get_tag()))?;
            x.encode(e, ctx)?
        }
        Ok(())
    }
}

impl<'b, C> minicbor::Decode<'b, C> for KeyDerivationCall {
    fn decode(d: &mut Decoder<'b>, ctx: &mut C) -> Result<Self, minicbor::decode::Error> {
        let mut result = KeyDerivationCall::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 {
                SCHEMAS => {
                    let mut schemas = vec![];
                    cbor_array(d, obj, |_index, _obj, d| {
                        d.tag()?;
                        schemas.push(KeyDerivationSchema::decode(d, ctx)?);
                        Ok(())
                    })?;
                    obj.set_schemas(schemas)
                }
                _ => {}
            }
            Ok(())
        })?;
        Ok(result)
    }
}