// Copyright 2022-2024 Vergara Technologies LLC
//
// This file is part of Zcash-Haskell.
//
use std::{
    marker::PhantomData,
    io::{
        Write,
        Cursor
    },
};

use nonempty::NonEmpty;

use rand_core::OsRng;

use f4jumble;

use borsh::{BorshDeserialize, BorshSerialize};

use haskell_ffi::{
    error::Result,
    from_haskell::{marshall_from_haskell_var, marshall_from_haskell_fixed},
    to_haskell::{marshall_to_haskell_var, marshall_to_haskell_fixed},
    FromHaskell, HaskellSize, ToHaskell
};

use secp256k1::SecretKey;

use jubjub::Fr;

use incrementalmerkletree::{
    Hashable,
    Level,
    Position,
    frontier::{
        CommitmentTree,
        Frontier,
        NonEmptyFrontier
    },
    witness::IncrementalWitness
};

use zip32::{
    Scope as SaplingScope,
    ChildIndex
};


use sapling_crypto::{
    NOTE_COMMITMENT_TREE_DEPTH as SAPLING_DEPTH,
    Node,
    MerklePath,
    PaymentAddress,
    Anchor as SaplingAnchor,
    value::ValueCommitment as SaplingValueCommitment,
    note::{
        ExtractedNoteCommitment as SaplingNoteCommitment,
        Note as SaplingNote,
        Rseed
    },
    keys::{
        PreparedIncomingViewingKey as SaplingPreparedIncomingViewingKey,
        ExpandedSpendingKey,
        FullViewingKey as SaplingFullViewingKey
    },
    note_encryption::{
        SaplingDomain,
        Zip212Enforcement
    },
    bundle::{
        GrothProofBytes,
        OutputDescription,
        SpendDescription,
        Authorized as SaplingAuthorized,
        Bundle as SaplingBundle
    },
    value::NoteValue as SaplingNoteValue,
    circuit::{
        SpendParameters,
        OutputParameters
    },
    zip32::{
        sapling_find_address,
        DiversifierKey
    }
};

use bip0039::{Count, Mnemonic, English};

use zcash_primitives::{
    merkle_tree::{
        read_commitment_tree,
        write_commitment_tree,
        read_incremental_witness,
        write_incremental_witness,
        read_frontier_v1,
        read_nonempty_frontier_v1
    },
    legacy::{
        Script,
        TransparentAddress
    },
    transaction::{
        Transaction,
        fees::zip317::FeeRule,
        builder::{
            Builder,
            Error,
            BuildConfig
        },
        components::{
            amount::{
                Amount,
                NonNegativeAmount
            },
            transparent::{
                Bundle as TransparentBundle,
                TxIn,
                TxOut,
                OutPoint,
                Authorized
            }
        }
    },
    memo::MemoBytes,
    consensus::{
        BranchId::Nu5,
        MainNetwork,
        TestNetwork,
        BlockHeight
    }
};

use zcash_address::{
    Network,
    unified::{Address, Encoding, Ufvk, Container, Fvk, Receiver},
    ZcashAddress
};

use zcash_client_backend::encoding::decode_payment_address;
use zcash_client_backend::keys::sapling::{
    spending_key,
    ExtendedFullViewingKey,
    ExtendedSpendingKey,
    DiversifiableFullViewingKey
};

use zcash_primitives::zip32::DiversifierIndex;

use orchard::{
    Address as OrchardAddress,
    Bundle as OrchardBundle,
    bundle::{
        Authorized as OrchardAuthorized,
        Flags
    },
    Action,
    keys::{SpendingKey, FullViewingKey, PreparedIncomingViewingKey, Scope},
    note::{Rho, RandomSeed, Note, Nullifier, TransmittedNoteCiphertext, ExtractedNoteCommitment},
    note_encryption::OrchardDomain,
    primitives::redpallas::{VerificationKey, SpendAuth, Signature},
    tree::{
        MerklePath as OrchardMerklePath,
        MerkleHashOrchard,
        Anchor as OrchardAnchor
    },
    value::{
        ValueCommitment,
        NoteValue
    }
};

use bech32::{
    Hrp,
    Bech32,
    Bech32m
};

use wagyu_zcash_parameters::load_sapling_parameters;

pub enum RW {}
pub const RW: PhantomData<RW> = PhantomData;

#[derive(Debug, BorshSerialize, BorshDeserialize)]
pub struct RawData {
    hrp: Vec<u8>,
    bytes: Vec<u8>
}

impl<RW> ToHaskell<RW> for RawData {
    fn to_haskell<W: Write>(&self, writer: &mut W, _tag: PhantomData<RW>) -> Result<()> {
        self.serialize(writer)?;
        Ok(())
    }
}

//impl<RW> FromHaskell<RW> for RawData {
    //fn from_haskell(buf: &mut &[u8], _tag: PhantomData<RW>) -> Result<Self> {
        //let x = RawData::deserialize(buf)?;
        //Ok(x)
    //}
//}

#[derive(Debug, BorshSerialize, BorshDeserialize)]
pub struct HrawTx {
    bytes: Vec<u8>,
    s: bool,
    o: bool
}

impl<RW> ToHaskell<RW> for HrawTx {
    fn to_haskell<W: Write>(&self, writer: &mut W, _tag: PhantomData<RW>) -> Result<()> {
        self.serialize(writer)?;
        Ok(())
    }
}

#[derive(Debug, BorshSerialize, BorshDeserialize)]
pub struct HshieldedOutput {
    pub cv: Hhex,
    cmu: Hhex,
    eph_key: Hhex,
    enc_txt: Hhex,
    out_txt: Hhex,
    proof: Hhex
}

impl<RW> FromHaskell<RW> for HshieldedOutput {
    fn from_haskell(buf: &mut &[u8], _tag: PhantomData<RW>) -> Result<Self> {
        let x = HshieldedOutput::deserialize(buf)?;
        Ok(x)
    }
}

impl<RW> ToHaskell<RW> for HshieldedOutput {
    fn to_haskell<W: Write>(&self, writer: &mut W, _tag: PhantomData<RW>) -> Result<()> {
        self.serialize(writer)?;
        Ok(())
    }
}

impl HshieldedOutput {
    fn from_object(s: &OutputDescription<GrothProofBytes>) -> HshieldedOutput {
        HshieldedOutput { cv: Hhex{ bytes: s.cv().to_bytes().to_vec()}, cmu: Hhex{ bytes: s.cmu().to_bytes().to_vec()}, eph_key: Hhex{ bytes: s.ephemeral_key().0.to_vec()}, enc_txt: Hhex{ bytes: s.enc_ciphertext().to_vec()}, out_txt: Hhex{ bytes: s.out_ciphertext().to_vec()}, proof: Hhex{ bytes: s.zkproof().to_vec()} }
    }
    pub fn pack(sp: &[OutputDescription<GrothProofBytes>]) -> Vec<HshieldedOutput> {
        let mut r = Vec::new();
        for s in sp {
            r.push(HshieldedOutput::from_object(s));
        }
        return r
    }
    pub fn to_output_description(&mut self) -> Result<OutputDescription<GrothProofBytes>> {
        let cv = SaplingValueCommitment::from_bytes_not_small_order(&to_array(self.cv.bytes.clone())).unwrap();
        let cmu = SaplingNoteCommitment::from_bytes(&to_array(self.cmu.bytes.clone())).unwrap();
        let eph_key = zcash_note_encryption::EphemeralKeyBytes::from(to_array(self.eph_key.bytes.clone()));
        let x = OutputDescription::from_parts(cv, cmu, eph_key, to_array(self.enc_txt.bytes.clone()), to_array(self.out_txt.bytes.clone()), to_array(self.proof.bytes.clone()));
        return Ok(x)
    }
}

#[derive(Debug, BorshSerialize, BorshDeserialize)]
pub struct Hhex {
    bytes: Vec<u8>
}

impl<RW> ToHaskell<RW> for Hhex {
    fn to_haskell<W: Write>(&self, writer: &mut W, _tag: PhantomData<RW>) -> Result<()> {
        self.serialize(writer)?;
        Ok(())
    }
}


#[derive(Debug, BorshSerialize, BorshDeserialize)]
pub struct Haction {
    nf: Hhex,
    rk: Hhex,
    cmx: Hhex,
    eph_key: Hhex,
    enc_txt: Hhex,
    out_txt: Hhex,
    cv: Hhex,
    auth: Hhex
}

impl<RW> FromHaskell<RW> for Haction {
    fn from_haskell(buf: &mut &[u8], _tag: PhantomData<RW>) -> Result<Self> {
        let x = Haction::deserialize(buf)?;
        Ok(x)
    }
}

impl Haction {
    pub fn pack(sp: &NonEmpty<Action<Signature<SpendAuth>>>) -> Vec<Haction> {
        let mut r = Vec::new();
        for s in sp {
            r.push(Haction {nf: Hhex { bytes: s.nullifier().to_bytes().to_vec()}, rk: Hhex { bytes: <[u8; 32]>::from(s.rk()).to_vec()}, cmx: Hhex{bytes: s.cmx().to_bytes().to_vec()}, eph_key: Hhex{ bytes: s.encrypted_note().epk_bytes.to_vec()}, enc_txt: Hhex {bytes: s.encrypted_note().enc_ciphertext.to_vec()}, out_txt: Hhex {bytes: s.encrypted_note().out_ciphertext.to_vec()}, cv: Hhex {bytes: s.cv_net().to_bytes().to_vec()}, auth: Hhex { bytes: <[u8; 64]>::from(s.authorization()).to_vec()}});
        }
        return r
    }
}

#[derive(Debug, BorshSerialize, BorshDeserialize)]
pub struct Hnote {
    note: u64,
    recipient: Vec<u8>,
    memo: Vec<u8>,
    nullifier: Vec<u8>,
    rho: Vec<u8>,
    rseed: Hrseed
}

impl<RW> ToHaskell<RW> for Hnote {
    fn to_haskell<W: Write>(&self, writer: &mut W, _tag: PhantomData<RW>) -> Result<()> {
        self.serialize(writer)?;
        Ok(())
    }
}

#[derive(Debug, BorshSerialize, BorshDeserialize)]
pub struct Hrseed {
    kind: u8,
    bytes: Vec<u8>
}


impl<RW> FromHaskell<RW> for Hrseed {
    fn from_haskell(buf: &mut &[u8], _tag: PhantomData<RW>) -> Result<Self> {
        let x = Hrseed::deserialize(buf)?;
        Ok(x)
    }
}

impl<RW> ToHaskell<RW> for Hrseed {
    fn to_haskell<W: Write>(&self, writer: &mut W, _tag: PhantomData<RW>) -> Result<()> {
        self.serialize(writer)?;
        Ok(())
    }
}

#[derive(Debug, BorshSerialize, BorshDeserialize)]
pub struct Hua {
    net: u8,
    o_rec: Vec<u8>,
    s_rec: Vec<u8>,
    t_rec: Vec<u8>,
    to_rec: Vec<u8>
}

impl<RW> ToHaskell<RW> for Hua {
    fn to_haskell<W: Write>(&self, writer: &mut W, _tag: PhantomData<RW>) -> Result<()> {
        self.serialize(writer)?;
        Ok(())
    }
}

impl Hua {
    fn add_rec(&mut self, rec: &Receiver) {
        if let Receiver::Orchard(x) = rec {
            self.o_rec = x.to_vec();
        }
        if let Receiver::Sapling(y) = rec {
            self.s_rec = y.to_vec();
        }
        if let Receiver::P2pkh(z) = rec {
            self.t_rec = z.to_vec();
        }
        if let Receiver::P2sh(w) = rec {
            self.to_rec = w.to_vec();
        }
    }
}

#[derive(Debug, BorshSerialize, BorshDeserialize)]
pub struct Htx {
    txid: Vec<u8>,
    locktime: u32,
    expiry: u32,
    t_bundle: HTBundle,
    s_bundle: HSBundle,
    o_bundle: HOBundle
}

impl<RW> ToHaskell<RW> for Htx {
    fn to_haskell<W: Write>(&self, writer: &mut W, _tag: PhantomData<RW>) -> Result<()> {
        self.serialize(writer)?;
        Ok(())
    }
}


#[derive(Debug, BorshSerialize, BorshDeserialize)]
pub struct HTBundle {
    empty: bool,
    vin: Vec<HTxIn>,
    vout: Vec<HTxOut>,
    coinbase: bool
}

impl<RW> ToHaskell<RW> for HTBundle {
    fn to_haskell<W: Write>(&self, writer: &mut W, _tag: PhantomData<RW>) -> Result<()> {
        self.serialize(writer)?;
        Ok(())
    }
}

impl HTBundle {
    pub fn from_bundle(b: &TransparentBundle<Authorized>) -> HTBundle {
        HTBundle {empty: false, vin: b.vin.iter().map(HTxIn::pack).collect() , vout: b.vout.iter().map(HTxOut::pack).collect(), coinbase: b.is_coinbase()}
    }
}

#[derive(Debug, BorshSerialize, BorshDeserialize)]
pub struct HTxIn {
    outpoint: Houtpoint,
    script: Vec<u8>,
    sequence: u32
}

impl<RW> ToHaskell<RW> for HTxIn {
    fn to_haskell<W: Write>(&self, writer: &mut W, _tag: PhantomData<RW>) -> Result<()> {
        self.serialize(writer)?;
        Ok(())
    }
}

impl HTxIn {
    pub fn pack(t: &TxIn<Authorized>) -> HTxIn {
        return HTxIn { outpoint: Houtpoint::pack(&t.prevout), script: t.script_sig.0.clone(), sequence: t.sequence}
    }
}

#[derive(Debug, BorshSerialize, BorshDeserialize)]
pub struct HTxOut {
    amt: i64,
    script: Vec<u8>
}

impl<RW> FromHaskell<RW> for HTxOut {
    fn from_haskell(buf: &mut &[u8], _tag: PhantomData<RW>) -> Result<Self> {
        let x = HTxOut::deserialize(buf)?;
        Ok(x)
    }
}

impl<RW> ToHaskell<RW> for HTxOut {
    fn to_haskell<W: Write>(&self, writer: &mut W, _tag: PhantomData<RW>) -> Result<()> {
        self.serialize(writer)?;
        Ok(())
    }
}

impl HTxOut {
    pub fn pack(t: &TxOut) -> HTxOut {
        return HTxOut { amt: i64::from_le_bytes(t.value.to_i64_le_bytes()) , script: t.script_pubkey.0.clone() }
    }
    pub fn unpack(&self) -> TxOut {
        TxOut { value: NonNegativeAmount::from_nonnegative_i64(self.amt).unwrap(), script_pubkey: Script(self.script.clone())}
    }
}

#[derive(Debug, BorshSerialize, BorshDeserialize)]
pub struct Houtpoint {
    hash: Vec<u8>,
    index: u32
}

impl<RW> FromHaskell<RW> for Houtpoint {
    fn from_haskell(buf: &mut &[u8], _tag: PhantomData<RW>) -> Result<Self> {
        let x = Houtpoint::deserialize(buf)?;
        Ok(x)
    }
}

impl<RW> ToHaskell<RW> for Houtpoint {
    fn to_haskell<W: Write>(&self, writer: &mut W, _tag: PhantomData<RW>) -> Result<()> {
        self.serialize(writer)?;
        Ok(())
    }
}

impl Houtpoint {
    pub fn pack(o: &OutPoint) -> Houtpoint {
        return Houtpoint {hash: o.hash().to_vec() , index: o.n() }
    }

    pub fn unpack(&self) -> OutPoint {
        OutPoint::new(to_array(self.hash.clone()), self.index)
    }
}

#[derive(Debug, BorshSerialize, BorshDeserialize)]
pub struct HtransparentInput {
    sk: Vec<u8>,
    utxo: Houtpoint,
    coin: HTxOut
}

impl<RW> FromHaskell<RW> for HtransparentInput {
    fn from_haskell(buf: &mut &[u8], _tag: PhantomData<RW>) -> Result<Self> {
        let x = HtransparentInput::deserialize(buf)?;
        Ok(x)
    }
}

impl<RW> ToHaskell<RW> for HtransparentInput {
    fn to_haskell<W: Write>(&self, writer: &mut W, _tag: PhantomData<RW>) -> Result<()> {
        self.serialize(writer)?;
        Ok(())
    }
}

#[derive(Debug, BorshSerialize, BorshDeserialize)]
pub struct HSBundle {
    empty: bool,
    spends: Vec<Hspend>,
    outputs: Vec<HshieldedOutput> ,
    value: i64,
    sig: Vec<u8> 
}

impl<RW> ToHaskell<RW> for HSBundle {
    fn to_haskell<W: Write>(&self, writer: &mut W, _tag: PhantomData<RW>) -> Result<()> {
        self.serialize(writer)?;
        Ok(())
    }
}

impl HSBundle {
    pub fn from_bundle(sb: &SaplingBundle<SaplingAuthorized, Amount>) -> HSBundle {
        let sig = <[u8; 64]>::from(sb.authorization().binding_sig);
        return HSBundle {empty: false,  spends: Hspend::pack(sb.shielded_spends()) , outputs: HshieldedOutput::pack(sb.shielded_outputs()) , value: i64::from(sb.value_balance()) , sig: sig.to_vec()}
    }
}

#[derive(Debug, BorshSerialize, BorshDeserialize)]
pub struct Hspend {
    cv: Hhex,
    anchor: Hhex,
    nullifier: Hhex,
    rk: Hhex,
    proof: Hhex,
    authsig: Hhex
}

impl<RW> ToHaskell<RW> for Hspend {
    fn to_haskell<W: Write>(&self, writer: &mut W, _tag: PhantomData<RW>) -> Result<()> {
        self.serialize(writer)?;
        Ok(())
    }
}

impl Hspend {
    pub fn pack(sp: &[SpendDescription<SaplingAuthorized>]) -> Vec<Hspend> {
        let mut r = Vec::new();
        for s in sp {
            let rk = s.rk().clone();
            let sig = s.spend_auth_sig().clone();
            r.push(Hspend {cv: Hhex{bytes:s.cv().to_bytes().to_vec()}, anchor: Hhex{bytes:s.anchor().to_bytes().to_vec()}, nullifier: Hhex{bytes:s.nullifier().to_vec()}, rk: Hhex{bytes: <[u8; 32]>::from(rk).to_vec()}, proof: Hhex{bytes:s.zkproof().to_vec()}, authsig: Hhex{bytes: <[u8; 64]>::from(sig).to_vec()}});
        }
        return r
    }
}

#[derive(Debug, BorshSerialize, BorshDeserialize)]
pub struct HsaplingInput {
    sk: Vec<u8>,
    note: Hnote,
    iw: Vec<u8>
}

impl<RW> FromHaskell<RW> for HsaplingInput {
    fn from_haskell(buf: &mut &[u8], _tag: PhantomData<RW>) -> Result<Self> {
        let x = HsaplingInput::deserialize(buf)?;
        Ok(x)
    }
}


#[derive(Debug, BorshSerialize, BorshDeserialize)]
pub struct HorchardInput {
    sk: Vec<u8>,
    note: Hnote,
    iw: Vec<u8>
}

impl<RW> FromHaskell<RW> for HorchardInput {
    fn from_haskell(buf: &mut &[u8], _tag: PhantomData<RW>) -> Result<Self> {
        let x = HorchardInput::deserialize(buf)?;
        Ok(x)
    }
}

#[derive(Debug, BorshSerialize, BorshDeserialize)]
pub struct Houtput {
    kind: u8,
    ovk: Vec<u8>,
    to: Vec<u8>,
    amt: u64,
    memo: Vec<u8>,
    chg: bool
}

impl<RW> FromHaskell<RW> for Houtput {
    fn from_haskell(buf: &mut &[u8], _tag: PhantomData<RW>) -> Result<Self> {
        let x = Houtput::deserialize(buf)?;
        Ok(x)
    }
}

#[derive(Debug, BorshSerialize, BorshDeserialize)]
pub struct HOBundle {
    empty: bool,
    actions: Vec<Haction>,
    flags: Hflags,
    value: i64,
    anchor: Hhex,
    proof: Hhex,
    bindingsig: Hhex
}

impl<RW> ToHaskell<RW> for HOBundle {
    fn to_haskell<W: Write>(&self, writer: &mut W, _tag: PhantomData<RW>) -> Result<()> {
        self.serialize(writer)?;
        Ok(())
    }
}

impl HOBundle {
    pub fn from_bundle(b: &OrchardBundle<OrchardAuthorized, Amount>) -> HOBundle {
        return HOBundle {empty: false, actions: Haction::pack(b.actions()), flags: Hflags::pack(b.flags()), value: i64::from(b.value_balance()), anchor: Hhex{ bytes: b.anchor().to_bytes().to_vec()}, proof: Hhex { bytes: b.authorization().proof().as_ref().to_vec()}, bindingsig: Hhex {bytes: <[u8; 64]>::from(b.authorization().binding_signature()).to_vec()}}
    }
}


#[derive(Debug, BorshSerialize, BorshDeserialize)]
pub struct Hflags {
    spends: bool,
    outputs: bool
}

impl<RW> ToHaskell<RW> for Hflags {
    fn to_haskell<W: Write>(&self, writer: &mut W, _tag: PhantomData<RW>) -> Result<()> {
        self.serialize(writer)?;
        Ok(())
    }
}

impl Hflags {
    pub fn pack(f: &Flags) -> Hflags {
        return Hflags {spends: f.spends_enabled(), outputs: f.outputs_enabled()}
    }
}

#[derive(Debug, BorshSerialize, BorshDeserialize)]
pub struct Hufvk {
    net: u8,
    orchard: Vec<u8>,
    sapling: Vec<u8>,
    transparent: Vec<u8>
}

impl<RW> ToHaskell<RW> for Hufvk {
    fn to_haskell<W: Write>(&self, writer: &mut W, _tag: PhantomData<RW>) -> Result<()> {
        self.serialize(writer)?;
        Ok(())
    }
}

impl Hufvk {
    fn add_key_section(&mut self, fvk: &Fvk) {
        if let Fvk::Orchard(v) = fvk {
            self.orchard = v.to_vec();
        }
        if let Fvk::Sapling(w) = fvk {
            self.sapling = w.to_vec();
        }
        if let Fvk::P2pkh(x) = fvk {
            self.transparent = x.to_vec();
        }
    }
}

#[derive(Debug, BorshSerialize, BorshDeserialize)]
pub struct Hsvk {
    vk: Vec<u8>,
    ovk: Vec<u8>
}

impl<RW> ToHaskell<RW> for Hsvk {
    fn to_haskell<W: Write>(&self, writer: &mut W, _tag: PhantomData<RW>) -> Result<()> {
        self.serialize(writer)?;
        Ok(())
    }
}

#[derive(BorshSerialize, BorshDeserialize)]
pub struct Hfrontier {
    position: u64,
    leaf: Hhex,
    ommers: Vec<Hhex>
}
 
impl<RW> ToHaskell<RW> for Hfrontier {
    fn to_haskell<W: Write>(&self, writer: &mut W, _tag: PhantomData<RW>) -> Result<()> {
        self.serialize(writer)?;
        Ok(())
    }
}

impl<RW> FromHaskell<RW> for Hfrontier {
    fn from_haskell(buf: &mut &[u8], _tag: PhantomData<RW>) -> Result<Self> {
        let x = Hfrontier::deserialize(buf)?;
        Ok(x)
    }
}

fn to_array<T, const N: usize>(v: Vec<T>) -> [T; N] {
    v.try_into().unwrap_or_else(|v: Vec<T>| panic!("Expected a Vec of length {} but it was {}", N, v.len()))
}

#[no_mangle]
pub extern "C" fn rust_wrapper_f4jumble(
    input: *const u8,
    input_len: usize,
    out: *mut u8,
    out_len: &mut usize) {
    let input: Vec<u8> = marshall_from_haskell_var(input, input_len, RW);
    let result = f4jumble::f4jumble(&input).unwrap();
    marshall_to_haskell_var(&result, out, out_len, RW);
}

#[no_mangle]
pub extern "C" fn rust_wrapper_f4unjumble(
    input: *const u8,
    input_len: usize,
    out: *mut u8,
    out_len: &mut usize) {
    let input: Vec<u8> = marshall_from_haskell_var(input, input_len, RW);
    let result = f4jumble::f4jumble_inv(&input).unwrap();
    marshall_to_haskell_var(&result, out, out_len, RW);
}

#[no_mangle]
pub extern "C" fn rust_wrapper_ua_decode(
    input: *const u8,
    input_len: usize,
    out: *mut u8,
    out_len: &mut usize) {
    let input: String = marshall_from_haskell_var(input, input_len, RW);
    let dec_addy = Address::decode(&input);
    match dec_addy {
        Ok((n, ua)) => {
            let x = match n {
                Network::Main => 1,
                Network::Test => 2,
                Network::Regtest => 3
                };
            let mut hk = Hua { net: x, o_rec: vec![0], s_rec: vec![0], t_rec: vec![0], to_rec: vec![0] };
            let recvs = ua.items();
            recvs.iter().for_each(|k| hk.add_rec(k));
            marshall_to_haskell_var(&hk, out, out_len, RW);
        }
        Err(_e) => {
            let hk0 = Hua { net: 0, o_rec: vec![0], s_rec: vec![0], t_rec: vec![0], to_rec: vec![0]};
            marshall_to_haskell_var(&hk0, out, out_len, RW);
        }
    }
    //marshall_to_haskell_var(&result, out, out_len, RW);
}

#[no_mangle]
pub extern "C" fn rust_wrapper_shielded_decode(
    input: *const u8,
    input_len: usize) -> bool {
    let input: String = marshall_from_haskell_var(input, input_len, RW);
    ZcashAddress::try_from_encoded(&input).is_ok()
}

#[no_mangle]
pub extern "C" fn rust_wrapper_bech32decode(
    input: *const u8,
    input_len: usize,
    out: *mut u8,
    out_len: &mut usize
    ) {
    let input: String = marshall_from_haskell_var(input, input_len, RW);
    let decoded_bytes = bech32::decode(&input);
    match decoded_bytes {
        Ok((hrp, bytes)) => {
            let rd = RawData {hrp: hrp.as_bytes().to_vec(), bytes};
            marshall_to_haskell_var(&rd, out, out_len, RW);
        }
        Err(_e) => {
            let rd1 = RawData {hrp: "fail".into(), bytes: vec![0]};
            marshall_to_haskell_var(&rd1, out, out_len, RW);
        }
    }
}

#[no_mangle]
pub extern "C" fn rust_wrapper_bech32m_encode(
    hr: *const u8,
    hr_len: usize,
    b: *const u8,
    b_len: usize,
    out: *mut u8,
    out_len: &mut usize
    ) {
    let hr: String = marshall_from_haskell_var(hr, hr_len, RW);
    let hrp = Hrp::parse(&hr).unwrap();
    let b: Vec<u8> = marshall_from_haskell_var(b, b_len, RW);
    let string = bech32::encode::<Bech32m>(hrp, &b).unwrap();
    marshall_to_haskell_var(&string, out, out_len, RW);
}

#[no_mangle]
pub extern "C" fn rust_wrapper_svk_decode(
    input: *const u8,
    input_len: usize
    ) -> bool {
    let input: Vec<u8> = marshall_from_haskell_var(input, input_len, RW);
    let svk = ExtendedFullViewingKey::read(&*input);
    match svk {
        Ok(_k) => {
            true
        }
        Err(e) => {
            print!("{:?}", e);
            false
        }
    }
}

#[no_mangle]
pub extern "C" fn rust_wrapper_svk_check_address(
    key_input: *const u8,
    key_input_len: usize,
    address_input: *const u8,
    address_input_len: usize
    ) -> bool {
    let key_input: Vec<u8> = marshall_from_haskell_var(key_input, key_input_len, RW);
    let address_input: Vec<u8> = marshall_from_haskell_var(address_input, address_input_len, RW);
    let svk = ExtendedFullViewingKey::read(&*key_input);
    let sa = PaymentAddress::from_bytes(&to_array(address_input)).unwrap();
    match svk {
        Ok(k) => {
            let (_div_index, def_address) = k.default_address();
            sa == def_address
        }
        Err(_e) => {
            false
        }
    }
}

#[no_mangle]
pub extern "C" fn rust_wrapper_ufvk_check_address(
    key_input: *const u8,
    key_input_len: usize,
    address_input: *const u8,
    address_input_len: usize
    ) -> bool {
    let key: String = marshall_from_haskell_var(key_input, key_input_len, RW);
    let addy: String = marshall_from_haskell_var(address_input, address_input_len, RW);
    let dec_key = Ufvk::decode(&key);
    let dec_addy = Address::decode(&addy);
    match dec_key {
        Ok((n, ufvk)) => {
            let i = ufvk.items();
            if let Fvk::Orchard(k) = i[0] {
                let orch_key = FullViewingKey::from_bytes(&k).unwrap();
                let orch_addy = orch_key.address_at(0u32, Scope::External).to_raw_address_bytes();
                match dec_addy {
                    Ok((n, recs)) => {
                        let j = recs.items();
                        j[0] == Receiver::Orchard(orch_addy)
                    },
                    Err(_e) => {
                        false
                    }
                }
            } else {
                false
            }
        },
        Err(_e) => {
            false
        }
    }
}

#[no_mangle]
pub extern "C" fn rust_wrapper_ufvk_decode(
    input: *const u8,
    input_len: usize,
    out: *mut u8,
    out_len: &mut usize
    ) {
    let input: String = marshall_from_haskell_var(input, input_len, RW);
    let dec_key = Ufvk::decode(&input);
    match dec_key {
        Ok((n, ufvk)) => {
            let x = match n {
                Network::Main => 1,
                Network::Test => 2,
                Network::Regtest => 3
                };
            let mut hk = Hufvk { net: x, orchard: vec![0], sapling: vec![0], transparent: vec![0] };
            let fvks = ufvk.items();
            fvks.iter().for_each(|k| hk.add_key_section(k));
            marshall_to_haskell_var(&hk, out, out_len, RW);
        }
        Err(_e) => {
            let hk0 = Hufvk { net: 0, orchard: vec![0], sapling: vec![0], transparent: vec![0] };
            marshall_to_haskell_var(&hk0, out, out_len, RW);
        }
    }
}

#[no_mangle]
pub extern "C" fn rust_wrapper_sapling_esk_decrypt(
    key: *const u8,
    key_len: usize,
    note: *const u8,
    note_len: usize,
    external: bool,
    net: bool,
    pos: u64,
    out: *mut u8,
    out_len: &mut usize
 ){
    let sk: Vec<u8> = marshall_from_haskell_var(key, key_len, RW);
    let mut note_input: HshieldedOutput = marshall_from_haskell_var(note,note_len,RW);
    let esk = ExtendedSpendingKey::from_bytes(&sk);
    let main_domain = SaplingDomain::new(Zip212Enforcement::On);
    //let test_domain = SaplingDomain::for_height(TestNetwork, BlockHeight::from_u32(2000000));
    let scope = if external {
        SaplingScope::External
    } else {
        SaplingScope::Internal
    };
    match esk {
        Ok(k) => {
            let action = note_input.to_output_description();
                match action {
                Ok(action2) => {
                    let dfvk = k.to_diversifiable_full_viewing_key();
                    let ivk = dfvk.to_ivk(scope);
                    let nk = dfvk.to_nk(scope);
                    let pivk = SaplingPreparedIncomingViewingKey::new(&ivk);
                    let result = zcash_note_encryption::try_note_decryption(&main_domain, &pivk, &action2);
                    match result {
                        Some((n, r, m)) => {
                            let nullifier = n.nf(&nk, pos);
                            let rseed = match n.rseed() {
                                Rseed::BeforeZip212(x) => {
                                    Hrseed {kind: 1, bytes: x.to_bytes().to_vec()}
                                },
                                Rseed::AfterZip212(y) => {
                                    Hrseed {kind: 2, bytes: y.to_vec()}
                                }
                            };
                            let hn = Hnote {note: n.value().inner(), recipient: r.to_bytes().to_vec(), memo: m.as_slice().to_vec(), nullifier: nullifier.to_vec(), rho: vec![0], rseed };
                            marshall_to_haskell_var(&hn, out, out_len, RW);
                        },
                        None => {
                            let hn0 = Hnote { note: 0, recipient: vec![0], memo: vec![0], nullifier: vec![0], rho: vec![0], rseed: Hrseed{ kind: 0, bytes: vec![0]}};
                            marshall_to_haskell_var(&hn0, out, out_len, RW);
                        }
                    }
                },
                Err(_e1) => {
                    let hn0 = Hnote { note: 0, recipient: vec![0], memo: vec![0], nullifier: vec![0], rho: vec![0], rseed: Hrseed{ kind: 0, bytes: vec![0]} };
                    marshall_to_haskell_var(&hn0, out, out_len, RW);
                }
            }
        },
        Err(_e) => {
            let hn0 = Hnote { note: 0, recipient: vec![0], memo: vec![0], nullifier: vec![0], rho: vec![0], rseed: Hrseed{ kind: 0, bytes: vec![0]} };
            marshall_to_haskell_var(&hn0, out, out_len, RW);
        }
    }
}

#[no_mangle]
pub extern "C" fn rust_wrapper_sapling_note_decrypt_v2(
    key: *const u8,
    key_len: usize,
    note: *const u8,
    note_len: usize,
    out: *mut u8,
    out_len: &mut usize
    ){
    let evk: Vec<u8> = marshall_from_haskell_var(key, key_len, RW);
    let mut note_input: HshieldedOutput = marshall_from_haskell_var(note,note_len,RW);
    let svk = ExtendedFullViewingKey::read(&*evk);
    match svk {
        Ok(k) => {
            let domain = SaplingDomain::new(Zip212Enforcement::On);
            let action2 = note_input.to_output_description();
            match action2 {
                Ok(action3) => {
                    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, &action3);
                    match result {
                        Some((n, r, m)) => {
                            let rseed = match n.rseed() {
                                Rseed::BeforeZip212(x) => {
                                    Hrseed { kind: 1, bytes: x.to_bytes().to_vec()}
                                },
                                Rseed::AfterZip212(y) => {
                                    Hrseed { kind: 2, bytes: y.to_vec()}
                                }
                            };
                            let hn = Hnote {note: n.value().inner(), recipient: r.to_bytes().to_vec(), memo: m.as_slice().to_vec(), nullifier: vec![0], rho: vec![0], rseed};
                            marshall_to_haskell_var(&hn, out, out_len, RW);
                        }
                        None => {
                            let hn0 = Hnote { note: 0, recipient: vec![0], memo: vec![0], nullifier: vec![0], rho: vec![0], rseed: Hrseed {kind: 0, bytes: vec![0]}};
                            marshall_to_haskell_var(&hn0, out, out_len, RW);
                        }
                    }
                },
                Err(_e1) => {
                    let hn0 = Hnote { note: 0, recipient: vec![0], memo: vec![0] , nullifier: vec![0], rho: vec![0], rseed: Hrseed {kind: 0, bytes: vec![0]}};
                    marshall_to_haskell_var(&hn0, out, out_len, RW);
                }
            }
        }
        Err(_e) => {
            let hn0 = Hnote { note: 0, recipient: vec![0], memo: vec![0], nullifier: vec![0], rho: vec![0], rseed: Hrseed {kind: 0, bytes: vec![0]}};
            marshall_to_haskell_var(&hn0, out, out_len, RW);
        }
    }
}

#[no_mangle]
pub extern "C" fn rust_wrapper_orchard_note_decrypt(
    key: *const u8,
    key_len: usize,
    note: *const u8,
    note_len: usize,
    out: *mut u8,
    out_len: &mut usize
    ){
    let fvk_input: Vec<u8> = marshall_from_haskell_var(key, key_len, RW);
    let note_input: Haction = marshall_from_haskell_var(note, note_len, RW);
    let action: Action<Signature<SpendAuth>> = Action::from_parts(
        Nullifier::from_bytes(&to_array(note_input.nf.bytes)).unwrap(), 
        VerificationKey::try_from(to_array(note_input.rk.bytes)).unwrap(), 
        ExtractedNoteCommitment::from_bytes(&to_array(note_input.cmx.bytes)).unwrap(), 
        TransmittedNoteCiphertext {epk_bytes: to_array(note_input.eph_key.bytes), enc_ciphertext: to_array(note_input.enc_txt.bytes), out_ciphertext: to_array(note_input.out_txt.bytes)}, 
        ValueCommitment::from_bytes(&to_array(note_input.cv.bytes)).unwrap(), 
        Signature::from(to_array(note_input.auth.bytes)));
    let fvk_array = to_array(fvk_input);
    let domain = OrchardDomain::for_action(&action);
    let dec_fvk = FullViewingKey::from_bytes(&fvk_array);
    match dec_fvk {
        Some(fvk) => {
            let ivk = fvk.to_ivk(Scope::External);
            let pivk = PreparedIncomingViewingKey::new(&ivk);
            let result = zcash_note_encryption::try_note_decryption(&domain, &pivk, &action);
            match result {
                Some((n, r, m)) => {
                    let rho = n.rho().to_bytes().to_vec();
                    let rseed = Hrseed {kind: 3, bytes: n.rseed().as_bytes().to_vec()};
                    let hn = Hnote {note: n.value().inner(), recipient: r.to_raw_address_bytes().to_vec(), memo: m.to_vec(), nullifier: vec![0], rho, rseed};
                    marshall_to_haskell_var(&hn, out, out_len, RW);
                }
                None => {
                    let hn0 = Hnote { note: 0, recipient: vec![0], memo: vec![0], nullifier: vec![0], rho: vec![0], rseed: Hrseed {kind: 0, bytes: vec![0]}};
                    marshall_to_haskell_var(&hn0, out, out_len, RW);
                }
            }
        },
        None => {
            let hn0 = Hnote { note: 0, recipient: vec![0], memo: vec![0], nullifier: vec![0], rho: vec![0], rseed: Hrseed {kind: 0, bytes: vec![0]}};
            marshall_to_haskell_var(&hn0, out, out_len, RW);
        }
    }
}

#[no_mangle]
pub extern "C" fn rust_wrapper_orchard_note_decrypt_sk(
    key: *const u8,
    key_len: usize,
    note: *const u8,
    note_len: usize,
    external: bool,
    out: *mut u8,
    out_len: &mut usize
    ){
    let sk_input: Vec<u8> = marshall_from_haskell_var(key, key_len, RW);
    let note_input: Haction = marshall_from_haskell_var(note, note_len, RW);
    let action: Action<Signature<SpendAuth>> = Action::from_parts(
        Nullifier::from_bytes(&to_array(note_input.nf.bytes)).unwrap(), 
        VerificationKey::try_from(to_array(note_input.rk.bytes)).unwrap(), 
        ExtractedNoteCommitment::from_bytes(&to_array(note_input.cmx.bytes)).unwrap(), 
        TransmittedNoteCiphertext {epk_bytes: to_array(note_input.eph_key.bytes), enc_ciphertext: to_array(note_input.enc_txt.bytes), out_ciphertext: to_array(note_input.out_txt.bytes)}, 
        ValueCommitment::from_bytes(&to_array(note_input.cv.bytes)).unwrap(), 
        Signature::from(to_array(note_input.auth.bytes)));
    let sk_array = to_array(sk_input);
    let domain = OrchardDomain::for_action(&action);
    let dec_sk = SpendingKey::from_bytes(sk_array).unwrap();
    let fvk = FullViewingKey::from(&dec_sk);
    let ivk = if external {
        fvk.to_ivk(Scope::External)
    } else {
        fvk.to_ivk(Scope::Internal)
    };
    let pivk = PreparedIncomingViewingKey::new(&ivk);
    let result = zcash_note_encryption::try_note_decryption(&domain, &pivk, &action);
    match result {
        Some((n, r, m)) => {
            let rho = n.rho().to_bytes().to_vec();
            let rseed = Hrseed {kind: 3, bytes: n.rseed().as_bytes().to_vec()};
            let hn = Hnote {note: n.value().inner(), recipient: r.to_raw_address_bytes().to_vec(), memo: m.to_vec(), nullifier: n.nullifier(&fvk).to_bytes().to_vec(), rho, rseed};
            marshall_to_haskell_var(&hn, out, out_len, RW);
        }
        None => {
            let hn0 = Hnote { note: 0, recipient: vec![0], memo: vec![0], nullifier: vec![0], rho: vec![0], rseed: Hrseed {kind: 0, bytes: vec![0]}};
            marshall_to_haskell_var(&hn0, out, out_len, RW);
        }
    }
}

#[no_mangle]
pub extern "C" fn rust_wrapper_tx_read(
    tx: *const u8,
    tx_len: usize,
    out: *mut u8,
    out_len: &mut usize
    ){
    let tx_input: Vec<u8> = marshall_from_haskell_var(tx, tx_len, RW);
    let mut tx_reader = Cursor::new(tx_input);
    let parsed_tx = Transaction::read(&mut tx_reader, Nu5);
    match parsed_tx {
        Ok(t) => {
            let tb = t.transparent_bundle();
            let sb = t.sapling_bundle();
            let ob = t.orchard_bundle();
            let h1 = Htx 
                { txid: t.txid().as_ref().to_vec()
                , locktime: t.lock_time()
                , expiry: u32::from(t.expiry_height())
                , t_bundle: match tb {
                    Some(tb1) => {HTBundle::from_bundle(tb1)},
                    None => {HTBundle {empty: true, vin: vec![HTxIn {outpoint: Houtpoint {hash: vec![0], index: 0}, script: vec![0], sequence: 0}], vout: vec![HTxOut {amt: 0, script: vec![0]}], coinbase: false}}}
                , s_bundle: match sb {
                    Some(sb1) => {HSBundle::from_bundle(sb1)},
                    None => {HSBundle{empty: true, spends: vec![Hspend{cv:Hhex { bytes: vec![0]} , anchor:Hhex { bytes: vec![0]} , nullifier:Hhex { bytes: vec![0]} , rk:Hhex { bytes: vec![0]} , proof:Hhex { bytes: vec![0]} , authsig:Hhex { bytes: vec![0]} }], outputs: vec![HshieldedOutput {cv: Hhex { bytes: vec![0]}, cmu: Hhex { bytes: vec![0]}, eph_key: Hhex { bytes: vec![0]}, enc_txt: Hhex { bytes: vec![0]}, out_txt: Hhex { bytes: vec![0]}, proof: Hhex { bytes: vec![0]}}], value: 0, sig: vec![0]}} }
                , o_bundle: match ob {
                    Some(ob1) => {HOBundle::from_bundle(ob1)},
                    None => {HOBundle{empty: true, actions: vec![Haction {nf:Hhex { bytes: vec![0]} , rk:Hhex { bytes: vec![0]} , cmx:Hhex { bytes: vec![0]} , eph_key:Hhex { bytes: vec![0]} , enc_txt:Hhex { bytes: vec![0]} , out_txt:Hhex { bytes: vec![0]} , cv:Hhex { bytes: vec![0]} , auth:Hhex { bytes: vec![0]} }], flags: Hflags{ spends:false, outputs:false}, value: 0, anchor: Hhex { bytes: vec![0]}, proof: Hhex { bytes: vec![0]} , bindingsig: Hhex { bytes: vec![0]}}}
                }
                };
            marshall_to_haskell_var(&h1, out, out_len, RW);
        },
        Err(_e) => {
            let h0 = Htx 
                        {txid: vec![0], 
                        locktime: 0, 
                        expiry: 0, 
                        t_bundle: HTBundle 
                            {empty: true, 
                            vin: vec![HTxIn {outpoint: Houtpoint {hash: vec![0], index: 0}, script: vec![0], sequence: 0}], 
                            vout: vec![HTxOut {amt: 0, script: vec![0]}], 
                            coinbase: true},
                        s_bundle: HSBundle{empty: true, spends: vec![Hspend{cv:Hhex { bytes: vec![0]} , anchor:Hhex { bytes: vec![0]} , nullifier:Hhex { bytes: vec![0]} , rk:Hhex { bytes: vec![0]} , proof:Hhex { bytes: vec![0]} , authsig:Hhex { bytes: vec![0]} }], outputs: vec![HshieldedOutput {cv: Hhex { bytes: vec![0]}, cmu: Hhex { bytes: vec![0]}, eph_key: Hhex { bytes: vec![0]}, enc_txt: Hhex { bytes: vec![0]}, out_txt: Hhex { bytes: vec![0]}, proof: Hhex { bytes: vec![0]}}], value: 0, sig: vec![0]},
                        o_bundle: HOBundle{empty: true, actions: vec![Haction {nf:Hhex { bytes: vec![0]} , rk:Hhex { bytes: vec![0]} , cmx:Hhex { bytes: vec![0]} , eph_key:Hhex { bytes: vec![0]} , enc_txt:Hhex { bytes: vec![0]} , out_txt:Hhex { bytes: vec![0]} , cv:Hhex { bytes: vec![0]} , auth:Hhex { bytes: vec![0]} }], flags: Hflags{ spends:false, outputs:false}, value: 0, anchor: Hhex { bytes: vec![0]}, proof: Hhex { bytes: vec![0]} , bindingsig: Hhex { bytes: vec![0]}}
                        };
            marshall_to_haskell_var(&h0, out, out_len, RW);
        }
    }
}

#[no_mangle]
pub extern "C" fn rust_wrapper_tx_parse(
    tx: *const u8,
    tx_len: usize,
    out: *mut u8,
    out_len: &mut usize
    ){
    let tx_input: Vec<u8> = marshall_from_haskell_var(tx, tx_len, RW);
    let mut tx_reader = Cursor::new(tx_input);
    let parsed_tx = Transaction::read(&mut tx_reader, Nu5);
    match parsed_tx {
        Ok(t) => {
            let s_bundle = t.sapling_bundle();
            match s_bundle {
                Some(b) => {
                    let s_output = HshieldedOutput::pack(b.shielded_outputs());
                    marshall_to_haskell_var(&s_output, out, out_len, RW);
                },
                None => {
                    let mut z = Vec::new();
                    z.push(vec![0]);
                    marshall_to_haskell_var(&z, out, out_len, RW);
                }
            }

        },
        Err(_e) => {
            let mut y = Vec::new();
            y.push(vec![0]);
            marshall_to_haskell_var(&y, out, out_len, RW);
        }
    }
}

#[no_mangle]
pub extern "C" fn rust_wrapper_gen_seed_phrase(
    out: *mut u8,
    out_len: &mut usize
    ){
    let mnemonic: Mnemonic<English> = Mnemonic::generate(Count::Words24);
    let seed = mnemonic.phrase().as_bytes().to_vec();
    marshall_to_haskell_var(&seed, out, out_len, RW);
}

#[no_mangle]
pub extern "C" fn rust_wrapper_recover_seed(
    input: *const u8,
    input_len: usize,
    out: *mut u8,
    out_len: &mut usize
    ){
    let phrase: String = marshall_from_haskell_var(input, input_len, RW);
    let mnemonic = <Mnemonic<English>>::from_phrase(phrase);
    match mnemonic {
        Ok(m) => {
            let s = m.to_seed("").to_vec();
            marshall_to_haskell_var(&s, out, out_len, RW);
        },
        Err(_e) => {
            marshall_to_haskell_var(&vec![0], out, out_len, RW);
        }
    }
}

#[no_mangle]
pub extern "C" fn rust_wrapper_sapling_spendingkey(
    seed: *const u8,
    seed_len: usize,
    coin_type: u32,
    acc_id: u32,
    out: *mut u8,
    out_len: &mut usize
    ){
    let s: Vec<u8> = marshall_from_haskell_var(seed, seed_len, RW);
    let sk = spending_key(&s, coin_type, zcash_primitives::zip32::AccountId::try_from(acc_id).unwrap());
    marshall_to_haskell_var(&sk.to_bytes().to_vec(), out, out_len, RW);
}

#[no_mangle]
pub extern "C" fn rust_wrapper_sapling_paymentaddress(
    extspk: *const u8,
    extspk_len: usize,
    div_ix: u32,
    out: *mut u8,
    out_len: &mut usize
    ){
    let extspk: Vec<u8> = marshall_from_haskell_var(extspk, extspk_len, RW);
    if div_ix == 0 {
        let sp_key = ExtendedSpendingKey::from_bytes(&extspk);
        match sp_key {
            Ok(sp_key_x) => {
                let (_def_div, def_address) = sp_key_x.default_address();
                marshall_to_haskell_var(&def_address.to_bytes().to_vec(), out, out_len, RW);
            },
            Err(_e) => {
                marshall_to_haskell_var(&vec![0], out, out_len, RW);
            }
        }
    } else {
        let expsk = ExpandedSpendingKey::from_spending_key(&extspk);
        let fvk = SaplingFullViewingKey::from_expanded_spending_key(&expsk); 
        let dk = DiversifierKey::master(&extspk);
        let result = sapling_find_address(&fvk, &dk, DiversifierIndex::from(div_ix));
        match result {
            Some((_d, p_address)) => {
                marshall_to_haskell_var(&p_address.to_bytes().to_vec(), out, out_len, RW);
            },
            None => {
                marshall_to_haskell_var(&vec![0], out, out_len, RW);
            }
        }
    }
}

#[no_mangle]
pub extern "C" fn rust_wrapper_sapling_chgpaymentaddress(
    extspk: *const u8,
    extspk_len: usize,
    out: *mut u8,
    out_len: &mut usize
    ){
    let vexspk: Vec<u8> = marshall_from_haskell_var(extspk, extspk_len, RW);
    let vexspkp = &vexspk;
    let extspku8 : &[u8] = &vexspkp;
    let extspk =  match ExtendedSpendingKey::from_bytes(&extspku8) {
        Ok( k ) => k,
        Err( _e ) => {
            // error recovering ExtendedSpendingKey
            marshall_to_haskell_var(&vec![0], out, out_len, RW);
            return
        }
    };
    let dfvk = extspk.to_diversifiable_full_viewing_key();
    let ( _divIx, cPmtAddress ) = dfvk.change_address();
    marshall_to_haskell_var(&cPmtAddress.to_bytes().to_vec(), out, out_len, RW);
}

#[no_mangle]
pub extern "C" fn rust_wrapper_derive_orchard_spending_key(
    seed: *const u8,
    seed_len: usize,
    coin_type: u32,
    acc_id: u32,
    out: *mut u8,
    out_len: &mut usize
    ){
    let s: Vec<u8> = marshall_from_haskell_var(seed, seed_len, RW);
    let sk = SpendingKey::from_zip32_seed(&s, coin_type, zip32::AccountId::try_from(acc_id).unwrap());
    match sk {
        Ok(key) => {
            marshall_to_haskell_var(&key.to_bytes().to_vec(), out, out_len, RW);
        },
        Err(_e) => {
            marshall_to_haskell_var(&vec![0], out, out_len, RW);
        }
    }
}

#[no_mangle]
pub extern "C" fn rust_wrapper_derive_orchard_receiver(
    spend_key: *const u8,
    spend_key_len: usize,
    add_id: u32,
    scope: bool,
    out: *mut u8,
    out_len: &mut usize
    ){
    let sk_in: Vec<u8> = marshall_from_haskell_var(spend_key, spend_key_len, RW);
    let sk = SpendingKey::from_bytes(sk_in[0..32].try_into().unwrap()).unwrap();
    let fvk = FullViewingKey::from(&sk);
    let sc = if scope {
        Scope::External
    } else {Scope::Internal};
    let o_rec = fvk.address_at(add_id, sc);
    marshall_to_haskell_var(&o_rec.to_raw_address_bytes().to_vec(), out, out_len, RW);

}

#[no_mangle]
pub extern "C" fn rust_wrapper_bech32_encode(
    hr: *const u8,
    hr_len: usize,
    b: *const u8,
    b_len: usize,
    out: *mut u8,
    out_len: &mut usize
    ) {
    let hr: String = marshall_from_haskell_var(hr, hr_len, RW);
    let hrp = Hrp::parse(&hr).unwrap();
    let b: Vec<u8> = marshall_from_haskell_var(b, b_len, RW);
    let string = bech32::encode::<Bech32>(hrp, &b).unwrap();
    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| Hhex { bytes: 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![Hhex { bytes: 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,
    tree_len: usize,
    node: *const u8,
    node_len: usize,
    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.bytes.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| Hhex { bytes: 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![Hhex { bytes: vec![0]}]};
        marshall_to_haskell_var(&f0, out, out_len, RW);
    }
}

#[no_mangle]
pub extern "C" fn rust_wrapper_read_sapling_witness(
    tree: *const u8,
    tree_len: usize,
    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.bytes.clone())).unwrap() ).collect()).unwrap();
    let ct: CommitmentTree<Node, SAPLING_DEPTH> = CommitmentTree::from_frontier(&frontier);
    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);
    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);
        }
    }
}

#[no_mangle]
pub extern "C" fn rust_wrapper_read_sapling_position(
    wit: *const u8,
    wit_len: usize,
    ) -> u64 {
    let wit_in: Vec<u8> = marshall_from_haskell_var(wit, wit_len, RW);
    let wit_reader = Cursor::new(wit_in);
    let iw: IncrementalWitness<Node, SAPLING_DEPTH> = read_incremental_witness(wit_reader).unwrap();
    let pos = iw.witnessed_position();
    return u64::from(pos);
}

#[no_mangle]
pub extern "C" fn rust_wrapper_update_sapling_witness(
    wit: *const u8,
    wit_len: usize,
    cmus: *const u8,
    cmus_len: usize,
    out: *mut u8,
    out_len: &mut usize
    ) {
    let wit_in: Vec<u8> = marshall_from_haskell_var(wit, wit_len, RW);
    let wit_reader = Cursor::new(wit_in);
    let mut iw: IncrementalWitness<Node, SAPLING_DEPTH> = read_incremental_witness(wit_reader).unwrap();
    let cmu: Vec<Vec<u8>> = marshall_from_haskell_var(cmus, cmus_len, RW);
    for c in cmu {
        let sap_note_comm = SaplingNoteCommitment::from_bytes(&to_array(c));
        if sap_note_comm.is_some().into() {
            let n = Node::from_cmu(&sap_note_comm.unwrap());
            iw.append(n);
        }
    }
    let mut out_bytes: Vec<u8> = Vec::new();
    let result = write_incremental_witness(&iw, &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);
        }
    }
}

#[no_mangle]
pub extern "C" fn rust_wrapper_read_orchard_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 = read_commitment_tree(tree_reader);
    //let comm_tree = read_frontier_v1(tree_reader);
    //let frontier: Frontier<MerkleHashOrchard, 32> = comm_tree.to_frontier();
    match comm_tree {
        Ok::<CommitmentTree<MerkleHashOrchard, 32>, _>(f1) => {
            let frontier = f1.to_frontier();
            match frontier.value() {
                Some(f2) => {
                    let (pos, leaf, omm) = f2.clone().into_parts();
                    let f = Hfrontier { position: <u64>::from(pos), leaf: Hhex { bytes: leaf.to_bytes().to_vec()}, ommers: omm.iter().map(|&x| Hhex { bytes: 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![Hhex { bytes: vec![0]}]};
                    marshall_to_haskell_var(&f0, out, out_len, RW);
                }
            }
        },
        Err(_e) => {
            let f0 = Hfrontier { position: 0, leaf: Hhex { bytes: vec![0]}, ommers: vec![Hhex { bytes: vec![0]}]};
            marshall_to_haskell_var(&f0, out, out_len, RW);
        }
    }
}

#[no_mangle]
pub extern "C" fn rust_wrapper_read_orchard_tree_anchor(
    tree: *const u8,
    tree_len: usize,
    out: *mut u8,
    out_len: &mut usize
    ){
    let tree_in: Hfrontier = marshall_from_haskell_var(tree, tree_len, RW);
    let leaf = MerkleHashOrchard::from_bytes(&to_array(tree_in.leaf.bytes)).unwrap();
    let comm_tree: NonEmptyFrontier<MerkleHashOrchard> = NonEmptyFrontier::from_parts(Position::from(tree_in.position), leaf, tree_in.ommers.iter().map(|x| MerkleHashOrchard::from_bytes(&to_array(x.bytes.clone())).unwrap() ).collect()).unwrap();
    let root = comm_tree.root(None);
    let h = Hhex { bytes: root.to_bytes().to_vec() };
    marshall_to_haskell_var(&h, out, out_len, RW);
}

#[no_mangle]
pub extern "C" fn rust_wrapper_read_orchard_witness_anchor(
    wit: *const u8,
    wit_len: usize,
    out: *mut u8,
    out_len: &mut usize
    ) {
    let wit_in: Vec<u8> = marshall_from_haskell_var(wit, wit_len, RW);
    let wit_reader = Cursor::new(wit_in);
    let iw: IncrementalWitness<MerkleHashOrchard, 32> = read_incremental_witness(wit_reader).unwrap();
    let root = iw.root();
    let h = Hhex { bytes: root.to_bytes().to_vec() };
    marshall_to_haskell_var(&h, out, out_len, RW);
}

#[no_mangle]
pub extern "C" fn rust_wrapper_read_orchard_node(
    cmx: *const u8,
    cmx_len: usize,
    out: *mut u8,
    out_len: &mut usize
    ){
    let node_in: Vec<u8> = marshall_from_haskell_var(cmx, cmx_len, RW);
    let orchard_note_comm = ExtractedNoteCommitment::from_bytes(&to_array(node_in));
    if orchard_note_comm.is_some().into() {
        let n = MerkleHashOrchard::from_cmx(&orchard_note_comm.unwrap());
        let h = Hhex { bytes: n.to_bytes().to_vec()};
        marshall_to_haskell_var(&h, out, out_len, RW);
    } else {
        let h0 = Hhex { bytes: vec![0] };
        marshall_to_haskell_var(&h0, out, out_len, RW);
    }
}

#[no_mangle]
pub extern "C" fn rust_wrapper_combine_orchard_nodes(
    level: u8,
    left: *const u8,
    left_len: usize,
    right: *const u8,
    right_len: usize,
    out: *mut u8,
    out_len: &mut usize
    ){
    let left_in: Vec<u8> = marshall_from_haskell_var(left, left_len, RW);
    let right_in: Vec<u8> = marshall_from_haskell_var(right, right_len, RW);
    if left_in.len() == 1 {
            let n = MerkleHashOrchard::combine(Level::new(level), &MerkleHashOrchard::empty_leaf(), &MerkleHashOrchard::empty_leaf());
            let h = Hhex { bytes: n.to_bytes().to_vec() };
            marshall_to_haskell_var(&h, out, out_len, RW);
    } else {
        let left_node = MerkleHashOrchard::from_bytes(&to_array(left_in));
        if left_node.is_some().into() {
            if right_in.len() > 1 {
                let right_node = MerkleHashOrchard::from_bytes(&to_array(right_in));
                if right_node.is_some().into() {
                    let n = MerkleHashOrchard::combine(Level::new(level), &left_node.unwrap(), &right_node.unwrap());
                    let h = Hhex { bytes: n.to_bytes().to_vec() };
                    marshall_to_haskell_var(&h, out, out_len, RW);
                } else {
                    let h0 = Hhex { bytes: vec![0] };
                    marshall_to_haskell_var(&h0, out, out_len, RW);
                }
            } else {
                let n = MerkleHashOrchard::combine(Level::new(level), &left_node.unwrap(), &MerkleHashOrchard::empty_leaf());
                let h = Hhex { bytes: n.to_bytes().to_vec() };
                marshall_to_haskell_var(&h, out, out_len, RW);
            }
        } else {
            let h0 = Hhex { bytes: vec![0] };
            marshall_to_haskell_var(&h0, out, out_len, RW);
        }
    }
}


#[no_mangle]
pub extern "C" fn rust_wrapper_read_orchard_commitment_tree(
    tree: *const u8,
    tree_len: usize,
    node: *const u8,
    node_len: usize,
    out: *mut u8,
    out_len: &mut usize
    ){
    let tree_in: Hfrontier = marshall_from_haskell_var(tree, tree_len, RW);
    //let tree_reader = Cursor::new(tree_in);
    //let mut comm_tree: CommitmentTree<MerkleHashOrchard, 32> = read_commitment_tree(tree_reader).unwrap();
    //let mut comm_tree: Frontier<MerkleHashOrchard, 32> = read_frontier_v1(tree_reader).unwrap();
    let leaf = MerkleHashOrchard::from_bytes(&to_array(tree_in.leaf.bytes)).unwrap();
    let mut comm_tree: NonEmptyFrontier<MerkleHashOrchard> = NonEmptyFrontier::from_parts(Position::from(tree_in.position), leaf, tree_in.ommers.iter().map(|x| MerkleHashOrchard::from_bytes(&to_array(x.bytes.clone())).unwrap() ).collect()).unwrap();
    let node_in: Vec<u8> = marshall_from_haskell_var(node, node_len, RW);
    let orchard_note_comm = ExtractedNoteCommitment::from_bytes(&to_array(node_in));
    if orchard_note_comm.is_some().into() {
        let n = MerkleHashOrchard::from_cmx(&orchard_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| Hhex { bytes: 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![Hhex { bytes: vec![0]}]};
        marshall_to_haskell_var(&f0, out, out_len, RW);
    }
}

#[no_mangle]
pub extern "C" fn rust_wrapper_read_orchard_witness(
    tree: *const u8,
    tree_len: usize,
    out: *mut u8,
    out_len: &mut usize
    ){
    let tree_in: Hfrontier = marshall_from_haskell_var(tree, tree_len, RW);
    let leaf = MerkleHashOrchard::from_bytes(&to_array(tree_in.leaf.bytes)).unwrap();
    let frontier: Frontier<MerkleHashOrchard, 32> = Frontier::from_parts(Position::from(tree_in.position), leaf, tree_in.ommers.iter().map(|x| MerkleHashOrchard::from_bytes(&to_array(x.bytes.clone())).unwrap() ).collect()).unwrap();
    let ct: CommitmentTree<MerkleHashOrchard, 32> = CommitmentTree::from_frontier(&frontier);
    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);
    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);
        }
    }
}


#[no_mangle]
pub extern "C" fn rust_wrapper_read_orchard_position(
    wit: *const u8,
    wit_len: usize,
    ) -> u64 {
    let wit_in: Vec<u8> = marshall_from_haskell_var(wit, wit_len, RW);
    let wit_reader = Cursor::new(wit_in);
    let iw: IncrementalWitness<MerkleHashOrchard, 32> = read_incremental_witness(wit_reader).unwrap();
    let path = iw.path();
    match path {
        Some(p) => {
            let pos = p.position();
            return u64::from(pos);
        },
        None => {
            return 0;
        }
    }
}

#[no_mangle]
pub extern "C" fn rust_wrapper_update_orchard_witness(
    wit: *const u8,
    wit_len: usize,
    cm: *const u8,
    cm_len: usize,
    out: *mut u8,
    out_len: &mut usize
    ) {
    let wit_in: Vec<u8> = marshall_from_haskell_var(wit, wit_len, RW);
    let wit_reader = Cursor::new(wit_in);
    let mut iw: IncrementalWitness<MerkleHashOrchard, 32> = read_incremental_witness(wit_reader).unwrap();
    let cmu: Vec<Vec<u8>> = marshall_from_haskell_var(cm, cm_len, RW);
    for c in cmu {
            let orchard_note_comm = ExtractedNoteCommitment::from_bytes(&to_array(c));
            if orchard_note_comm.is_some().into() {
                let n = MerkleHashOrchard::from_cmx(&orchard_note_comm.unwrap());
                iw.append(n);
            }
    }
    let mut out_bytes: Vec<u8> = Vec::new();
    let result = write_incremental_witness(&iw, &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);
            }
    }
}

#[no_mangle]
pub extern "C" fn rust_wrapper_decode_sapling_address(
    sapling: *const u8,
    sapling_len: usize,
    out: *mut u8,
    out_len: &mut usize){
    let sapling_address_from_haskell : Vec<u8> = marshall_from_haskell_var(sapling, sapling_len, RW);
    let sapling_address = std::str::from_utf8(&sapling_address_from_haskell).unwrap();

    let mut netid = 0;
    match sapling_address.find("1") {
        Some(ix) => {
                let netstr = &sapling_address[0..ix];
                if  netstr == "zs" {
                    netid = 1
                } else {
                    if netstr == "ztestsapling" {
                        netid = 2
                    }    
                } 
            match decode_payment_address(netstr, sapling_address) {
                Ok( t )=> {
                    let address_to_bytes = t.to_bytes();
                    let mut out_bytes_temp : [u8;44] = [0;44];
                    out_bytes_temp[0] = netid;
                    let mut iy = 1;
                    for ix in 0..43 {
                        out_bytes_temp[iy] = address_to_bytes[ix];
                        iy += 1;
                    } 
                    let out_bytes: Vec<u8> = out_bytes_temp.to_vec();
                    marshall_to_haskell_var(&out_bytes, out, out_len, RW);
                }
                Err(_e) => {
                    let h = vec![0];
                    marshall_to_haskell_var(&h, out, out_len, RW);
                }
            }
        }
        None => {
            let h = vec![0];
            marshall_to_haskell_var(&h, out, out_len, RW);
        }
    } 
} 

#[no_mangle]
pub extern "C" fn rust_wrapper_create_transaction(
    sap_wit: *const u8,
    sap_wit_len: usize,
    orch_wit: *const u8,
    orch_wit_len: usize,
    t_input: *const u8,
    t_input_len: usize,
    s_input: *const u8,
    s_input_len: usize,
    o_input: *const u8,
    o_input_len: usize,
    out_list: *const u8,
    out_list_len: usize,
    net: bool,
    bl_height: u32,
    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() {
            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_input: Vec<HorchardInput> = marshall_from_haskell_var(o_input, o_input_len, RW);
    //let orch_anchor = match orch_iw {
        //Ok(o_iw) => {
            //Some(OrchardAnchor::from(o_iw.root()))
        //},
        //Err(_e) => {
            //None
        //}
    //}; 
    let orch_anchor =
        if orch_input.is_empty() {
            None
        } else {
            let oi = &orch_input[0];
            let wit_reader = Cursor::new(&oi.iw);
            let iw: IncrementalWitness<MerkleHashOrchard, 32> = read_incremental_witness(wit_reader).unwrap();
            Some(OrchardAnchor::from(iw.root()))
        };
    let build_config = BuildConfig::Standard {sapling_anchor: sap_anchor, orchard_anchor: orch_anchor};
    let mut main_builder = Builder::new(MainNetwork, BlockHeight::from(bl_height), build_config);
    let mut test_builder =  Builder::new(TestNetwork, BlockHeight::from(bl_height), build_config);
    let trans_input: Vec<HtransparentInput> = marshall_from_haskell_var(t_input, t_input_len, RW);
    for t_in in trans_input {
        if t_in.sk.len() > 1 {
            println!("t inp: {:?}", t_in);
            let k = SecretKey::from_slice(&t_in.sk).unwrap();
            if net {
                match main_builder.add_transparent_input(k, t_in.utxo.unpack(), t_in.coin.unpack()) {
                    Ok(()) => {
                        //println!("added t-input in main");
                        continue;
                    },
                    Err(_e) => { println!("Error reading transparent input"); }
                }
            } else {
                match test_builder.add_transparent_input(k, t_in.utxo.unpack(), t_in.coin.unpack()) {
                    Ok(()) => {
                        //println!("added t-input in test");
                        continue;
                    },
                    Err(_e) => { println!("Error reading transparent input"); }
                }
            }
        }
    }
    for s_in in sap_input {
        if s_in.sk.len() > 1 {
            println!("s inp: {:?}", s_in);
            let sp_key = ExtendedSpendingKey::from_bytes(&s_in.sk);
            match sp_key {
                Ok(sk) => {
                    let pay_addr = PaymentAddress::from_bytes(&to_array(s_in.note.recipient)).unwrap();
                    let rseed = if s_in.note.rseed.kind == 1 {
                        Rseed::BeforeZip212(Fr::from_bytes(&to_array(s_in.note.rseed.bytes)).unwrap())
                    } else {
                        Rseed::AfterZip212(to_array(s_in.note.rseed.bytes))
                    };
                    let note = SaplingNote::from_parts(pay_addr, SaplingNoteValue::from_raw(s_in.note.note), rseed);
                    let wit_reader = Cursor::new(s_in.iw);
                    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);
                            }
                        }
                    } 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);
                            }
                        }
                    }
                },
                Err(_e) => {
                    let x = Hhex {bytes: vec![5]};
                    marshall_to_haskell_var(&x, out, out_len, RW);
                }
            }
        }
    }
    for o_in in orch_input {
        if o_in.sk.len() > 1 {
            println!("o inp: {:?}", o_in);
            let sp_key = SpendingKey::from_bytes(o_in.sk[0..32].try_into().unwrap()).unwrap();
            let pay_addr = OrchardAddress::from_raw_address_bytes(&to_array(o_in.note.recipient)).unwrap();
            let rho = Rho::from_bytes(&to_array(o_in.note.rho)).unwrap();
            let rseed = RandomSeed::from_bytes(to_array(o_in.note.rseed.bytes), &rho).unwrap();
            let val = NoteValue::from_raw(o_in.note.note);
            let note = Note::from_parts(pay_addr, val, rho, rseed).unwrap();
            let wit_reader = Cursor::new(o_in.iw);
            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);
                    }
                }
            } 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 outputs: Vec<Houtput> = marshall_from_haskell_var(out_list, out_list_len, RW);
    for output in outputs {
        match output.kind {
            1 => {
                let recipient = TransparentAddress::PublicKeyHash(to_array(output.to));
                let val = NonNegativeAmount::from_u64(output.amt).unwrap();
                println!("t out: {:?} {:?}", val, output.chg);
                if net {
                    let _mb = main_builder.add_transparent_output(&recipient, val);
                } else {
                    let _tb = test_builder.add_transparent_output(&recipient, val);
                }
            },
            2 => {
                let recipient = TransparentAddress::ScriptHash(to_array(output.to));
                let val = NonNegativeAmount::from_u64(output.amt).unwrap();
                println!("t out: {:?} {:?}", val, output.chg);
                if net {
                    let _mb = main_builder.add_transparent_output(&recipient, val);
                } else {
                    let _tb = test_builder.add_transparent_output(&recipient, val);
                }
            },
            3 => {
                let ovk = Some(ExpandedSpendingKey::from_spending_key(&output.ovk).ovk);
                let recipient = PaymentAddress::from_bytes(&to_array(output.to)).unwrap();
                let val = NonNegativeAmount::from_u64(output.amt).unwrap();
                let memo = MemoBytes::from_bytes(&output.memo).unwrap();
                println!("s out: {:?} {:?}", val, output.chg);
                if net {
                    let _mb = main_builder.add_sapling_output::<String>(ovk, recipient, val, memo);
                } else {
                    let _tb = test_builder.add_sapling_output::<String>(ovk, recipient, val, memo);
                }
            },
            4 => {
                let sk = SpendingKey::from_bytes(output.ovk[0..32].try_into().unwrap()).unwrap();
                let ovk = if output.chg {
                    Some(FullViewingKey::from(&sk).to_ovk(Scope::Internal))
                } else {
                    Some(FullViewingKey::from(&sk).to_ovk(Scope::External))
                        };
                let recipient = OrchardAddress::from_raw_address_bytes(&to_array(output.to)).unwrap();
                let val = output.amt;
                println!("o out: {:?} {:?}", val, output.chg);
                let memo = MemoBytes::from_bytes(&output.memo).unwrap();
                if net {
                    let _mb = main_builder.add_orchard_output::<String>(ovk, recipient, val, memo);
                } else {
                    let _tb = test_builder.add_orchard_output::<String>(ovk, recipient, val, memo);
                }
            },
            _ => {
                continue;
            }
        }
    }
    if build {
        let (spend_params_in, output_params_in) = load_sapling_parameters();
        //let spend_params_in: Vec<u8> = marshall_from_haskell_var(sapspend, sapspend_len, RW);
        let spend_params_reader = Cursor::new(spend_params_in);
        let spend_prover = SpendParameters::read(spend_params_reader, false).unwrap();
        //let output_params_in: Vec<u8> = marshall_from_haskell_var(sapoutput, sapoutput_len, RW);
        let output_params_reader = Cursor::new(output_params_in);
        let output_prover = OutputParameters::read(output_params_reader, false).unwrap();
        let result = if net {
            main_builder.build(OsRng, &spend_prover, &output_prover, &FeeRule::standard())
        } else {
            test_builder.build(OsRng, &spend_prover, &output_prover, &FeeRule::standard())
        };
        match result {
            Ok(r) => {
                let mut out_bytes: Vec<u8> = Vec::new();
                let _t = r.transaction().write_v5(&mut out_bytes);
                let h = Hhex {bytes: out_bytes};
                marshall_to_haskell_var(&h, out, out_len, RW);
            },
            Err(e) => {
                match e {
                    Error::InsufficientFunds(y) => {
                        let x = Hhex {bytes: vec![0]};
                        marshall_to_haskell_var(&x, out, out_len, RW);
                    },
                    Error::ChangeRequired(y1) => {
                        let x = Hhex {bytes: vec![1]};
                        marshall_to_haskell_var(&x, out, out_len, RW);
                    },
                    Error::Fee(_y2) => {
                        let x = Hhex {bytes: vec![2]};
                        marshall_to_haskell_var(&x, out, out_len, RW);
                    },
                    Error::Balance(y3) => {
                        let x = Hhex {bytes: vec![3]};
                        marshall_to_haskell_var(&x, out, out_len, RW);
                    },
                    Error::TransparentBuild(y4) => {
                        let x = Hhex {bytes: vec![4]};
                        marshall_to_haskell_var(&x, out, out_len, RW);
                    },
                    Error::SaplingBuild(y5) => {
                        let x = Hhex {bytes: vec![5]};
                        marshall_to_haskell_var(&x, out, out_len, RW);
                    },
                    Error::OrchardBuild(y7) => {
                        let x = Hhex {bytes: vec![6]};
                        marshall_to_haskell_var(&x, out, out_len, RW);
                    },
                    Error::OrchardSpend(y8) => {
                        let x = Hhex {bytes: vec![7]};
                        marshall_to_haskell_var(&x, out, out_len, RW);
                    },
                    Error::OrchardRecipient(y9) => {
                        let x = Hhex {bytes: vec![8]};
                        marshall_to_haskell_var(&x, out, out_len, RW);
                    },
                    Error::SaplingBuilderNotAvailable => {
                        let x = Hhex {bytes: vec![9]};
                        marshall_to_haskell_var(&x, out, out_len, RW);
                    },
                    Error::OrchardBuilderNotAvailable => {
                        let x = Hhex {bytes: vec![10]};
                        marshall_to_haskell_var(&x, out, out_len, RW);
                    }
                }
            }
        }
    } else {
        let result = if net {
            main_builder.get_fee(&FeeRule::standard())
        } else {
            test_builder.get_fee(&FeeRule::standard())
        };
        match result {
            Ok(r) => {
                let x = Hhex {bytes: r.to_i64_le_bytes().to_vec()};
                marshall_to_haskell_var(&x, out, out_len, RW);
            },
            Err(e) => {
                let x = Hhex {bytes: vec![2]};
                marshall_to_haskell_var(&x, out, out_len, RW);
            }
        }
    }
}