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 }