CHANGELOG.md

@@ -5,12 +5,6 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.7.2.0]
-
-### Changed
-
-- Modified Sapling commitment trees to use Frontier
-
 ## [0.7.1.1]
 
 ### Added

librustzcash-wrapper/src/lib.rs

@@ -1369,31 +1369,6 @@ pub extern "C" fn rust_wrapper_bech32_encode(
     marshall_to_haskell_var(&string, out, out_len, RW);
 }
 
-#[no_mangle]
-pub extern "C" fn rust_wrapper_read_sapling_frontier(
-    tree: *const u8,
-    tree_len: usize,
-    out: *mut u8,
-    out_len: &mut usize
-    ){
-    let tree_in: Vec<u8> = marshall_from_haskell_var(tree, tree_len, RW);
-    let tree_reader = Cursor::new(tree_in);
-    let comm_tree: CommitmentTree<Node, SAPLING_DEPTH> = read_commitment_tree(tree_reader).unwrap();
-    //let comm_tree: Frontier<MerkleHashOrchard, 32> = read_frontier_v1(tree_reader).unwrap();
-    let frontier: Frontier<Node, SAPLING_DEPTH> = comm_tree.to_frontier();
-    match frontier.value() {
-        Some(f1) => {
-            let (pos, leaf, omm) = f1.clone().into_parts();
-            let f = Hfrontier { position: <u64>::from(pos), leaf: Hhex { bytes: leaf.to_bytes().to_vec()}, ommers: omm.iter().map(|&x| x.to_bytes().to_vec()).collect()};
-            marshall_to_haskell_var(&f, out, out_len, RW);
-        },
-        None => {
-            let f0 = Hfrontier { position: 0, leaf: Hhex { bytes: vec![0]}, ommers: vec![vec![0]]};
-            marshall_to_haskell_var(&f0, out, out_len, RW);
-        }
-    }
-}
-
 #[no_mangle]
 pub extern "C" fn rust_wrapper_read_sapling_commitment_tree(
     tree: *const u8,
@@ -1403,21 +1378,39 @@ pub extern "C" fn rust_wrapper_read_sapling_commitment_tree(
     out: *mut u8,
     out_len: &mut usize
     ){
-    let tree_in: Hfrontier = marshall_from_haskell_var(tree, tree_len, RW);
-    let leaf = Node::from_bytes(to_array(tree_in.leaf.bytes)).unwrap();
-    let mut comm_tree = NonEmptyFrontier::from_parts(Position::from(tree_in.position), leaf, tree_in.ommers.iter().map(|x| Node::from_bytes(to_array(x.clone())).unwrap() ).collect()).unwrap();
-    let node_in: Vec<u8> = marshall_from_haskell_var(node, node_len, RW);
-    let sap_note_comm = SaplingNoteCommitment::from_bytes(&to_array(node_in));
-    if sap_note_comm.is_some().into() {
-        let n = Node::from_cmu(&sap_note_comm.unwrap());
-        comm_tree.append(n);
-        let (pos, leaf, omm) = comm_tree.into_parts();
-        let f = Hfrontier { position: <u64>::from(pos), leaf: Hhex { bytes: leaf.to_bytes().to_vec()}, ommers: omm.iter().map(|&x| x.to_bytes().to_vec()).collect()};
-        marshall_to_haskell_var(&f, out, out_len, RW);
-    } else {
-        let f0 = Hfrontier { position: 0, leaf: Hhex { bytes: vec![0]}, ommers: vec![vec![0]]};
-        marshall_to_haskell_var(&f0, out, out_len, RW);
+    let tree_in: Vec<u8> = marshall_from_haskell_var(tree, tree_len, RW);
+    let tree_reader = Cursor::new(tree_in);
+    let mut ct = read_commitment_tree::<Node, Cursor<Vec<u8>>, SAPLING_DEPTH>(tree_reader);
+    match ct {
+        Ok(mut comm_tree) => {
+            let node_in: Vec<u8> = marshall_from_haskell_var(node, node_len, RW);
+            let sap_note_comm = SaplingNoteCommitment::from_bytes(&to_array(node_in));
+            if sap_note_comm.is_some().into() {
+                let n = Node::from_cmu(&sap_note_comm.unwrap());
+                comm_tree.append(n);
+                let mut out_bytes: Vec<u8> = Vec::new();
+                let result = write_commitment_tree(&comm_tree, &mut out_bytes );
+                match result {
+                    Ok(()) => {
+                        let h = Hhex { bytes: out_bytes};
+                        marshall_to_haskell_var(&h, out, out_len, RW);
+                    },
+                    Err(_e) => {
+                        let h0 = Hhex { bytes: vec![0]};
+                        marshall_to_haskell_var(&h0, out, out_len, RW);
+                    }
+                }
+            } else {
+                let h0 = Hhex { bytes: vec![0]};
+                marshall_to_haskell_var(&h0, out, out_len, RW);
+            }
+        },
+        Err(_e) => {
+            let h0 = Hhex { bytes: vec![0]};
+            marshall_to_haskell_var(&h0, out, out_len, RW);
+        }
     }
+
 }
 
 #[no_mangle]
@@ -1427,10 +1420,9 @@ pub extern "C" fn rust_wrapper_read_sapling_witness(
     out: *mut u8,
     out_len: &mut usize
     ){
-    let tree_in: Hfrontier = marshall_from_haskell_var(tree, tree_len, RW);
-    let leaf = Node::from_bytes(to_array(tree_in.leaf.bytes)).unwrap();
-    let frontier: Frontier<Node, SAPLING_DEPTH> = Frontier::from_parts(Position::from(tree_in.position), leaf, tree_in.ommers.iter().map(|x| Node::from_bytes(to_array(x.clone())).unwrap() ).collect()).unwrap();
-    let ct: CommitmentTree<Node, SAPLING_DEPTH> = CommitmentTree::from_frontier(&frontier);
+    let tree_in: Vec<u8> = marshall_from_haskell_var(tree, tree_len, RW);
+    let tree_reader = Cursor::new(tree_in);
+    let ct: CommitmentTree<Node, SAPLING_DEPTH> = read_commitment_tree(tree_reader).unwrap();
     let inc_wit = IncrementalWitness::from_tree(ct);
     let mut out_bytes: Vec<u8> = Vec::new();
     let result = write_incremental_witness(&inc_wit, &mut out_bytes);
@@ -1695,31 +1687,21 @@ pub extern "C" fn rust_wrapper_create_transaction(
     build: bool,
     out: *mut u8,
     out_len: &mut usize){
-    //let sap_wit_in: Vec<u8> = marshall_from_haskell_var(sap_wit, sap_wit_len, RW);
-    //let sap_wit_reader = Cursor::new(sap_wit_in);
-    //let sap_iw = read_commitment_tree::<Node, Cursor<Vec<u8>>, SAPLING_DEPTH>(sap_wit_reader);
-    let sap_input: Vec<HsaplingInput> = marshall_from_haskell_var(s_input, s_input_len, RW);
-    let sap_anchor =
-        if sap_input.is_empty() {
+    let sap_wit_in: Vec<u8> = marshall_from_haskell_var(sap_wit, sap_wit_len, RW);
+    let sap_wit_reader = Cursor::new(sap_wit_in);
+    let sap_iw = read_commitment_tree::<Node, Cursor<Vec<u8>>, SAPLING_DEPTH>(sap_wit_reader);
+    let sap_anchor = match sap_iw {
+        Ok(s_iw) => {
+            Some(SaplingAnchor::from(s_iw.root()))
+        },
+        Err(_e) => {
             None
-        } else {
-            let si = &sap_input[0];
-            let swit_reader = Cursor::new(&si.iw);
-            let iw: IncrementalWitness<Node, SAPLING_DEPTH> = read_incremental_witness(swit_reader).unwrap();
-            Some(SaplingAnchor::from(iw.root()))
-        };
-    //let sap_anchor = match sap_iw {
-        //Ok(s_iw) => {
-            //Some(SaplingAnchor::from(s_iw.root()))
-        //},
-        //Err(_e) => {
-            //None
-        //}
-    //};
+        }
+    };
     //println!("{:?}", sap_anchor);
-    //let orch_wit_in: Vec<u8> = marshall_from_haskell_var(orch_wit, orch_wit_len, RW);
-    //let orch_wit_reader = Cursor::new(orch_wit_in);
-    //let orch_iw = read_commitment_tree::<MerkleHashOrchard, Cursor<Vec<u8>>, 32>(orch_wit_reader);
+    let orch_wit_in: Vec<u8> = marshall_from_haskell_var(orch_wit, orch_wit_len, RW);
+    let orch_wit_reader = Cursor::new(orch_wit_in);
+    let orch_iw = read_commitment_tree::<MerkleHashOrchard, Cursor<Vec<u8>>, 32>(orch_wit_reader);
     let orch_input: Vec<HorchardInput> = marshall_from_haskell_var(o_input, o_input_len, RW);
     //let orch_anchor = match orch_iw {
         //Ok(o_iw) => {
@@ -1764,6 +1746,7 @@ pub extern "C" fn rust_wrapper_create_transaction(
             }
         }
     }
+    let sap_input: Vec<HsaplingInput> = marshall_from_haskell_var(s_input, s_input_len, RW);
     for s_in in sap_input {
         if s_in.sk.len() > 1 {
             let sp_key = ExtendedSpendingKey::from_bytes(&s_in.sk);
@@ -1780,32 +1763,13 @@ pub extern "C" fn rust_wrapper_create_transaction(
                     let iw: IncrementalWitness<Node, SAPLING_DEPTH> = read_incremental_witness(wit_reader).unwrap();
                     let merkle_path = iw.path().unwrap();
                     if net {
-                        let mb = main_builder.add_sapling_spend::<String>(&sk, note, merkle_path);
-                        match mb {
-                            Ok(()) => {
-                                continue;
-                            },
-                            Err(_e) => {
-                                let x = Hhex {bytes: vec![5]};
-                                marshall_to_haskell_var(&x, out, out_len, RW);
-                            }
-                        }
+                        let _mb = main_builder.add_sapling_spend::<String>(&sk, note, merkle_path).unwrap();
                     } else {
-                        let tb = test_builder.add_sapling_spend::<String>(&sk, note, merkle_path);
-                        match tb {
-                            Ok(()) => {
-                                continue;
-                            },
-                            Err(_e) => {
-                                let x = Hhex {bytes: vec![5]};
-                                marshall_to_haskell_var(&x, out, out_len, RW);
-                            }
-                        }
+                        let _tb = test_builder.add_sapling_spend::<String>(&sk, note, merkle_path).unwrap();
                     }
                 },
                 Err(_e) => {
-                    let x = Hhex {bytes: vec![5]};
-                    marshall_to_haskell_var(&x, out, out_len, RW);
+                    continue;
                 }
             }
         }
@@ -1822,27 +1786,9 @@ pub extern "C" fn rust_wrapper_create_transaction(
             let iw: IncrementalWitness<MerkleHashOrchard, 32> = read_incremental_witness(wit_reader).unwrap();
             let merkle_path = OrchardMerklePath::from(iw.path().unwrap());
             if net {
-                let mb = main_builder.add_orchard_spend::<String>(&sp_key, note, merkle_path);
-                match mb {
-                    Ok(()) => {
-                        continue;
-                    },
-                    Err(_e) => {
-                        let x = Hhex {bytes: vec![7]};
-                        marshall_to_haskell_var(&x, out, out_len, RW);
-                    }
-                }
+                let _mb = main_builder.add_orchard_spend::<String>(&sp_key, note, merkle_path).unwrap();
             } else {
-                let tb = test_builder.add_orchard_spend::<String>(&sp_key, note, merkle_path);
-                match tb {
-                    Ok(()) => {
-                        continue;
-                    },
-                    Err(_e) => {
-                        let x = Hhex {bytes: vec![7]};
-                        marshall_to_haskell_var(&x, out, out_len, RW);
-                    }
-                }
+                let _tb = test_builder.add_orchard_spend::<String>(&sp_key, note, merkle_path).unwrap();
             }
         }
     }

src/C/Zcash.chs

@@ -204,15 +204,15 @@ import ZcashHaskell.Types
 #}
 
 {# fun unsafe rust_wrapper_read_sapling_commitment_tree as rustWrapperReadSaplingCommitmentTree
-     { toBorshVar* `SaplingFrontier'&
+     { toBorshVar* `BS.ByteString'&
      , toBorshVar* `BS.ByteString'&
-     , getVarBuffer `Buffer SaplingFrontier'&
+     , getVarBuffer `Buffer HexString'&
      }
   -> `()'
 #}
 
 {# fun unsafe rust_wrapper_read_sapling_witness as rustWrapperReadSaplingWitness
-     { toBorshVar* `SaplingFrontier'&
+     { toBorshVar* `BS.ByteString'&
      , getVarBuffer `Buffer HexString'&
      }
   -> `()'
@@ -232,13 +232,6 @@ import ZcashHaskell.Types
   -> `()'
 #}
 
-{# fun unsafe rust_wrapper_read_sapling_frontier as rustWrapperReadSaplingFrontier
-     { toBorshVar* `BS.ByteString'&
-     , getVarBuffer `Buffer SaplingFrontier'&
-     }
-  -> `()'
-#}
-
 {# fun unsafe rust_wrapper_decode_sapling_address as rustWrapperDecodeSaplingAddress
      { toBorshVar* `BS.ByteString'&
      , getVarBuffer `Buffer (BS.ByteString)'&

src/ZcashHaskell/Sapling.hs

@@ -21,7 +21,6 @@ import C.Zcash
   ( rustWrapperDecodeSaplingAddress
   , rustWrapperIsShielded
   , rustWrapperReadSaplingCommitmentTree
-  , rustWrapperReadSaplingFrontier
   , rustWrapperReadSaplingPosition
   , rustWrapperReadSaplingWitness
   , rustWrapperSaplingCheck
@@ -185,38 +184,32 @@ genSaplingInternalAddress sk =
     res =
       withPureBorshVarBuffer (rustWrapperSaplingChgPaymentAddress $ getBytes sk)
 
-getSaplingFrontier :: SaplingCommitmentTree -> Maybe SaplingFrontier
-getSaplingFrontier tree =
-  if sf_pos updatedTree > 1
-    then Just updatedTree
-    else Nothing
-  where
-    updatedTree =
-      withPureBorshVarBuffer $
-      rustWrapperReadSaplingFrontier $ toBytes $ sapTree tree
-
 -- | Update a Sapling commitment tree
 updateSaplingCommitmentTree ::
-     SaplingFrontier -- ^ the base tree
+     SaplingCommitmentTree -- ^ the base tree
   -> HexString -- ^ the new note commitment
-  -> Maybe SaplingFrontier
+  -> Maybe SaplingCommitmentTree
 updateSaplingCommitmentTree tree cmu =
-  if sf_pos updatedTree > 1
-    then Just updatedTree
+  if BS.length (hexBytes updatedTree) > 1
+    then Just $ SaplingCommitmentTree updatedTree
     else Nothing
   where
     updatedTree =
       withPureBorshVarBuffer $
-      rustWrapperReadSaplingCommitmentTree tree (hexBytes cmu)
+      rustWrapperReadSaplingCommitmentTree
+        (hexBytes $ sapTree tree)
+        (hexBytes cmu)
 
 -- | Get the Sapling incremental witness from a commitment tree
-getSaplingWitness :: SaplingFrontier -> Maybe SaplingWitness
+getSaplingWitness :: SaplingCommitmentTree -> Maybe SaplingWitness
 getSaplingWitness tree =
   if BS.length (hexBytes wit) > 1
     then Just $ SaplingWitness wit
     else Nothing
   where
-    wit = withPureBorshVarBuffer $ rustWrapperReadSaplingWitness tree
+    wit =
+      withPureBorshVarBuffer $
+      rustWrapperReadSaplingWitness (hexBytes $ sapTree tree)
 
 -- | Get the Sapling note position from a witness
 getSaplingNotePosition :: SaplingWitness -> Integer

src/ZcashHaskell/Types.hs

@@ -611,15 +611,6 @@ newtype SaplingCommitmentTree = SaplingCommitmentTree
   { sapTree :: HexString
   } deriving (Eq, Prelude.Show, Read)
 
-data SaplingFrontier = SaplingFrontier
-  { sf_pos :: !Int64
-  , sf_leaf :: !HexString
-  , sf_ommers :: ![BS.ByteString]
-  } deriving stock (Eq, Prelude.Show, GHC.Generic)
-    deriving anyclass (SOP.Generic, SOP.HasDatatypeInfo)
-    deriving anyclass (Data.Structured.Show)
-    deriving (BorshSize, ToBorsh, FromBorsh) via AsStruct SaplingFrontier
-
 -- | Type for a Sapling incremental witness
 newtype SaplingWitness = SaplingWitness
   { sapWit :: HexString

zcash-haskell.cabal

@@ -5,7 +5,7 @@ cabal-version: 3.0
 -- see: https://github.com/sol/hpack
 
 name:           zcash-haskell
-version:        0.7.2.0
+version:        0.7.1.1
 synopsis:       Utilities to interact with the Zcash blockchain
 description:    Please see the README on the repo at <https://git.vergara.tech/Vergara_Tech/zcash-haskell#readme>
 category:       Blockchain