//! Demo implementation of TZE consensus rules.
//!
//! The demo program implements a dual-hash-lock encumbrance with the following form:
//!
//! > `hash = BLAKE2b_256(preimage_1 || BLAKE2b_256(preimage_2))`
//!
//! The two preimages are revealed in sequential transactions, demonstrating how TZEs can
//! impose constraints on how program modes are chained together.
//!
//! The demo program has two modes:
//!
//! - Mode 0: `hash_1 = BLAKE2b_256(preimage_1 || hash_2)`
//! - Mode 1: `hash_2 = BLAKE2b_256(preimage_2)`
//!
//! and uses the following transaction formats:
//!
//! - `tx_a`: `[ [any input types...] ----> TzeOut(value, hash_1) ]`
//! - `tx_b`: `[ TzeIn(tx_a, preimage_1) -> TzeOut(value, hash_2) ]`
//! - `tx_c`: `[ TzeIn(tx_b, preimage_2) -> [any output types...] ]`

use std::convert::TryFrom;
use std::convert::TryInto;
use std::fmt;
use std::ops::{Deref, DerefMut};

use blake2b_simd::Params;

use zcash_primitives::{
    extensions::transparent::{Extension, ExtensionTxBuilder, FromPayload, ToPayload},
    transaction::components::{
        amount::Amount,
        tze::{OutPoint, TzeOut},
    },
};

/// Types and constants used for Mode 0 (open a channel)
mod open {
    pub const MODE: u32 = 0;

    #[derive(Debug, PartialEq)]
    pub struct Precondition(pub [u8; 32]);

    #[derive(Debug, PartialEq)]
    pub struct Witness(pub [u8; 32]);
}

/// Types and constants used for Mode 1 (close a channel)
mod close {
    pub const MODE: u32 = 1;

    #[derive(Debug, PartialEq)]
    pub struct Precondition(pub [u8; 32]);

    #[derive(Debug, PartialEq)]
    pub struct Witness(pub [u8; 32]);
}

/// The precondition type for the demo extension.
#[derive(Debug, PartialEq)]
pub enum Precondition {
    Open(open::Precondition),
    Close(close::Precondition),
}

impl Precondition {
    /// Convenience constructor for opening precondition values.
    pub fn open(hash: [u8; 32]) -> Self {
        Precondition::Open(open::Precondition(hash))
    }

    /// Convenience constructor for closing precondition values.
    pub fn close(hash: [u8; 32]) -> Self {
        Precondition::Close(close::Precondition(hash))
    }
}

/// Errors that may be produced during parsing and verification of demo preconditions and
/// witnesses.
#[derive(Debug, PartialEq)]
pub enum Error {
    /// Parse error indicating that the payload of the condition or the witness was
    /// not 32 bytes.
    IllegalPayloadLength(usize),
    /// Verification error indicating that the specified mode was not recognized by
    /// the extension.
    ModeInvalid(u32),
    /// Verification error indicating that the transaction provided in the verification
    /// context was missing required TZE inputs or outputs.
    NonTzeTxn,
    /// Verification error indicating that the witness being verified did not satisfy the
    /// precondition under inspection.
    HashMismatch,
    /// Verification error indicating that the mode requested by the witness value did not
    /// conform to that of the precondition under inspection.
    ModeMismatch,
    /// Verification error indicating that an `Open`-mode precondition was encountered
    /// when a `Close` was expected.
    ExpectedClose,
    /// Verification error indicating that an unexpected number of TZE outputs (more than
    /// one) was encountered in the transaction under inspection, in violation of
    /// the extension's invariants.
    InvalidOutputQty(usize),
}

impl fmt::Display for Error {
    fn fmt<'a>(&self, f: &mut fmt::Formatter<'a>) -> fmt::Result {
        match self {
            Error::IllegalPayloadLength(sz) => write!(f, "Illegal payload length for demo: {}", sz),
            Error::ModeInvalid(m) => write!(f, "Invalid TZE mode for demo program: {}", m),
            Error::NonTzeTxn => write!(f, "Transaction has non-TZE inputs."),
            Error::HashMismatch => write!(f, "Hash mismatch"),
            Error::ModeMismatch => write!(f, "Extension operation mode mismatch."),
            Error::ExpectedClose => write!(f, "Got open, expected close."),
            Error::InvalidOutputQty(qty) => write!(f, "Incorrect number of outputs: {}", qty),
        }
    }
}

impl TryFrom<(u32, Precondition)> for Precondition {
    type Error = Error;

    fn try_from(from: (u32, Self)) -> Result<Self, Self::Error> {
        match from {
            (open::MODE, Precondition::Open(p)) => Ok(Precondition::Open(p)),
            (close::MODE, Precondition::Close(p)) => Ok(Precondition::Close(p)),
            _ => Err(Error::ModeInvalid(from.0)),
        }
    }
}

impl FromPayload for Precondition {
    type Error = Error;

    fn from_payload(mode: u32, payload: &[u8]) -> Result<Self, Self::Error> {
        match mode {
            open::MODE => payload
                .try_into()
                .map_err(|_| Error::IllegalPayloadLength(payload.len()))
                .map(Precondition::open),

            close::MODE => payload
                .try_into()
                .map_err(|_| Error::IllegalPayloadLength(payload.len()))
                .map(Precondition::close),

            _ => Err(Error::ModeInvalid(mode)),
        }
    }
}

impl ToPayload for Precondition {
    fn to_payload(&self) -> (u32, Vec<u8>) {
        match self {
            Precondition::Open(p) => (open::MODE, p.0.to_vec()),
            Precondition::Close(p) => (close::MODE, p.0.to_vec()),
        }
    }
}

/// The witness type for the demo extension.
#[derive(Debug, PartialEq)]
pub enum Witness {
    Open(open::Witness),
    Close(close::Witness),
}

impl Witness {
    pub fn open(preimage: [u8; 32]) -> Self {
        Witness::Open(open::Witness(preimage))
    }

    pub fn close(preimage: [u8; 32]) -> Self {
        Witness::Close(close::Witness(preimage))
    }
}

impl TryFrom<(u32, Witness)> for Witness {
    type Error = Error;

    fn try_from(from: (u32, Self)) -> Result<Self, Self::Error> {
        match from {
            (open::MODE, Witness::Open(p)) => Ok(Witness::Open(p)),
            (close::MODE, Witness::Close(p)) => Ok(Witness::Close(p)),
            _ => Err(Error::ModeInvalid(from.0)),
        }
    }
}

impl FromPayload for Witness {
    type Error = Error;

    fn from_payload(mode: u32, payload: &[u8]) -> Result<Self, Self::Error> {
        match mode {
            open::MODE => payload
                .try_into()
                .map_err(|_| Error::IllegalPayloadLength(payload.len()))
                .map(Witness::open),

            close::MODE => payload
                .try_into()
                .map_err(|_| Error::IllegalPayloadLength(payload.len()))
                .map(Witness::close),

            _ => Err(Error::ModeInvalid(mode)),
        }
    }
}

impl ToPayload for Witness {
    fn to_payload(&self) -> (u32, Vec<u8>) {
        match self {
            Witness::Open(w) => (open::MODE, w.0.to_vec()),
            Witness::Close(w) => (close::MODE, w.0.to_vec()),
        }
    }
}

/// This trait defines the context information that the demo extension requires
/// be made available to it by a consensus node integrating this extension.
///
/// This context type provides accessors to information relevant to a single
/// transaction being validated by the extension.
pub trait Context {
    /// Predicate used to determine whether this transaction has only TZE
    /// inputs and outputs. The demo extension does not support verification
    /// of transactions which have either shielded or transparent inputs and
    /// outputs.
    fn is_tze_only(&self) -> bool;

    /// List of all TZE outputs in the transaction being validate by the extension.
    fn tx_tze_outputs(&self) -> &[TzeOut];
}

/// Marker type for the demo extension.
///
/// A value of this type will be used as the receiver for
/// `zcash_primitives::extensions::transparent::Extension` method invocations.
pub struct Program;

impl<C: Context> Extension<C> for Program {
    type Precondition = Precondition;
    type Witness = Witness;
    type Error = Error;

    /// Runs the program against the given precondition, witness, and context.
    ///
    /// At this point the precondition and witness have been parsed and validated
    /// non-contextually, and are guaranteed to both be for this program. All subsequent
    /// validation is this function's responsibility.
    fn verify_inner(
        &self,
        precondition: &Precondition,
        witness: &Witness,
        context: &C,
    ) -> Result<(), Error> {
        // This match statement is selecting the mode that the program is operating in,
        // based on the enums defined in the parser.
        match (precondition, witness) {
            (Precondition::Open(p_open), Witness::Open(w_open)) => {
                // In OPEN mode, we enforce that the transaction must only contain inputs
                // and outputs from this program. The consensus rules enforce that if a
                // transaction contains both TZE inputs and TZE outputs, they must all be
                // of the same program type. Therefore we only need to check that the
                // transaction does not contain any other type of input or output.
                if !context.is_tze_only() {
                    return Err(Error::NonTzeTxn);
                }

                // Next, check that there is only a single TZE output of the correct type.
                let outputs = context.tx_tze_outputs();
                match outputs {
                    [tze_out] => match Precondition::from_payload(
                        tze_out.precondition.mode,
                        &tze_out.precondition.payload,
                    ) {
                        Ok(Precondition::Close(p_close)) => {
                            // Finally, check the precondition:
                            // precondition_open = BLAKE2b_256(witness_open || precondition_close)
                            let hash = Params::new()
                                .hash_length(32)
                                .personal(b"demo_pc_h1_perso")
                                .to_state()
                                .update(&w_open.0)
                                .update(&p_close.0)
                                .finalize();
                            if hash.as_bytes() == p_open.0 {
                                Ok(())
                            } else {
                                Err(Error::HashMismatch)
                            }
                        }
                        Ok(Precondition::Open(_)) => Err(Error::ExpectedClose),
                        Err(e) => Err(e),
                    },
                    _ => Err(Error::InvalidOutputQty(outputs.len())),
                }
            }
            (Precondition::Close(p), Witness::Close(w)) => {
                // In CLOSE mode, we only require that the precondition is satisfied:
                // precondition_close = BLAKE2b_256(witness_close)
                let hash = Params::new()
                    .hash_length(32)
                    .personal(b"demo_pc_h2_perso")
                    .hash(&w.0);
                if hash.as_bytes() == p.0 {
                    Ok(())
                } else {
                    Err(Error::HashMismatch)
                }
            }
            _ => Err(Error::ModeMismatch),
        }
    }
}

fn hash_1(preimage_1: &[u8; 32], hash_2: &[u8; 32]) -> [u8; 32] {
    let mut hash = [0; 32];
    hash.copy_from_slice(
        Params::new()
            .hash_length(32)
            .personal(b"demo_pc_h1_perso")
            .to_state()
            .update(preimage_1)
            .update(hash_2)
            .finalize()
            .as_bytes(),
    );
    hash
}

/// Wrapper for [`zcash_primitives::transaction::builder::Builder`] that simplifies
/// constructing transactions that utilize the features of the demo extension.
pub struct DemoBuilder<B> {
    /// The wrapped transaction builder.
    pub txn_builder: B,

    /// The assigned identifier for this extension. This is necessary as the author
    /// of the demo extension will not know ahead of time what identifier will be
    /// assigned to it at the time of inclusion in the Zcash consensus rules.
    pub extension_id: u32,
}

impl<B> Deref for DemoBuilder<B> {
    type Target = B;

    fn deref(&self) -> &Self::Target {
        &self.txn_builder
    }
}

impl<B> DerefMut for DemoBuilder<B> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.txn_builder
    }
}

/// Errors that can occur in construction of transactions using `DemoBuilder`.
#[derive(Debug)]
pub enum DemoBuildError<E> {
    /// Wrapper for errors returned from the underlying `Builder`
    BaseBuilderError(E),
    ExpectedOpen,
    ExpectedClose,
    PrevoutParseFailure(Error),
    TransferMismatch {
        expected: [u8; 32],
        actual: [u8; 32],
    },
    CloseMismatch {
        expected: [u8; 32],
        actual: [u8; 32],
    },
}

/// Convenience methods for use with [`zcash_primitives::transaction::builder::Builder`]
/// for constructing transactions that utilize the features of the demo extension.
impl<'a, B: ExtensionTxBuilder<'a>> DemoBuilder<B> {
    /// Add a channel-opening precondition to the outputs of the transaction under
    /// construction.
    pub fn demo_open(
        &mut self,
        value: Amount,
        hash_1: [u8; 32],
    ) -> Result<(), DemoBuildError<B::BuildError>> {
        // Call through to the generic builder.
        self.txn_builder
            .add_tze_output(self.extension_id, value, &Precondition::open(hash_1))
            .map_err(DemoBuildError::BaseBuilderError)
    }

    /// Add a witness to a previous channel-opening precondition and a new channel-closing
    /// precondition to the transaction under construction.
    pub fn demo_transfer_to_close(
        &mut self,
        prevout: (OutPoint, TzeOut),
        transfer_amount: Amount,
        preimage_1: [u8; 32],
        hash_2: [u8; 32],
    ) -> Result<(), DemoBuildError<B::BuildError>> {
        let h1 = hash_1(&preimage_1, &hash_2);

        // eagerly validate the relationship between prevout.1 and preimage_1
        match Precondition::from_payload(
            prevout.1.precondition.mode,
            &prevout.1.precondition.payload,
        ) {
            Err(parse_failure) => Err(DemoBuildError::PrevoutParseFailure(parse_failure)),

            Ok(Precondition::Close(_)) => Err(DemoBuildError::ExpectedOpen),

            Ok(Precondition::Open(hash)) if hash.0 != h1 => Err(DemoBuildError::TransferMismatch {
                expected: hash.0,
                actual: h1,
            }),

            Ok(Precondition::Open(_)) => {
                self.txn_builder
                    .add_tze_input(self.extension_id, open::MODE, prevout, move |_| {
                        Ok(Witness::open(preimage_1))
                    })
                    .map_err(DemoBuildError::BaseBuilderError)?;

                self.txn_builder
                    .add_tze_output(
                        self.extension_id,
                        transfer_amount,
                        &Precondition::close(hash_2),
                    )
                    .map_err(DemoBuildError::BaseBuilderError)
            }
        }
    }

    /// Add a channel-closing witness to the transaction under construction.
    pub fn demo_close(
        &mut self,
        prevout: (OutPoint, TzeOut),
        preimage_2: [u8; 32],
    ) -> Result<(), DemoBuildError<B::BuildError>> {
        let hash_2 = {
            let mut hash = [0; 32];
            hash.copy_from_slice(
                Params::new()
                    .hash_length(32)
                    .personal(b"demo_pc_h2_perso")
                    .hash(&preimage_2)
                    .as_bytes(),
            );

            hash
        };

        // eagerly validate the relationship between prevout.1 and preimage_2
        match Precondition::from_payload(
            prevout.1.precondition.mode,
            &prevout.1.precondition.payload,
        ) {
            Err(parse_failure) => Err(DemoBuildError::PrevoutParseFailure(parse_failure)),

            Ok(Precondition::Open(_)) => Err(DemoBuildError::ExpectedClose),

            Ok(Precondition::Close(hash)) if hash.0 != hash_2 => {
                Err(DemoBuildError::CloseMismatch {
                    expected: hash.0,
                    actual: hash_2,
                })
            }

            Ok(Precondition::Close(_)) => self
                .txn_builder
                .add_tze_input(self.extension_id, close::MODE, prevout, move |_| {
                    Ok(Witness::close(preimage_2))
                })
                .map_err(DemoBuildError::BaseBuilderError),
        }
    }
}

#[cfg(test)]
mod tests {
    use blake2b_simd::Params;
    use ff::{Field, PrimeField};
    use rand_core::OsRng;

    use zcash_proofs::prover::LocalTxProver;

    use zcash_primitives::{
        consensus::{BlockHeight, BranchId, NetworkUpgrade, Parameters},
        constants,
        extensions::transparent::{self as tze, Extension, FromPayload, ToPayload},
        legacy::TransparentAddress,
        merkle_tree::{CommitmentTree, IncrementalWitness},
        sapling::{Node, Rseed},
        transaction::{
            builder::Builder,
            components::{
                amount::{Amount, DEFAULT_FEE},
                tze::{Authorized, Bundle, OutPoint, TzeIn, TzeOut},
            },
            Transaction, TransactionData, TxVersion,
        },
        zip32::ExtendedSpendingKey,
    };

    use super::{close, hash_1, open, Context, DemoBuilder, Precondition, Program, Witness};

    #[derive(PartialEq, Copy, Clone, Debug)]
    struct FutureNetwork;

    impl Parameters for FutureNetwork {
        fn activation_height(&self, nu: NetworkUpgrade) -> Option<BlockHeight> {
            match nu {
                NetworkUpgrade::Overwinter => Some(BlockHeight::from_u32(207_500)),
                NetworkUpgrade::Sapling => Some(BlockHeight::from_u32(280_000)),
                NetworkUpgrade::Blossom => Some(BlockHeight::from_u32(584_000)),
                NetworkUpgrade::Heartwood => Some(BlockHeight::from_u32(903_800)),
                NetworkUpgrade::Canopy => Some(BlockHeight::from_u32(1_028_500)),
                NetworkUpgrade::Nu5 => Some(BlockHeight::from_u32(1_200_000)),
                NetworkUpgrade::ZFuture => Some(BlockHeight::from_u32(1_400_000)),
            }
        }

        fn address_network(&self) -> Option<zcash_address::Network> {
            None
        }

        fn coin_type(&self) -> u32 {
            constants::testnet::COIN_TYPE
        }

        fn hrp_sapling_extended_spending_key(&self) -> &str {
            constants::testnet::HRP_SAPLING_EXTENDED_SPENDING_KEY
        }

        fn hrp_sapling_extended_full_viewing_key(&self) -> &str {
            constants::testnet::HRP_SAPLING_EXTENDED_FULL_VIEWING_KEY
        }

        fn hrp_sapling_payment_address(&self) -> &str {
            constants::testnet::HRP_SAPLING_PAYMENT_ADDRESS
        }

        fn b58_pubkey_address_prefix(&self) -> [u8; 2] {
            constants::testnet::B58_PUBKEY_ADDRESS_PREFIX
        }

        fn b58_script_address_prefix(&self) -> [u8; 2] {
            constants::testnet::B58_SCRIPT_ADDRESS_PREFIX
        }
    }
    fn demo_hashes(preimage_1: &[u8; 32], preimage_2: &[u8; 32]) -> ([u8; 32], [u8; 32]) {
        let hash_2 = {
            let mut hash = [0; 32];
            hash.copy_from_slice(
                Params::new()
                    .hash_length(32)
                    .personal(b"demo_pc_h2_perso")
                    .hash(preimage_2)
                    .as_bytes(),
            );
            hash
        };

        (hash_1(preimage_1, &hash_2), hash_2)
    }

    #[test]
    fn precondition_open_round_trip() {
        let data = vec![7; 32];
        let p = Precondition::from_payload(open::MODE, &data).unwrap();
        assert_eq!(p, Precondition::Open(open::Precondition([7; 32])));
        assert_eq!(p.to_payload(), (open::MODE, data));
    }

    #[test]
    fn precondition_close_round_trip() {
        let data = vec![7; 32];
        let p = Precondition::from_payload(close::MODE, &data).unwrap();
        assert_eq!(p, Precondition::Close(close::Precondition([7; 32])));
        assert_eq!(p.to_payload(), (close::MODE, data));
    }

    #[test]
    fn precondition_rejects_invalid_mode_or_length() {
        for mode in 0..3 {
            for len in &[31, 33] {
                let p = Precondition::from_payload(mode, &vec![7; *len]);
                assert!(p.is_err());
            }
        }
    }

    #[test]
    fn witness_open_round_trip() {
        let data = vec![7; 32];
        let w = Witness::from_payload(open::MODE, &data).unwrap();
        assert_eq!(w, Witness::open([7; 32]));
        assert_eq!(w.to_payload(), (open::MODE, data));
    }

    #[test]
    fn witness_close_round_trip() {
        let data = vec![7; 32];
        let p = Witness::from_payload(close::MODE, &data).unwrap();
        assert_eq!(p, Witness::close([7; 32]));
        assert_eq!(p.to_payload(), (close::MODE, data));
    }

    #[test]
    fn witness_rejects_invalid_mode_or_length() {
        for mode in 0..3 {
            for len in &[31, 33] {
                let p = Witness::from_payload(mode, &vec![7; *len]);
                assert!(p.is_err());
            }
        }
    }

    /// Dummy context
    pub struct Ctx<'a> {
        pub tx: &'a Transaction,
    }

    /// Implementation of required operations for the demo extension, as satisfied
    /// by the context.
    impl<'a> Context for Ctx<'a> {
        fn is_tze_only(&self) -> bool {
            self.tx.transparent_bundle().is_none()
                && self.tx.sapling_bundle().is_none()
                && self.tx.sprout_bundle().is_none()
                && self.tx.orchard_bundle().is_none()
        }

        fn tx_tze_outputs(&self) -> &[TzeOut] {
            match self.tx.tze_bundle() {
                Some(b) => &b.vout,
                None => &[],
            }
        }
    }

    fn demo_builder<'a>(height: BlockHeight) -> DemoBuilder<Builder<'a, FutureNetwork, OsRng>> {
        DemoBuilder {
            txn_builder: Builder::new(FutureNetwork, height),
            extension_id: 0,
        }
    }

    #[test]
    fn demo_program() {
        let preimage_1 = [1; 32];
        let preimage_2 = [2; 32];

        let hash_2 = {
            let mut hash = [0; 32];
            hash.copy_from_slice(
                Params::new()
                    .hash_length(32)
                    .personal(b"demo_pc_h2_perso")
                    .hash(&preimage_2)
                    .as_bytes(),
            );
            hash
        };

        let hash_1 = {
            let mut hash = [0; 32];
            hash.copy_from_slice(
                Params::new()
                    .hash_length(32)
                    .personal(b"demo_pc_h1_perso")
                    .to_state()
                    .update(&preimage_1)
                    .update(&hash_2)
                    .finalize()
                    .as_bytes(),
            );
            hash
        };

        //
        // Opening transaction
        //

        let out_a = TzeOut {
            value: Amount::from_u64(1).unwrap(),
            precondition: tze::Precondition::from(0, &Precondition::open(hash_1)),
        };

        let tx_a = TransactionData::from_parts(
            TxVersion::ZFuture,
            BranchId::ZFuture,
            0,
            0u32.into(),
            None,
            None,
            None,
            None,
            Some(Bundle {
                vin: vec![],
                vout: vec![out_a],
                authorization: Authorized,
            }),
        )
        .freeze()
        .unwrap();

        //
        // Transfer
        //

        let in_b = TzeIn {
            prevout: OutPoint::new(tx_a.txid(), 0),
            witness: tze::Witness::from(0, &Witness::open(preimage_1)),
        };
        let out_b = TzeOut {
            value: Amount::from_u64(1).unwrap(),
            precondition: tze::Precondition::from(0, &Precondition::close(hash_2)),
        };

        let tx_b = TransactionData::from_parts(
            TxVersion::ZFuture,
            BranchId::ZFuture,
            0,
            0u32.into(),
            None,
            None,
            None,
            None,
            Some(Bundle {
                vin: vec![in_b],
                vout: vec![out_b],
                authorization: Authorized,
            }),
        )
        .freeze()
        .unwrap();

        //
        // Closing transaction
        //

        let in_c = TzeIn {
            prevout: OutPoint::new(tx_b.txid(), 0),
            witness: tze::Witness::from(0, &Witness::close(preimage_2)),
        };

        let tx_c = TransactionData::from_parts(
            TxVersion::ZFuture,
            BranchId::ZFuture,
            0,
            0u32.into(),
            None,
            None,
            None,
            None,
            Some(Bundle {
                vin: vec![in_c],
                vout: vec![],
                authorization: Authorized,
            }),
        )
        .freeze()
        .unwrap();

        // Verify tx_b
        {
            let ctx = Ctx { tx: &tx_b };
            assert_eq!(
                Program.verify(
                    &tx_a.tze_bundle().unwrap().vout[0].precondition,
                    &tx_b.tze_bundle().unwrap().vin[0].witness,
                    &ctx
                ),
                Ok(())
            );
        }

        // Verify tx_c
        {
            let ctx = Ctx { tx: &tx_c };
            assert_eq!(
                Program.verify(
                    &tx_b.tze_bundle().unwrap().vout[0].precondition,
                    &tx_c.tze_bundle().unwrap().vin[0].witness,
                    &ctx
                ),
                Ok(())
            );
        }
    }

    #[test]
    fn demo_builder_program() {
        let preimage_1 = [1; 32];
        let preimage_2 = [2; 32];

        let tx_height = FutureNetwork
            .activation_height(NetworkUpgrade::ZFuture)
            .unwrap();

        // Only run the test if we have the prover parameters.
        let prover = match LocalTxProver::with_default_location() {
            Some(prover) => prover,
            None => return,
        };

        //
        // Opening transaction
        //

        let mut rng = OsRng;

        // create some inputs to spend
        let extsk = ExtendedSpendingKey::master(&[]);
        let to = extsk.default_address().1;
        let note1 = to
            .create_note(110000, Rseed::BeforeZip212(jubjub::Fr::random(&mut rng)))
            .unwrap();
        let cm1 = Node::new(note1.cmu().to_repr());
        let mut tree = CommitmentTree::empty();
        // fake that the note appears in some previous
        // shielded output
        tree.append(cm1).unwrap();
        let witness1 = IncrementalWitness::from_tree(&tree);

        let mut builder_a = demo_builder(tx_height);
        builder_a
            .add_sapling_spend(extsk, *to.diversifier(), note1, witness1.path().unwrap())
            .unwrap();

        let value = Amount::from_u64(100000).unwrap();
        let (h1, h2) = demo_hashes(&preimage_1, &preimage_2);
        builder_a
            .demo_open(value, h1)
            .map_err(|e| format!("open failure: {:?}", e))
            .unwrap();
        let (tx_a, _) = builder_a
            .txn_builder
            .build(&prover)
            .map_err(|e| format!("build failure: {:?}", e))
            .unwrap();
        let tze_a = tx_a.tze_bundle().unwrap();

        //
        // Transfer
        //

        let mut builder_b = demo_builder(tx_height + 1);
        let prevout_a = (OutPoint::new(tx_a.txid(), 0), tze_a.vout[0].clone());
        let value_xfr = (value - DEFAULT_FEE).unwrap();
        builder_b
            .demo_transfer_to_close(prevout_a, value_xfr, preimage_1, h2)
            .map_err(|e| format!("transfer failure: {:?}", e))
            .unwrap();
        let (tx_b, _) = builder_b
            .txn_builder
            .build(&prover)
            .map_err(|e| format!("build failure: {:?}", e))
            .unwrap();
        let tze_b = tx_b.tze_bundle().unwrap();

        //
        // Closing transaction
        //

        let mut builder_c = demo_builder(tx_height + 2);
        let prevout_b = (OutPoint::new(tx_a.txid(), 0), tze_b.vout[0].clone());
        builder_c
            .demo_close(prevout_b, preimage_2)
            .map_err(|e| format!("close failure: {:?}", e))
            .unwrap();

        builder_c
            .add_transparent_output(
                &TransparentAddress::PublicKey([0; 20]),
                (value_xfr - DEFAULT_FEE).unwrap(),
            )
            .unwrap();

        let (tx_c, _) = builder_c
            .txn_builder
            .build(&prover)
            .map_err(|e| format!("build failure: {:?}", e))
            .unwrap();
        let tze_c = tx_c.tze_bundle().unwrap();

        // Verify tx_b
        let ctx0 = Ctx { tx: &tx_b };
        assert_eq!(
            Program.verify(&tze_a.vout[0].precondition, &tze_b.vin[0].witness, &ctx0),
            Ok(())
        );

        // Verify tx_c
        let ctx1 = Ctx { tx: &tx_c };
        assert_eq!(
            Program.verify(&tze_b.vout[0].precondition, &tze_c.vin[0].witness, &ctx1),
            Ok(())
        );
    }
}