From d90d77d608d34a4dcaa9a45b90eaad188b8c7721 Mon Sep 17 00:00:00 2001 From: Illia Kripaka Date: Fri, 5 Jun 2026 18:29:56 +0300 Subject: [PATCH] macros: add Default trait implementation for witness and arguments * edit namings and add default usage in ui tests --- crates/build/src/macros/codegen.rs | 32 +++++++++++++++ crates/build/src/macros/types.rs | 33 ++++++++++++++++ crates/simplex/tests/ui/array_tr_storage.rs | 13 +++---- crates/simplex/tests/ui/bytes32_tr_storage.rs | 12 +++--- .../simplex/tests/ui/dual_currency_deposit.rs | 39 +++---------------- .../tests/ui/either_with_single_witness.rs | 15 +++---- crates/simplex/tests/ui/exotic_values.rs | 14 +++---- crates/simplex/tests/ui/list_check.rs | 6 +-- crates/simplex/tests/ui/option_offer.rs | 18 +++------ crates/simplex/tests/ui/options.rs | 23 +++-------- crates/simplex/tests/ui/simple_storage.rs | 13 +++---- crates/simplex/tests/ui/single_bit.rs | 16 ++++---- 12 files changed, 119 insertions(+), 115 deletions(-) diff --git a/crates/build/src/macros/codegen.rs b/crates/build/src/macros/codegen.rs index ee62e9e..7c289b5 100644 --- a/crates/build/src/macros/codegen.rs +++ b/crates/build/src/macros/codegen.rs @@ -104,6 +104,7 @@ impl WitnessStruct { proc_macro2::TokenStream, proc_macro2::TokenStream, ) = self.generate_from_args_conversion_with_param_name("args"); + let default_mapping: proc_macro2::TokenStream = self.generate_default_mapping(); Ok(GeneratedArgumentTokens { imports: quote! { @@ -162,6 +163,12 @@ impl WitnessStruct { Self::from_arguments(&x).map_err(simplex::serde::de::Error::custom) } } + + impl core::default::Default for #struct_name { + fn default() -> Self { + #default_mapping + } + } }, }) } @@ -178,6 +185,7 @@ impl WitnessStruct { proc_macro2::TokenStream, proc_macro2::TokenStream, ) = self.generate_from_args_conversion_with_param_name("witness"); + let default_mapping: proc_macro2::TokenStream = self.generate_default_mapping(); Ok(GeneratedWitnessTokens { imports: quote! { @@ -235,6 +243,12 @@ impl WitnessStruct { Self::from_witness(&x).map_err(simplex::serde::de::Error::custom) } } + + impl core::default::Default for #struct_name { + fn default() -> Self { + #default_mapping + } + } }, }) } @@ -281,6 +295,24 @@ impl WitnessStruct { } } + fn generate_default_mapping(&self) -> proc_macro2::TokenStream { + let name = format_ident!("{}", self.struct_name); + let fields: Vec = self + .witness_values + .iter() + .map(|field| { + let field_name = format_ident!("{}", field.struct_rust_field); + let field_default_value = field.rust_type.get_default_value(); + quote! { #field_name: #field_default_value } + }) + .collect(); + quote! { + #name { + #(#fields),* + } + } + } + #[inline] fn construct_witness_tuples(&self) -> Vec { self.witness_values.iter().map(WitnessField::to_token_stream).collect() diff --git a/crates/build/src/macros/types.rs b/crates/build/src/macros/types.rs index 3e9a373..8c928ea 100644 --- a/crates/build/src/macros/types.rs +++ b/crates/build/src/macros/types.rs @@ -60,6 +60,39 @@ impl RustTypeContext { } impl RustType { + pub fn get_default_value(&self) -> proc_macro2::TokenStream { + match self { + RustType::Bool => quote! { Default::default() }, + RustType::U1 => quote! { Default::default() }, + RustType::U2 => quote! { Default::default() }, + RustType::U4 => quote! { Default::default() }, + RustType::U8 => quote! { Default::default() }, + RustType::U16 => quote! { Default::default() }, + RustType::U32 => quote! { Default::default() }, + RustType::U64 => quote! { Default::default() }, + RustType::U128 => quote! { Default::default() }, + RustType::U256Array => quote! { [Default::default(); 32] }, + RustType::Array(element, size) => { + let element_ty = element.get_default_value(); + quote! { [#element_ty; #size] } + } + RustType::Tuple(elements) => { + let element_types: Vec<_> = elements.iter().map(RustType::get_default_value).collect(); + quote! { (#(#element_types),*) } + } + RustType::Either(left, _) => { + let left_ty = left.get_default_value(); + quote! { simplex::either::Either::Left(#left_ty) } + } + RustType::Option(_inner) => { + quote! { Default::default() } + } + RustType::List(_element, _size) => { + quote! { Default::default() } + } + } + } + pub fn from_resolved_type(ty: &ResolvedType) -> syn::Result { use simplicityhl::types::{TypeInner, UIntType}; diff --git a/crates/simplex/tests/ui/array_tr_storage.rs b/crates/simplex/tests/ui/array_tr_storage.rs index 4d3a5f9..26ad3d9 100644 --- a/crates/simplex/tests/ui/array_tr_storage.rs +++ b/crates/simplex/tests/ui/array_tr_storage.rs @@ -4,20 +4,17 @@ use simplex::program::{ArgumentsTrait, WitnessTrait}; include_simf!("../../../../crates/simplex/tests/ui_simfs/array_tr_storage.simf"); fn main() -> Result<(), String> { - let original_witness = derived_array_tr_storage::ArrayTrStorageWitness { - changed_index: 0, - state: Default::default(), - }; + let original_witness = derived_array_tr_storage::ArrayTrStorageWitness::default(); let witness_values = original_witness.build_witness(); let recovered_witness = derived_array_tr_storage::ArrayTrStorageWitness::from_witness(&witness_values)?; assert_eq!(original_witness, recovered_witness); - let original_arguments = derived_array_tr_storage::ArrayTrStorageArguments {}; + let original_arguments = derived_array_tr_storage::ArrayTrStorageArguments::default(); - let witness_values = original_arguments.build_arguments(); - let recovered_witness = derived_array_tr_storage::ArrayTrStorageArguments::from_arguments(&witness_values)?; - assert_eq!(original_arguments, recovered_witness); + let arguments_values = original_arguments.build_arguments(); + let recovered_arguments = derived_array_tr_storage::ArrayTrStorageArguments::from_arguments(&arguments_values)?; + assert_eq!(original_arguments, recovered_arguments); Ok(()) } diff --git a/crates/simplex/tests/ui/bytes32_tr_storage.rs b/crates/simplex/tests/ui/bytes32_tr_storage.rs index e36c867..de30a3f 100644 --- a/crates/simplex/tests/ui/bytes32_tr_storage.rs +++ b/crates/simplex/tests/ui/bytes32_tr_storage.rs @@ -4,19 +4,17 @@ use simplex::program::{WitnessTrait, ArgumentsTrait}; include_simf!("../../../../crates/simplex/tests/ui_simfs/bytes32_tr_storage.simf"); fn main() -> Result<(), String> { - let original_witness = derived_bytes32_tr_storage::Bytes32TrStorageWitness { - state: Default::default(), - }; + let original_witness = derived_bytes32_tr_storage::Bytes32TrStorageWitness::default(); let witness_values = original_witness.build_witness(); let recovered_witness = derived_bytes32_tr_storage::Bytes32TrStorageWitness::from_witness(&witness_values)?; assert_eq!(original_witness, recovered_witness); - let original_arguments = derived_bytes32_tr_storage::Bytes32TrStorageArguments {}; + let original_arguments = derived_bytes32_tr_storage::Bytes32TrStorageArguments::default(); - let witness_values = original_arguments.build_arguments(); - let recovered_witness = derived_bytes32_tr_storage::Bytes32TrStorageArguments::from_arguments(&witness_values)?; - assert_eq!(original_arguments, recovered_witness); + let arguments_values = original_arguments.build_arguments(); + let recovered_arguments = derived_bytes32_tr_storage::Bytes32TrStorageArguments::from_arguments(&arguments_values)?; + assert_eq!(original_arguments, recovered_arguments); Ok(()) } diff --git a/crates/simplex/tests/ui/dual_currency_deposit.rs b/crates/simplex/tests/ui/dual_currency_deposit.rs index 33db4bf..a139575 100644 --- a/crates/simplex/tests/ui/dual_currency_deposit.rs +++ b/crates/simplex/tests/ui/dual_currency_deposit.rs @@ -4,45 +4,18 @@ use simplex::program::{WitnessTrait, ArgumentsTrait}; include_simf!("../../../../crates/simplex/tests/ui_simfs/dual_currency_deposit.simf"); fn main() -> Result<(), String> { - let original_witness = derived_dual_currency_deposit::DualCurrencyDepositWitness { - merge_branch: simplex::either::Left(simplex::either::Right(())), - token_branch: simplex::either::Left(()), - path: simplex::either::Left(simplex::either::Left(simplex::either::Left((0, 1, 2, 3)))), - }; + let original_witness = derived_dual_currency_deposit::DualCurrencyDepositWitness::default(); let witness_values = original_witness.build_witness(); let recovered_witness = derived_dual_currency_deposit::DualCurrencyDepositWitness::from_witness(&witness_values)?; assert_eq!(original_witness, recovered_witness); - let original_arguments = derived_dual_currency_deposit::DualCurrencyDepositArguments { - grantor_per_settlement_asset: 0, - settlement_asset_id: [1; 32], - grantor_settlement_token_asset: [1; 32], - strike_price: 0, - incentive_basis_points: 0, - grantor_collateral_token_asset: [1; 32], - contract_expiry_time: 0, - filler_per_settlement_asset: 0, - filler_per_principal_collateral: 0, - filler_token_asset: [1; 32], - grantor_per_settlement_collateral: 0, - grantor_settlement_per_deposited_asset: 0, - fee_script_hash: [1; 32], - taker_funding_end_time: 0, - settlement_height: 0, - collateral_asset_id: [1; 32], - taker_funding_start_time: 0, - filler_per_settlement_collateral: 0, - oracle_pk: [1; 32], - fee_basis_points: 0, - grantor_collateral_per_deposited_collateral: 0, - early_termination_end_time: 0, - }; + let original_arguments = derived_dual_currency_deposit::DualCurrencyDepositArguments::default(); - let witness_values = original_arguments.build_arguments(); - let recovered_witness = - derived_dual_currency_deposit::DualCurrencyDepositArguments::from_arguments(&witness_values)?; - assert_eq!(original_arguments, recovered_witness); + let arguments_values = original_arguments.build_arguments(); + let recovered_arguments = + derived_dual_currency_deposit::DualCurrencyDepositArguments::from_arguments(&arguments_values)?; + assert_eq!(original_arguments, recovered_arguments); Ok(()) } diff --git a/crates/simplex/tests/ui/either_with_single_witness.rs b/crates/simplex/tests/ui/either_with_single_witness.rs index 2dffcee..9f1186e 100644 --- a/crates/simplex/tests/ui/either_with_single_witness.rs +++ b/crates/simplex/tests/ui/either_with_single_witness.rs @@ -4,22 +4,19 @@ use simplex::program::{WitnessTrait, ArgumentsTrait}; include_simf!("../../../../crates/simplex/tests/ui_simfs/either_with_single_witness.simf"); fn main() -> Result<(), String> { - let original_witness = derived_either_with_single_witness::EitherWithSingleWitnessWitness { - path: simplex::either::Left((simplex::either::Left(11_u16), simplex::either::Left(Some(true)))), - signature: [0; 64], - }; + let original_witness = derived_either_with_single_witness::EitherWithSingleWitnessWitness::default(); let witness_values = original_witness.build_witness(); let recovered_witness = derived_either_with_single_witness::EitherWithSingleWitnessWitness::from_witness(&witness_values)?; assert_eq!(original_witness, recovered_witness); - let original_arguments = derived_either_with_single_witness::EitherWithSingleWitnessArguments {}; + let original_arguments = derived_either_with_single_witness::EitherWithSingleWitnessArguments::default(); - let witness_values = original_arguments.build_arguments(); - let recovered_witness = - derived_either_with_single_witness::EitherWithSingleWitnessArguments::from_arguments(&witness_values)?; - assert_eq!(original_arguments, recovered_witness); + let arguments_values = original_arguments.build_arguments(); + let recovered_arguments = + derived_either_with_single_witness::EitherWithSingleWitnessArguments::from_arguments(&arguments_values)?; + assert_eq!(original_arguments, recovered_arguments); Ok(()) } diff --git a/crates/simplex/tests/ui/exotic_values.rs b/crates/simplex/tests/ui/exotic_values.rs index b486a9d..e0aab6a 100644 --- a/crates/simplex/tests/ui/exotic_values.rs +++ b/crates/simplex/tests/ui/exotic_values.rs @@ -4,20 +4,18 @@ use simplex::program::{WitnessTrait, ArgumentsTrait}; include_simf!("../../../../crates/simplex/tests/ui_simfs/exotic_values.simf"); fn main() -> Result<(), String> { - let original_witness = derived_exotic_values::ExoticValuesWitness { - path: simplex::either::Left((simplex::either::Left(1), simplex::either::Left(Some(false)))), - }; + let original_witness = derived_exotic_values::ExoticValuesWitness::default(); let witness_values = original_witness.build_witness(); let recovered_witness = derived_exotic_values::ExoticValuesWitness::from_witness(&witness_values)?; assert_eq!(original_witness, recovered_witness); - let original_arguments = derived_exotic_values::ExoticValuesArguments {}; + let original_arguments = derived_exotic_values::ExoticValuesArguments::default(); - let witness_values = original_arguments.build_arguments(); - let recovered_witness = - derived_exotic_values::ExoticValuesArguments::from_arguments(&witness_values)?; - assert_eq!(original_arguments, recovered_witness); + let arguments_values = original_arguments.build_arguments(); + let recovered_arguments = + derived_exotic_values::ExoticValuesArguments::from_arguments(&arguments_values)?; + assert_eq!(original_arguments, recovered_arguments); Ok(()) } diff --git a/crates/simplex/tests/ui/list_check.rs b/crates/simplex/tests/ui/list_check.rs index eb6a78d..a36079a 100644 --- a/crates/simplex/tests/ui/list_check.rs +++ b/crates/simplex/tests/ui/list_check.rs @@ -19,9 +19,9 @@ fn main() -> Result<(), String> { let original_arguments = derived_list_check::ListCheckArguments {}; - let witness_values = original_arguments.build_arguments(); - let recovered_witness = derived_list_check::ListCheckArguments::from_arguments(&witness_values)?; - assert_eq!(original_arguments, recovered_witness); + let arguments_values = original_arguments.build_arguments(); + let recovered_arguments = derived_list_check::ListCheckArguments::from_arguments(&arguments_values)?; + assert_eq!(original_arguments, recovered_arguments); // Build Witness, which would panic on building let original_witness = derived_list_check::ListCheckWitness { diff --git a/crates/simplex/tests/ui/option_offer.rs b/crates/simplex/tests/ui/option_offer.rs index fdb5ac2..3ace0ae 100644 --- a/crates/simplex/tests/ui/option_offer.rs +++ b/crates/simplex/tests/ui/option_offer.rs @@ -4,25 +4,17 @@ use simplex::program::{WitnessTrait, ArgumentsTrait}; include_simf!("../../../../crates/simplex/tests/ui_simfs/option_offer.simf"); fn main() -> Result<(), String> { - let original_witness = derived_option_offer::OptionOfferWitness { path: simplex::either::Left((0, false)) }; + let original_witness = derived_option_offer::OptionOfferWitness::default(); let witness_values = original_witness.build_witness(); let recovered_witness = derived_option_offer::OptionOfferWitness::from_witness(&witness_values)?; assert_eq!(original_witness, recovered_witness); - let original_arguments = derived_option_offer::OptionOfferArguments { - user_pubkey: [1; 32], - premium_per_collateral: 0, - premium_asset_id: [1; 32], - settlement_asset_id: [1; 32], - collateral_asset_id: [1; 32], - collateral_per_contract: 0, - expiry_time: 0, - }; + let original_arguments = derived_option_offer::OptionOfferArguments::default(); - let witness_values = original_arguments.build_arguments(); - let recovered_witness = derived_option_offer::OptionOfferArguments::from_arguments(&witness_values)?; - assert_eq!(original_arguments, recovered_witness); + let arguments_values = original_arguments.build_arguments(); + let recovered_arguments = derived_option_offer::OptionOfferArguments::from_arguments(&arguments_values)?; + assert_eq!(original_arguments, recovered_arguments); Ok(()) } diff --git a/crates/simplex/tests/ui/options.rs b/crates/simplex/tests/ui/options.rs index 97bd6bd..9dad90a 100644 --- a/crates/simplex/tests/ui/options.rs +++ b/crates/simplex/tests/ui/options.rs @@ -4,30 +4,17 @@ use simplex::program::{WitnessTrait, ArgumentsTrait}; include_simf!("../../../../crates/simplex/tests/ui_simfs/options.simf"); fn main() -> Result<(), String> { - let original_witness = derived_options::OptionsWitness { - path: simplicityhl::either::Either::Right(simplicityhl::either::Either::Left((true, 100, 200))), - }; + let original_witness = derived_options::OptionsWitness::default(); let witness_values = original_witness.build_witness(); let recovered_witness = derived_options::OptionsWitness::from_witness(&witness_values)?; assert_eq!(original_witness, recovered_witness); - let original_arguments = derived_options::OptionsArguments { - start_time: 0, - expiry_time: 0, - grantor_reissuance_token_asset: Default::default(), - grantor_token_asset: Default::default(), - settlement_per_contract: Default::default(), - settlement_asset_id: Default::default(), - collateral_per_contract: Default::default(), - collateral_asset_id: Default::default(), - option_reissuance_token_asset: Default::default(), - option_token_asset: Default::default(), - }; + let original_arguments = derived_options::OptionsArguments::default(); - let witness_values = original_arguments.build_arguments(); - let recovered_witness = derived_options::OptionsArguments::from_arguments(&witness_values)?; - assert_eq!(original_arguments, recovered_witness); + let arguments_values = original_arguments.build_arguments(); + let recovered_arguments = derived_options::OptionsArguments::from_arguments(&arguments_values)?; + assert_eq!(original_arguments, recovered_arguments); Ok(()) } diff --git a/crates/simplex/tests/ui/simple_storage.rs b/crates/simplex/tests/ui/simple_storage.rs index 10513ef..3414770 100644 --- a/crates/simplex/tests/ui/simple_storage.rs +++ b/crates/simplex/tests/ui/simple_storage.rs @@ -4,20 +4,17 @@ use simplex::program::{WitnessTrait, ArgumentsTrait}; include_simf!("../../../../crates/simplex/tests/ui_simfs/simple_storage.simf"); fn main() -> Result<(), String> { - let original_witness = derived_simple_storage::SimpleStorageWitness { - new_value: 0, - user_signature: [1; 64], - }; + let original_witness = derived_simple_storage::SimpleStorageWitness::default(); let witness_values = original_witness.build_witness(); let recovered_witness = derived_simple_storage::SimpleStorageWitness::from_witness(&witness_values)?; assert_eq!(original_witness, recovered_witness); - let original_arguments = derived_simple_storage::SimpleStorageArguments { user: Default::default(), slot_id: Default::default() }; + let original_arguments = derived_simple_storage::SimpleStorageArguments::default(); - let witness_values = original_arguments.build_arguments(); - let recovered_witness = derived_simple_storage::SimpleStorageArguments::from_arguments(&witness_values)?; - assert_eq!(original_arguments, recovered_witness); + let arguments_values = original_arguments.build_arguments(); + let recovered_arguments = derived_simple_storage::SimpleStorageArguments::from_arguments(&arguments_values)?; + assert_eq!(original_arguments, recovered_arguments); Ok(()) } diff --git a/crates/simplex/tests/ui/single_bit.rs b/crates/simplex/tests/ui/single_bit.rs index 2aad822..d1397cc 100644 --- a/crates/simplex/tests/ui/single_bit.rs +++ b/crates/simplex/tests/ui/single_bit.rs @@ -16,8 +16,8 @@ fn main() -> Result<(), String> { let original_arguments = derived_single_bit::SingleBitArguments { flag: 1 }; - let witness_values = original_arguments.build_arguments(); - let recovered_arguments = derived_single_bit::SingleBitArguments::from_arguments(&witness_values)?; + let arguments_values = original_arguments.build_arguments(); + let recovered_arguments = derived_single_bit::SingleBitArguments::from_arguments(&arguments_values)?; assert_eq!( original_arguments, recovered_arguments, "Testing values with (FLAG = 1, BIT = 1) (Arguments)" @@ -35,8 +35,8 @@ fn main() -> Result<(), String> { let original_arguments = derived_single_bit::SingleBitArguments { flag: 0 }; - let witness_values = original_arguments.build_arguments(); - let recovered_arguments = derived_single_bit::SingleBitArguments::from_arguments(&witness_values)?; + let arguments_values = original_arguments.build_arguments(); + let recovered_arguments = derived_single_bit::SingleBitArguments::from_arguments(&arguments_values)?; assert_eq!( original_arguments, recovered_arguments, "Testing values with (FLAG = 0, BIT = 1) (Arguments)" @@ -54,8 +54,8 @@ fn main() -> Result<(), String> { let original_arguments = derived_single_bit::SingleBitArguments { flag: 1 }; - let witness_values = original_arguments.build_arguments(); - let recovered_arguments = derived_single_bit::SingleBitArguments::from_arguments(&witness_values)?; + let arguments_values = original_arguments.build_arguments(); + let recovered_arguments = derived_single_bit::SingleBitArguments::from_arguments(&arguments_values)?; assert_eq!( original_arguments, recovered_arguments, "Testing values with (FLAG = 1, BIT = 0) (Arguments)" @@ -73,8 +73,8 @@ fn main() -> Result<(), String> { let original_arguments = derived_single_bit::SingleBitArguments { flag: 0 }; - let witness_values = original_arguments.build_arguments(); - let recovered_arguments = derived_single_bit::SingleBitArguments::from_arguments(&witness_values)?; + let arguments_values = original_arguments.build_arguments(); + let recovered_arguments = derived_single_bit::SingleBitArguments::from_arguments(&arguments_values)?; assert_eq!( original_arguments, recovered_arguments, "Testing values with (FLAG = 0, BIT = 0) (Arguments)"