Update raw Tx parsing to extract shielded outputs

CHANGELOG.md

@@ -9,6 +9,8 @@ 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(
+pub extern "C" fn rust_wrapper_sapling_note_decrypt_v2(
     key: *const u8,
     key_len: usize,
     note: *const u8,
@@ -364,12 +364,10 @@ pub extern "C" fn rust_wrapper_sapling_note_decrypt(
     match svk {
         Ok(k) => {
             let domain = SaplingDomain::for_height(MainNetwork, BlockHeight::from_u32(2000000));
-            let action2: Transaction = Transaction::read(&mut note_reader, Nu5).unwrap();
-            let bundle = action2.sapling_bundle().unwrap();
-            let sh_out = bundle.shielded_outputs();
+            let action2 = OutputDescription::read(&mut note_reader).unwrap();
             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, &sh_out[0]);
+            let result = zcash_note_encryption::try_note_decryption(&domain, &pivk, &action2);
             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() };
@@ -447,41 +445,15 @@ 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();
-            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);
-                        }
-                    }
-                }
+            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); 
             }
+            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 as rustWrapperSaplingNoteDecode
+{# fun unsafe rust_wrapper_sapling_note_decrypt_v2 as rustWrapperSaplingNoteDecode
     { toBorshVar* `BS.ByteString'&
     , toBorshVar* `BS.ByteString'&
     , getVarBuffer `Buffer DecodedNote'&
@@ -95,3 +95,9 @@ import ZcashHaskell.Types
   -> `()'
 #}
 
+{# fun unsafe rust_wrapper_tx_parse as rustWrapperTxParse
+     { toBorshVar* `BS.ByteString'&
+     , getVarBuffer `Buffer [BS.ByteString]'&
+     }
+  -> `()'
+#}

src/ZcashHaskell/Sapling.hs

@@ -1,3 +1,5 @@
+{-# LANGUAGE OverloadedStrings #-}
+
 module ZcashHaskell.Sapling where
 
 import C.Zcash
@@ -5,15 +7,25 @@ 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(..), ShieldedOutput(..))
+import ZcashHaskell.Types
+  ( DecodedNote(..)
+  , RawTxResponse(..)
+  , ShieldedOutput(..)
+  , decodeHexText
+  )
 
 -- | 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
@@ -31,3 +43,17 @@ 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,20 +103,10 @@ instance FromJSON BlockResponse where
 data RawTxResponse = RawTxResponse
   { rt_id :: T.Text
   , rt_hex :: BS.ByteString
-  , rt_shieldedOutputs :: [ShieldedOutput]
+  , rt_shieldedOutputs :: [BS.ByteString]
   , 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