CHANGELOG.md

@@ -9,8 +9,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
-- `makeZcashCall` function moved into this library
-- `RpcResponse`, `RpcCall` types moved into this library
 - Functions to decode Sapling transactions
 - Tests for Sapling decoding
 - Type for block response

librustzcash-wrapper/src/lib.rs

@@ -349,7 +349,7 @@ pub extern "C" fn rust_wrapper_ufvk_decode(
 }
 
 #[no_mangle]
-pub extern "C" fn rust_wrapper_sapling_note_decrypt_v2(
+pub extern "C" fn rust_wrapper_sapling_note_decrypt(
     key: *const u8,
     key_len: usize,
     note: *const u8,
@@ -364,10 +364,12 @@ pub extern "C" fn rust_wrapper_sapling_note_decrypt_v2(
     match svk {
         Ok(k) => {
             let domain = SaplingDomain::for_height(MainNetwork, BlockHeight::from_u32(2000000));
-            let action2 = OutputDescription::read(&mut note_reader).unwrap();
+            let action2: Transaction = Transaction::read(&mut note_reader, Nu5).unwrap();
+            let bundle = action2.sapling_bundle().unwrap();
+            let sh_out = bundle.shielded_outputs();
             let fvk = k.to_diversifiable_full_viewing_key().to_ivk(SaplingScope::External);
             let pivk = SaplingPreparedIncomingViewingKey::new(&fvk);
-            let result = zcash_note_encryption::try_note_decryption(&domain, &pivk, &action2);
+            let result = zcash_note_encryption::try_note_decryption(&domain, &pivk, &sh_out[0]);
             match result {
                 Some((n, r, m)) => {
                     let hn = Hnote {note: n.value().inner(), recipient: r.to_bytes().to_vec(), memo: m.as_slice().to_vec() };
@@ -445,15 +447,41 @@ pub extern "C" fn rust_wrapper_tx_parse(
     let parsed_tx = Transaction::read(&mut tx_reader, Nu5);
     match parsed_tx {
         Ok(t) => {
-            let s_bundle = t.sapling_bundle().unwrap().shielded_outputs();
-            let mut s_output = Vec::new();
-            for s_each_out in s_bundle.iter() {
-                let mut out_bytes = Vec::new();
-                let _ = s_each_out.write_v4(&mut out_bytes);
-                s_output.push(out_bytes); 
+            let s_bundle = t.sapling_bundle();
+            let o_bundle = t.orchard_bundle();
+            match s_bundle {
+                Some(sb) => {
+                    let s_o = true;
+                    match o_bundle {
+                        Some(ob) => {
+                            let o_a = true;
+                            let x = HrawTx { bytes: tx_bytes, s: s_o, o: o_a};
+                            marshall_to_haskell_var(&x, out, out_len, RW);
+                        },
+                        None => {
+                            let o_a = false;
+                            let x = HrawTx { bytes: tx_bytes, s: s_o, o: o_a};
+                            marshall_to_haskell_var(&x, out, out_len, RW);
+                        }
+                    }
+
+                },
+                None => {
+                    let s_o = false;
+                    match o_bundle {
+                        Some(ob) => {
+                            let o_a = true;
+                            let x = HrawTx { bytes: tx_bytes, s: s_o, o: o_a};
+                            marshall_to_haskell_var(&x, out, out_len, RW);
+                        },
+                        None => {
+                            let o_a = false;
+                            let x = HrawTx { bytes: tx_bytes, s: s_o, o: o_a};
+                            marshall_to_haskell_var(&x, out, out_len, RW);
+                        }
+                    }
+                }
             }
-            marshall_to_haskell_var(&s_output, out, out_len, RW);
-            //TODO: write array of bytes
 
         },
         Err(_e) => {

src/C/Zcash.chs

@@ -72,7 +72,7 @@ import ZcashHaskell.Types
   -> `Bool'
 #}
 
-{# fun unsafe rust_wrapper_sapling_note_decrypt_v2 as rustWrapperSaplingNoteDecode
+{# fun unsafe rust_wrapper_sapling_note_decrypt as rustWrapperSaplingNoteDecode
     { toBorshVar* `BS.ByteString'&
     , toBorshVar* `BS.ByteString'&
     , getVarBuffer `Buffer DecodedNote'&
@@ -95,9 +95,3 @@ import ZcashHaskell.Types
   -> `()'
 #}
 
-{# fun unsafe rust_wrapper_tx_parse as rustWrapperTxParse
-     { toBorshVar* `BS.ByteString'&
-     , getVarBuffer `Buffer [BS.ByteString]'&
-     }
-  -> `()'
-#}

src/ZcashHaskell/Sapling.hs

@@ -1,5 +1,3 @@
-{-# LANGUAGE OverloadedStrings #-}
-
 module ZcashHaskell.Sapling where
 
 import C.Zcash
@@ -7,25 +5,15 @@ import C.Zcash
   , rustWrapperSaplingCheck
   , rustWrapperSaplingNoteDecode
   , rustWrapperSaplingVkDecode
-  , rustWrapperTxParse
   )
-import Data.Aeson
 import qualified Data.ByteString as BS
 import Foreign.Rust.Marshall.Variable (withPureBorshVarBuffer)
-import ZcashHaskell.Types
-  ( DecodedNote(..)
-  , RawTxResponse(..)
-  , ShieldedOutput(..)
-  , decodeHexText
-  )
+import ZcashHaskell.Types (DecodedNote(..), ShieldedOutput(..))
 
 -- | Check if given bytesting is a valid encoded shielded address
 isValidShieldedAddress :: BS.ByteString -> Bool
 isValidShieldedAddress = rustWrapperIsShielded
 
-getShieldedOutputs :: BS.ByteString -> [BS.ByteString]
-getShieldedOutputs t = withPureBorshVarBuffer $ rustWrapperTxParse t
-
 -- | Check if given bytestring is a valid Sapling viewing key
 isValidSaplingViewingKey :: BS.ByteString -> Bool
 isValidSaplingViewingKey = rustWrapperSaplingVkDecode
@@ -43,17 +31,3 @@ decodeSaplingOutput key out =
   where
     decodedAction =
       withPureBorshVarBuffer $ rustWrapperSaplingNoteDecode key out
-
-instance FromJSON RawTxResponse where
-  parseJSON =
-    withObject "RawTxResponse" $ \obj -> do
-      i <- obj .: "txid"
-      o <- obj .: "orchard"
-      h <- obj .: "hex"
-      a <- o .: "actions"
-      pure $
-        RawTxResponse
-          i
-          (decodeHexText h)
-          (getShieldedOutputs (decodeHexText h))
-          a

src/ZcashHaskell/Types.hs

@@ -103,10 +103,20 @@ instance FromJSON BlockResponse where
 data RawTxResponse = RawTxResponse
   { rt_id :: T.Text
   , rt_hex :: BS.ByteString
-  , rt_shieldedOutputs :: [BS.ByteString]
+  , rt_shieldedOutputs :: [ShieldedOutput]
   , rt_orchardActions :: [OrchardAction]
   } deriving (Prelude.Show, Eq)
 
+instance FromJSON RawTxResponse where
+  parseJSON =
+    withObject "RawTxResponse" $ \obj -> do
+      i <- obj .: "txid"
+      s <- obj .: "vShieldedOutput"
+      o <- obj .: "orchard"
+      h <- obj .: "hex"
+      a <- o .: "actions"
+      pure $ RawTxResponse i (decodeHexText h) s a
+
 -- * Sapling
 -- | Type to represent a Sapling Shielded Output as provided by the @getrawtransaction@ RPC method of @zcashd@.
 data ShieldedOutput = ShieldedOutput