From e2331d34b56b48c715539df1eddcaed176ef2197 Mon Sep 17 00:00:00 2001
From: Matthew LeVan <matthew@coeli.network>
Date: Tue, 3 Oct 2023 16:57:39 -0400
Subject: [PATCH] jets: add `shax`

---
 rust/ares/src/jets/crypto.rs | 65 +++++++++++++++++++++++++++++++++++-
 rust/ares/src/noun.rs        |  4 +++
 2 files changed, 68 insertions(+), 1 deletion(-)

diff --git a/rust/ares/src/jets/crypto.rs b/rust/ares/src/jets/crypto.rs
index 2e9361631..a0f1a8bb9 100644
--- a/rust/ares/src/jets/crypto.rs
+++ b/rust/ares/src/jets/crypto.rs
@@ -3,11 +3,49 @@ use crate::jets::util::{met, slot};
 use crate::jets::{JetErr, Result};
 use crate::mem::NockStack;
 use crate::newt::Newt;
-use crate::noun::{IndirectAtom, Noun};
+use crate::noun::{DirectAtom, IndirectAtom, Noun};
 use urcrypt_sys::*;
 
 crate::gdb!();
 
+pub fn jet_shas(stack: &mut NockStack, _newt: &mut Option<&mut Newt>, subject: Noun) -> Result {
+    let sam = slot(subject, 6)?;
+    let sal = slot(sam, 2)?.as_atom()?;
+    let ruz= slot(sam, 3)?.as_atom()?;
+
+    let mut sdc: DirectAtom;
+    let mut sic: IndirectAtom;
+    let salt = match sal.as_either() {
+        Left(direct) => {
+            sdc = direct.clone();
+            sdc.as_byteslice_mut()
+        }
+        Right(indirect) => {
+            sic = indirect.clone();
+            sic.as_mut_bytes()
+        }
+    };
+
+    let mdc: DirectAtom;
+    let mic: IndirectAtom;
+    let message = match ruz.as_either() {
+        Left(direct) => {
+            mdc = direct.clone();
+            mdc.as_byteslice()
+        }
+        Right(indirect) => {
+            mic = indirect.clone();
+            mic.as_bytes()
+        }
+    };
+
+    unsafe {
+        let (mut ida, out) = IndirectAtom::new_raw_mut_bytes(stack, 32);
+        urcrypt_shas(salt.as_mut_ptr(), salt.len(), message.as_ptr(), message.len(), out.as_mut_ptr());
+        Ok(ida.normalize_as_atom().as_noun())
+    }
+}
+
 pub fn jet_shax(stack: &mut NockStack, _newt: &mut Option<&mut Newt>, subject: Noun) -> Result {
     let sam = slot(subject, 6)?;
     let a = sam.as_atom()?;
@@ -124,5 +162,30 @@ mod tests {
             D(123456789),
             ubig!(_0xa1d6eb6ef33f233ae6980ca7c4fc65f90fe1bdee11c730d41607b4747c83de72)
         );
+
+        // TODO test indirect atoms
+    }
+
+    #[test]
+    fn test_shas() {
+        let s = &mut init_stack();
+
+        let sam = T(s, &[D(1), D(1)]);
+        assert_jet_ubig(
+            s,
+            jet_shas,
+            sam,
+            ubig!(_0x547da92584bc986e5784edb746c29504bfd6b34572c83b7b96440ca77d35cdfc)
+        );
+
+        let sam = T(s, &[D(2), D(2)]);
+        assert_jet_ubig(
+            s,
+            jet_shas,
+            sam,
+            ubig!(_0x4cf01fe7cc56ef70d17735322488de0d31857afcfe451e199abe6295f78f5328)
+        );
+
+        // TODO test indirect atoms
     }
 }
diff --git a/rust/ares/src/noun.rs b/rust/ares/src/noun.rs
index 197a7fe50..6dbef6f82 100644
--- a/rust/ares/src/noun.rs
+++ b/rust/ares/src/noun.rs
@@ -411,6 +411,10 @@ impl IndirectAtom {
         unsafe { from_raw_parts(self.data_pointer() as *const u8, self.size() << 3) }
     }
 
+    pub fn as_mut_bytes(&mut self) -> &mut [u8] {
+        unsafe { from_raw_parts_mut(self.data_pointer_mut() as *mut u8, self.size() << 3) }
+    }
+
     /** BitSlice view on an indirect atom, with lifetime tied to reference to indirect atom. */
     pub fn as_bitslice(&self) -> &BitSlice<u64, Lsb0> {
         BitSlice::from_slice(self.as_slice())