lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

decode.rs (11137B)


      1 //! Closed data decoding. No source, participant, authority or consent is admitted.
      2 use super::{TERMS_MAX_BYTES, TermsWireError};
      3 use crate::{
      4     command::{CommandError, check_frame, object, parse_object, required_nullable},
      5     listing_values,
      6     private_json::{self as text, RawArray},
      7 };
      8 use alloc::{string::String, vec::Vec};
      9 use radroots_domain::{
     10     AgreedFixedPrice, AgreementLine, AgreementLineId, AgreementPrice, Decimal, DiscountBps,
     11     EnvelopeEventId, FulfillmentGroup, FulfillmentGroupId, FuturePromise, ListingOptionId, Money,
     12     PositiveDecimal, PrivateFulfillment, PublicKey, SupplyCommitment, Terms, TimeZoneId,
     13     UnixSeconds, VariableWeight, Window,
     14     listing::{FulfillmentMode, ListingCoordinate, ListingId, ListingRevision, MeasurementUnit},
     15 };
     16 use serde::Deserialize;
     17 use serde_json::value::RawValue;
     18 
     19 /// Decodes bounded closed Terms claims and checks every domain constructor.
     20 /// Original private bytes belong to the caller. No signature, approval, current
     21 /// source availability, stock backing or application permission is established.
     22 pub fn decode(raw: &[u8]) -> Result<Terms, TermsWireError> {
     23     if raw.len() > TERMS_MAX_BYTES {
     24         return Err(TermsWireError::LimitExceeded);
     25     }
     26     check_frame(raw).map_err(command_error)?;
     27     let value: RawTerms<'_> = parse_object(raw).map_err(command_error)?;
     28     if value.cancellation != "mutual_residual_v1" || value.rounding != "half_even_net_line_v1" {
     29         return Err(TermsWireError::UnsupportedProfile);
     30     }
     31     let lines = value
     32         .lines
     33         .0
     34         .into_iter()
     35         .map(line)
     36         .collect::<Result<Vec<_>, _>>()?;
     37     let groups = value
     38         .fulfillment
     39         .0
     40         .into_iter()
     41         .map(group)
     42         .collect::<Result<Vec<_>, _>>()?;
     43     invalid(Terms::new(
     44         value.buyer,
     45         value.seller,
     46         lines,
     47         groups,
     48         money(value.fulfillment_charge)?,
     49         money(value.maximum_total)?,
     50         supply(value.supply)?,
     51     ))
     52 }
     53 fn invalid<T, E>(result: Result<T, E>) -> Result<T, TermsWireError> {
     54     result.map_err(|_| TermsWireError::InvalidInput)
     55 }
     56 fn command_error(error: CommandError) -> TermsWireError {
     57     match error {
     58         CommandError::LimitExceeded => TermsWireError::LimitExceeded,
     59         CommandError::UnsupportedProfile => TermsWireError::UnsupportedProfile,
     60         _ => TermsWireError::InvalidInput,
     61     }
     62 }
     63 fn parse<'a, T: Deserialize<'a>>(raw: &'a RawValue) -> Result<T, TermsWireError> {
     64     parse_object(raw.get().as_bytes()).map_err(command_error)
     65 }
     66 
     67 #[derive(Deserialize)]
     68 #[serde(deny_unknown_fields)]
     69 struct RawTerms<'a> {
     70     #[serde(deserialize_with = "crate::command::canonical_key")]
     71     buyer: PublicKey,
     72     #[serde(deserialize_with = "crate::command::canonical_key")]
     73     seller: PublicKey,
     74     #[serde(borrow)]
     75     lines: RawArray<'a, 32>,
     76     #[serde(borrow)]
     77     fulfillment: RawArray<'a, 8>,
     78     #[serde(borrow)]
     79     fulfillment_charge: &'a RawValue,
     80     #[serde(borrow)]
     81     maximum_total: &'a RawValue,
     82     #[serde(borrow)]
     83     supply: &'a RawValue,
     84     cancellation: String,
     85     rounding: String,
     86 }
     87 #[derive(Deserialize)]
     88 #[serde(deny_unknown_fields)]
     89 struct RawLine<'a> {
     90     id: AgreementLineId,
     91     #[serde(borrow)]
     92     source: &'a RawValue,
     93     option_id: ListingOptionId,
     94     #[serde(borrow)]
     95     product: &'a RawValue,
     96     #[serde(borrow)]
     97     option: &'a RawValue,
     98     amount: PositiveDecimal,
     99     fulfillment_group: FulfillmentGroupId,
    100     #[serde(borrow, deserialize_with = "required_nullable")]
    101     source_lot_label: Option<&'a RawValue>,
    102     #[serde(borrow)]
    103     price: &'a RawValue,
    104     #[serde(borrow)]
    105     maximum_line_total: &'a RawValue,
    106 }
    107 fn line(raw: &RawValue) -> Result<AgreementLine, TermsWireError> {
    108     let value: RawLine<'_> = parse(raw)?;
    109     let lot = value
    110         .source_lot_label
    111         .map(|v| text::decode(v.get(), 120).map_err(command_error))
    112         .transpose()?;
    113     invalid(AgreementLine::new(
    114         value.id,
    115         source(value.source)?,
    116         value.option_id,
    117         listing_values::product(value.product).map_err(command_error)?,
    118         listing_values::option(value.option).map_err(command_error)?,
    119         value.amount,
    120         value.fulfillment_group,
    121         lot.as_deref().map(String::as_str),
    122         price(value.price)?,
    123         money(value.maximum_line_total)?,
    124     ))
    125 }
    126 #[derive(Deserialize)]
    127 #[serde(deny_unknown_fields)]
    128 struct RawSource {
    129     #[serde(deserialize_with = "object")]
    130     coordinate: RawCoordinate,
    131     event_id: EnvelopeEventId,
    132 }
    133 #[derive(Deserialize)]
    134 #[serde(deny_unknown_fields)]
    135 struct RawCoordinate {
    136     kind: u16,
    137     #[serde(deserialize_with = "crate::command::canonical_key")]
    138     author: PublicKey,
    139     d: ListingId,
    140 }
    141 fn source(raw: &RawValue) -> Result<ListingRevision, TermsWireError> {
    142     let value: RawSource = parse(raw)?;
    143     if value.coordinate.kind != 30402 {
    144         return Err(TermsWireError::InvalidInput);
    145     }
    146     Ok(ListingRevision::new(
    147         ListingCoordinate::new(value.coordinate.author, value.coordinate.d),
    148         value.event_id,
    149     ))
    150 }
    151 #[derive(Deserialize)]
    152 #[serde(deny_unknown_fields)]
    153 struct RawMoney<'a> {
    154     #[serde(borrow)]
    155     currency: &'a RawValue,
    156     #[serde(borrow)]
    157     minor: &'a RawValue,
    158     exponent: u8,
    159 }
    160 pub(crate) fn money(raw: &RawValue) -> Result<Money, TermsWireError> {
    161     let value: RawMoney<'_> = parse(raw)?;
    162     let code = text::decode(value.currency.get(), 3).map_err(command_error)?;
    163     let minor = text::decode(value.minor.get(), 15).map_err(command_error)?;
    164     invalid(Money::from_parts(&code, &minor, value.exponent))
    165 }
    166 #[derive(Deserialize)]
    167 struct Tag {
    168     #[serde(rename = "type")]
    169     kind: String,
    170 }
    171 #[derive(Deserialize)]
    172 #[serde(deny_unknown_fields)]
    173 struct RawFixed<'a> {
    174     #[serde(rename = "type")]
    175     kind: String,
    176     #[serde(borrow)]
    177     rate: &'a RawValue,
    178     basis: PositiveDecimal,
    179     discount_bps: u16,
    180     #[serde(deserialize_with = "required_nullable")]
    181     selected_tier_from: Option<Decimal>,
    182 }
    183 #[derive(Deserialize)]
    184 #[serde(deny_unknown_fields)]
    185 struct RawVariable<'a> {
    186     #[serde(rename = "type")]
    187     kind: String,
    188     measurement_unit: String,
    189     minimum: PositiveDecimal,
    190     maximum: PositiveDecimal,
    191     #[serde(borrow)]
    192     rate: &'a RawValue,
    193     basis: PositiveDecimal,
    194     #[serde(borrow)]
    195     maximum_total: &'a RawValue,
    196 }
    197 fn measurement_unit(value: &str) -> Result<MeasurementUnit, TermsWireError> {
    198     match value {
    199         "g" => Ok(MeasurementUnit::Gram),
    200         "kg" => Ok(MeasurementUnit::Kilogram),
    201         "mL" => Ok(MeasurementUnit::Millilitre),
    202         "L" => Ok(MeasurementUnit::Litre),
    203         "each" => Ok(MeasurementUnit::Each),
    204         _ => Err(TermsWireError::UnsupportedProfile),
    205     }
    206 }
    207 fn price(raw: &RawValue) -> Result<AgreementPrice, TermsWireError> {
    208     let tag: Tag = parse(raw)?;
    209     match tag.kind.as_str() {
    210         "fixed" => {
    211             let value: RawFixed<'_> = parse(raw)?;
    212             if value.kind != "fixed" {
    213                 return Err(TermsWireError::InvalidInput);
    214             }
    215             Ok(AgreementPrice::Fixed(AgreedFixedPrice::new(
    216                 money(value.rate)?,
    217                 value.basis,
    218                 invalid(DiscountBps::new(value.discount_bps))?,
    219                 value.selected_tier_from,
    220             )))
    221         }
    222         "variable_weight" => {
    223             let value: RawVariable<'_> = parse(raw)?;
    224             if value.kind != "variable_weight" {
    225                 return Err(TermsWireError::InvalidInput);
    226             }
    227             Ok(AgreementPrice::VariableWeight(invalid(
    228                 VariableWeight::new(
    229                     measurement_unit(&value.measurement_unit)?,
    230                     value.minimum,
    231                     value.maximum,
    232                     money(value.rate)?,
    233                     value.basis,
    234                     money(value.maximum_total)?,
    235                 ),
    236             )?))
    237         }
    238         _ => Err(TermsWireError::UnsupportedProfile),
    239     }
    240 }
    241 #[derive(Deserialize)]
    242 #[serde(deny_unknown_fields)]
    243 struct RawGroup<'a> {
    244     id: FulfillmentGroupId,
    245     #[serde(borrow)]
    246     terms: &'a RawValue,
    247 }
    248 #[derive(Deserialize)]
    249 #[serde(deny_unknown_fields)]
    250 struct RawFulfillment<'a> {
    251     mode: String,
    252     #[serde(borrow)]
    253     window: &'a RawValue,
    254     #[serde(borrow)]
    255     address: &'a RawValue,
    256     #[serde(borrow)]
    257     instructions: &'a RawValue,
    258     #[serde(borrow, deserialize_with = "required_nullable")]
    259     contact: Option<&'a RawValue>,
    260 }
    261 fn group(raw: &RawValue) -> Result<FulfillmentGroup, TermsWireError> {
    262     let value: RawGroup<'_> = parse(raw)?;
    263     let terms: RawFulfillment<'_> = parse(value.terms)?;
    264     let address = text::decode(terms.address.get(), 2048).map_err(command_error)?;
    265     let instructions = text::decode(terms.instructions.get(), 2048).map_err(command_error)?;
    266     let contact = terms
    267         .contact
    268         .map(|v| text::decode(v.get(), 256).map_err(command_error))
    269         .transpose()?;
    270     Ok(FulfillmentGroup::new(
    271         value.id,
    272         invalid(PrivateFulfillment::new(
    273             match terms.mode.as_str() {
    274                 "pickup" => FulfillmentMode::Pickup,
    275                 "delivery" => FulfillmentMode::Delivery,
    276                 _ => return Err(TermsWireError::UnsupportedProfile),
    277             },
    278             window(terms.window)?,
    279             &address,
    280             &instructions,
    281             contact.as_deref().map(String::as_str),
    282         ))?,
    283     ))
    284 }
    285 #[derive(Deserialize)]
    286 #[serde(deny_unknown_fields)]
    287 struct RawWindow<'a> {
    288     start: UnixSeconds,
    289     end: UnixSeconds,
    290     #[serde(borrow)]
    291     timezone: &'a RawValue,
    292 }
    293 pub(crate) fn window(raw: &RawValue) -> Result<Window, TermsWireError> {
    294     let value: RawWindow<'_> = parse(raw)?;
    295     let zone = text::decode(value.timezone.get(), 80).map_err(command_error)?;
    296     invalid(Window::new(
    297         value.start,
    298         value.end,
    299         invalid(TimeZoneId::from_name(&zone))?,
    300     ))
    301 }
    302 #[derive(Deserialize)]
    303 #[serde(deny_unknown_fields)]
    304 struct Stock {
    305     #[serde(rename = "type")]
    306     kind: String,
    307 }
    308 #[derive(Deserialize)]
    309 #[serde(deny_unknown_fields)]
    310 struct Future<'a> {
    311     #[serde(rename = "type")]
    312     kind: String,
    313     #[serde(borrow)]
    314     expected_window: &'a RawValue,
    315     #[serde(borrow)]
    316     risk_disclosure: &'a RawValue,
    317 }
    318 fn supply(raw: &RawValue) -> Result<SupplyCommitment, TermsWireError> {
    319     let tag: Tag = parse(raw)?;
    320     match tag.kind.as_str() {
    321         "stock_backed" => {
    322             let value: Stock = parse(raw)?;
    323             if value.kind != "stock_backed" {
    324                 return Err(TermsWireError::InvalidInput);
    325             }
    326             Ok(SupplyCommitment::StockBacked)
    327         }
    328         "future_promise" => {
    329             let value: Future<'_> = parse(raw)?;
    330             if value.kind != "future_promise" {
    331                 return Err(TermsWireError::InvalidInput);
    332             }
    333             let risk = text::decode(value.risk_disclosure.get(), 512).map_err(command_error)?;
    334             Ok(SupplyCommitment::FuturePromise(invalid(
    335                 FuturePromise::new(window(value.expected_window)?, &risk),
    336             )?))
    337         }
    338         _ => Err(TermsWireError::UnsupportedProfile),
    339     }
    340 }