fix: align counter codes with CESR V2 specification

mitfik · mitfik · commit 9d6da4a29012 · 2026-04-17T12:23:23.000+02:00
Revert V1 alignment and off-by-one commits, restore correct V2 codes: Universal codes (unchanged): A=GenericPipeline, C=Attachments, E=ESSR Group codes: K=ControllerIdxSigs, L=WitnessIdxSigs, M=NonTransReceipt, O=FirstSeenReplay, S=SealSourceCouples, T=AnchoringEventSeals, P=PathedMaterial, Z=TSPPayload Fix S/T swap: SealSourceCouples is -S (was -T), AnchoringEventSeals is -T (was -S), matching the published spec at https://trustoverip.github.io/kswg-cesr-specification/
diff --git a/cesr/src/group/codes.rs b/cesr/src/group/codes.rs
@@ -35,14 +35,14 @@ impl DerivationCode for GroupCode {
 
     fn to_str(&self) -> String {
         let (code, count) = match self {
-            GroupCode::IndexedControllerSignatures(count) => ("-A", count),
-            GroupCode::IndexedWitnessSignatures(count) => ("-B", count),
-            GroupCode::NontransferableReceiptCouples(count) => ("-C", count),
-            GroupCode::FirstSeenReplyCouples(count) => ("-E", count),
-            GroupCode::SealSourceCouples(count) => ("-G", count),
-            GroupCode::AnchoringEventSeals(count) => ("-I", count),
+            GroupCode::IndexedControllerSignatures(count) => ("-K", count),
+            GroupCode::IndexedWitnessSignatures(count) => ("-L", count),
+            GroupCode::NontransferableReceiptCouples(count) => ("-M", count),
+            GroupCode::FirstSeenReplyCouples(count) => ("-O", count),
+            GroupCode::SealSourceCouples(count) => ("-S", count),
+            GroupCode::AnchoringEventSeals(count) => ("-T", count),
             #[cfg(feature = "cesr-proof")]
-            GroupCode::PathedMaterialQuadruple(len) => ("-L", len),
+            GroupCode::PathedMaterialQuadruple(len) => ("-P", len),
             GroupCode::TSPPayload(len) => ("-Z", len),
         };
         [code, &adjust_with_num(count.to_owned(), self.soft_size())].join("")
@@ -57,14 +57,21 @@ impl FromStr for GroupCode {
         let count_part = s.get(2..4).ok_or(Error::EmptyCodeError)?;
         let count = b64_to_num(count_part)?;
         match code {
-            "-A" => Ok(Self::IndexedControllerSignatures(count)),
-            "-B" => Ok(Self::IndexedWitnessSignatures(count)),
-            "-C" => Ok(Self::NontransferableReceiptCouples(count)),
-            "-E" => Ok(Self::FirstSeenReplyCouples(count)),
-            "-G" => Ok(Self::SealSourceCouples(count)),
-            "-I" => Ok(Self::AnchoringEventSeals(count)),
+            "-K" => Ok(Self::IndexedControllerSignatures(count)),
+            "-L" => Ok(Self::IndexedWitnessSignatures(count)),
+            "-M" => Ok(Self::NontransferableReceiptCouples(count)),
+            "-N" => todo!(),
+            "-O" => Ok(Self::FirstSeenReplyCouples(count)),
             #[cfg(feature = "cesr-proof")]
-            "-L" => Ok(Self::PathedMaterialQuadruple(count)),
+            "-P" => Ok(Self::PathedMaterialQuadruple(count)),
+            "-R" => todo!(),
+            "-S" => Ok(Self::SealSourceCouples(count)),
+            "-T" => Ok(Self::AnchoringEventSeals(count)),
+            "-U" => todo!(),
+            "-V" => todo!(),
+            "-W" => todo!(),
+            "-X" => todo!(),
+            "-Y" => todo!(),
             "-Z" => Ok(Self::TSPPayload(count)),
             _ => Err(Error::UnknownCodeError),
         }
@@ -73,28 +80,28 @@ impl FromStr for GroupCode {
 
 #[test]
 pub fn test_group_codes_to_str() -> Result<(), Error> {
-    assert_eq!(GroupCode::IndexedControllerSignatures(3).to_str(), "-AAD");
-    assert_eq!(GroupCode::IndexedWitnessSignatures(30).to_str(), "-BAe");
+    assert_eq!(GroupCode::IndexedControllerSignatures(3).to_str(), "-KAD");
+    assert_eq!(GroupCode::IndexedWitnessSignatures(30).to_str(), "-LAe");
     assert_eq!(
         GroupCode::NontransferableReceiptCouples(100).to_str(),
-        "-CBk"
+        "-MBk"
     );
-    assert_eq!(GroupCode::FirstSeenReplyCouples(127).to_str(), "-EB_");
-    assert_eq!(GroupCode::AnchoringEventSeals(4095).to_str(), "-I__");
-    assert_eq!(GroupCode::SealSourceCouples(0).to_str(), "-GAA");
+    assert_eq!(GroupCode::FirstSeenReplyCouples(127).to_str(), "-OB_");
+    assert_eq!(GroupCode::SealSourceCouples(0).to_str(), "-SAA");
+    assert_eq!(GroupCode::AnchoringEventSeals(4095).to_str(), "-T__");
     Ok(())
 }
 
 #[test]
 pub fn test_group_codes_from_str() -> Result<(), Error> {
-    assert_eq!(GroupCode::IndexedControllerSignatures(3), "-AAD".parse()?);
-    assert_eq!(GroupCode::IndexedWitnessSignatures(30), "-BAe".parse()?);
+    assert_eq!(GroupCode::IndexedControllerSignatures(3), "-KAD".parse()?);
+    assert_eq!(GroupCode::IndexedWitnessSignatures(30), "-LAe".parse()?);
     assert_eq!(
         GroupCode::NontransferableReceiptCouples(100),
-        "-CBk".parse()?
+        "-MBk".parse()?
     );
-    assert_eq!(GroupCode::AnchoringEventSeals(4095), "-I__".parse()?);
-    assert_eq!(GroupCode::FirstSeenReplyCouples(127), "-EB_".parse()?);
-    assert_eq!(GroupCode::SealSourceCouples(0), "-GAA".parse()?);
+    assert_eq!(GroupCode::SealSourceCouples(0), "-SAA".parse()?);
+    assert_eq!(GroupCode::FirstSeenReplyCouples(127), "-OB_".parse()?);
+    assert_eq!(GroupCode::AnchoringEventSeals(4095), "-T__".parse()?);
     Ok(())
 }
diff --git a/cesr/src/group/parsers.rs b/cesr/src/group/parsers.rs
@@ -29,6 +29,15 @@ pub fn group_code(s: &str) -> nom::IResult<&str, GroupCode> {
 }
 
 pub fn parse_group(stream: &str) -> nom::IResult<&str, Group> {
+    // let first_byte = stream
+    //     .first()
+    //     .ok_or(nom::Err::Error(make_error(stream, ErrorKind::Eof)))?;
+    // let first_three_bits = check_first_three_bits(first_byte);
+    // if !(first_three_bits == 0b111 || first_three_bits == 0b001 || first_three_bits == 0b010) {
+    //     // It's not attachment
+    //     return Err(nom::Err::Error(make_error(stream, ErrorKind::IsNot)));
+    // }
+
     let (rest, group_code) = group_code(stream)?;
     Ok(match group_code {
         GroupCode::IndexedControllerSignatures(n) => {
@@ -112,7 +121,7 @@ pub fn parse_group(stream: &str) -> nom::IResult<&str, Group> {
 #[test]
 pub fn test_parse_group() {
     use crate::primitives::Timestamp;
-    let group_str = "-EAB0AAAAAAAAAAAAAAAAAAAAAAA1AAG2022-10-25T12c04c30d175309p00c00";
+    let group_str = "-OAB0AAAAAAAAAAAAAAAAAAAAAAA1AAG2022-10-25T12c04c30d175309p00c00";
     let (_rest, group) = parse_group(group_str).unwrap();
     let expected = (
         0,
@@ -128,7 +137,7 @@ pub fn test_parse_group() {
 fn test_pathed_material() {
     use crate::cesr_proof::MaterialPath;
 
-    let attached_str = "-LAZ5AABAA-a-AABAAFjjD99-xy7J0LGmCkSE_zYceED5uPF4q7l8J23nNQ64U-oWWulHI5dh3cFDWT4eICuEQCALdh8BO5ps-qx0qBA";
+    let attached_str = "-PAZ5AABAA-a-KABAAFjjD99-xy7J0LGmCkSE_zYceED5uPF4q7l8J23nNQ64U-oWWulHI5dh3cFDWT4eICuEQCALdh8BO5ps-qx0qBA";
     let (_rest, attached_material) = parse_group(attached_str).unwrap();
     let expected_path = MaterialPath::create_from_str("-a".into());
     if let Group::PathedMaterialQuadruplet(material_path, groups) = attached_material {
diff --git a/cesr/src/universal_codes.rs b/cesr/src/universal_codes.rs
@@ -46,7 +46,7 @@ impl FromStr for UniversalGroupCode {
                 let group_code = GenusCountCode::from_str(genus_code)?;
                 Ok(Self::Genus(group_code))
             }
-            'T' | 'V' => {
+            'A' | 'B' | 'C' => {
                 let length = s.get(1..3).ok_or(Error::EmptyCodeError)?;
                 let quadlets = b64_to_num(length)?;
                 let special_code = CustomizableCode::from_str(&code.to_string())?;
@@ -150,8 +150,8 @@ impl FromStr for CustomizableCode {
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let code = s.get(..1).ok_or(Error::EmptyCodeError)?;
         match code {
-            "T" => Ok(Self::GenericPipeline),
-            "V" => Ok(Self::Attachments),
+            "A" => Ok(Self::GenericPipeline),
+            "C" => Ok(Self::Attachments),
             _ => Err(Error::UnknownCodeError),
         }
     }
@@ -160,8 +160,8 @@ impl FromStr for CustomizableCode {
 impl Display for CustomizableCode {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            CustomizableCode::GenericPipeline => write!(f, "T"),
-            CustomizableCode::Attachments => write!(f, "V"),
+            CustomizableCode::GenericPipeline => write!(f, "A"),
+            CustomizableCode::Attachments => write!(f, "C"),
         }
     }
 }
@@ -178,7 +178,7 @@ impl FromStr for FixedCode {
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let code = s.get(..1).ok_or(Error::EmptyCodeError)?;
         match code {
-            "Z" => Ok(Self::Essr),
+            "E" => Ok(Self::Essr),
             _ => Err(Error::UnknownCodeError),
         }
     }
@@ -187,7 +187,7 @@ impl FromStr for FixedCode {
 impl Display for FixedCode {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            FixedCode::Essr => write!(f, "Z"),
+            FixedCode::Essr => write!(f, "E"),
         }
     }
 }
diff --git a/cesr/src/value.rs b/cesr/src/value.rs
@@ -49,7 +49,7 @@ pub fn parse_value(stream: &str) -> IResult<&str, Value> {
                     let (rest, genus) = genus_code(rest)?;
                     Ok((rest, Value::VersionGenus(genus)))
                 }
-                'T' | 'V' => {
+                'A' | 'B' | 'C' | 'E' => {
                     // Universal group code
                     let (rest, group_code) = short_universal_group_code(rest)?;
                     let length = group_code.value_size();
@@ -134,7 +134,7 @@ mod tests {
 
     #[test]
     fn test_parse_controller_signatures() {
-        let stream = "-AABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
+        let stream = "-KABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
         let (_, val) = parse_value(stream).unwrap();
         let expected_val = Value::SpecificGroup(Group::IndexedControllerSignatures(vec![(
             AttachedSignatureCode {
@@ -146,7 +146,7 @@ mod tests {
         assert_eq!(val, expected_val);
         assert_eq!(val.to_string(), stream);
 
-        let stream = "-AACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
+        let stream = "-KACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
         let (_rest, val) = parse_value(stream).unwrap();
         let expected_val = Value::SpecificGroup(Group::IndexedControllerSignatures(vec![
             (
@@ -167,7 +167,7 @@ mod tests {
         assert_eq!(val, expected_val);
         assert_eq!(val.to_string(), stream);
 
-        let stream_with_extra_data = "-AACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAextra data";
+        let stream_with_extra_data = "-KACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAextra data";
         let (rest, val) = parse_value(stream_with_extra_data).unwrap();
         let expected_val = Value::SpecificGroup(Group::IndexedControllerSignatures(vec![
             (
@@ -192,12 +192,12 @@ mod tests {
             stream_with_extra_data[..stream_with_extra_data.len() - 10]
         );
 
-        assert!(parse_value("-AABAA0Q7bqPvenjWXo_YIikMBKOg-pghLKwBi1Plm0PEqdv67L1_c6dq9bll7OFnoLp0a74Nw1cBGdjIPcu-yAllHAw").is_ok());
+        assert!(parse_value("-KABAA0Q7bqPvenjWXo_YIikMBKOg-pghLKwBi1Plm0PEqdv67L1_c6dq9bll7OFnoLp0a74Nw1cBGdjIPcu-yAllHAw").is_ok());
     }
 
     #[test]
     fn test_parse_groups() {
-        let attached_str = "-GAC0AAAAAAAAAAAAAAAAAAAAAABEJtQndkvwnMpVGE5oVVbLWSCm-jLviGw1AOOkzBvNwsS0AAAAAAAAAAAAAAAAAAAAAABEJtQndkvwnMpVGE5oVVbLWSCm-jLviGw1AOOkzBvNwsS";
+        let attached_str = "-SAC0AAAAAAAAAAAAAAAAAAAAAABEJtQndkvwnMpVGE5oVVbLWSCm-jLviGw1AOOkzBvNwsS0AAAAAAAAAAAAAAAAAAAAAABEJtQndkvwnMpVGE5oVVbLWSCm-jLviGw1AOOkzBvNwsS";
         let (_rest, attached_sn_dig) = parse_value(attached_str).unwrap();
         let expected_value = Value::SpecificGroup(Group::SourceSealCouples(vec![
             (
@@ -224,7 +224,7 @@ mod tests {
         assert_eq!(attached_sn_dig, expected_value);
         assert_eq!(attached_sn_dig.to_string(), attached_str);
 
-        let attached_str = "-IABEKC8085pwSwzLwUGzh-HrEoFDwZnCJq27bVp5atdMT9o0AAAAAAAAAAAAAAAAAAAAAAAEKC8085pwSwzLwUGzh-HrEoFDwZnCJq27bVp5atdMT9o-AABAABB5IVZOhEfcH4TBQgOCyMgyQrJujtBBjT8K_zTPk0-FLMtTZuBgXV7jnLw6fDe6FWtzshh2HGCL_H_j4i1b9kF";
+        let attached_str = "-TABEKC8085pwSwzLwUGzh-HrEoFDwZnCJq27bVp5atdMT9o0AAAAAAAAAAAAAAAAAAAAAAAEKC8085pwSwzLwUGzh-HrEoFDwZnCJq27bVp5atdMT9o-KABAABB5IVZOhEfcH4TBQgOCyMgyQrJujtBBjT8K_zTPk0-FLMtTZuBgXV7jnLw6fDe6FWtzshh2HGCL_H_j4i1b9kF";
         let (rest, value) = parse_value(attached_str).unwrap();
         let expected_value_1 = Value::SpecificGroup(Group::AnchoringSeals(vec![(
             (
@@ -264,7 +264,7 @@ mod tests {
         assert_eq!(value, expected_value_2);
         assert_eq!(value.to_string(), attached_str[116..]);
 
-        let attached_str = "-CABBMrwi0a-Zblpqe5Hg7w7iz9JCKnMgWKu_W9w4aNUL64y0BB6cL0DtDVDW26lgjbQu0_D_Pd_6ovBZj6fU-Qjmm7epVs51jEOOwXKbmG4yUvCSN-DQSYSc7HXZRp8CfAw9DQL";
+        let attached_str = "-MABBMrwi0a-Zblpqe5Hg7w7iz9JCKnMgWKu_W9w4aNUL64y0BB6cL0DtDVDW26lgjbQu0_D_Pd_6ovBZj6fU-Qjmm7epVs51jEOOwXKbmG4yUvCSN-DQSYSc7HXZRp8CfAw9DQL";
         let (_rest, value) = parse_value(attached_str).unwrap();
         let expected_value = Value::SpecificGroup(Group::NontransReceiptCouples(vec![(
             (
@@ -288,7 +288,7 @@ mod tests {
         assert_eq!(value, expected_value);
         assert_eq!(value.to_string(), attached_str);
 
-        let cesr_attachment = "-AABAAB6P97kZ3al3V3z3VstRtHRPeOrotuqZZUgBl2yHzgpGyOjAXYGinVqWLAMhdmQ089FTSAzqSTBmJzI8RvIezsJ";
+        let cesr_attachment = "-KABAAB6P97kZ3al3V3z3VstRtHRPeOrotuqZZUgBl2yHzgpGyOjAXYGinVqWLAMhdmQ089FTSAzqSTBmJzI8RvIezsJ";
         let (_rest, value) = parse_value(cesr_attachment).unwrap();
         let expected_value = Value::SpecificGroup(Group::IndexedControllerSignatures(vec![(
             AttachedSignatureCode {
@@ -325,7 +325,7 @@ mod tests {
 
     #[test]
     fn test_parse_nested() {
-        let input = "-TAX-AABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
+        let input = "-AAX-KABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
         let (rest, value) = parse_value(input).unwrap();
         match &value {
             Value::UniversalGroup(
@@ -357,7 +357,7 @@ mod tests {
 
     #[test]
     fn test_parse_stream() {
-        let input = r#"{"hello":"world"}-TAX-AABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"#;
+        let input = r#"{"hello":"world"}-AAX-KABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"#;
         let (rest, value) = nom::multi::many0(parse_value)(input).unwrap();
         assert!(rest.is_empty());
         assert_eq!(value.len(), 2);
diff --git a/cesr/tests/client.rs b/cesr/tests/client.rs
@@ -11,7 +11,7 @@ pub mod test {
 
     #[test]
     pub fn test_hello_cesr() {
-        let cesr_stream = r#"{"name":"John","surname":"Doe"}-CABBPKahcQ56qkcaTNiGjNYUCQyfM3u-NEymzPv6tKFYthx0BC9uKulSSZ6Ta30reEA4kImQBu-wZ4hISXoSSOGKB0lBIpkLaBMjVS16A_KMsxBtE6VbL1Ry9FHJAg7ygdZbqkK"#;
+        let cesr_stream = r#"{"name":"John","surname":"Doe"}-MABBPKahcQ56qkcaTNiGjNYUCQyfM3u-NEymzPv6tKFYthx0BC9uKulSSZ6Ta30reEA4kImQBu-wZ4hISXoSSOGKB0lBIpkLaBMjVS16A_KMsxBtE6VbL1Ry9FHJAg7ygdZbqkK"#;
 
         let (_rest, values) = parse_all(cesr_stream).unwrap();
         assert_eq!(values.len(), 2);
@@ -71,7 +71,7 @@ pub mod test {
 
         assert_eq!(
             &cesr_stream,
-            r#"{"name":"John","surname":"Doe"}-CABBNdamAGCsQq31Uv-08lkBzoO4XLz2qYjJa8CGmj3B1Ea0BDkGKpYn5i5fhRrE57RGGonHMlwmfZBmsIAex6rPXuZqScZY3NPdyP60fDHmGjLy7kQj04vZsFBAyid1XOJxBgG"#
+            r#"{"name":"John","surname":"Doe"}-MABBNdamAGCsQq31Uv-08lkBzoO4XLz2qYjJa8CGmj3B1Ea0BDkGKpYn5i5fhRrE57RGGonHMlwmfZBmsIAex6rPXuZqScZY3NPdyP60fDHmGjLy7kQj04vZsFBAyid1XOJxBgG"#
         );
 
         let (_rest, parsed_data) = parse_all(&cesr_stream).unwrap();
@@ -82,19 +82,19 @@ pub mod test {
 
     #[test]
     fn test_incomplete_stream() {
-        let cesr_stream = r#"{"hello":"world"}-IABEECGIp5CTCJZlZg-kap5Ma04x_tP_xWG90oKRPTW0Geq0AAAAAAAAAAAAAAAAAAAAAAAEECGIp5CTCJZlZg-kap5Ma04x_tP_xWG90oKRPTW0Geq-AABAAArmG_maHPKlUvMXkJfEysM_ej84lWdbtJXYWlrOBkhM1td1idMU0wUIBm5XkaRIw78QmFHUrYoi_kkryhJJy8J-CABBDg3H7Sr-eES0XWXiO8nvMxW6mD_1LxLeE1nuiZxhGp40BBFHf56jD6v15vWezesWY-RPj2ZiXGC-"#;
+        let cesr_stream = r#"{"hello":"world"}-TABEECGIp5CTCJZlZg-kap5Ma04x_tP_xWG90oKRPTW0Geq0AAAAAAAAAAAAAAAAAAAAAAAEECGIp5CTCJZlZg-kap5Ma04x_tP_xWG90oKRPTW0Geq-KABAAArmG_maHPKlUvMXkJfEysM_ej84lWdbtJXYWlrOBkhM1td1idMU0wUIBm5XkaRIw78QmFHUrYoi_kkryhJJy8J-MABBDg3H7Sr-eES0XWXiO8nvMxW6mD_1LxLeE1nuiZxhGp40BBFHf56jD6v15vWezesWY-RPj2ZiXGC-"#;
 
         let (rest, values) = parse_all(cesr_stream).expect("Invalid CESR stream");
         assert_eq!(values.len(), 3);
         assert_eq!(
             rest,
-            "-CABBDg3H7Sr-eES0XWXiO8nvMxW6mD_1LxLeE1nuiZxhGp40BBFHf56jD6v15vWezesWY-RPj2ZiXGC-"
+            "-MABBDg3H7Sr-eES0XWXiO8nvMxW6mD_1LxLeE1nuiZxhGp40BBFHf56jD6v15vWezesWY-RPj2ZiXGC-"
         );
     }
 
     #[test]
     fn test_parse_and_send() {
-        let input = r#"{"v":"KERI10JSON000188_","t":"icp","d":"EJ11vJy_lLwv-lWGZnjhuWUh4EjMQyyMHRH1-uDAxiLg","i":"EJ11vJy_lLwv-lWGZnjhuWUh4EjMQyyMHRH1-uDAxiLg","s":"0","kt":"1","k":["DA4cgeFcpglZf6fQ7u1j8fMs7GbkOQBzVHhBJlaHQLC9"],"nt":"1","n":["EJMujtnS0x3RGp_kHC2bh3p6cAz_4nKp6E3Yrj2u-Lsh"],"bt":"2","b":["BJq7UABlttINuWJh1Xl2lkqZG4NTdUdqnbFJDa6ZyxCC","BDg1zxxf8u4Hx5IPraZzmStfSCZFZbDzMHjqVcFW5OfP"],"c":[],"a":[]}-AABAADZCv1YufmwIvFbzC9jNoVZx2ZgOF8hzrxcuP9vlhJ0tNAYIvNEh0yKIGtkk1bIhrLIAEScbBmxxPosX-rGSAsD-CABBDg1zxxf8u4Hx5IPraZzmStfSCZFZbDzMHjqVcFW5OfP0BCQwOrc3LZqdYs8OEKhQlP4LpB9AqCVpwyGHCB1nfjrBjSYiWtlcvSYI5Vugh3H3rh0gfDqGHUfRKEQrIXKTWAC-CABBJq7UABlttINuWJh1Xl2lkqZG4NTdUdqnbFJDa6ZyxCC0BCO8ycCB9reZHhv7wT4yEAy-q_IFbCA29ttaU3IcQ1tZAIGNKYNkZMY9EjGfRsq8shizeURuoxdYoRXGscQFVQM{"v":"KERI10JSON000160_","t":"rot","d":"EO3KriXb_p3p4dWuG87UIILNR5CsqNClvuc08oRWaAl5","i":"EJ11vJy_lLwv-lWGZnjhuWUh4EjMQyyMHRH1-uDAxiLg","s":"1","p":"EJ11vJy_lLwv-lWGZnjhuWUh4EjMQyyMHRH1-uDAxiLg","kt":"1","k":["BMUt1GfFIZXF_2dI1AGBEdmHjMDsSQOGSORU3igbzSvD"],"nt":"1","n":["ELSdoQmwS1FA2p0d1rlabH8nogFS_-ehA1D45kAmYkkJ"],"bt":"1","br":[],"ba":[],"a":[]}-AABAABXD4O4zkPCDSSTUPCVfFy3fFN4ycOKfUoGd-WOXHflJIGaU137PE6ututuwU8xClsES5ByLw8ytvZw4I1mXRgL-CABBDg1zxxf8u4Hx5IPraZzmStfSCZFZbDzMHjqVcFW5OfP0BCVRmDSy-EvjDxhQXJuUgWw_XhKZ2hxQxsDMxcz9K67Lqy3g9kGevXhlP3bAbmRZ6dmWiyoA_3rYG20LJX7CA4K-CABBJq7UABlttINuWJh1Xl2lkqZG4NTdUdqnbFJDa6ZyxCC0BDLp2_wVt_GWUNSm9BDizNWgyGCPnSXdiM5tObP3dze5ah1Me-laex_xFDozxq5beWT3XZf56pYYsdjUYv_iFsA{"v"#;
+        let input = r#"{"v":"KERI10JSON000188_","t":"icp","d":"EJ11vJy_lLwv-lWGZnjhuWUh4EjMQyyMHRH1-uDAxiLg","i":"EJ11vJy_lLwv-lWGZnjhuWUh4EjMQyyMHRH1-uDAxiLg","s":"0","kt":"1","k":["DA4cgeFcpglZf6fQ7u1j8fMs7GbkOQBzVHhBJlaHQLC9"],"nt":"1","n":["EJMujtnS0x3RGp_kHC2bh3p6cAz_4nKp6E3Yrj2u-Lsh"],"bt":"2","b":["BJq7UABlttINuWJh1Xl2lkqZG4NTdUdqnbFJDa6ZyxCC","BDg1zxxf8u4Hx5IPraZzmStfSCZFZbDzMHjqVcFW5OfP"],"c":[],"a":[]}-KABAADZCv1YufmwIvFbzC9jNoVZx2ZgOF8hzrxcuP9vlhJ0tNAYIvNEh0yKIGtkk1bIhrLIAEScbBmxxPosX-rGSAsD-MABBDg1zxxf8u4Hx5IPraZzmStfSCZFZbDzMHjqVcFW5OfP0BCQwOrc3LZqdYs8OEKhQlP4LpB9AqCVpwyGHCB1nfjrBjSYiWtlcvSYI5Vugh3H3rh0gfDqGHUfRKEQrIXKTWAC-MABBJq7UABlttINuWJh1Xl2lkqZG4NTdUdqnbFJDa6ZyxCC0BCO8ycCB9reZHhv7wT4yEAy-q_IFbCA29ttaU3IcQ1tZAIGNKYNkZMY9EjGfRsq8shizeURuoxdYoRXGscQFVQM{"v":"KERI10JSON000160_","t":"rot","d":"EO3KriXb_p3p4dWuG87UIILNR5CsqNClvuc08oRWaAl5","i":"EJ11vJy_lLwv-lWGZnjhuWUh4EjMQyyMHRH1-uDAxiLg","s":"1","p":"EJ11vJy_lLwv-lWGZnjhuWUh4EjMQyyMHRH1-uDAxiLg","kt":"1","k":["BMUt1GfFIZXF_2dI1AGBEdmHjMDsSQOGSORU3igbzSvD"],"nt":"1","n":["ELSdoQmwS1FA2p0d1rlabH8nogFS_-ehA1D45kAmYkkJ"],"bt":"1","br":[],"ba":[],"a":[]}-KABAABXD4O4zkPCDSSTUPCVfFy3fFN4ycOKfUoGd-WOXHflJIGaU137PE6ututuwU8xClsES5ByLw8ytvZw4I1mXRgL-MABBDg1zxxf8u4Hx5IPraZzmStfSCZFZbDzMHjqVcFW5OfP0BCVRmDSy-EvjDxhQXJuUgWw_XhKZ2hxQxsDMxcz9K67Lqy3g9kGevXhlP3bAbmRZ6dmWiyoA_3rYG20LJX7CA4K-MABBJq7UABlttINuWJh1Xl2lkqZG4NTdUdqnbFJDa6ZyxCC0BDLp2_wVt_GWUNSm9BDizNWgyGCPnSXdiM5tObP3dze5ah1Me-laex_xFDozxq5beWT3XZf56pYYsdjUYv_iFsA{"v"#;
 
         let (tx, rx) = std::sync::mpsc::channel();
 
diff --git a/said/sad_macros/src/field.rs b/said/sad_macros/src/field.rs

Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ impl FromStr for UniversalGroupCode {`
`46`	`46`	`let group_code = GenusCountCode::from_str(genus_code)?;`
`47`	`47`	`Ok(Self::Genus(group_code))`
`48`	`48`	`}`
`49`		`- 'T' \| 'V' => {`
	`49`	`+ 'A' \| 'B' \| 'C' => {`
`50`	`50`	`let length = s.get(1..3).ok_or(Error::EmptyCodeError)?;`
`51`	`51`	`let quadlets = b64_to_num(length)?;`
`52`	`52`	`let special_code = CustomizableCode::from_str(&code.to_string())?;`
`@@ -150,8 +150,8 @@ impl FromStr for CustomizableCode {`
`150`	`150`	`fn from_str(s: &str) -> Result<Self, Self::Err> {`
`151`	`151`	`let code = s.get(..1).ok_or(Error::EmptyCodeError)?;`
`152`	`152`	`match code {`
`153`		`- "T" => Ok(Self::GenericPipeline),`
`154`		`- "V" => Ok(Self::Attachments),`
	`153`	`+ "A" => Ok(Self::GenericPipeline),`
	`154`	`+ "C" => Ok(Self::Attachments),`
`155`	`155`	`_ => Err(Error::UnknownCodeError),`
`156`	`156`	`}`
`157`	`157`	`}`
`@@ -160,8 +160,8 @@ impl FromStr for CustomizableCode {`
`160`	`160`	`impl Display for CustomizableCode {`
`161`	`161`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`162`	`162`	`match self {`
`163`		`- CustomizableCode::GenericPipeline => write!(f, "T"),`
`164`		`- CustomizableCode::Attachments => write!(f, "V"),`
	`163`	`+ CustomizableCode::GenericPipeline => write!(f, "A"),`
	`164`	`+ CustomizableCode::Attachments => write!(f, "C"),`
`165`	`165`	`}`
`166`	`166`	`}`
`167`	`167`	`}`
`@@ -178,7 +178,7 @@ impl FromStr for FixedCode {`
`178`	`178`	`fn from_str(s: &str) -> Result<Self, Self::Err> {`
`179`	`179`	`let code = s.get(..1).ok_or(Error::EmptyCodeError)?;`
`180`	`180`	`match code {`
`181`		`- "Z" => Ok(Self::Essr),`
	`181`	`+ "E" => Ok(Self::Essr),`
`182`	`182`	`_ => Err(Error::UnknownCodeError),`
`183`	`183`	`}`
`184`	`184`	`}`
`@@ -187,7 +187,7 @@ impl FromStr for FixedCode {`
`187`	`187`	`impl Display for FixedCode {`
`188`	`188`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`189`	`189`	`match self {`
`190`		`- FixedCode::Essr => write!(f, "Z"),`
	`190`	`+ FixedCode::Essr => write!(f, "E"),`
`191`	`191`	`}`
`192`	`192`	`}`
`193`	`193`	`}`