include_simc! macros

[ikripaka]

I'm now able to introduce a draft version of macros that would simplify building Witness and Arguments for a program.

https://github.com/BlockstreamResearch/simplicity-contracts/blob/main/crates/contracts/src/finance/options/mod.rs

The most common task when building witness and arguments are:

• constructing them from hash maps;
• building witness values;
• defining hte contract source and function to compile it into program.
  https://github.com/BlockstreamResearch/simplicity-contracts/blob/aaaf2fbc521cc20711e33d4726cbd4aa68c34962/crates/contracts/src/finance/options/build_arguments.rs#L215

Needless to note, that this feature can be made with the help of AbiMeta struct, which is defined here.
Proc macro expands in compile time, so we're able to use its functionality.

We have a macro called include_simf, where you only need to insert the path to the SimplicityHL contract.
Currently, it expands and can create the following:

• module with contract name
• CONTRACT_SOURCE
• get_options_template_program
• build_witness::<contract_name>Witness struct
• build_arguments::<contract_name>Witness::build_witness()
• build_arguments::<contract_name>Witness::from_witness()
• build_arguments::<contract_name>Arguments struct
• build_arguments::<contract_name>Arguments::build_arguments()
• build_arguments::<contract_name>Arguments::from_arguments()

We also plan to deliver derive macros that can match branch sides and expand code.

#[derive(Debug, Clone)]
#[to_simf(Options2Witness)]
pub enum OptionBranch {
    #[left, left]
    Funding {
        expected_asset_amount: u64,
        input_option_abf: U256,
        input_option_vbf: U256,
        input_grantor_abf: U256,
        input_grantor_vbf: U256,
        output_option_abf: U256,
        output_option_vbf: U256,
        output_grantor_abf: U256,
        output_grantor_vbf: U256,
    },
    #[left, right]
    Exercise {
        is_change_needed: bool,
        amount_to_burn: u64,
        collateral_amount_to_get: u64,
        asset_amount: u64,
    },
    #[right, left, left]
    Settlement {
        is_change_needed: bool,
        grantor_token_amount_to_burn: u64,
        asset_amount: u64,
    },
    #[right, left, right]
    Expiry {
        is_change_needed: bool,
        grantor_token_amount_to_burn: u64,
        collateral_amount_to_withdraw: u64,
    },
    #[right, right, left]
    Cancellation {
        is_change_needed: bool,
        amount_to_burn: u64,
        collateral_amount_to_withdraw: u64,
    },
}

Expansion example

#![feature(prelude_import)]
#[macro_use]
extern crate std;
#[prelude_import]
use std::prelude::rust_2024::*;
use bincode::error::{DecodeError, EncodeError};
use bincode::*;
use simplicityhl_macros::include_simf;
pub mod derived_options {
    use simplicityhl::elements::Address;
    use simplicityhl::simplicity::bitcoin::XOnlyPublicKey;
    use simplicityhl_core::{
        create_p2tr_address, load_program, ProgramError, SimplicityNetwork,
    };
    use simplicityhl::CompiledProgram;
    pub const OPTIONS_CONTRACT_SOURCE: &str = "<contract source>";
    /// Get the options template program for instantiation.
    ///
    /// # Panics
    /// - if the embedded source fails to compile (should never happen).
    #[must_use]
    pub fn get_template_program() -> ::simplicityhl::TemplateProgram {
        ::simplicityhl::TemplateProgram::new(OPTIONS_CONTRACT_SOURCE)
            .expect("INTERNAL: expected 'options' Program to compile successfully.")
    }
    /// Derive P2TR address for an option offer contract.
    ///
    /// # Errors
    ///
    /// Returns error if program compilation fails.
    pub fn get_option_offer_address(
        x_only_public_key: &XOnlyPublicKey,
        arguments: &OptionsArguments,
        network: SimplicityNetwork,
    ) -> Result<Address, ProgramError> {
        Ok(
            create_p2tr_address(
                get_loaded_program(arguments)?.commit().cmr(),
                x_only_public_key,
                network.address_params(),
            ),
        )
    }
    /// Compile option offer program with the given arguments.
    ///
    /// # Errors
    ///
    /// Returns error if compilation fails.
    pub fn get_loaded_program(
        arguments: &OptionsArguments,
    ) -> Result<CompiledProgram, ProgramError> {
        load_program(OPTIONS_CONTRACT_SOURCE, arguments.build_arguments())
    }
    /// Get compiled option offer program, panicking on failure.
    ///
    /// # Panics
    ///
    /// Panics if program instantiation fails.
    #[must_use]
    pub fn get_compiled_program(arguments: &OptionsArguments) -> CompiledProgram {
        let program = get_template_program();
        program.instantiate(arguments.build_arguments(), true).unwrap()
    }
    pub use build_witness::*;
    mod build_witness {
        use std::collections::HashMap;
        use simplicityhl::{WitnessValues, Value, ResolvedType};
        use simplicityhl::value::{UIntValue, ValueInner};
        use simplicityhl::num::U256;
        use simplicityhl::str::WitnessName;
        use simplicityhl::types::TypeConstructible;
        use simplicityhl::value::ValueConstructible;
        pub struct OptionsWitness {
            pub path: ::simplicityhl::either::Either<
                ::simplicityhl::either::Either<
                    (
                        u64,
                        [u8; 32],
                        [u8; 32],
                        [u8; 32],
                        [u8; 32],
                        [u8; 32],
                        [u8; 32],
                        [u8; 32],
                        [u8; 32],
                    ),
                    ::simplicityhl::either::Either<
                        (bool, u64, u64, u64),
                        (bool, u64, u64),
                    >,
                >,
                ::simplicityhl::either::Either<(bool, u64, u64), (bool, u64, u64)>,
            >,
        }
        #[automatically_derived]
        impl ::core::fmt::Debug for OptionsWitness {
            #[inline]
            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                ::core::fmt::Formatter::debug_struct_field1_finish(
                    f,
                    "OptionsWitness",
                    "path",
                    &&self.path,
                )
            }
        }
        #[automatically_derived]
        impl ::core::clone::Clone for OptionsWitness {
            #[inline]
            fn clone(&self) -> OptionsWitness {
                OptionsWitness {
                    path: ::core::clone::Clone::clone(&self.path),
                }
            }
        }
        #[automatically_derived]
        impl ::core::marker::StructuralPartialEq for OptionsWitness {}
        #[automatically_derived]
        impl ::core::cmp::PartialEq for OptionsWitness {
            #[inline]
            fn eq(&self, other: &OptionsWitness) -> bool {
                self.path == other.path
            }
        }
        #[automatically_derived]
        impl ::core::cmp::Eq for OptionsWitness {
            #[inline]
            #[doc(hidden)]
            #[coverage(off)]
            fn assert_receiver_is_total_eq(&self) -> () {
                let _: ::core::cmp::AssertParamIsEq<
                    ::simplicityhl::either::Either<
                        ::simplicityhl::either::Either<
                            (
                                u64,
                                [u8; 32],
                                [u8; 32],
                                [u8; 32],
                                [u8; 32],
                                [u8; 32],
                                [u8; 32],
                                [u8; 32],
                                [u8; 32],
                            ),
                            ::simplicityhl::either::Either<
                                (bool, u64, u64, u64),
                                (bool, u64, u64),
                            >,
                        >,
                        ::simplicityhl::either::Either<
                            (bool, u64, u64),
                            (bool, u64, u64),
                        >,
                    >,
                >;
            }
        }
        #[doc(hidden)]
        #[allow(
            non_upper_case_globals,
            unused_attributes,
            unused_qualifications,
            clippy::absolute_paths,
        )]
        const _: () = {
            #[allow(unused_extern_crates, clippy::useless_attribute)]
            extern crate serde as _serde;
            #[automatically_derived]
            impl _serde::Serialize for OptionsWitness {
                fn serialize<__S>(
                    &self,
                    __serializer: __S,
                ) -> _serde::__private228::Result<__S::Ok, __S::Error>
                where
                    __S: _serde::Serializer,
                {
                    let mut __serde_state = _serde::Serializer::serialize_struct(
                        __serializer,
                        "OptionsWitness",
                        false as usize + 1,
                    )?;
                    _serde::ser::SerializeStruct::serialize_field(
                        &mut __serde_state,
                        "path",
                        &self.path,
                    )?;
                    _serde::ser::SerializeStruct::end(__serde_state)
                }
            }
        };
        #[doc(hidden)]
        #[allow(
            non_upper_case_globals,
            unused_attributes,
            unused_qualifications,
            clippy::absolute_paths,
        )]
        const _: () = {
            #[allow(unused_extern_crates, clippy::useless_attribute)]
            extern crate serde as _serde;
            #[automatically_derived]
            impl<'de> _serde::Deserialize<'de> for OptionsWitness {
                fn deserialize<__D>(
                    __deserializer: __D,
                ) -> _serde::__private228::Result<Self, __D::Error>
                where
                    __D: _serde::Deserializer<'de>,
                {
                    #[allow(non_camel_case_types)]
                    #[doc(hidden)]
                    enum __Field {
                        __field0,
                        __ignore,
                    }
                    #[doc(hidden)]
                    struct __FieldVisitor;
                    #[automatically_derived]
                    impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
                        type Value = __Field;
                        fn expecting(
                            &self,
                            __formatter: &mut _serde::__private228::Formatter,
                        ) -> _serde::__private228::fmt::Result {
                            _serde::__private228::Formatter::write_str(
                                __formatter,
                                "field identifier",
                            )
                        }
                        fn visit_u64<__E>(
                            self,
                            __value: u64,
                        ) -> _serde::__private228::Result<Self::Value, __E>
                        where
                            __E: _serde::de::Error,
                        {
                            match __value {
                                0u64 => _serde::__private228::Ok(__Field::__field0),
                                _ => _serde::__private228::Ok(__Field::__ignore),
                            }
                        }
                        fn visit_str<__E>(
                            self,
                            __value: &str,
                        ) -> _serde::__private228::Result<Self::Value, __E>
                        where
                            __E: _serde::de::Error,
                        {
                            match __value {
                                "path" => _serde::__private228::Ok(__Field::__field0),
                                _ => _serde::__private228::Ok(__Field::__ignore),
                            }
                        }
                        fn visit_bytes<__E>(
                            self,
                            __value: &[u8],
                        ) -> _serde::__private228::Result<Self::Value, __E>
                        where
                            __E: _serde::de::Error,
                        {
                            match __value {
                                b"path" => _serde::__private228::Ok(__Field::__field0),
                                _ => _serde::__private228::Ok(__Field::__ignore),
                            }
                        }
                    }
                    #[automatically_derived]
                    impl<'de> _serde::Deserialize<'de> for __Field {
                        #[inline]
                        fn deserialize<__D>(
                            __deserializer: __D,
                        ) -> _serde::__private228::Result<Self, __D::Error>
                        where
                            __D: _serde::Deserializer<'de>,
                        {
                            _serde::Deserializer::deserialize_identifier(
                                __deserializer,
                                __FieldVisitor,
                            )
                        }
                    }
                    #[doc(hidden)]
                    struct __Visitor<'de> {
                        marker: _serde::__private228::PhantomData<OptionsWitness>,
                        lifetime: _serde::__private228::PhantomData<&'de ()>,
                    }
                    #[automatically_derived]
                    impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
                        type Value = OptionsWitness;
                        fn expecting(
                            &self,
                            __formatter: &mut _serde::__private228::Formatter,
                        ) -> _serde::__private228::fmt::Result {
                            _serde::__private228::Formatter::write_str(
                                __formatter,
                                "struct OptionsWitness",
                            )
                        }
                        #[inline]
                        fn visit_seq<__A>(
                            self,
                            mut __seq: __A,
                        ) -> _serde::__private228::Result<Self::Value, __A::Error>
                        where
                            __A: _serde::de::SeqAccess<'de>,
                        {
                            let __field0 = match _serde::de::SeqAccess::next_element::<
                                ::simplicityhl::either::Either<
                                    ::simplicityhl::either::Either<
                                        (
                                            u64,
                                            [u8; 32],
                                            [u8; 32],
                                            [u8; 32],
                                            [u8; 32],
                                            [u8; 32],
                                            [u8; 32],
                                            [u8; 32],
                                            [u8; 32],
                                        ),
                                        ::simplicityhl::either::Either<
                                            (bool, u64, u64, u64),
                                            (bool, u64, u64),
                                        >,
                                    >,
                                    ::simplicityhl::either::Either<
                                        (bool, u64, u64),
                                        (bool, u64, u64),
                                    >,
                                >,
                            >(&mut __seq)? {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None => {
                                    return _serde::__private228::Err(
                                        _serde::de::Error::invalid_length(
                                            0usize,
                                            &"struct OptionsWitness with 1 element",
                                        ),
                                    );
                                }
                            };
                            _serde::__private228::Ok(OptionsWitness { path: __field0 })
                        }
                        #[inline]
                        fn visit_map<__A>(
                            self,
                            mut __map: __A,
                        ) -> _serde::__private228::Result<Self::Value, __A::Error>
                        where
                            __A: _serde::de::MapAccess<'de>,
                        {
                            let mut __field0: _serde::__private228::Option<
                                ::simplicityhl::either::Either<
                                    ::simplicityhl::either::Either<
                                        (
                                            u64,
                                            [u8; 32],
                                            [u8; 32],
                                            [u8; 32],
                                            [u8; 32],
                                            [u8; 32],
                                            [u8; 32],
                                            [u8; 32],
                                            [u8; 32],
                                        ),
                                        ::simplicityhl::either::Either<
                                            (bool, u64, u64, u64),
                                            (bool, u64, u64),
                                        >,
                                    >,
                                    ::simplicityhl::either::Either<
                                        (bool, u64, u64),
                                        (bool, u64, u64),
                                    >,
                                >,
                            > = _serde::__private228::None;
                            while let _serde::__private228::Some(__key) = _serde::de::MapAccess::next_key::<
                                __Field,
                            >(&mut __map)? {
                                match __key {
                                    __Field::__field0 => {
                                        if _serde::__private228::Option::is_some(&__field0) {
                                            return _serde::__private228::Err(
                                                <__A::Error as _serde::de::Error>::duplicate_field("path"),
                                            );
                                        }
                                        __field0 = _serde::__private228::Some(
                                            _serde::de::MapAccess::next_value::<
                                                ::simplicityhl::either::Either<
                                                    ::simplicityhl::either::Either<
                                                        (
                                                            u64,
                                                            [u8; 32],
                                                            [u8; 32],
                                                            [u8; 32],
                                                            [u8; 32],
                                                            [u8; 32],
                                                            [u8; 32],
                                                            [u8; 32],
                                                            [u8; 32],
                                                        ),
                                                        ::simplicityhl::either::Either<
                                                            (bool, u64, u64, u64),
                                                            (bool, u64, u64),
                                                        >,
                                                    >,
                                                    ::simplicityhl::either::Either<
                                                        (bool, u64, u64),
                                                        (bool, u64, u64),
                                                    >,
                                                >,
                                            >(&mut __map)?,
                                        );
                                    }
                                    _ => {
                                        let _ = _serde::de::MapAccess::next_value::<
                                            _serde::de::IgnoredAny,
                                        >(&mut __map)?;
                                    }
                                }
                            }
                            let __field0 = match __field0 {
                                _serde::__private228::Some(__field0) => __field0,
                                _serde::__private228::None => {
                                    _serde::__private228::de::missing_field("path")?
                                }
                            };
                            _serde::__private228::Ok(OptionsWitness { path: __field0 })
                        }
                    }
                    #[doc(hidden)]
                    const FIELDS: &'static [&'static str] = &["path"];
                    _serde::Deserializer::deserialize_struct(
                        __deserializer,
                        "OptionsWitness",
                        FIELDS,
                        __Visitor {
                            marker: _serde::__private228::PhantomData::<OptionsWitness>,
                            lifetime: _serde::__private228::PhantomData,
                        },
                    )
                }
            }
        };
        impl OptionsWitness {
            /// Build Simplicity witness values for contract execution.
            #[must_use]
            pub fn build_witness(&self) -> simplicityhl::WitnessValues {
                simplicityhl::WitnessValues::from(
                    HashMap::from([
                        (
                            ::simplicityhl::str::WitnessName::from_str_unchecked("PATH"),
                            match &self.path {
                                ::simplicityhl::either::Either::Left(left_val) => {
                                    Value::left(
                                        match &left_val {
                                            ::simplicityhl::either::Either::Left(left_val) => {
                                                Value::left(
                                                    Value::tuple([
                                                        Value::from(UIntValue::U64(left_val.0)),
                                                        Value::from(
                                                            UIntValue::U256(U256::from_byte_array(left_val.1)),
                                                        ),
                                                        Value::from(
                                                            UIntValue::U256(U256::from_byte_array(left_val.2)),
                                                        ),
                                                        Value::from(
                                                            UIntValue::U256(U256::from_byte_array(left_val.3)),
                                                        ),
                                                        Value::from(
                                                            UIntValue::U256(U256::from_byte_array(left_val.4)),
                                                        ),
                                                        Value::from(
                                                            UIntValue::U256(U256::from_byte_array(left_val.5)),
                                                        ),
                                                        Value::from(
                                                            UIntValue::U256(U256::from_byte_array(left_val.6)),
                                                        ),
                                                        Value::from(
                                                            UIntValue::U256(U256::from_byte_array(left_val.7)),
                                                        ),
                                                        Value::from(
                                                            UIntValue::U256(U256::from_byte_array(left_val.8)),
                                                        ),
                                                    ]),
                                                    ResolvedType::either(
                                                        ResolvedType::tuple([
                                                            ResolvedType::boolean(),
                                                            ResolvedType::u64(),
                                                            ResolvedType::u64(),
                                                            ResolvedType::u64(),
                                                        ]),
                                                        ResolvedType::tuple([
                                                            ResolvedType::boolean(),
                                                            ResolvedType::u64(),
                                                            ResolvedType::u64(),
                                                        ]),
                                                    ),
                                                )
                                            }
                                            ::simplicityhl::either::Either::Right(right_val) => {
                                                Value::right(
                                                    ResolvedType::tuple([
                                                        ResolvedType::u64(),
                                                        ResolvedType::u256(),
                                                        ResolvedType::u256(),
                                                        ResolvedType::u256(),
                                                        ResolvedType::u256(),
                                                        ResolvedType::u256(),
                                                        ResolvedType::u256(),
                                                        ResolvedType::u256(),
                                                        ResolvedType::u256(),
                                                    ]),
                                                    match &right_val {
                                                        ::simplicityhl::either::Either::Left(left_val) => {
                                                            Value::left(
                                                                Value::tuple([
                                                                    Value::from(left_val.0),
                                                                    Value::from(UIntValue::U64(left_val.1)),
                                                                    Value::from(UIntValue::U64(left_val.2)),
                                                                    Value::from(UIntValue::U64(left_val.3)),
                                                                ]),
                                                                ResolvedType::tuple([
                                                                    ResolvedType::boolean(),
                                                                    ResolvedType::u64(),
                                                                    ResolvedType::u64(),
                                                                ]),
                                                            )
                                                        }
                                                        ::simplicityhl::either::Either::Right(right_val) => {
                                                            Value::right(
                                                                ResolvedType::tuple([
                                                                    ResolvedType::boolean(),
                                                                    ResolvedType::u64(),
                                                                    ResolvedType::u64(),
                                                                    ResolvedType::u64(),
                                                                ]),
                                                                Value::tuple([
                                                                    Value::from(right_val.0),
                                                                    Value::from(UIntValue::U64(right_val.1)),
                                                                    Value::from(UIntValue::U64(right_val.2)),
                                                                ]),
                                                            )
                                                        }
                                                    },
                                                )
                                            }
                                        },
                                        ResolvedType::either(
                                            ResolvedType::tuple([
                                                ResolvedType::boolean(),
                                                ResolvedType::u64(),
                                                ResolvedType::u64(),
                                            ]),
                                            ResolvedType::tuple([
                                                ResolvedType::boolean(),
                                                ResolvedType::u64(),
                                                ResolvedType::u64(),
                                            ]),
                                        ),
                                    )
                                }
                                ::simplicityhl::either::Either::Right(right_val) => {
                                    Value::right(
                                        ResolvedType::either(
                                            ResolvedType::tuple([
                                                ResolvedType::u64(),
                                                ResolvedType::u256(),
                                                ResolvedType::u256(),
                                                ResolvedType::u256(),
                                                ResolvedType::u256(),
                                                ResolvedType::u256(),
                                                ResolvedType::u256(),
                                                ResolvedType::u256(),
                                                ResolvedType::u256(),
                                            ]),
                                            ResolvedType::either(
                                                ResolvedType::tuple([
                                                    ResolvedType::boolean(),
                                                    ResolvedType::u64(),
                                                    ResolvedType::u64(),
                                                    ResolvedType::u64(),
                                                ]),
                                                ResolvedType::tuple([
                                                    ResolvedType::boolean(),
                                                    ResolvedType::u64(),
                                                    ResolvedType::u64(),
                                                ]),
                                            ),
                                        ),
                                        match &right_val {
                                            ::simplicityhl::either::Either::Left(left_val) => {
                                                Value::left(
                                                    Value::tuple([
                                                        Value::from(left_val.0),
                                                        Value::from(UIntValue::U64(left_val.1)),
                                                        Value::from(UIntValue::U64(left_val.2)),
                                                    ]),
                                                    ResolvedType::tuple([
                                                        ResolvedType::boolean(),
                                                        ResolvedType::u64(),
                                                        ResolvedType::u64(),
                                                    ]),
                                                )
                                            }
                                            ::simplicityhl::either::Either::Right(right_val) => {
                                                Value::right(
                                                    ResolvedType::tuple([
                                                        ResolvedType::boolean(),
                                                        ResolvedType::u64(),
                                                        ResolvedType::u64(),
                                                    ]),
                                                    Value::tuple([
                                                        Value::from(right_val.0),
                                                        Value::from(UIntValue::U64(right_val.1)),
                                                        Value::from(UIntValue::U64(right_val.2)),
                                                    ]),
                                                )
                                            }
                                        },
                                    )
                                }
                            },
                        ),
                    ]),
                )
            }
            /// Build struct from Simplicity WitnessValues.
            ///
            /// # Errors
            ///
            /// Returns error if any required witness is missing, has wrong type, or has invalid value.
            pub fn from_witness(witness: &WitnessValues) -> Result<Self, String> {
                let path = {
                    let witness_name = WitnessName::from_str_unchecked("PATH");
                    let value = witness
                        .get(&witness_name)
                        .ok_or_else(|| ::alloc::__export::must_use({
                            ::alloc::fmt::format(
                                format_args!("Missing witness: {0}", "PATH"),
                            )
                        }))?;
                    match value.inner() {
                        simplicityhl::value::ValueInner::Either(either_val) => {
                            match either_val {
                                ::simplicityhl::either::Either::Left(left_val) => {
                                    Ok(
                                        ::simplicityhl::either::Either::Left(
                                            match left_val.inner() {
                                                simplicityhl::value::ValueInner::Either(either_val) => {
                                                    match either_val {
                                                        ::simplicityhl::either::Either::Left(left_val) => {
                                                            Ok(
                                                                ::simplicityhl::either::Either::Left(
                                                                    match left_val.inner() {
                                                                        simplicityhl::value::ValueInner::Tuple(tuple_value) => {
                                                                            Ok((
                                                                                match tuple_value[0usize].inner() {
                                                                                    simplicityhl::value::ValueInner::UInt(UIntValue::U64(v)) => {
                                                                                        *v
                                                                                    }
                                                                                    _ => {
                                                                                        return Err(
                                                                                            ::alloc::__export::must_use({
                                                                                                ::alloc::fmt::format(
                                                                                                    format_args!(
                                                                                                        "Wrong tuple element type at index {0}",
                                                                                                        0usize,
                                                                                                    ),
                                                                                                )
                                                                                            }),
                                                                                        );
                                                                                    }
                                                                                },
                                                                                match tuple_value[1usize].inner() {
                                                                                    simplicityhl::value::ValueInner::UInt(
                                                                                        UIntValue::U256(u256),
                                                                                    ) => u256.to_byte_array(),
                                                                                    _ => {
                                                                                        return Err(
                                                                                            ::alloc::__export::must_use({
                                                                                                ::alloc::fmt::format(
                                                                                                    format_args!(
                                                                                                        "Wrong tuple element type at index {0}",
                                                                                                        1usize,
                                                                                                    ),
                                                                                                )
                                                                                            }),
                                                                                        );
                                                                                    }
                                                                                },
                                                                                match tuple_value[2usize].inner() {
                                                                                    simplicityhl::value::ValueInner::UInt(
                                                                                        UIntValue::U256(u256),
                                                                                    ) => u256.to_byte_array(),
                                                                                    _ => {
                                                                                        return Err(
                                                                                            ::alloc::__export::must_use({
                                                                                                ::alloc::fmt::format(
                                                                                                    format_args!(
                                                                                                        "Wrong tuple element type at index {0}",
                                                                                                        2usize,
                                                                                                    ),
                                                                                                )
                                                                                            }),
                                                                                        );
                                                                                    }
                                                                                },
                                                                                match tuple_value[3usize].inner() {
                                                                                    simplicityhl::value::ValueInner::UInt(
                                                                                        UIntValue::U256(u256),
                                                                                    ) => u256.to_byte_array(),
                                                                                    _ => {
                                                                                        return Err(
                                                                                            ::alloc::__export::must_use({
                                                                                                ::alloc::fmt::format(
                                                                                                    format_args!(
                                                                                                        "Wrong tuple element type at index {0}",
                                                                                                        3usize,
                                                                                                    ),
                                                                                                )
                                                                                            }),
                                                                                        );
                                                                                    }
                                                                                },
                                                                                match tuple_value[4usize].inner() {
                                                                                    simplicityhl::value::ValueInner::UInt(
                                                                                        UIntValue::U256(u256),
                                                                                    ) => u256.to_byte_array(),
                                                                                    _ => {
                                                                                        return Err(
                                                                                            ::alloc::__export::must_use({
                                                                                                ::alloc::fmt::format(
                                                                                                    format_args!(
                                                                                                        "Wrong tuple element type at index {0}",
                                                                                                        4usize,
                                                                                                    ),
                                                                                                )
                                                                                            }),
                                                                                        );
                                                                                    }
                                                                                },
                                                                                match tuple_value[5usize].inner() {
                                                                                    simplicityhl::value::ValueInner::UInt(
                                                                                        UIntValue::U256(u256),
                                                                                    ) => u256.to_byte_array(),
                                                                                    _ => {
                                                                                        return Err(
                                                                                            ::alloc::__export::must_use({
                                                                                                ::alloc::fmt::format(
                                                                                                    format_args!(
                                                                                                        "Wrong tuple element type at index {0}",
                                                                                                        5usize,
                                                                                                    ),
                                                                                                )
                                                                                            }),
                                                                                        );
                                                                                    }
                                                                                },
                                                                                match tuple_value[6usize].inner() {
                                                                                    simplicityhl::value::ValueInner::UInt(
                                                                                        UIntValue::U256(u256),
                                                                                    ) => u256.to_byte_array(),
                                                                                    _ => {
                                                                                        return Err(
                                                                                            ::alloc::__export::must_use({
                                                                                                ::alloc::fmt::format(
                                                                                                    format_args!(
                                                                                                        "Wrong tuple element type at index {0}",
                                                                                                        6usize,
                                                                                                    ),
                                                                                                )
                                                                                            }),
                                                                                        );
                                                                                    }
                                                                                },
                                                                                match tuple_value[7usize].inner() {
                                                                                    simplicityhl::value::ValueInner::UInt(
                                                                                        UIntValue::U256(u256),
                                                                                    ) => u256.to_byte_array(),
                                                                                    _ => {
                                                                                        return Err(
                                                                                            ::alloc::__export::must_use({
                                                                                                ::alloc::fmt::format(
                                                                                                    format_args!(
                                                                                                        "Wrong tuple element type at index {0}",
                                                                                                        7usize,
                                                                                                    ),
                                                                                                )
                                                                                            }),
                                                                                        );
                                                                                    }
                                                                                },
                                                                                match tuple_value[8usize].inner() {
                                                                                    simplicityhl::value::ValueInner::UInt(
                                                                                        UIntValue::U256(u256),
                                                                                    ) => u256.to_byte_array(),
                                                                                    _ => {
                                                                                        return Err(
                                                                                            ::alloc::__export::must_use({
                                                                                                ::alloc::fmt::format(
                                                                                                    format_args!(
                                                                                                        "Wrong tuple element type at index {0}",
                                                                                                        8usize,
                                                                                                    ),
                                                                                                )
                                                                                            }),
                                                                                        );
                                                                                    }
                                                                                },
                                                                            ))
                                                                        }
                                                                        _ => {
                                                                            Err("Wrong either branch type: expected Tuple".to_string())
                                                                        }
                                                                    }?,
                                                                ),
                                                            )
                                                        }
                                                        ::simplicityhl::either::Either::Right(right_val) => {
                                                            Ok(
                                                                ::simplicityhl::either::Either::Right(
                                                                    match right_val.inner() {
                                                                        simplicityhl::value::ValueInner::Either(either_val) => {
                                                                            match either_val {
                                                                                ::simplicityhl::either::Either::Left(left_val) => {
                                                                                    Ok(
                                                                                        ::simplicityhl::either::Either::Left(
                                                                                            match left_val.inner() {
                                                                                                simplicityhl::value::ValueInner::Tuple(tuple_value) => {
                                                                                                    Ok((
                                                                                                        match tuple_value[0usize].inner() {
                                                                                                            simplicityhl::value::ValueInner::Boolean(b) => *b,
                                                                                                            _ => {
                                                                                                                return Err(
                                                                                                                    ::alloc::__export::must_use({
                                                                                                                        ::alloc::fmt::format(
                                                                                                                            format_args!(
                                                                                                                                "Wrong tuple element type at index {0}",
                                                                                                                                0usize,
                                                                                                                            ),
                                                                                                                        )
                                                                                                                    }),
                                                                                                                );
                                                                                                            }
                                                                                                        },
                                                                                                        match tuple_value[1usize].inner() {
                                                                                                            simplicityhl::value::ValueInner::UInt(UIntValue::U64(v)) => {
                                                                                                                *v
                                                                                                            }
                                                                                                            _ => {
                                                                                                                return Err(
                                                                                                                    ::alloc::__export::must_use({
                                                                                                                        ::alloc::fmt::format(
                                                                                                                            format_args!(
                                                                                                                                "Wrong tuple element type at index {0}",
                                                                                                                                1usize,
                                                                                                                            ),
                                                                                                                        )
                                                                                                                    }),
                                                                                                                );
                                                                                                            }
                                                                                                        },
                                                                                                        match tuple_value[2usize].inner() {
                                                                                                            simplicityhl::value::ValueInner::UInt(UIntValue::U64(v)) => {
                                                                                                                *v
                                                                                                            }
                                                                                                            _ => {
                                                                                                                return Err(
                                                                                                                    ::alloc::__export::must_use({
                                                                                                                        ::alloc::fmt::format(
                                                                                                                            format_args!(
                                                                                                                                "Wrong tuple element type at index {0}",
                                                                                                                                2usize,
                                                                                                                            ),
                                                                                                                        )
                                                                                                                    }),
                                                                                                                );
                                                                                                            }
                                                                                                        },
                                                                                                        match tuple_value[3usize].inner() {
                                                                                                            simplicityhl::value::ValueInner::UInt(UIntValue::U64(v)) => {
                                                                                                                *v
                                                                                                            }
                                                                                                            _ => {
                                                                                                                return Err(
                                                                                                                    ::alloc::__export::must_use({
                                                                                                                        ::alloc::fmt::format(
                                                                                                                            format_args!(
                                                                                                                                "Wrong tuple element type at index {0}",
                                                                                                                                3usize,
                                                                                                                            ),
                                                                                                                        )
                                                                                                                    }),
                                                                                                                );
                                                                                                            }
                                                                                                        },
                                                                                                    ))
                                                                                                }
                                                                                                _ => {
                                                                                                    Err("Wrong either branch type: expected Tuple".to_string())
                                                                                                }
                                                                                            }?,
                                                                                        ),
                                                                                    )
                                                                                }
                                                                                ::simplicityhl::either::Either::Right(right_val) => {
                                                                                    Ok(
                                                                                        ::simplicityhl::either::Either::Right(
                                                                                            match right_val.inner() {
                                                                                                simplicityhl::value::ValueInner::Tuple(tuple_value) => {
                                                                                                    Ok((
                                                                                                        match tuple_value[0usize].inner() {
                                                                                                            simplicityhl::value::ValueInner::Boolean(b) => *b,
                                                                                                            _ => {
                                                                                                                return Err(
                                                                                                                    ::alloc::__export::must_use({
                                                                                                                        ::alloc::fmt::format(
                                                                                                                            format_args!(
                                                                                                                                "Wrong tuple element type at index {0}",
                                                                                                                                0usize,
                                                                                                                            ),
                                                                                                                        )
                                                                                                                    }),
                                                                                                                );
                                                                                                            }
                                                                                                        },
                                                                                                        match tuple_value[1usize].inner() {
                                                                                                            simplicityhl::value::ValueInner::UInt(UIntValue::U64(v)) => {
                                                                                                                *v
                                                                                                            }
                                                                                                            _ => {
                                                                                                                return Err(
                                                                                                                    ::alloc::__export::must_use({
                                                                                                                        ::alloc::fmt::format(
                                                                                                                            format_args!(
                                                                                                                                "Wrong tuple element type at index {0}",
                                                                                                                                1usize,
                                                                                                                            ),
                                                                                                                        )
                                                                                                                    }),
                                                                                                                );
                                                                                                            }
                                                                                                        },
                                                                                                        match tuple_value[2usize].inner() {
                                                                                                            simplicityhl::value::ValueInner::UInt(UIntValue::U64(v)) => {
                                                                                                                *v
                                                                                                            }
                                                                                                            _ => {
                                                                                                                return Err(
                                                                                                                    ::alloc::__export::must_use({
                                                                                                                        ::alloc::fmt::format(
                                                                                                                            format_args!(
                                                                                                                                "Wrong tuple element type at index {0}",
                                                                                                                                2usize,
                                                                                                                            ),
                                                                                                                        )
                                                                                                                    }),
                                                                                                                );
                                                                                                            }
                                                                                                        },
                                                                                                    ))
                                                                                                }
                                                                                                _ => {
                                                                                                    Err("Wrong either branch type: expected Tuple".to_string())
                                                                                                }
                                                                                            }?,
                                                                                        ),
                                                                                    )
                                                                                }
                                                                            }
                                                                        }
                                                                        _ => {
                                                                            Err("Wrong either branch type: expected Either".to_string())
                                                                        }
                                                                    }?,
                                                                ),
                                                            )
                                                        }
                                                    }
                                                }
                                                _ => {
                                                    Err("Wrong either branch type: expected Either".to_string())
                                                }
                                            }?,
                                        ),
                                    )
                                }
                                ::simplicityhl::either::Either::Right(right_val) => {
                                    Ok(
                                        ::simplicityhl::either::Either::Right(
                                            match right_val.inner() {
                                                simplicityhl::value::ValueInner::Either(either_val) => {
                                                    match either_val {
                                                        ::simplicityhl::either::Either::Left(left_val) => {
                                                            Ok(
                                                                ::simplicityhl::either::Either::Left(
                                                                    match left_val.inner() {
                                                                        simplicityhl::value::ValueInner::Tuple(tuple_value) => {
                                                                            Ok((
                                                                                match tuple_value[0usize].inner() {
                                                                                    simplicityhl::value::ValueInner::Boolean(b) => *b,
                                                                                    _ => {
                                                                                        return Err(
                                                                                            ::alloc::__export::must_use({
                                                                                                ::alloc::fmt::format(
                                                                                                    format_args!(
                                                                                                        "Wrong tuple element type at index {0}",
                                                                                                        0usize,
                                                                                                    ),
                                                                                                )
                                                                                            }),
                                                                                        );
                                                                                    }
                                                                                },
                                                                                match tuple_value[1usize].inner() {
                                                                                    simplicityhl::value::ValueInner::UInt(UIntValue::U64(v)) => {
                                                                                        *v
                                                                                    }
                                                                                    _ => {
                                                                                        return Err(
                                                                                            ::alloc::__export::must_use({
                                                                                                ::alloc::fmt::format(
                                                                                                    format_args!(
                                                                                                        "Wrong tuple element type at index {0}",
                                                                                                        1usize,
                                                                                                    ),
                                                                                                )
                                                                                            }),
                                                                                        );
                                                                                    }
                                                                                },
                                                                                match tuple_value[2usize].inner() {
                                                                                    simplicityhl::value::ValueInner::UInt(UIntValue::U64(v)) => {
                                                                                        *v
                                                                                    }
                                                                                    _ => {
                                                                                        return Err(
                                                                                            ::alloc::__export::must_use({
                                                                                                ::alloc::fmt::format(
                                                                                                    format_args!(
                                                                                                        "Wrong tuple element type at index {0}",
                                                                                                        2usize,
                                                                                                    ),
                                                                                                )
                                                                                            }),
                                                                                        );
                                                                                    }
                                                                                },
                                                                            ))
                                                                        }
                                                                        _ => {
                                                                            Err("Wrong either branch type: expected Tuple".to_string())
                                                                        }
                                                                    }?,
                                                                ),
                                                            )
                                                        }
                                                        ::simplicityhl::either::Either::Right(right_val) => {
                                                            Ok(
                                                                ::simplicityhl::either::Either::Right(
                                                                    match right_val.inner() {
                                                                        simplicityhl::value::ValueInner::Tuple(tuple_value) => {
                                                                            Ok((
                                                                                match tuple_value[0usize].inner() {
                                                                                    simplicityhl::value::ValueInner::Boolean(b) => *b,
                                                                                    _ => {
                                                                                        return Err(
                                                                                            ::alloc::__export::must_use({
                                                                                                ::alloc::fmt::format(
                                                                                                    format_args!(
                                                                                                        "Wrong tuple element type at index {0}",
                                                                                                        0usize,
                                                                                                    ),
                                                                                                )
                                                                                            }),
                                                                                        );
                                                                                    }
                                                                                },
                                                                                match tuple_value[1usize].inner() {
                                                                                    simplicityhl::value::ValueInner::UInt(UIntValue::U64(v)) => {
                                                                                        *v
                                                                                    }
                                                                                    _ => {
                                                                                        return Err(
                                                                                            ::alloc::__export::must_use({
                                                                                                ::alloc::fmt::format(
                                                                                                    format_args!(
                                                                                                        "Wrong tuple element type at index {0}",
                                                                                                        1usize,
                                                                                                    ),
                                                                                                )
                                                                                            }),
                                                                                        );
                                                                                    }
                                                                                },
                                                                                match tuple_value[2usize].inner() {
                                                                                    simplicityhl::value::ValueInner::UInt(UIntValue::U64(v)) => {
                                                                                        *v
                                                                                    }
                                                                                    _ => {
                                                                                        return Err(
                                                                                            ::alloc::__export::must_use({
                                                                                                ::alloc::fmt::format(
                                                                                                    format_args!(
                                                                                                        "Wrong tuple element type at index {0}",
                                                                                                        2usize,
                                                                                                    ),
                                                                                                )
                                                                                            }),
                                                                                        );
                                                                                    }
                                                                                },
                                                                            ))
                                                                        }
                                                                        _ => {
                                                                            Err("Wrong either branch type: expected Tuple".to_string())
                                                                        }
                                                                    }?,
                                                                ),
                                                            )
                                                        }
                                                    }
                                                }
                                                _ => {
                                                    Err("Wrong either branch type: expected Either".to_string())
                                                }
                                            }?,
                                        ),
                                    )
                                }
                            }
                        }
                        _ => {
                            Err(
                                ::alloc::__export::must_use({
                                    ::alloc::fmt::format(
                                        format_args!("Wrong type for {0}: expected Either", "PATH"),
                                    )
                                }),
                            )
                        }
                    }
                }?;
                Ok(Self { path })
            }
        }
    }
    pub use build_arguments::*;
    mod build_arguments {
        use std::collections::HashMap;
        use simplicityhl::{Arguments, Value, ResolvedType};
        use simplicityhl::value::{UIntValue, ValueInner};
        use simplicityhl::num::U256;
        use simplicityhl::str::WitnessName;
        use simplicityhl::types::TypeConstructible;
        use simplicityhl::value::ValueConstructible;
        use bincode::*;
        pub struct OptionsArguments {
            pub grantor_token_asset: [u8; 32],
            pub grantor_reissuance_token_asset: [u8; 32],
            pub settlement_asset_id: [u8; 32],
            pub collateral_per_contract: u64,
            pub start_time: u32,
            pub option_reissuance_token_asset: [u8; 32],
            pub settlement_per_contract: u64,
            pub collateral_asset_id: [u8; 32],
            pub option_token_asset: [u8; 32],
            pub expiry_time: u32,
        }
        #[automatically_derived]
        impl ::core::fmt::Debug for OptionsArguments {
            #[inline]
            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                let names: &'static _ = &[
                    "grantor_token_asset",
                    "grantor_reissuance_token_asset",
                    "settlement_asset_id",
                    "collateral_per_contract",
                    "start_time",
                    "option_reissuance_token_asset",
                    "settlement_per_contract",
                    "collateral_asset_id",
                    "option_token_asset",
                    "expiry_time",
                ];
                let values: &[&dyn ::core::fmt::Debug] = &[
                    &self.grantor_token_asset,
                    &self.grantor_reissuance_token_asset,
                    &self.settlement_asset_id,
                    &self.collateral_per_contract,
                    &self.start_time,
                    &self.option_reissuance_token_asset,
                    &self.settlement_per_contract,
                    &self.collateral_asset_id,
                    &self.option_token_asset,
                    &&self.expiry_time,
                ];
                ::core::fmt::Formatter::debug_struct_fields_finish(
                    f,
                    "OptionsArguments",
                    names,
                    values,
                )
            }
        }
        #[automatically_derived]
        impl ::core::clone::Clone for OptionsArguments {
            #[inline]
            fn clone(&self) -> OptionsArguments {
                OptionsArguments {
                    grantor_token_asset: ::core::clone::Clone::clone(
                        &self.grantor_token_asset,
                    ),
                    grantor_reissuance_token_asset: ::core::clone::Clone::clone(
                        &self.grantor_reissuance_token_asset,
                    ),
                    settlement_asset_id: ::core::clone::Clone::clone(
                        &self.settlement_asset_id,
                    ),
                    collateral_per_contract: ::core::clone::Clone::clone(
                        &self.collateral_per_contract,
                    ),
                    start_time: ::core::clone::Clone::clone(&self.start_time),
                    option_reissuance_token_asset: ::core::clone::Clone::clone(
                        &self.option_reissuance_token_asset,
                    ),
                    settlement_per_contract: ::core::clone::Clone::clone(
                        &self.settlement_per_contract,
                    ),
                    collateral_asset_id: ::core::clone::Clone::clone(
                        &self.collateral_asset_id,
                    ),
                    option_token_asset: ::core::clone::Clone::clone(
                        &self.option_token_asset,
                    ),
                    expiry_time: ::core::clone::Clone::clone(&self.expiry_time),
                }
            }
        }
        #[automatically_derived]
        impl ::core::marker::StructuralPartialEq for OptionsArguments {}
        #[automatically_derived]
        impl ::core::cmp::PartialEq for OptionsArguments {
            #[inline]
            fn eq(&self, other: &OptionsArguments) -> bool {
                self.collateral_per_contract == other.collateral_per_contract
                    && self.start_time == other.start_time
                    && self.settlement_per_contract == other.settlement_per_contract
                    && self.expiry_time == other.expiry_time
                    && self.grantor_token_asset == other.grantor_token_asset
                    && self.grantor_reissuance_token_asset
                        == other.grantor_reissuance_token_asset
                    && self.settlement_asset_id == other.settlement_asset_id
                    && self.option_reissuance_token_asset
                        == other.option_reissuance_token_asset
                    && self.collateral_asset_id == other.collateral_asset_id
                    && self.option_token_asset == other.option_token_asset
            }
        }
        #[automatically_derived]
        impl ::core::cmp::Eq for OptionsArguments {
            #[inline]
            #[doc(hidden)]
            #[coverage(off)]
            fn assert_receiver_is_total_eq(&self) -> () {
                let _: ::core::cmp::AssertParamIsEq<[u8; 32]>;
                let _: ::core::cmp::AssertParamIsEq<[u8; 32]>;
                let _: ::core::cmp::AssertParamIsEq<[u8; 32]>;
                let _: ::core::cmp::AssertParamIsEq<u64>;
                let _: ::core::cmp::AssertParamIsEq<u32>;
                let _: ::core::cmp::AssertParamIsEq<[u8; 32]>;
                let _: ::core::cmp::AssertParamIsEq<[u8; 32]>;
                let _: ::core::cmp::AssertParamIsEq<[u8; 32]>;
            }
        }
        #[doc(hidden)]
        #[allow(
            non_upper_case_globals,
            unused_attributes,
            unused_qualifications,
            clippy::absolute_paths,
        )]
        const _: () = {
            #[allow(unused_extern_crates, clippy::useless_attribute)]
            extern crate serde as _serde;
            #[automatically_derived]
            impl _serde::Serialize for OptionsArguments {
                fn serialize<__S>(
                    &self,
                    __serializer: __S,
                ) -> _serde::__private228::Result<__S::Ok, __S::Error>
                where
                    __S: _serde::Serializer,
                {
                    let mut __serde_state = _serde::Serializer::serialize_struct(
                        __serializer,
                        "OptionsArguments",
                        false as usize + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1,
                    )?;
                    _serde::ser::SerializeStruct::serialize_field(
                        &mut __serde_state,
                        "grantor_token_asset",
                        &self.grantor_token_asset,
                    )?;
                    _serde::ser::SerializeStruct::serialize_field(
                        &mut __serde_state,
                        "grantor_reissuance_token_asset",
                        &self.grantor_reissuance_token_asset,
                    )?;
                    _serde::ser::SerializeStruct::serialize_field(
                        &mut __serde_state,
                        "settlement_asset_id",
                        &self.settlement_asset_id,
                    )?;
                    _serde::ser::SerializeStruct::serialize_field(
                        &mut __serde_state,
                        "collateral_per_contract",
                        &self.collateral_per_contract,
                    )?;
                    _serde::ser::SerializeStruct::serialize_field(
                        &mut __serde_state,
                        "start_time",
                        &self.start_time,
                    )?;
                    _serde::ser::SerializeStruct::serialize_field(
                        &mut __serde_state,
                        "option_reissuance_token_asset",
                        &self.option_reissuance_token_asset,
                    )?;
                    _serde::ser::SerializeStruct::serialize_field(
                        &mut __serde_state,
                        "settlement_per_contract",
                        &self.settlement_per_contract,
                    )?;
                    _serde::ser::SerializeStruct::serialize_field(
                        &mut __serde_state,
                        "collateral_asset_id",
                        &self.collateral_asset_id,
                    )?;
                    _serde::ser::SerializeStruct::serialize_field(
                        &mut __serde_state,
                        "option_token_asset",
                        &self.option_token_asset,
                    )?;
                    _serde::ser::SerializeStruct::serialize_field(
                        &mut __serde_state,
                        "expiry_time",
                        &self.expiry_time,
                    )?;
                    _serde::ser::SerializeStruct::end(__serde_state)
                }
            }
        };
        #[doc(hidden)]
        #[allow(
            non_upper_case_globals,
            unused_attributes,
            unused_qualifications,
            clippy::absolute_paths,
        )]
        const _: () = {
            #[allow(unused_extern_crates, clippy::useless_attribute)]
            extern crate serde as _serde;
            #[automatically_derived]
            impl<'de> _serde::Deserialize<'de> for OptionsArguments {
                fn deserialize<__D>(
                    __deserializer: __D,
                ) -> _serde::__private228::Result<Self, __D::Error>
                where
                    __D: _serde::Deserializer<'de>,
                {
                    #[allow(non_camel_case_types)]
                    #[doc(hidden)]
                    enum __Field {
                        __field0,
                        __field1,
                        __field2,
                        __field3,
                        __field4,
                        __field5,
                        __field6,
                        __field7,
                        __field8,
                        __field9,
                        __ignore,
                    }
                    #[doc(hidden)]
                    struct __FieldVisitor;
                    #[automatically_derived]
                    impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
                        type Value = __Field;
                        fn expecting(
                            &self,
                            __formatter: &mut _serde::__private228::Formatter,
                        ) -> _serde::__private228::fmt::Result {
                            _serde::__private228::Formatter::write_str(
                                __formatter,
                                "field identifier",
                            )
                        }
                        fn visit_u64<__E>(
                            self,
                            __value: u64,
                        ) -> _serde::__private228::Result<Self::Value, __E>
                        where
                            __E: _serde::de::Error,
                        {
                            match __value {
                                0u64 => _serde::__private228::Ok(__Field::__field0),
                                1u64 => _serde::__private228::Ok(__Field::__field1),
                                2u64 => _serde::__private228::Ok(__Field::__field2),
                                3u64 => _serde::__private228::Ok(__Field::__field3),
                                4u64 => _serde::__private228::Ok(__Field::__field4),
                                5u64 => _serde::__private228::Ok(__Field::__field5),
                                6u64 => _serde::__private228::Ok(__Field::__field6),
                                7u64 => _serde::__private228::Ok(__Field::__field7),
                                8u64 => _serde::__private228::Ok(__Field::__field8),
                                9u64 => _serde::__private228::Ok(__Field::__field9),
                                _ => _serde::__private228::Ok(__Field::__ignore),
                            }
                        }
                        fn visit_str<__E>(
                            self,
                            __value: &str,
                        ) -> _serde::__private228::Result<Self::Value, __E>
                        where
                            __E: _serde::de::Error,
                        {
                            match __value {
                                "grantor_token_asset" => {
                                    _serde::__private228::Ok(__Field::__field0)
                                }
                                "grantor_reissuance_token_asset" => {
                                    _serde::__private228::Ok(__Field::__field1)
                                }
                                "settlement_asset_id" => {
                                    _serde::__private228::Ok(__Field::__field2)
                                }
                                "collateral_per_contract" => {
                                    _serde::__private228::Ok(__Field::__field3)
                                }
                                "start_time" => _serde::__private228::Ok(__Field::__field4),
                                "option_reissuance_token_asset" => {
                                    _serde::__private228::Ok(__Field::__field5)
                                }
                                "settlement_per_contract" => {
                                    _serde::__private228::Ok(__Field::__field6)
                                }
                                "collateral_asset_id" => {
                                    _serde::__private228::Ok(__Field::__field7)
                                }
                                "option_token_asset" => {
                                    _serde::__private228::Ok(__Field::__field8)
                                }
                                "expiry_time" => _serde::__private228::Ok(__Field::__field9),
                                _ => _serde::__private228::Ok(__Field::__ignore),
                            }
                        }
                        fn visit_bytes<__E>(
                            self,
                            __value: &[u8],
                        ) -> _serde::__private228::Result<Self::Value, __E>
                        where
                            __E: _serde::de::Error,
                        {
                            match __value {
                                b"grantor_token_asset" => {
                                    _serde::__private228::Ok(__Field::__field0)
                                }
                                b"grantor_reissuance_token_asset" => {
                                    _serde::__private228::Ok(__Field::__field1)
                                }
                                b"settlement_asset_id" => {
                                    _serde::__private228::Ok(__Field::__field2)
                                }
                                b"collateral_per_contract" => {
                                    _serde::__private228::Ok(__Field::__field3)
                                }
                                b"start_time" => _serde::__private228::Ok(__Field::__field4),
                                b"option_reissuance_token_asset" => {
                                    _serde::__private228::Ok(__Field::__field5)
                                }
                                b"settlement_per_contract" => {
                                    _serde::__private228::Ok(__Field::__field6)
                                }
                                b"collateral_asset_id" => {
                                    _serde::__private228::Ok(__Field::__field7)
                                }
                                b"option_token_asset" => {
                                    _serde::__private228::Ok(__Field::__field8)
                                }
                                b"expiry_time" => {
                                    _serde::__private228::Ok(__Field::__field9)
                                }
                                _ => _serde::__private228::Ok(__Field::__ignore),
                            }
                        }
                    }
                    #[automatically_derived]
                    impl<'de> _serde::Deserialize<'de> for __Field {
                        #[inline]
                        fn deserialize<__D>(
                            __deserializer: __D,
                        ) -> _serde::__private228::Result<Self, __D::Error>
                        where
                            __D: _serde::Deserializer<'de>,
                        {
                            _serde::Deserializer::deserialize_identifier(
                                __deserializer,
                                __FieldVisitor,
                            )
                        }
                    }
                    #[doc(hidden)]
                    struct __Visitor<'de> {
                        marker: _serde::__private228::PhantomData<OptionsArguments>,
                        lifetime: _serde::__private228::PhantomData<&'de ()>,
                    }
                    #[automatically_derived]
                    impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
                        type Value = OptionsArguments;
                        fn expecting(
                            &self,
                            __formatter: &mut _serde::__private228::Formatter,
                        ) -> _serde::__private228::fmt::Result {
                            _serde::__private228::Formatter::write_str(
                                __formatter,
                                "struct OptionsArguments",
                            )
                        }
                        #[inline]
                        fn visit_seq<__A>(
                            self,
                            mut __seq: __A,
                        ) -> _serde::__private228::Result<Self::Value, __A::Error>
                        where
                            __A: _serde::de::SeqAccess<'de>,
                        {
                            let __field0 = match _serde::de::SeqAccess::next_element::<
                                [u8; 32],
                            >(&mut __seq)? {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None => {
                                    return _serde::__private228::Err(
                                        _serde::de::Error::invalid_length(
                                            0usize,
                                            &"struct OptionsArguments with 10 elements",
                                        ),
                                    );
                                }
                            };
                            let __field1 = match _serde::de::SeqAccess::next_element::<
                                [u8; 32],
                            >(&mut __seq)? {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None => {
                                    return _serde::__private228::Err(
                                        _serde::de::Error::invalid_length(
                                            1usize,
                                            &"struct OptionsArguments with 10 elements",
                                        ),
                                    );
                                }
                            };
                            let __field2 = match _serde::de::SeqAccess::next_element::<
                                [u8; 32],
                            >(&mut __seq)? {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None => {
                                    return _serde::__private228::Err(
                                        _serde::de::Error::invalid_length(
                                            2usize,
                                            &"struct OptionsArguments with 10 elements",
                                        ),
                                    );
                                }
                            };
                            let __field3 = match _serde::de::SeqAccess::next_element::<
                                u64,
                            >(&mut __seq)? {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None => {
                                    return _serde::__private228::Err(
                                        _serde::de::Error::invalid_length(
                                            3usize,
                                            &"struct OptionsArguments with 10 elements",
                                        ),
                                    );
                                }
                            };
                            let __field4 = match _serde::de::SeqAccess::next_element::<
                                u32,
                            >(&mut __seq)? {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None => {
                                    return _serde::__private228::Err(
                                        _serde::de::Error::invalid_length(
                                            4usize,
                                            &"struct OptionsArguments with 10 elements",
                                        ),
                                    );
                                }
                            };
                            let __field5 = match _serde::de::SeqAccess::next_element::<
                                [u8; 32],
                            >(&mut __seq)? {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None => {
                                    return _serde::__private228::Err(
                                        _serde::de::Error::invalid_length(
                                            5usize,
                                            &"struct OptionsArguments with 10 elements",
                                        ),
                                    );
                                }
                            };
                            let __field6 = match _serde::de::SeqAccess::next_element::<
                                u64,
                            >(&mut __seq)? {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None => {
                                    return _serde::__private228::Err(
                                        _serde::de::Error::invalid_length(
                                            6usize,
                                            &"struct OptionsArguments with 10 elements",
                                        ),
                                    );
                                }
                            };
                            let __field7 = match _serde::de::SeqAccess::next_element::<
                                [u8; 32],
                            >(&mut __seq)? {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None => {
                                    return _serde::__private228::Err(
                                        _serde::de::Error::invalid_length(
                                            7usize,
                                            &"struct OptionsArguments with 10 elements",
                                        ),
                                    );
                                }
                            };
                            let __field8 = match _serde::de::SeqAccess::next_element::<
                                [u8; 32],
                            >(&mut __seq)? {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None => {
                                    return _serde::__private228::Err(
                                        _serde::de::Error::invalid_length(
                                            8usize,
                                            &"struct OptionsArguments with 10 elements",
                                        ),
                                    );
                                }
                            };
                            let __field9 = match _serde::de::SeqAccess::next_element::<
                                u32,
                            >(&mut __seq)? {
                                _serde::__private228::Some(__value) => __value,
                                _serde::__private228::None => {
                                    return _serde::__private228::Err(
                                        _serde::de::Error::invalid_length(
                                            9usize,
                                            &"struct OptionsArguments with 10 elements",
                                        ),
                                    );
                                }
                            };
                            _serde::__private228::Ok(OptionsArguments {
                                grantor_token_asset: __field0,
                                grantor_reissuance_token_asset: __field1,
                                settlement_asset_id: __field2,
                                collateral_per_contract: __field3,
                                start_time: __field4,
                                option_reissuance_token_asset: __field5,
                                settlement_per_contract: __field6,
                                collateral_asset_id: __field7,
                                option_token_asset: __field8,
                                expiry_time: __field9,
                            })
                        }
                        #[inline]
                        fn visit_map<__A>(
                            self,
                            mut __map: __A,
                        ) -> _serde::__private228::Result<Self::Value, __A::Error>
                        where
                            __A: _serde::de::MapAccess<'de>,
                        {
                            let mut __field0: _serde::__private228::Option<[u8; 32]> = _serde::__private228::None;
                            let mut __field1: _serde::__private228::Option<[u8; 32]> = _serde::__private228::None;
                            let mut __field2: _serde::__private228::Option<[u8; 32]> = _serde::__private228::None;
                            let mut __field3: _serde::__private228::Option<u64> = _serde::__private228::None;
                            let mut __field4: _serde::__private228::Option<u32> = _serde::__private228::None;
                            let mut __field5: _serde::__private228::Option<[u8; 32]> = _serde::__private228::None;
                            let mut __field6: _serde::__private228::Option<u64> = _serde::__private228::None;
                            let mut __field7: _serde::__private228::Option<[u8; 32]> = _serde::__private228::None;
                            let mut __field8: _serde::__private228::Option<[u8; 32]> = _serde::__private228::None;
                            let mut __field9: _serde::__private228::Option<u32> = _serde::__private228::None;
                            while let _serde::__private228::Some(__key) = _serde::de::MapAccess::next_key::<
                                __Field,
                            >(&mut __map)? {
                                match __key {
                                    __Field::__field0 => {
                                        if _serde::__private228::Option::is_some(&__field0) {
                                            return _serde::__private228::Err(
                                                <__A::Error as _serde::de::Error>::duplicate_field(
                                                    "grantor_token_asset",
                                                ),
                                            );
                                        }
                                        __field0 = _serde::__private228::Some(
                                            _serde::de::MapAccess::next_value::<[u8; 32]>(&mut __map)?,
                                        );
                                    }
                                    __Field::__field1 => {
                                        if _serde::__private228::Option::is_some(&__field1) {
                                            return _serde::__private228::Err(
                                                <__A::Error as _serde::de::Error>::duplicate_field(
                                                    "grantor_reissuance_token_asset",
                                                ),
                                            );
                                        }
                                        __field1 = _serde::__private228::Some(
                                            _serde::de::MapAccess::next_value::<[u8; 32]>(&mut __map)?,
                                        );
                                    }
                                    __Field::__field2 => {
                                        if _serde::__private228::Option::is_some(&__field2) {
                                            return _serde::__private228::Err(
                                                <__A::Error as _serde::de::Error>::duplicate_field(
                                                    "settlement_asset_id",
                                                ),
                                            );
                                        }
                                        __field2 = _serde::__private228::Some(
                                            _serde::de::MapAccess::next_value::<[u8; 32]>(&mut __map)?,
                                        );
                                    }
                                    __Field::__field3 => {
                                        if _serde::__private228::Option::is_some(&__field3) {
                                            return _serde::__private228::Err(
                                                <__A::Error as _serde::de::Error>::duplicate_field(
                                                    "collateral_per_contract",
                                                ),
                                            );
                                        }
                                        __field3 = _serde::__private228::Some(
                                            _serde::de::MapAccess::next_value::<u64>(&mut __map)?,
                                        );
                                    }
                                    __Field::__field4 => {
                                        if _serde::__private228::Option::is_some(&__field4) {
                                            return _serde::__private228::Err(
                                                <__A::Error as _serde::de::Error>::duplicate_field(
                                                    "start_time",
                                                ),
                                            );
                                        }
                                        __field4 = _serde::__private228::Some(
                                            _serde::de::MapAccess::next_value::<u32>(&mut __map)?,
                                        );
                                    }
                                    __Field::__field5 => {
                                        if _serde::__private228::Option::is_some(&__field5) {
                                            return _serde::__private228::Err(
                                                <__A::Error as _serde::de::Error>::duplicate_field(
                                                    "option_reissuance_token_asset",
                                                ),
                                            );
                                        }
                                        __field5 = _serde::__private228::Some(
                                            _serde::de::MapAccess::next_value::<[u8; 32]>(&mut __map)?,
                                        );
                                    }
                                    __Field::__field6 => {
                                        if _serde::__private228::Option::is_some(&__field6) {
                                            return _serde::__private228::Err(
                                                <__A::Error as _serde::de::Error>::duplicate_field(
                                                    "settlement_per_contract",
                                                ),
                                            );
                                        }
                                        __field6 = _serde::__private228::Some(
                                            _serde::de::MapAccess::next_value::<u64>(&mut __map)?,
                                        );
                                    }
                                    __Field::__field7 => {
                                        if _serde::__private228::Option::is_some(&__field7) {
                                            return _serde::__private228::Err(
                                                <__A::Error as _serde::de::Error>::duplicate_field(
                                                    "collateral_asset_id",
                                                ),
                                            );
                                        }
                                        __field7 = _serde::__private228::Some(
                                            _serde::de::MapAccess::next_value::<[u8; 32]>(&mut __map)?,
                                        );
                                    }
                                    __Field::__field8 => {
                                        if _serde::__private228::Option::is_some(&__field8) {
                                            return _serde::__private228::Err(
                                                <__A::Error as _serde::de::Error>::duplicate_field(
                                                    "option_token_asset",
                                                ),
                                            );
                                        }
                                        __field8 = _serde::__private228::Some(
                                            _serde::de::MapAccess::next_value::<[u8; 32]>(&mut __map)?,
                                        );
                                    }
                                    __Field::__field9 => {
                                        if _serde::__private228::Option::is_some(&__field9) {
                                            return _serde::__private228::Err(
                                                <__A::Error as _serde::de::Error>::duplicate_field(
                                                    "expiry_time",
                                                ),
                                            );
                                        }
                                        __field9 = _serde::__private228::Some(
                                            _serde::de::MapAccess::next_value::<u32>(&mut __map)?,
                                        );
                                    }
                                    _ => {
                                        let _ = _serde::de::MapAccess::next_value::<
                                            _serde::de::IgnoredAny,
                                        >(&mut __map)?;
                                    }
                                }
                            }
                            let __field0 = match __field0 {
                                _serde::__private228::Some(__field0) => __field0,
                                _serde::__private228::None => {
                                    _serde::__private228::de::missing_field(
                                        "grantor_token_asset",
                                    )?
                                }
                            };
                            let __field1 = match __field1 {
                                _serde::__private228::Some(__field1) => __field1,
                                _serde::__private228::None => {
                                    _serde::__private228::de::missing_field(
                                        "grantor_reissuance_token_asset",
                                    )?
                                }
                            };
                            let __field2 = match __field2 {
                                _serde::__private228::Some(__field2) => __field2,
                                _serde::__private228::None => {
                                    _serde::__private228::de::missing_field(
                                        "settlement_asset_id",
                                    )?
                                }
                            };
                            let __field3 = match __field3 {
                                _serde::__private228::Some(__field3) => __field3,
                                _serde::__private228::None => {
                                    _serde::__private228::de::missing_field(
                                        "collateral_per_contract",
                                    )?
                                }
                            };
                            let __field4 = match __field4 {
                                _serde::__private228::Some(__field4) => __field4,
                                _serde::__private228::None => {
                                    _serde::__private228::de::missing_field("start_time")?
                                }
                            };
                            let __field5 = match __field5 {
                                _serde::__private228::Some(__field5) => __field5,
                                _serde::__private228::None => {
                                    _serde::__private228::de::missing_field(
                                        "option_reissuance_token_asset",
                                    )?
                                }
                            };
                            let __field6 = match __field6 {
                                _serde::__private228::Some(__field6) => __field6,
                                _serde::__private228::None => {
                                    _serde::__private228::de::missing_field(
                                        "settlement_per_contract",
                                    )?
                                }
                            };
                            let __field7 = match __field7 {
                                _serde::__private228::Some(__field7) => __field7,
                                _serde::__private228::None => {
                                    _serde::__private228::de::missing_field(
                                        "collateral_asset_id",
                                    )?
                                }
                            };
                            let __field8 = match __field8 {
                                _serde::__private228::Some(__field8) => __field8,
                                _serde::__private228::None => {
                                    _serde::__private228::de::missing_field(
                                        "option_token_asset",
                                    )?
                                }
                            };
                            let __field9 = match __field9 {
                                _serde::__private228::Some(__field9) => __field9,
                                _serde::__private228::None => {
                                    _serde::__private228::de::missing_field("expiry_time")?
                                }
                            };
                            _serde::__private228::Ok(OptionsArguments {
                                grantor_token_asset: __field0,
                                grantor_reissuance_token_asset: __field1,
                                settlement_asset_id: __field2,
                                collateral_per_contract: __field3,
                                start_time: __field4,
                                option_reissuance_token_asset: __field5,
                                settlement_per_contract: __field6,
                                collateral_asset_id: __field7,
                                option_token_asset: __field8,
                                expiry_time: __field9,
                            })
                        }
                    }
                    #[doc(hidden)]
                    const FIELDS: &'static [&'static str] = &[
                        "grantor_token_asset",
                        "grantor_reissuance_token_asset",
                        "settlement_asset_id",
                        "collateral_per_contract",
                        "start_time",
                        "option_reissuance_token_asset",
                        "settlement_per_contract",
                        "collateral_asset_id",
                        "option_token_asset",
                        "expiry_time",
                    ];
                    _serde::Deserializer::deserialize_struct(
                        __deserializer,
                        "OptionsArguments",
                        FIELDS,
                        __Visitor {
                            marker: _serde::__private228::PhantomData::<
                                OptionsArguments,
                            >,
                            lifetime: _serde::__private228::PhantomData,
                        },
                    )
                }
            }
        };
        impl OptionsArguments {
            /// Build Simplicity arguments for contract instantiation.
            #[must_use]
            pub fn build_arguments(&self) -> simplicityhl::Arguments {
                simplicityhl::Arguments::from(
                    HashMap::from([
                        (
                            ::simplicityhl::str::WitnessName::from_str_unchecked(
                                "GRANTOR_TOKEN_ASSET",
                            ),
                            Value::from(
                                UIntValue::U256(
                                    U256::from_byte_array(self.grantor_token_asset),
                                ),
                            ),
                        ),
                        (
                            ::simplicityhl::str::WitnessName::from_str_unchecked(
                                "GRANTOR_REISSUANCE_TOKEN_ASSET",
                            ),
                            Value::from(
                                UIntValue::U256(
                                    U256::from_byte_array(self.grantor_reissuance_token_asset),
                                ),
                            ),
                        ),
                        (
                            ::simplicityhl::str::WitnessName::from_str_unchecked(
                                "SETTLEMENT_ASSET_ID",
                            ),
                            Value::from(
                                UIntValue::U256(
                                    U256::from_byte_array(self.settlement_asset_id),
                                ),
                            ),
                        ),
                        (
                            ::simplicityhl::str::WitnessName::from_str_unchecked(
                                "COLLATERAL_PER_CONTRACT",
                            ),
                            Value::from(UIntValue::U64(self.collateral_per_contract)),
                        ),
                        (
                            ::simplicityhl::str::WitnessName::from_str_unchecked(
                                "START_TIME",
                            ),
                            Value::from(UIntValue::U32(self.start_time)),
                        ),
                        (
                            ::simplicityhl::str::WitnessName::from_str_unchecked(
                                "OPTION_REISSUANCE_TOKEN_ASSET",
                            ),
                            Value::from(
                                UIntValue::U256(
                                    U256::from_byte_array(self.option_reissuance_token_asset),
                                ),
                            ),
                        ),
                        (
                            ::simplicityhl::str::WitnessName::from_str_unchecked(
                                "SETTLEMENT_PER_CONTRACT",
                            ),
                            Value::from(UIntValue::U64(self.settlement_per_contract)),
                        ),
                        (
                            ::simplicityhl::str::WitnessName::from_str_unchecked(
                                "COLLATERAL_ASSET_ID",
                            ),
                            Value::from(
                                UIntValue::U256(
                                    U256::from_byte_array(self.collateral_asset_id),
                                ),
                            ),
                        ),
                        (
                            ::simplicityhl::str::WitnessName::from_str_unchecked(
                                "OPTION_TOKEN_ASSET",
                            ),
                            Value::from(
                                UIntValue::U256(
                                    U256::from_byte_array(self.option_token_asset),
                                ),
                            ),
                        ),
                        (
                            ::simplicityhl::str::WitnessName::from_str_unchecked(
                                "EXPIRY_TIME",
                            ),
                            Value::from(UIntValue::U32(self.expiry_time)),
                        ),
                    ]),
                )
            }
            /// Build struct from Simplicity Arguments.
            ///
            /// # Errors
            ///
            /// Returns error if any required witness is missing, has wrong type, or has invalid value.
            pub fn from_arguments(args: &Arguments) -> Result<Self, String> {
                let grantor_token_asset = {
                    let witness_name = WitnessName::from_str_unchecked(
                        "GRANTOR_TOKEN_ASSET",
                    );
                    let value = args
                        .get(&witness_name)
                        .ok_or_else(|| ::alloc::__export::must_use({
                            ::alloc::fmt::format(
                                format_args!("Missing witness: {0}", "GRANTOR_TOKEN_ASSET"),
                            )
                        }))?;
                    match value.inner() {
                        simplicityhl::value::ValueInner::UInt(UIntValue::U256(u256)) => {
                            Ok(u256.to_byte_array())
                        }
                        _ => {
                            Err(
                                ::alloc::__export::must_use({
                                    ::alloc::fmt::format(
                                        format_args!(
                                            "Wrong type for {0}: expected U256",
                                            "GRANTOR_TOKEN_ASSET",
                                        ),
                                    )
                                }),
                            )
                        }
                    }
                }?;
                let grantor_reissuance_token_asset = {
                    let witness_name = WitnessName::from_str_unchecked(
                        "GRANTOR_REISSUANCE_TOKEN_ASSET",
                    );
                    let value = args
                        .get(&witness_name)
                        .ok_or_else(|| ::alloc::__export::must_use({
                            ::alloc::fmt::format(
                                format_args!(
                                    "Missing witness: {0}",
                                    "GRANTOR_REISSUANCE_TOKEN_ASSET",
                                ),
                            )
                        }))?;
                    match value.inner() {
                        simplicityhl::value::ValueInner::UInt(UIntValue::U256(u256)) => {
                            Ok(u256.to_byte_array())
                        }
                        _ => {
                            Err(
                                ::alloc::__export::must_use({
                                    ::alloc::fmt::format(
                                        format_args!(
                                            "Wrong type for {0}: expected U256",
                                            "GRANTOR_REISSUANCE_TOKEN_ASSET",
                                        ),
                                    )
                                }),
                            )
                        }
                    }
                }?;
                let settlement_asset_id = {
                    let witness_name = WitnessName::from_str_unchecked(
                        "SETTLEMENT_ASSET_ID",
                    );
                    let value = args
                        .get(&witness_name)
                        .ok_or_else(|| ::alloc::__export::must_use({
                            ::alloc::fmt::format(
                                format_args!("Missing witness: {0}", "SETTLEMENT_ASSET_ID"),
                            )
                        }))?;
                    match value.inner() {
                        simplicityhl::value::ValueInner::UInt(UIntValue::U256(u256)) => {
                            Ok(u256.to_byte_array())
                        }
                        _ => {
                            Err(
                                ::alloc::__export::must_use({
                                    ::alloc::fmt::format(
                                        format_args!(
                                            "Wrong type for {0}: expected U256",
                                            "SETTLEMENT_ASSET_ID",
                                        ),
                                    )
                                }),
                            )
                        }
                    }
                }?;
                let collateral_per_contract = {
                    let witness_name = WitnessName::from_str_unchecked(
                        "COLLATERAL_PER_CONTRACT",
                    );
                    let value = args
                        .get(&witness_name)
                        .ok_or_else(|| ::alloc::__export::must_use({
                            ::alloc::fmt::format(
                                format_args!(
                                    "Missing witness: {0}",
                                    "COLLATERAL_PER_CONTRACT",
                                ),
                            )
                        }))?;
                    match value.inner() {
                        simplicityhl::value::ValueInner::UInt(UIntValue::U64(v)) => {
                            Ok(*v)
                        }
                        _ => {
                            Err(
                                ::alloc::__export::must_use({
                                    ::alloc::fmt::format(
                                        format_args!(
                                            "Wrong type for {0}: expected U64",
                                            "COLLATERAL_PER_CONTRACT",
                                        ),
                                    )
                                }),
                            )
                        }
                    }
                }?;
                let start_time = {
                    let witness_name = WitnessName::from_str_unchecked("START_TIME");
                    let value = args
                        .get(&witness_name)
                        .ok_or_else(|| ::alloc::__export::must_use({
                            ::alloc::fmt::format(
                                format_args!("Missing witness: {0}", "START_TIME"),
                            )
                        }))?;
                    match value.inner() {
                        simplicityhl::value::ValueInner::UInt(UIntValue::U32(v)) => {
                            Ok(*v)
                        }
                        _ => {
                            Err(
                                ::alloc::__export::must_use({
                                    ::alloc::fmt::format(
                                        format_args!(
                                            "Wrong type for {0}: expected U32",
                                            "START_TIME",
                                        ),
                                    )
                                }),
                            )
                        }
                    }
                }?;
                let option_reissuance_token_asset = {
                    let witness_name = WitnessName::from_str_unchecked(
                        "OPTION_REISSUANCE_TOKEN_ASSET",
                    );
                    let value = args
                        .get(&witness_name)
                        .ok_or_else(|| ::alloc::__export::must_use({
                            ::alloc::fmt::format(
                                format_args!(
                                    "Missing witness: {0}",
                                    "OPTION_REISSUANCE_TOKEN_ASSET",
                                ),
                            )
                        }))?;
                    match value.inner() {
                        simplicityhl::value::ValueInner::UInt(UIntValue::U256(u256)) => {
                            Ok(u256.to_byte_array())
                        }
                        _ => {
                            Err(
                                ::alloc::__export::must_use({
                                    ::alloc::fmt::format(
                                        format_args!(
                                            "Wrong type for {0}: expected U256",
                                            "OPTION_REISSUANCE_TOKEN_ASSET",
                                        ),
                                    )
                                }),
                            )
                        }
                    }
                }?;
                let settlement_per_contract = {
                    let witness_name = WitnessName::from_str_unchecked(
                        "SETTLEMENT_PER_CONTRACT",
                    );
                    let value = args
                        .get(&witness_name)
                        .ok_or_else(|| ::alloc::__export::must_use({
                            ::alloc::fmt::format(
                                format_args!(
                                    "Missing witness: {0}",
                                    "SETTLEMENT_PER_CONTRACT",
                                ),
                            )
                        }))?;
                    match value.inner() {
                        simplicityhl::value::ValueInner::UInt(UIntValue::U64(v)) => {
                            Ok(*v)
                        }
                        _ => {
                            Err(
                                ::alloc::__export::must_use({
                                    ::alloc::fmt::format(
                                        format_args!(
                                            "Wrong type for {0}: expected U64",
                                            "SETTLEMENT_PER_CONTRACT",
                                        ),
                                    )
                                }),
                            )
                        }
                    }
                }?;
                let collateral_asset_id = {
                    let witness_name = WitnessName::from_str_unchecked(
                        "COLLATERAL_ASSET_ID",
                    );
                    let value = args
                        .get(&witness_name)
                        .ok_or_else(|| ::alloc::__export::must_use({
                            ::alloc::fmt::format(
                                format_args!("Missing witness: {0}", "COLLATERAL_ASSET_ID"),
                            )
                        }))?;
                    match value.inner() {
                        simplicityhl::value::ValueInner::UInt(UIntValue::U256(u256)) => {
                            Ok(u256.to_byte_array())
                        }
                        _ => {
                            Err(
                                ::alloc::__export::must_use({
                                    ::alloc::fmt::format(
                                        format_args!(
                                            "Wrong type for {0}: expected U256",
                                            "COLLATERAL_ASSET_ID",
                                        ),
                                    )
                                }),
                            )
                        }
                    }
                }?;
                let option_token_asset = {
                    let witness_name = WitnessName::from_str_unchecked(
                        "OPTION_TOKEN_ASSET",
                    );
                    let value = args
                        .get(&witness_name)
                        .ok_or_else(|| ::alloc::__export::must_use({
                            ::alloc::fmt::format(
                                format_args!("Missing witness: {0}", "OPTION_TOKEN_ASSET"),
                            )
                        }))?;
                    match value.inner() {
                        simplicityhl::value::ValueInner::UInt(UIntValue::U256(u256)) => {
                            Ok(u256.to_byte_array())
                        }
                        _ => {
                            Err(
                                ::alloc::__export::must_use({
                                    ::alloc::fmt::format(
                                        format_args!(
                                            "Wrong type for {0}: expected U256",
                                            "OPTION_TOKEN_ASSET",
                                        ),
                                    )
                                }),
                            )
                        }
                    }
                }?;
                let expiry_time = {
                    let witness_name = WitnessName::from_str_unchecked("EXPIRY_TIME");
                    let value = args
                        .get(&witness_name)
                        .ok_or_else(|| ::alloc::__export::must_use({
                            ::alloc::fmt::format(
                                format_args!("Missing witness: {0}", "EXPIRY_TIME"),
                            )
                        }))?;
                    match value.inner() {
                        simplicityhl::value::ValueInner::UInt(UIntValue::U32(v)) => {
                            Ok(*v)
                        }
                        _ => {
                            Err(
                                ::alloc::__export::must_use({
                                    ::alloc::fmt::format(
                                        format_args!(
                                            "Wrong type for {0}: expected U32",
                                            "EXPIRY_TIME",
                                        ),
                                    )
                                }),
                            )
                        }
                    }
                }?;
                Ok(Self {
                    grantor_token_asset,
                    grantor_reissuance_token_asset,
                    settlement_asset_id,
                    collateral_per_contract,
                    start_time,
                    option_reissuance_token_asset,
                    settlement_per_contract,
                    collateral_asset_id,
                    option_token_asset,
                    expiry_time,
                })
            }
        }
    }
}
fn main() {}

[ikripaka]

Closing it, because macroses implementation would move to https://github.com/BlockstreamResearch/simplex