diff --git a/crates/contracts/simf/fee_collector.simf b/crates/contracts/simf/fee_collector.simf new file mode 100644 index 0000000..891fecf --- /dev/null +++ b/crates/contracts/simf/fee_collector.simf @@ -0,0 +1,9 @@ +fn checksig(pubkey: Pubkey, sig: Signature) { + let sighash: u256 = jet::sig_all_hash(); + + jet::bip_0340_verify((pubkey, sighash), sig); +} + +fn main() { + checksig(param::WITHDRAWAL_PUBKEY, witness::SIGNATURE); +} diff --git a/crates/contracts/src/artifacts/fee_collector.rs b/crates/contracts/src/artifacts/fee_collector.rs new file mode 100644 index 0000000..3788cc5 --- /dev/null +++ b/crates/contracts/src/artifacts/fee_collector.rs @@ -0,0 +1,71 @@ +// This file is @generated by Simplex. Do not edit manually. + +use simplex::include_simf; +use simplex::program::{ArgumentsTrait, Program}; +use simplex::provider::SimplicityNetwork; +use simplex::simplicityhl::elements::Script; +use simplex::simplicityhl::elements::secp256k1_zkp::XOnlyPublicKey; +pub struct FeeCollectorProgram { + program: Program, +} +impl FeeCollectorProgram { + pub const SOURCE: &'static str = derived_fee_collector::FEE_COLLECTOR_CONTRACT_SOURCE; + #[must_use] + pub fn new(arguments: &impl ArgumentsTrait) -> Self { + Self { + program: Program::new(Self::SOURCE, arguments), + } + } + #[must_use] + pub fn with_taproot_pubkey(mut self, pub_key: XOnlyPublicKey) -> Self { + self.program = self.program.with_taproot_pubkey(pub_key); + self + } + #[must_use] + pub fn with_storage_capacity(mut self, capacity: usize) -> Self { + self.program = self.program.with_storage_capacity(capacity); + self + } + pub fn set_storage_at(&mut self, index: usize, new_value: impl Into>) { + self.program.set_storage_at(index, new_value); + } + #[must_use] + pub fn get_storage_len(&self) -> usize { + self.program.get_storage_len() + } + #[must_use] + pub fn get_storage(&self) -> &[Vec] { + self.program.get_storage() + } + #[must_use] + pub fn get_storage_at(&self, index: usize) -> Vec { + self.program.get_storage_at(index) + } + #[must_use] + pub fn get_script_pubkey(&self, network: &SimplicityNetwork) -> Script { + self.program.get_script_pubkey(network) + } + #[must_use] + pub fn get_script_hash(&self, network: &SimplicityNetwork) -> [u8; 32] { + self.program.get_script_hash(network) + } + #[must_use] + pub fn get_cmr(&self) -> [u8; 32] { + self.program.get_cmr() + } + #[must_use] + pub fn get_tapleaf_hash(&self) -> [u8; 32] { + self.program.get_tapleaf_hash() + } +} +impl AsRef for FeeCollectorProgram { + fn as_ref(&self) -> &Program { + &self.program + } +} +impl AsMut for FeeCollectorProgram { + fn as_mut(&mut self) -> &mut Program { + &mut self.program + } +} +include_simf!("src/artifacts/simf/fee_collector.simf"); diff --git a/crates/contracts/src/artifacts/metadata.json b/crates/contracts/src/artifacts/metadata.json index 40c5f45..beb4ba6 100644 --- a/crates/contracts/src/artifacts/metadata.json +++ b/crates/contracts/src/artifacts/metadata.json @@ -8,6 +8,10 @@ "cmr": "568ad9598191e3583fe1866b3821430ac0c8401cc8a2fc17fbd840b710e14021", "content": "mod unit_1 {\n pub fn is_output_op_return(output_index: u32) -> bool {\n match jet::output_null_datum(output_index, 0){\n None => false,\n Some(entry: Option>>) => true,\n }}\n pub fn assert_output_is_op_return(output_index: u32) {\n assert!(is_output_op_return(output_index));\n }\n}\nmod unit_2 {\n pub fn checked_add_64(a: u64, b: u64) -> Option {\n let (carry, sum): (bool, u64) = jet::add_64(a, b);\n match carry{\n false => Some(sum),\n true => None,\n }}\n pub fn safe_add_64(a: u64, b: u64) -> u64 {\n unwrap(checked_add_64(a, b))}\n pub fn checked_sub_64(a: u64, b: u64) -> Option {\n let (borrow, diff): (bool, u64) = jet::subtract_64(a, b);\n match borrow{\n false => Some(diff),\n true => None,\n }}\n pub fn safe_sub_64(a: u64, b: u64) -> u64 {\n unwrap(checked_sub_64(a, b))}\n pub fn checked_mul_64(a: u64, b: u64) -> Option {\n let result: u128 = jet::multiply_64(a, b);\n let (high, low): (u64, u64) = ::into(result);\n match jet::is_zero_64(high){\n false => None,\n true => Some(low),\n }}\n pub fn safe_mul_64(a: u64, b: u64) -> u64 {\n unwrap(checked_mul_64(a, b))}\n pub fn checked_div_64(a: u64, b: u64) -> Option {\n match jet::is_zero_64(b){\n false => Some(jet::divide_64(a, b)),\n true => None,\n }}\n pub fn safe_div_64(a: u64, b: u64) -> u64 {\n unwrap(checked_div_64(a, b))}\n pub fn gt_64(a: u64, b: u64) -> bool {\n jet::lt_64(b, a)}\n pub fn ge_64(a: u64, b: u64) -> bool {\n jet::le_64(b, a)}\n}\nmod unit_9 {\n pub fn not(bit: bool) -> bool {\n ::into(jet::complement_1(::into(bit)))}\n pub fn or(a: bool, b: bool) -> bool {\n ::into(jet::or_1(::into(a), ::into(b)))}\n pub fn and(a: bool, b: bool) -> bool {\n ::into(jet::and_1(::into(a), ::into(b)))}\n pub fn xor(a: bool, b: bool) -> bool {\n and(or(a, b), not(and(a, b)))}\n}\nmod unit_8 {\n use crate::unit_9::and;\n pub fn and_128(a: u128, b: u128) -> u128 {\n let (a_high, a_low): (u64, u64) = ::into(a);\n let (b_high, b_low): (u64, u64) = ::into(b);\n <(u64, u64)>::into((jet::and_64(a_high, b_high), jet::and_64(a_low, b_low)))}\n pub fn or_128(a: u128, b: u128) -> u128 {\n let (a_high, a_low): (u64, u64) = ::into(a);\n let (b_high, b_low): (u64, u64) = ::into(b);\n <(u64, u64)>::into((jet::or_64(a_high, b_high), jet::or_64(a_low, b_low)))}\n pub fn eq_128(a: u128, b: u128) -> bool {\n let (a_high, a_low): (u64, u64) = ::into(a);\n let (b_high, b_low): (u64, u64) = ::into(b);\n and(jet::eq_64(a_high, b_high), jet::eq_64(a_low, b_low))}\n pub fn left_shift_128(shift: u8, a: u128) -> u128 {\n match jet::is_zero_8(shift){\n false => {\n let (a_high, a_low): (u64, u64) = ::into(a);\n match jet::lt_8(shift, 64){\n false => {\n let (_, shift): (bool, u8) = jet::subtract_8(shift, 64);\n <(u64, u64)>::into((jet::left_shift_64(shift, a_low), 0))}\n ,\n true => {\n let (_, low_to_high_amount): (bool, u8) = jet::subtract_8(64, shift);\n let shifted_bits: u64 = jet::right_shift_64(low_to_high_amount, a_low);\n let res_high: u64 = jet::or_64(jet::left_shift_64(shift, a_high), shifted_bits);\n <(u64, u64)>::into((res_high, jet::left_shift_64(shift, a_low)))}\n ,\n }}\n ,\n true => a,\n }}\n pub fn right_shift_128(shift: u8, a: u128) -> u128 {\n match jet::is_zero_8(shift){\n false => {\n let (a_high, a_low): (u64, u64) = ::into(a);\n match jet::lt_8(shift, 64){\n false => {\n let (_, shift): (bool, u8) = jet::subtract_8(shift, 64);\n <(u64, u64)>::into((0, jet::right_shift_64(shift, a_high)))}\n ,\n true => {\n let (_, high_to_low_amount): (bool, u8) = jet::subtract_8(64, shift);\n let shifted_bits: u64 = jet::left_shift_64(high_to_low_amount, a_high);\n let res_low: u64 = jet::or_64(jet::right_shift_64(shift, a_low), shifted_bits);\n <(u64, u64)>::into((jet::right_shift_64(shift, a_high), res_low))}\n ,\n }}\n ,\n true => a,\n }}\n}\nmod unit_6 {\n use crate::unit_8::eq_128;\n pub fn assert_eq_1(a: u1, b: u1) {\n assert!(jet::eq_1(a, b))}\n pub fn assert_eq_8(a: u8, b: u8) {\n assert!(jet::eq_8(a, b));\n }\n pub fn assert_eq_16(a: u16, b: u16) {\n assert!(jet::eq_16(a, b));\n }\n pub fn assert_eq_32(a: u32, b: u32) {\n assert!(jet::eq_32(a, b));\n }\n pub fn assert_eq_64(a: u64, b: u64) {\n assert!(jet::eq_64(a, b));\n }\n pub fn assert_eq_128(a: u128, b: u128) {\n assert!(eq_128(a, b));\n }\n pub fn assert_eq_256(a: u256, b: u256) {\n assert!(jet::eq_256(a, b));\n }\n pub fn assert_eq_bool(a: bool, b: bool) {\n assert_eq_1(::into(a), ::into(b));\n }\n pub fn assert_none_1(val: Option) {\n assert!(is_none::(val));\n }\n pub fn assert_none_8(val: Option) {\n assert!(is_none::(val));\n }\n pub fn assert_none_16(val: Option) {\n assert!(is_none::(val));\n }\n pub fn assert_none_32(val: Option) {\n assert!(is_none::(val));\n }\n pub fn assert_none_64(val: Option) {\n assert!(is_none::(val));\n }\n pub fn assert_none_128(val: Option) {\n assert!(is_none::(val));\n }\n pub fn assert_none_256(val: Option) {\n assert!(is_none::(val));\n }\n}\nmod unit_3 {\n use crate::unit_6::{assert_eq_1, assert_eq_64, assert_eq_256};\n pub fn get_explicit_asset_and_amount(index: u32, is_input_index: bool) -> (u256, u64) {\n let pair: (Asset1, Amount1) = match is_input_index{\n false => {\n unwrap(jet::output_amount(index))}\n ,\n true => {\n unwrap(jet::input_amount(index))}\n ,\n };\n let (asset, amount): (Asset1, Amount1) = pair;\n let asset_bits: u256 = unwrap_right::<(u1, u256)>(asset);\n let amount: u64 = unwrap_right::<(u1, u256)>(amount);\n (asset_bits, amount)}\n pub fn get_input_explicit_asset_and_amount(input_index: u32) -> (u256, u64) {\n get_explicit_asset_and_amount(input_index, true)}\n pub fn get_output_explicit_asset_and_amount(output_index: u32) -> (u256, u64) {\n get_explicit_asset_and_amount(output_index, false)}\n pub fn get_script_hash(index: u32, is_input_index: bool) -> u256 {\n match is_input_index{\n false => {\n unwrap(jet::output_script_hash(index))}\n ,\n true => {\n unwrap(jet::input_script_hash(index))}\n ,\n }}\n pub fn get_input_script_hash(input_index: u32) -> u256 {\n get_script_hash(input_index, true)}\n pub fn get_output_script_hash(output_index: u32) -> u256 {\n get_script_hash(output_index, false)}\n pub fn check_asset_amounts_eq(asset_amount_1: u64, asset_amount_2: u64) {\n assert_eq_64(asset_amount_1, asset_amount_2);\n }\n pub fn check_assets_eq(asset_bits_1: u256, asset_bits_2: u256) {\n assert_eq_256(asset_bits_1, asset_bits_2);\n }\n pub fn check_script_hashes_eq(script_1: u256, script_2: u256) {\n assert_eq_256(script_1, script_2);\n }\n pub fn check_flags_eq(flag_1: bool, flag_2: bool) {\n assert_eq_1(::into(flag_1), ::into(flag_2));\n }\n}\nmod unit_4 {\n use crate::unit_1::assert_output_is_op_return;\n use crate::unit_2::{ge_64, safe_add_64};\n use crate::unit_3::{get_input_explicit_asset_and_amount, get_output_explicit_asset_and_amount, get_input_script_hash, get_output_script_hash, check_asset_amounts_eq, check_assets_eq, check_script_hashes_eq};\n pub fn ensure_non_zero_amount(amount: u64) {\n assert!(jet::some_64(amount));\n }\n pub fn ensure_input_script_hash(input_index: u32, expected_script_hash: u256) {\n check_script_hashes_eq(get_input_script_hash(input_index), expected_script_hash);\n }\n pub fn ensure_output_script_hash(output_index: u32, expected_script_hash: u256) {\n check_script_hashes_eq(get_output_script_hash(output_index), expected_script_hash);\n }\n pub fn ensure_io_script_hashes_eq(input_index: u32, output_index: u32) {\n check_script_hashes_eq(get_input_script_hash(input_index), get_output_script_hash(output_index));\n }\n pub fn ensure_script_hash_transition(input_index: u32, output_index: u32, expected_input_script_hash: u256, expected_output_script_hash: u256) {\n ensure_input_script_hash(input_index, expected_input_script_hash);\n ensure_output_script_hash(output_index, expected_output_script_hash);\n }\n pub fn ensure_input_asset_and_amount(input_index: u32, expected_asset_bits: u256, expected_amount: u64) {\n let (asset_bits, amount): (u256, u64) = get_input_explicit_asset_and_amount(input_index);\n check_assets_eq(asset_bits, expected_asset_bits);\n check_asset_amounts_eq(amount, expected_amount);\n }\n pub fn ensure_output_asset_and_amount(output_index: u32, expected_asset_bits: u256, expected_amount: u64) {\n let (asset_bits, amount): (u256, u64) = get_output_explicit_asset_and_amount(output_index);\n check_assets_eq(asset_bits, expected_asset_bits);\n check_asset_amounts_eq(amount, expected_amount);\n }\n pub fn ensure_input_asset_and_amount_ge(input_index: u32, expected_asset_bits: u256, minimal_amount: u64) {\n let (asset_bits, amount): (u256, u64) = get_input_explicit_asset_and_amount(input_index);\n check_assets_eq(asset_bits, expected_asset_bits);\n assert!(ge_64(amount, minimal_amount));\n }\n pub fn ensure_output_asset_and_amount_ge(output_index: u32, expected_asset_bits: u256, minimal_amount: u64) {\n let (asset_bits, amount): (u256, u64) = get_output_explicit_asset_and_amount(output_index);\n check_assets_eq(asset_bits, expected_asset_bits);\n assert!(ge_64(amount, minimal_amount));\n }\n pub fn ensure_io_asset_eq(input_index: u32, output_index: u32, expected_asset_bits: u256) -> (u64, u64) {\n let (input_asset_bits, input_amount): (u256, u64) = get_input_explicit_asset_and_amount(input_index);\n let (output_asset_bits, output_amount): (u256, u64) = get_output_explicit_asset_and_amount(output_index);\n check_assets_eq(input_asset_bits, expected_asset_bits);\n check_assets_eq(input_asset_bits, output_asset_bits);\n (input_amount, output_amount)}\n pub fn ensure_io_asset_and_amount_eq(input_index: u32, output_index: u32, expected_asset_bits: u256, expected_amount: u64) {\n let (input_amount, output_amount): (u64, u64) = ensure_io_asset_eq(input_index, output_index, expected_asset_bits);\n check_asset_amounts_eq(input_amount, expected_amount);\n check_asset_amounts_eq(input_amount, output_amount);\n }\n pub fn ensure_input_asset_and_amount_burn(input_index: u32, output_index: u32, expected_asset_bits: u256, expected_asset_amount: u64) {\n ensure_io_asset_and_amount_eq(input_index, output_index, expected_asset_bits, expected_asset_amount);\n assert_output_is_op_return(output_index);\n }\n pub fn ensure_asset_transition_with_additional_amount(input_index: u32, output_index: u32, expected_asset_bits: u256, additional_amount: u64) {\n let (input_amount, output_amount): (u64, u64) = ensure_io_asset_eq(input_index, output_index, expected_asset_bits);\n let new_asset_amount: u64 = safe_add_64(input_amount, additional_amount);\n check_asset_amounts_eq(output_amount, new_asset_amount);\n }\n}\nmod unit_7 {\n pub fn u64_to_u128(a: u64) -> u128 {\n <(u64, u64)>::into((0, a))}\n pub fn u64_to_u256(a: u64) -> u256 {\n let a_u128: u128 = u64_to_u128(a);\n <(u128, u128)>::into((0, a_u128))}\n pub fn split_u64_into_u8(a: u64) -> (u8, u8, u8, u8, u8, u8, u8, u8) {\n ::into(a)}\n pub fn split_u64_into_u16(a: u64) -> (u16, u16, u16, u16) {\n ::into(a)}\n pub fn split_u64_into_u32(a: u64) -> (u32, u32) {\n ::into(a)}\n pub fn safe_u64_to_u1(a: u64) -> u1 {\n let u1_max: u64 = jet::left_pad_low_1_64(jet::high_1());\n assert!(jet::le_64(a, u1_max));\n jet::rightmost_64_1(a)}\n pub fn safe_u64_to_u8(a: u64) -> u8 {\n let u8_max: u64 = jet::left_pad_low_8_64(jet::high_8());\n assert!(jet::le_64(a, u8_max));\n jet::rightmost_64_8(a)}\n pub fn safe_u64_to_u16(a: u64) -> u16 {\n let u16_max: u64 = jet::left_pad_low_16_64(jet::high_16());\n assert!(jet::le_64(a, u16_max));\n jet::rightmost_64_16(a)}\n pub fn safe_u64_to_u32(a: u64) -> u32 {\n let u32_max: u64 = jet::left_pad_low_32_64(jet::high_32());\n assert!(jet::le_64(a, u32_max));\n jet::rightmost_64_32(a)}\n}\nmod unit_5 {\n use crate::unit_7::u64_to_u256;\n pub fn get_bool_slot_leaf(value: bool) -> u256 {\n let value_num: u256 = u64_to_u256(jet::left_pad_low_1_64(::into(value)));\n let state_ctx1: Ctx8 = jet::tapdata_init();\n let state_ctx2: Ctx8 = jet::sha_256_ctx_8_add_32(state_ctx1, value_num);\n jet::sha_256_ctx_8_finalize(state_ctx2)}\n pub fn get_u64_slot_leaf(value: u64) -> u256 {\n let value: u256 = u64_to_u256(value);\n let state_ctx1: Ctx8 = jet::tapdata_init();\n let state_ctx2: Ctx8 = jet::sha_256_ctx_8_add_32(state_ctx1, value);\n jet::sha_256_ctx_8_finalize(state_ctx2)}\n pub fn get_script_hash_from_tap_node(tap_node: u256) -> u256 {\n let bip0341_key: u256 = 0x50929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0;\n let tweaked_key: u256 = jet::build_taptweak(bip0341_key, tap_node);\n let hash_ctx1: Ctx8 = jet::sha_256_ctx_8_init();\n let hash_ctx2: Ctx8 = jet::sha_256_ctx_8_add_2(hash_ctx1, 0x5120);\n let hash_ctx3: Ctx8 = jet::sha_256_ctx_8_add_32(hash_ctx2, tweaked_key);\n jet::sha_256_ctx_8_finalize(hash_ctx3)}\n}\nmod unit_0 {\n use crate::unit_1::is_output_op_return;\n use crate::unit_2::{safe_add_64, safe_sub_64};\n use crate::unit_3::{get_explicit_asset_and_amount, check_asset_amounts_eq, check_assets_eq, check_flags_eq};\n use crate::unit_4::{ensure_io_asset_eq, ensure_input_script_hash, ensure_output_script_hash, ensure_asset_transition_with_additional_amount};\n use crate::unit_5::{get_bool_slot_leaf, get_u64_slot_leaf, get_script_hash_from_tap_node};\n fn ensure_vault_asset(index: u32, is_input_index: bool) -> u64 {\n let (vault_asset_id, vault_amount): (u256, u64) = get_explicit_asset_and_amount(index, is_input_index);\n check_assets_eq(vault_asset_id, param::VAULT_ASSET_ID);\n vault_amount}\n fn ensure_input_vault_asset(input_index: u32) -> u64 {\n ensure_vault_asset(input_index, true)}\n fn ensure_output_vault_asset(output_index: u32) -> u64 {\n ensure_vault_asset(output_index, false)}\n fn get_script_hash_for_storage(is_active: bool, already_supplied: u64) -> u256 {\n let is_active_slot_leaf: u256 = get_bool_slot_leaf(is_active);\n let already_supplied_slot_leaf: u256 = get_u64_slot_leaf(already_supplied);\n let first_tap_node: u256 = jet::build_tapbranch(jet::tapleaf_hash(), is_active_slot_leaf);\n let tap_node: u256 = jet::build_tapbranch(first_tap_node, already_supplied_slot_leaf);\n get_script_hash_from_tap_node(tap_node)}\n fn auth_with_burn_check(input_asset_index: u32, output_asset_index: u32, expected_asset_id: u256, with_asset_burn: bool) {\n let (input_amount, output_amount): (u64, u64) = ensure_io_asset_eq(input_asset_index, output_asset_index, expected_asset_id);\n check_asset_amounts_eq(input_amount, output_amount);\n match with_asset_burn{\n false => {\n }\n ,\n true => {\n assert!(is_output_op_return(output_asset_index));\n }\n ,\n }}\n fn get_amount_to_goal(already_supplied: u64) -> u64 {\n safe_sub_64(param::SUPPLY_GOAL, already_supplied)}\n fn withdraw_all(input_keeper_index: u32, output_keeper_index: u32) {\n let current_script_hash: u256 = get_script_hash_for_storage(false, param::SUPPLY_GOAL);\n ensure_input_script_hash(jet::current_index(), current_script_hash);\n auth_with_burn_check(input_keeper_index, output_keeper_index, param::KEEPER_AUTH_ASSET_ID, param::WITH_KEEPER_ASSET_BURN);\n let _: u64 = ensure_input_vault_asset(jet::current_index());\n }\n fn withdraw_part(input_keeper_index: u32, output_keeper_index: u32, vault_output_index: u32, already_supplied: u64, amount_to_withdraw: u64) {\n let current_script_hash: u256 = get_script_hash_for_storage(true, already_supplied);\n ensure_input_script_hash(jet::current_index(), current_script_hash);\n auth_with_burn_check(input_keeper_index, output_keeper_index, param::KEEPER_AUTH_ASSET_ID, false);\n ensure_output_script_hash(vault_output_index, current_script_hash);\n let vault_amount: u64 = ensure_input_vault_asset(jet::current_index());\n let output_vault_amount: u64 = ensure_output_vault_asset(vault_output_index);\n assert!(jet::lt_64(amount_to_withdraw, vault_amount));\n let vault_change: u64 = safe_sub_64(vault_amount, amount_to_withdraw);\n check_asset_amounts_eq(output_vault_amount, vault_change);\n }\n fn supply(input_supplier_index: u32, output_supplier_index: u32, vault_output_index: u32, already_supplied: u64, amount_to_supply: u64) {\n let current_script_hash: u256 = get_script_hash_for_storage(true, already_supplied);\n ensure_input_script_hash(jet::current_index(), current_script_hash);\n auth_with_burn_check(input_supplier_index, output_supplier_index, param::SUPPLIER_AUTH_ASSET_ID, false);\n let amount_to_goal: u64 = get_amount_to_goal(already_supplied);\n assert!(jet::some_64(amount_to_supply));\n assert!(jet::lt_64(amount_to_supply, amount_to_goal));\n let new_supplied_amount: u64 = safe_add_64(already_supplied, amount_to_supply);\n let new_script_hash: u256 = get_script_hash_for_storage(true, new_supplied_amount);\n ensure_output_script_hash(vault_output_index, new_script_hash);\n ensure_asset_transition_with_additional_amount(jet::current_index(), vault_output_index, param::VAULT_ASSET_ID, amount_to_supply);\n }\n fn final_supply(input_supplier_index: u32, output_supplier_index: u32, finalized_vault_output_index: u32, already_supplied: u64) {\n let current_script_hash: u256 = get_script_hash_for_storage(true, already_supplied);\n ensure_input_script_hash(jet::current_index(), current_script_hash);\n auth_with_burn_check(input_supplier_index, output_supplier_index, param::SUPPLIER_AUTH_ASSET_ID, param::WITH_SUPPLIER_ASSET_BURN);\n let finalized_vault_script_hash: u256 = get_script_hash_for_storage(false, param::SUPPLY_GOAL);\n ensure_output_script_hash(finalized_vault_output_index, finalized_vault_script_hash);\n ensure_asset_transition_with_additional_amount(jet::current_index(), finalized_vault_output_index, param::VAULT_ASSET_ID, get_amount_to_goal(already_supplied));\n }\n fn main() {\n match witness::PATH{\n Left(withdraw_params: Either<(u32, u32), (u32, u32, u32, u64, u64)>) => {\n match withdraw_params{\n Left(withdraw_all_params: (u32, u32)) => {\n let (input_keeper_index, output_keeper_index): (u32, u32) = withdraw_all_params;\n withdraw_all(input_keeper_index, output_keeper_index);\n }\n ,\n Right(withdraw_part_params: (u32, u32, u32, u64, u64)) => {\n let (input_keeper_index, output_keeper_index, vault_output_index, already_supplied, amount_to_withdraw): (u32, u32, u32, u64, u64) = withdraw_part_params;\n withdraw_part(input_keeper_index, output_keeper_index, vault_output_index, already_supplied, amount_to_withdraw);\n }\n ,\n }}\n ,\n Right(supply_params: Either<(u32, u32, u32, u64, u64), (u32, u32, u32, u64)>) => {\n match supply_params{\n Left(supply_params: (u32, u32, u32, u64, u64)) => {\n let (input_supplier_index, output_supplier_index, vault_output_index, already_supplied, amount_to_supply): (u32, u32, u32, u64, u64) = supply_params;\n supply(input_supplier_index, output_supplier_index, vault_output_index, already_supplied, amount_to_supply);\n }\n ,\n Right(final_supply_params: (u32, u32, u32, u64)) => {\n let (input_supplier_index, output_supplier_index, finalized_vault_output_index, already_supplied): (u32, u32, u32, u64) = final_supply_params;\n final_supply(input_supplier_index, output_supplier_index, finalized_vault_output_index, already_supplied);\n }\n ,\n }}\n ,\n }}\n}\n" }, + "fee_collector.simf": { + "cmr": "fb5f8978c685a963550b290db452b621461a2fc49763c0f5315f4dbf4e6435ea", + "content": "mod unit_0 {\n fn checksig(pubkey: Pubkey, sig: Signature) {\n let sighash: u256 = jet::sig_all_hash();\n jet::bip_0340_verify((pubkey, sighash), sig);\n }\n fn main() {\n checksig(param::WITHDRAWAL_PUBKEY, witness::SIGNATURE);\n }\n}\n" + }, "issuance_factory.simf": { "cmr": "0ad635b2294f143ba5dde75eb331d70d9e212f5df35be94d3eb0d691d89591e8", "content": "mod unit_8 {\n pub fn not(bit: bool) -> bool {\n ::into(jet::complement_1(::into(bit)))}\n pub fn or(a: bool, b: bool) -> bool {\n ::into(jet::or_1(::into(a), ::into(b)))}\n pub fn and(a: bool, b: bool) -> bool {\n ::into(jet::and_1(::into(a), ::into(b)))}\n pub fn xor(a: bool, b: bool) -> bool {\n and(or(a, b), not(and(a, b)))}\n}\nmod unit_5 {\n use crate::unit_8::and;\n pub fn and_128(a: u128, b: u128) -> u128 {\n let (a_high, a_low): (u64, u64) = ::into(a);\n let (b_high, b_low): (u64, u64) = ::into(b);\n <(u64, u64)>::into((jet::and_64(a_high, b_high), jet::and_64(a_low, b_low)))}\n pub fn or_128(a: u128, b: u128) -> u128 {\n let (a_high, a_low): (u64, u64) = ::into(a);\n let (b_high, b_low): (u64, u64) = ::into(b);\n <(u64, u64)>::into((jet::or_64(a_high, b_high), jet::or_64(a_low, b_low)))}\n pub fn eq_128(a: u128, b: u128) -> bool {\n let (a_high, a_low): (u64, u64) = ::into(a);\n let (b_high, b_low): (u64, u64) = ::into(b);\n and(jet::eq_64(a_high, b_high), jet::eq_64(a_low, b_low))}\n pub fn left_shift_128(shift: u8, a: u128) -> u128 {\n match jet::is_zero_8(shift){\n false => {\n let (a_high, a_low): (u64, u64) = ::into(a);\n match jet::lt_8(shift, 64){\n false => {\n let (_, shift): (bool, u8) = jet::subtract_8(shift, 64);\n <(u64, u64)>::into((jet::left_shift_64(shift, a_low), 0))}\n ,\n true => {\n let (_, low_to_high_amount): (bool, u8) = jet::subtract_8(64, shift);\n let shifted_bits: u64 = jet::right_shift_64(low_to_high_amount, a_low);\n let res_high: u64 = jet::or_64(jet::left_shift_64(shift, a_high), shifted_bits);\n <(u64, u64)>::into((res_high, jet::left_shift_64(shift, a_low)))}\n ,\n }}\n ,\n true => a,\n }}\n pub fn right_shift_128(shift: u8, a: u128) -> u128 {\n match jet::is_zero_8(shift){\n false => {\n let (a_high, a_low): (u64, u64) = ::into(a);\n match jet::lt_8(shift, 64){\n false => {\n let (_, shift): (bool, u8) = jet::subtract_8(shift, 64);\n <(u64, u64)>::into((0, jet::right_shift_64(shift, a_high)))}\n ,\n true => {\n let (_, high_to_low_amount): (bool, u8) = jet::subtract_8(64, shift);\n let shifted_bits: u64 = jet::left_shift_64(high_to_low_amount, a_high);\n let res_low: u64 = jet::or_64(jet::right_shift_64(shift, a_low), shifted_bits);\n <(u64, u64)>::into((jet::right_shift_64(shift, a_high), res_low))}\n ,\n }}\n ,\n true => a,\n }}\n}\nmod unit_1 {\n use crate::unit_5::eq_128;\n pub fn assert_eq_1(a: u1, b: u1) {\n assert!(jet::eq_1(a, b))}\n pub fn assert_eq_8(a: u8, b: u8) {\n assert!(jet::eq_8(a, b));\n }\n pub fn assert_eq_16(a: u16, b: u16) {\n assert!(jet::eq_16(a, b));\n }\n pub fn assert_eq_32(a: u32, b: u32) {\n assert!(jet::eq_32(a, b));\n }\n pub fn assert_eq_64(a: u64, b: u64) {\n assert!(jet::eq_64(a, b));\n }\n pub fn assert_eq_128(a: u128, b: u128) {\n assert!(eq_128(a, b));\n }\n pub fn assert_eq_256(a: u256, b: u256) {\n assert!(jet::eq_256(a, b));\n }\n pub fn assert_eq_bool(a: bool, b: bool) {\n assert_eq_1(::into(a), ::into(b));\n }\n pub fn assert_none_1(val: Option) {\n assert!(is_none::(val));\n }\n pub fn assert_none_8(val: Option) {\n assert!(is_none::(val));\n }\n pub fn assert_none_16(val: Option) {\n assert!(is_none::(val));\n }\n pub fn assert_none_32(val: Option) {\n assert!(is_none::(val));\n }\n pub fn assert_none_64(val: Option) {\n assert!(is_none::(val));\n }\n pub fn assert_none_128(val: Option) {\n assert!(is_none::(val));\n }\n pub fn assert_none_256(val: Option) {\n assert!(is_none::(val));\n }\n}\nmod unit_2 {\n pub fn checked_add_32(a: u32, b: u32) -> Option {\n let (carry, sum): (bool, u32) = jet::add_32(a, b);\n match carry{\n false => Some(sum),\n true => None,\n }}\n pub fn safe_add_32(a: u32, b: u32) -> u32 {\n unwrap(checked_add_32(a, b))}\n pub fn checked_sub_32(a: u32, b: u32) -> Option {\n let (borrow, diff): (bool, u32) = jet::subtract_32(a, b);\n match borrow{\n false => Some(diff),\n true => None,\n }}\n pub fn safe_sub_32(a: u32, b: u32) -> u32 {\n unwrap(checked_sub_32(a, b))}\n pub fn checked_mul_32(a: u32, b: u32) -> Option {\n let result: u64 = jet::multiply_32(a, b);\n let (high, low): (u32, u32) = ::into(result);\n match jet::is_zero_32(high){\n false => None,\n true => Some(low),\n }}\n pub fn safe_mul_32(a: u32, b: u32) -> u32 {\n unwrap(checked_mul_32(a, b))}\n pub fn checked_div_32(a: u32, b: u32) -> Option {\n match jet::is_zero_32(b){\n false => Some(jet::divide_32(a, b)),\n true => None,\n }}\n pub fn safe_div_32(a: u32, b: u32) -> u32 {\n unwrap(checked_div_32(a, b))}\n pub fn gt_32(a: u32, b: u32) -> bool {\n jet::lt_32(b, a)}\n pub fn ge_32(a: u32, b: u32) -> bool {\n jet::le_32(b, a)}\n}\nmod unit_3 {\n use crate::unit_1::{assert_eq_1, assert_eq_64, assert_eq_256};\n pub fn get_explicit_asset_and_amount(index: u32, is_input_index: bool) -> (u256, u64) {\n let pair: (Asset1, Amount1) = match is_input_index{\n false => {\n unwrap(jet::output_amount(index))}\n ,\n true => {\n unwrap(jet::input_amount(index))}\n ,\n };\n let (asset, amount): (Asset1, Amount1) = pair;\n let asset_bits: u256 = unwrap_right::<(u1, u256)>(asset);\n let amount: u64 = unwrap_right::<(u1, u256)>(amount);\n (asset_bits, amount)}\n pub fn get_input_explicit_asset_and_amount(input_index: u32) -> (u256, u64) {\n get_explicit_asset_and_amount(input_index, true)}\n pub fn get_output_explicit_asset_and_amount(output_index: u32) -> (u256, u64) {\n get_explicit_asset_and_amount(output_index, false)}\n pub fn get_script_hash(index: u32, is_input_index: bool) -> u256 {\n match is_input_index{\n false => {\n unwrap(jet::output_script_hash(index))}\n ,\n true => {\n unwrap(jet::input_script_hash(index))}\n ,\n }}\n pub fn get_input_script_hash(input_index: u32) -> u256 {\n get_script_hash(input_index, true)}\n pub fn get_output_script_hash(output_index: u32) -> u256 {\n get_script_hash(output_index, false)}\n pub fn check_asset_amounts_eq(asset_amount_1: u64, asset_amount_2: u64) {\n assert_eq_64(asset_amount_1, asset_amount_2);\n }\n pub fn check_assets_eq(asset_bits_1: u256, asset_bits_2: u256) {\n assert_eq_256(asset_bits_1, asset_bits_2);\n }\n pub fn check_script_hashes_eq(script_1: u256, script_2: u256) {\n assert_eq_256(script_1, script_2);\n }\n pub fn check_flags_eq(flag_1: bool, flag_2: bool) {\n assert_eq_1(::into(flag_1), ::into(flag_2));\n }\n}\nmod unit_6 {\n pub fn is_output_op_return(output_index: u32) -> bool {\n match jet::output_null_datum(output_index, 0){\n None => false,\n Some(entry: Option>>) => true,\n }}\n pub fn assert_output_is_op_return(output_index: u32) {\n assert!(is_output_op_return(output_index));\n }\n}\nmod unit_7 {\n pub fn checked_add_64(a: u64, b: u64) -> Option {\n let (carry, sum): (bool, u64) = jet::add_64(a, b);\n match carry{\n false => Some(sum),\n true => None,\n }}\n pub fn safe_add_64(a: u64, b: u64) -> u64 {\n unwrap(checked_add_64(a, b))}\n pub fn checked_sub_64(a: u64, b: u64) -> Option {\n let (borrow, diff): (bool, u64) = jet::subtract_64(a, b);\n match borrow{\n false => Some(diff),\n true => None,\n }}\n pub fn safe_sub_64(a: u64, b: u64) -> u64 {\n unwrap(checked_sub_64(a, b))}\n pub fn checked_mul_64(a: u64, b: u64) -> Option {\n let result: u128 = jet::multiply_64(a, b);\n let (high, low): (u64, u64) = ::into(result);\n match jet::is_zero_64(high){\n false => None,\n true => Some(low),\n }}\n pub fn safe_mul_64(a: u64, b: u64) -> u64 {\n unwrap(checked_mul_64(a, b))}\n pub fn checked_div_64(a: u64, b: u64) -> Option {\n match jet::is_zero_64(b){\n false => Some(jet::divide_64(a, b)),\n true => None,\n }}\n pub fn safe_div_64(a: u64, b: u64) -> u64 {\n unwrap(checked_div_64(a, b))}\n pub fn gt_64(a: u64, b: u64) -> bool {\n jet::lt_64(b, a)}\n pub fn ge_64(a: u64, b: u64) -> bool {\n jet::le_64(b, a)}\n}\nmod unit_4 {\n use crate::unit_6::assert_output_is_op_return;\n use crate::unit_7::{ge_64, safe_add_64};\n use crate::unit_3::{get_input_explicit_asset_and_amount, get_output_explicit_asset_and_amount, get_input_script_hash, get_output_script_hash, check_asset_amounts_eq, check_assets_eq, check_script_hashes_eq};\n pub fn ensure_non_zero_amount(amount: u64) {\n assert!(jet::some_64(amount));\n }\n pub fn ensure_input_script_hash(input_index: u32, expected_script_hash: u256) {\n check_script_hashes_eq(get_input_script_hash(input_index), expected_script_hash);\n }\n pub fn ensure_output_script_hash(output_index: u32, expected_script_hash: u256) {\n check_script_hashes_eq(get_output_script_hash(output_index), expected_script_hash);\n }\n pub fn ensure_io_script_hashes_eq(input_index: u32, output_index: u32) {\n check_script_hashes_eq(get_input_script_hash(input_index), get_output_script_hash(output_index));\n }\n pub fn ensure_script_hash_transition(input_index: u32, output_index: u32, expected_input_script_hash: u256, expected_output_script_hash: u256) {\n ensure_input_script_hash(input_index, expected_input_script_hash);\n ensure_output_script_hash(output_index, expected_output_script_hash);\n }\n pub fn ensure_input_asset_and_amount(input_index: u32, expected_asset_bits: u256, expected_amount: u64) {\n let (asset_bits, amount): (u256, u64) = get_input_explicit_asset_and_amount(input_index);\n check_assets_eq(asset_bits, expected_asset_bits);\n check_asset_amounts_eq(amount, expected_amount);\n }\n pub fn ensure_output_asset_and_amount(output_index: u32, expected_asset_bits: u256, expected_amount: u64) {\n let (asset_bits, amount): (u256, u64) = get_output_explicit_asset_and_amount(output_index);\n check_assets_eq(asset_bits, expected_asset_bits);\n check_asset_amounts_eq(amount, expected_amount);\n }\n pub fn ensure_input_asset_and_amount_ge(input_index: u32, expected_asset_bits: u256, minimal_amount: u64) {\n let (asset_bits, amount): (u256, u64) = get_input_explicit_asset_and_amount(input_index);\n check_assets_eq(asset_bits, expected_asset_bits);\n assert!(ge_64(amount, minimal_amount));\n }\n pub fn ensure_output_asset_and_amount_ge(output_index: u32, expected_asset_bits: u256, minimal_amount: u64) {\n let (asset_bits, amount): (u256, u64) = get_output_explicit_asset_and_amount(output_index);\n check_assets_eq(asset_bits, expected_asset_bits);\n assert!(ge_64(amount, minimal_amount));\n }\n pub fn ensure_io_asset_eq(input_index: u32, output_index: u32, expected_asset_bits: u256) -> (u64, u64) {\n let (input_asset_bits, input_amount): (u256, u64) = get_input_explicit_asset_and_amount(input_index);\n let (output_asset_bits, output_amount): (u256, u64) = get_output_explicit_asset_and_amount(output_index);\n check_assets_eq(input_asset_bits, expected_asset_bits);\n check_assets_eq(input_asset_bits, output_asset_bits);\n (input_amount, output_amount)}\n pub fn ensure_io_asset_and_amount_eq(input_index: u32, output_index: u32, expected_asset_bits: u256, expected_amount: u64) {\n let (input_amount, output_amount): (u64, u64) = ensure_io_asset_eq(input_index, output_index, expected_asset_bits);\n check_asset_amounts_eq(input_amount, expected_amount);\n check_asset_amounts_eq(input_amount, output_amount);\n }\n pub fn ensure_input_asset_and_amount_burn(input_index: u32, output_index: u32, expected_asset_bits: u256, expected_asset_amount: u64) {\n ensure_io_asset_and_amount_eq(input_index, output_index, expected_asset_bits, expected_asset_amount);\n assert_output_is_op_return(output_index);\n }\n pub fn ensure_asset_transition_with_additional_amount(input_index: u32, output_index: u32, expected_asset_bits: u256, additional_amount: u64) {\n let (input_amount, output_amount): (u64, u64) = ensure_io_asset_eq(input_index, output_index, expected_asset_bits);\n let new_asset_amount: u64 = safe_add_64(input_amount, additional_amount);\n check_asset_amounts_eq(output_amount, new_asset_amount);\n }\n}\nmod unit_0 {\n use crate::unit_1::assert_eq_32;\n use crate::unit_2::safe_add_32;\n use crate::unit_3::check_asset_amounts_eq;\n use crate::unit_4::{ensure_non_zero_amount, ensure_io_script_hashes_eq, ensure_output_asset_and_amount, ensure_io_asset_and_amount_eq, ensure_input_asset_and_amount_burn};\n fn get_current_explicit_asset() -> u256 {\n unwrap_right::<(u1, u256)>(jet::current_asset())}\n fn get_reissuance_flag(index: u8) -> bool {\n let shifted: u64 = jet::right_shift_64(index, param::REISSUANCE_FLAGS);\n let bit_val: u1 = jet::rightmost_64_1(shifted);\n ::into(bit_val)}\n fn verify_issuance(input_index: u32, output_index: u32, reissuance_flag: bool) {\n let contract_hash: u256 = unwrap(unwrap(jet::new_issuance_contract(input_index)));\n let outpoint: Outpoint = unwrap(jet::input_prev_outpoint(input_index));\n let issuance_entropy: u256 = jet::calculate_issuance_entropy(outpoint, contract_hash);\n let explicit_reissuance_tokens_amount: u64 = unwrap_right::<(u1, u256)>(unwrap(unwrap(jet::issuance_token_amount(input_index))));\n match reissuance_flag{\n false => {\n check_asset_amounts_eq(explicit_reissuance_tokens_amount, 0);\n }\n ,\n true => {\n ensure_non_zero_amount(explicit_reissuance_tokens_amount);\n }\n ,\n };\n let issuance_amount: Amount1 = unwrap(unwrap(jet::issuance_asset_amount(input_index)));\n let issuance_asset: ExplicitAsset = unwrap(unwrap(jet::issuance_asset(input_index)));\n let issuance_amount: u64 = unwrap_right::<(u1, u256)>(issuance_amount);\n ensure_output_asset_and_amount(output_index, issuance_asset, issuance_amount);\n }\n fn verify_issuance_step(acc: (), start_output_index: u32, i: u8) -> Either<(), ()> {\n match jet::le_8(param::ISSUING_UTXOS_COUNT, i){\n false => {\n let step_index: u32 = <(u16, u16)>::into((0, <(u8, u8)>::into((0, i))));\n let input_index: u32 = safe_add_32(jet::current_index(), step_index);\n let output_index: u32 = safe_add_32(start_output_index, step_index);\n verify_issuance(input_index, output_index, get_reissuance_flag(i));\n Right(())}\n ,\n true => {\n Left(())}\n ,\n }}\n fn get_asset_issuance_issuance_factory_indexes(start_input_index: u32, start_output_index: u32) -> (u32, u32) {\n (safe_add_32(start_input_index, 1), safe_add_32(start_output_index, 1))}\n fn get_asset_issuance_start_issued_output_index(start_output_index: u32) -> u32 {\n safe_add_32(start_output_index, 2)}\n fn issue_new_assets(output_index: u32) {\n let (auth_nft_input_index, auth_nft_output_index): (u32, u32) = (0, output_index);\n let (issuance_factory_input_index, issuance_factory_output_index): (u32, u32) = get_asset_issuance_issuance_factory_indexes(auth_nft_input_index, auth_nft_output_index);\n assert_eq_32(issuance_factory_input_index, jet::current_index());\n let current_asset_bits: u256 = get_current_explicit_asset();\n ensure_io_asset_and_amount_eq(auth_nft_input_index, auth_nft_output_index, current_asset_bits, 1);\n ensure_io_asset_and_amount_eq(issuance_factory_input_index, issuance_factory_output_index, current_asset_bits, 1);\n ensure_io_script_hashes_eq(issuance_factory_input_index, issuance_factory_output_index);\n let issued_outputs_start_index: u32 = get_asset_issuance_start_issued_output_index(auth_nft_output_index);\n unwrap_left::<()>(for_while::((), issued_outputs_start_index));\n }\n fn get_removing_auth_nft_indexes(start_input_index: u32, start_output_index: u32) -> (u32, u32) {\n (safe_add_32(start_input_index, 1), safe_add_32(start_output_index, 1))}\n fn remove_factory(output_index: u32) {\n let (issuance_factory_input_index, issuance_factory_output_index): (u32, u32) = (0, output_index);\n let (auth_nft_input_index, auth_nft_output_index): (u32, u32) = get_removing_auth_nft_indexes(issuance_factory_input_index, issuance_factory_output_index);\n assert_eq_32(issuance_factory_input_index, jet::current_index());\n let current_asset_bits: u256 = get_current_explicit_asset();\n ensure_input_asset_and_amount_burn(issuance_factory_input_index, issuance_factory_output_index, current_asset_bits, 1);\n ensure_input_asset_and_amount_burn(auth_nft_input_index, auth_nft_output_index, current_asset_bits, 1);\n }\n fn main() {\n match witness::PATH{\n Left(output_index: u32) => {\n issue_new_assets(output_index);\n }\n ,\n Right(output_index: u32) => {\n remove_factory(output_index);\n }\n ,\n }}\n}\n" diff --git a/crates/contracts/src/artifacts/mod.rs b/crates/contracts/src/artifacts/mod.rs index d782b8a..4400c1a 100644 --- a/crates/contracts/src/artifacts/mod.rs +++ b/crates/contracts/src/artifacts/mod.rs @@ -2,6 +2,8 @@ #![allow(clippy::all)] #[rustfmt::skip] +pub mod fee_collector; +#[rustfmt::skip] pub mod asset_auth; #[rustfmt::skip] pub mod issuance_factory; diff --git a/crates/contracts/src/programs/fee_collector/core.rs b/crates/contracts/src/programs/fee_collector/core.rs new file mode 100644 index 0000000..c4044b1 --- /dev/null +++ b/crates/contracts/src/programs/fee_collector/core.rs @@ -0,0 +1,56 @@ +use simplex::{ + program::Program, + provider::SimplicityNetwork, + simplicityhl::elements::AssetId, + transaction::{FinalTransaction, UTXO}, +}; + +use crate::artifacts::fee_collector::FeeCollectorProgram; + +use crate::programs::fee_collector::{FeeCollectorParameters, FeeCollectorWitnessParams}; +use crate::programs::program::SimplexProgram; + +pub struct FeeCollector { + program: FeeCollectorProgram, + parameters: FeeCollectorParameters, +} + +impl FeeCollector { + pub fn new(parameters: FeeCollectorParameters) -> Self { + Self { + program: FeeCollectorProgram::new(¶meters.build_arguments()), + parameters, + } + } + + pub fn get_parameters(&self) -> &FeeCollectorParameters { + &self.parameters + } + + pub fn attach_deposit(&self, ft: &mut FinalTransaction, asset_id: AssetId, amount: u64) { + self.add_program_output(ft, asset_id, amount); + } + + pub fn attach_withdrawal( + &self, + ft: &mut FinalTransaction, + program_utxo: UTXO, + witness_params: FeeCollectorWitnessParams, + ) { + self.add_program_input(ft, program_utxo, witness_params.build_witness()); + } +} + +impl SimplexProgram for FeeCollector { + fn get_program_source_code() -> &'static str { + FeeCollectorProgram::SOURCE + } + + fn get_program(&self) -> &Program { + self.program.as_ref() + } + + fn get_network(&self) -> &SimplicityNetwork { + &self.parameters.network + } +} diff --git a/crates/contracts/src/programs/fee_collector/mod.rs b/crates/contracts/src/programs/fee_collector/mod.rs new file mode 100644 index 0000000..329766a --- /dev/null +++ b/crates/contracts/src/programs/fee_collector/mod.rs @@ -0,0 +1,7 @@ +mod core; +mod params; +mod witness; + +pub use core::FeeCollector; +pub use params::FeeCollectorParameters; +pub use witness::FeeCollectorWitnessParams; diff --git a/crates/contracts/src/programs/fee_collector/params.rs b/crates/contracts/src/programs/fee_collector/params.rs new file mode 100644 index 0000000..e823537 --- /dev/null +++ b/crates/contracts/src/programs/fee_collector/params.rs @@ -0,0 +1,17 @@ +use simplex::{provider::SimplicityNetwork, simplicityhl::elements::secp256k1_zkp::XOnlyPublicKey}; + +use crate::artifacts::fee_collector::derived_fee_collector::FeeCollectorArguments; + +#[derive(Debug, Clone, Copy)] +pub struct FeeCollectorParameters { + pub withdrawal_pubkey: XOnlyPublicKey, + pub network: SimplicityNetwork, +} + +impl FeeCollectorParameters { + pub fn build_arguments(&self) -> FeeCollectorArguments { + FeeCollectorArguments { + withdrawal_pubkey: self.withdrawal_pubkey.serialize(), + } + } +} diff --git a/crates/contracts/src/programs/fee_collector/witness.rs b/crates/contracts/src/programs/fee_collector/witness.rs new file mode 100644 index 0000000..5e1f3e6 --- /dev/null +++ b/crates/contracts/src/programs/fee_collector/witness.rs @@ -0,0 +1,18 @@ +use crate::artifacts::fee_collector::derived_fee_collector::FeeCollectorWitness; + +#[derive(Debug, Clone, Copy)] +pub struct FeeCollectorWitnessParams { + pub signature: [u8; 64], +} + +impl FeeCollectorWitnessParams { + pub fn new(signature: [u8; 64]) -> Self { + Self { signature } + } + + pub fn build_witness(&self) -> Box { + Box::new(FeeCollectorWitness { + signature: self.signature, + }) + } +} diff --git a/crates/contracts/src/programs/lending/scanners.rs b/crates/contracts/src/programs/lending/scanners.rs index f70b4ff..353300b 100644 --- a/crates/contracts/src/programs/lending/scanners.rs +++ b/crates/contracts/src/programs/lending/scanners.rs @@ -1052,10 +1052,8 @@ mod tests { let protocol_after_supplied = 2_u64; let lender_after_supplied = lender_before + (amount_to_repay - 1); - let lender_after = AssetAuthVault::new_active( - params.get_lender_vault_parameters(), - lender_after_supplied, - ); + let lender_after = + AssetAuthVault::new_active(params.get_lender_vault_parameters(), lender_after_supplied); let protocol_after = AssetAuthVault::new_active( params.get_protocol_fee_vault_parameters(), protocol_after_supplied, diff --git a/crates/contracts/src/programs/mod.rs b/crates/contracts/src/programs/mod.rs index 922814d..d1734c7 100644 --- a/crates/contracts/src/programs/mod.rs +++ b/crates/contracts/src/programs/mod.rs @@ -1,5 +1,6 @@ pub mod asset_auth; pub mod asset_auth_vault; +pub mod fee_collector; pub mod issuance_factory; pub mod lending; pub mod program;