0.7.28 - final

kb_lib/src/token_metadata.rs

@@ -677,59 +677,16 @@ fn clean_metaplex_string(value: &str) -> std::option::Option<std::string::String
 }
 
 fn decode_base64_standard(text: &str) -> Result<std::vec::Vec<u8>, crate::Error> {
-    let mut output = std::vec::Vec::new();
-    let mut group = [0u8; 4];
-    let mut group_len = 0usize;
-    let mut padding_count = 0usize;
-    for byte in text.bytes() {
-        if byte == b'\r' || byte == b'\n' || byte == b'\t' || byte == b' ' {
-            continue;
-        }
-        let value_option = base64_value(byte);
-        let value = match value_option {
-            Some(value) => value,
-            None => {
-                return Err(crate::Error::Json(format!(
-                    "invalid base64 character '{}'",
-                    byte as char
-                )));
-            },
-        };
-        if byte == b'=' {
-            padding_count += 1;
-        }
-        group[group_len] = value;
-        group_len += 1;
-        if group_len == 4 {
-            output.push((group[0] << 2) | (group[1] >> 4));
-            if padding_count < 2 {
-                output.push((group[1] << 4) | (group[2] >> 2));
-            }
-            if padding_count == 0 {
-                output.push((group[2] << 6) | group[3]);
-            }
-            group = [0u8; 4];
-            group_len = 0;
-            padding_count = 0;
-        }
-    }
-    if group_len != 0 {
-        return Err(crate::Error::Json(
-            "invalid base64 length: trailing partial group".to_string(),
-        ));
-    }
-    return Ok(output);
-}
-
-fn base64_value(byte: u8) -> std::option::Option<u8> {
-    match byte {
-        b'A'..=b'Z' => return Some(byte - b'A'),
-        b'a'..=b'z' => return Some(byte - b'a' + 26),
-        b'0'..=b'9' => return Some(byte - b'0' + 52),
-        b'+' => return Some(62),
-        b'/' => return Some(63),
-        b'=' => return Some(0),
-        _ => return None,
+    use base64::Engine;
+    let decoded_result = base64::engine::general_purpose::STANDARD.decode(text);
+    match decoded_result {
+        Ok(decoded) => return Ok(decoded),
+        Err(error) => {
+            return Err(crate::Error::Json(format!(
+                "cannot decode standard base64 payload: {}",
+                error
+            )));
+        },
     }
 }