src/ZcashHaskell/Sapling.hs

@@ -43,6 +43,25 @@ import Foreign.Rust.Marshall.Variable
   , withPureBorshVarBuffer
   )
 import ZcashHaskell.Types  
+--import ZcashHaskell.Types
+--  ( AccountId
+--  , CoinType
+--  , DecodedNote(..)
+--  , RawData(..)
+--  , RawTxResponse(..)
+--  , SaplingAddress(..)
+--  , SaplingCommitmentTree(..)
+--  , SaplingReceiver(..)
+--  , SaplingSpendingKey(..)
+--  , SaplingWitness(..)
+--  , Scope(..)
+--  , Seed(..)
+--  , ShieldedOutput(..)
+--  , ToBytes(..)
+--  , ZcashNet(..)
+--  , decodeHexText
+--  , getValue
+--  )
 import ZcashHaskell.Utils (decodeBech32, encodeBech32, encodeBech32m)
 
 -- | Check if given bytesting is a valid encoded shielded address

src/ZcashHaskell/Transparent.hs

@@ -22,7 +22,6 @@ import qualified Data.ByteArray as BA
 import qualified Data.ByteString as BS
 import Data.ByteString.Base58 (bitcoinAlphabet, decodeBase58, encodeBase58)
 import Data.Char (chr)
-import qualified Data.ByteString.Char8 as BC
 import Data.HexString
 import qualified Data.Text as T
 import qualified Data.Text.Encoding as E
@@ -31,20 +30,19 @@ import Haskoin.Address (Address(..))
 import qualified Haskoin.Crypto.Hash as H
 import Haskoin.Crypto.Keys.Extended
 import ZcashHaskell.Types
---  ( AccountId
+  ( AccountId
---  , CoinType(..)
+  , CoinType(..)
---  , Scope(..)
+  , Scope(..)
---  , Seed(..)
+  , Seed(..)
---  , ToBytes(..)
+  , ToBytes(..)
---  , TransparentAddress(..)
+  , TransparentAddress(..)
---  , TransparentReceiver(..)
+  , TransparentReceiver(..)
---  , TransparentSpendingKey(..)
+  , TransparentSpendingKey(..)
---  , TransparentType(..)
+  , TransparentType(..)
---  , ZcashNet(..)
+  , ZcashNet(..)
---  , getTransparentPrefix
+  , getTransparentPrefix
---  , getValue
+  , getValue
---  )
+  )
-import ZcashHaskell.Utils( encodeBech32m, decodeBech32 )
 
 -- | Required for `TransparentReceiver` encoding and decoding 
 sha256 :: BS.ByteString -> BS.ByteString
@@ -144,43 +142,3 @@ decodeTransparentAddress taddress = do
                          TransparentReceiver P2PKH (fromRawBytes transparentReceiver)
                     else Nothing
                 _ -> Nothing
-
--- | Encode an Exchange Addresss into HRF from TransparentReceiver
-encodeExchangeAddress:: ZcashNet -> TransparentReceiver -> Maybe T.Text
-encodeExchangeAddress net tr = do 
-  case (tr_type tr) of
-    P2PKH -> do 
-      case net of
-        MainNet -> do
-          let vhash = encodeBech32m (BC.pack "tex") (toBytes (tr_bytes tr))
-          Just vhash
-        TestNet -> do  
-          let vhash = encodeBech32m (BC.pack "textest") (toBytes (tr_bytes tr))
-          Just vhash
-    _ -> Nothing          
-
--- | Decode an Exchange Address into a TransparentAddress
-decodeExchangeAddress:: T.Text-> Maybe TransparentAddress
-decodeExchangeAddress ex = do  
-  if (T.length ex ) > 1
-    then do  
-      let rawd =  decodeBech32 (E.encodeUtf8 ex)
-      let tMain =  BS.unpack (BC.pack "tex")
-      let tTest =  BS.unpack (BC.pack "textest")
-      let tFail =  BS.unpack (BC.pack "fail")
-      let hr = BS.unpack (hrp rawd) 
-      if hr /= tFail
-        then do
-          let transparentReceiver = bytes rawd
-          if hr == tMain 
-            then Just $
-                 TransparentAddress MainNet $
-                 TransparentReceiver P2PKH (fromRawBytes transparentReceiver)
-            else do  
-              if hr == tTest  
-                then Just $
-                     TransparentAddress TestNet $
-                     TransparentReceiver P2PKH (fromRawBytes transparentReceiver)
-                else Nothing                  
-        else Nothing
-    else Nothing  

src/ZcashHaskell/Types.hs

@@ -434,12 +434,6 @@ data TransparentAddress = TransparentAddress
   , ta_receiver :: !TransparentReceiver
   } deriving (Eq, Prelude.Show, Read)
 
--- | Type to represent a TEX Zcash addresses
-data ExchangeAddress = ExchangeAddress
-  { ex_network :: !ZcashNet
-  , ex_address :: !TransparentReceiver
-  } deriving (Eq, Prelude.Show, Read)
-
 -- | Wrapper types for transparent elements
 data RawTxIn = RawTxIn
   { rti_outpoint :: !RawOutPoint

test/Spec.hs

@@ -1068,22 +1068,6 @@ main = do
                                 p
                         dn `shouldNotBe` Nothing
 
-      describe "Generate an ExchangeAddress (MainNet) from transparent address" $ do
-        let ta = decodeTransparentAddress "t1dMjvesbzdG41xgKaGU3HgwYJwSgbCK54e"
-        it "Try to generate valid ExchangeAddress from Transparent Address" $ do
-          case ta of 
-            Nothing -> assertFailure "Failed to decode transparent address" 
-            Just t  -> do  
-              case  (tr_type (ta_receiver t) ) of
-                P2SH -> assertFailure "P2SH not supported for ExchengeAddress generation" 
-                P2PKH -> do
-                  let exch = encodeExchangeAddress (ta_network t) (ta_receiver t)
-                  case exch of
-                    Nothing -> assertFailure "Failed to encode Exchange address" 
-                    Just addr -> do  
-                      let tadr = decodeExchangeAddress addr
-                      tadr `shouldNotBe` Nothing 
-
 -- | Properties
 prop_PhraseLength :: Property
 prop_PhraseLength =