From 1bc092b063766410bfac904ef621151f5b1ab6d2 Mon Sep 17 00:00:00 2001
From: Florian Klink <flokli@flokli.de>
Date: Mon, 21 Oct 2024 14:23:18 +0200
Subject: [PATCH] refactor(tvix/castore/digest): stop using bytes::Bytes
 internally

Change-Id: I07a13da0ae4aee4298025fca4345d738f40cfe5a
Reviewed-on: https://cl.tvl.fyi/c/depot/+/12757
Reviewed-by: Ilan Joselevich <personal@ilanjoselevich.com>
Reviewed-by: edef <edef@edef.eu>
Tested-by: BuildkiteCI
---
 tvix/castore/src/digests.rs | 49 +++++++++++++++++++------------------
 1 file changed, 25 insertions(+), 24 deletions(-)

diff --git a/tvix/castore/src/digests.rs b/tvix/castore/src/digests.rs
index 4d919ff0d..6c9104582 100644
--- a/tvix/castore/src/digests.rs
+++ b/tvix/castore/src/digests.rs
@@ -2,8 +2,10 @@ use bytes::Bytes;
 use data_encoding::BASE64;
 use thiserror::Error;
 
+pub const B3_LEN: usize = blake3::OUT_LEN;
+
 #[derive(PartialEq, Eq, Hash)]
-pub struct B3Digest(Bytes);
+pub struct B3Digest([u8; B3_LEN]);
 
 // TODO: allow converting these errors to crate::Error
 #[derive(Error, Debug, PartialEq)]
@@ -12,8 +14,6 @@ pub enum Error {
     InvalidDigestLen(usize),
 }
 
-pub const B3_LEN: usize = 32;
-
 impl B3Digest {
     pub fn as_slice(&self) -> &[u8] {
         &self.0[..]
@@ -22,59 +22,60 @@ impl B3Digest {
 
 impl From<B3Digest> for bytes::Bytes {
     fn from(val: B3Digest) -> Self {
-        val.0
+        Bytes::copy_from_slice(&val.0)
     }
 }
 
 impl From<blake3::Hash> for B3Digest {
     fn from(value: blake3::Hash) -> Self {
-        Self(Bytes::copy_from_slice(value.as_bytes()))
+        Self(*value.as_bytes())
     }
 }
 impl From<digest::Output<blake3::Hasher>> for B3Digest {
     fn from(value: digest::Output<blake3::Hasher>) -> Self {
-        let v = Into::<[u8; B3_LEN]>::into(value);
-        Self(Bytes::copy_from_slice(&v))
+        Self(value.into())
     }
 }
 
-impl TryFrom<Vec<u8>> for B3Digest {
+impl TryFrom<&[u8]> for B3Digest {
     type Error = Error;
 
-    // constructs a [B3Digest] from a [Vec<u8>].
+    // constructs a [B3Digest] from a &[u8].
     // Returns an error if the digest has the wrong length.
-    fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {
-        if value.len() != B3_LEN {
-            Err(Error::InvalidDigestLen(value.len()))
-        } else {
-            Ok(Self(value.into()))
-        }
+    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
+        Ok(Self(
+            value
+                .try_into()
+                .map_err(|_e| Error::InvalidDigestLen(value.len()))?,
+        ))
     }
 }
 
 impl TryFrom<bytes::Bytes> for B3Digest {
     type Error = Error;
 
-    // constructs a [B3Digest] from a [bytes::Bytes].
-    // Returns an error if the digest has the wrong length.
     fn try_from(value: bytes::Bytes) -> Result<Self, Self::Error> {
-        if value.len() != B3_LEN {
-            Err(Error::InvalidDigestLen(value.len()))
-        } else {
-            Ok(Self(value))
-        }
+        value[..].try_into()
+    }
+}
+
+impl TryFrom<Vec<u8>> for B3Digest {
+    type Error = Error;
+
+    fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {
+        value[..].try_into()
     }
 }
 
 impl From<&[u8; B3_LEN]> for B3Digest {
     fn from(value: &[u8; B3_LEN]) -> Self {
-        Self(value.to_vec().into())
+        Self(*value)
     }
 }
 
 impl From<B3Digest> for [u8; B3_LEN] {
     fn from(value: B3Digest) -> Self {
-        value.0.to_vec().try_into().unwrap()
+        value.0
     }
 }