From bdda43bef8023c31b60ae7643ff21ff5e6e14348 Mon Sep 17 00:00:00 2001 From: Emmyt24 Date: Wed, 21 Jan 2026 23:33:40 +0100 Subject: [PATCH 1/8] feat: Implement remittance split logic and exhaustive tests validate and store split configuration with defaults and update support calculate split amounts with rounding guarantees and overflow-safe math add comprehensive edge-case tests and clearer function docs --- remittance_split/src/lib.rs | 340 +++++++++++++++++- .../test/test_calculate_split_basic.1.json | 238 ++++++++++++ ...te_split_default_when_uninitialized.1.json | 153 ++++++++ .../test_calculate_split_large_amount.1.json | 153 ++++++++ ...te_split_large_non_divisible_amount.1.json | 153 ++++++++ ...est_calculate_split_negative_amount.1.json | 153 ++++++++ ...culate_split_rounding_total_matches.1.json | 238 ++++++++++++ ...e_split_rounding_varied_percentages.1.json | 238 ++++++++++++ ...lculate_split_small_amount_rounding.1.json | 153 ++++++++ ...alculate_split_with_zero_categories.1.json | 238 ++++++++++++ .../test_calculate_split_zero_amount.1.json | 153 ++++++++ .../test_get_split_configured_values.1.json | 221 ++++++++++++ .../test/test_get_split_default.1.json | 136 +++++++ ...ze_split_invalid_does_not_overwrite.1.json | 284 +++++++++++++++ ...t_initialize_split_invalid_over_100.1.json | 199 ++++++++++ .../test_initialize_split_invalid_sum.1.json | 199 ++++++++++ ...st_initialize_split_update_existing.1.json | 284 +++++++++++++++ .../test/test_initialize_split_valid.1.json | 221 ++++++++++++ ...tialize_split_with_zero_percentages.1.json | 221 ++++++++++++ 19 files changed, 3957 insertions(+), 18 deletions(-) create mode 100644 remittance_split/test_snapshots/test/test_calculate_split_basic.1.json create mode 100644 remittance_split/test_snapshots/test/test_calculate_split_default_when_uninitialized.1.json create mode 100644 remittance_split/test_snapshots/test/test_calculate_split_large_amount.1.json create mode 100644 remittance_split/test_snapshots/test/test_calculate_split_large_non_divisible_amount.1.json create mode 100644 remittance_split/test_snapshots/test/test_calculate_split_negative_amount.1.json create mode 100644 remittance_split/test_snapshots/test/test_calculate_split_rounding_total_matches.1.json create mode 100644 remittance_split/test_snapshots/test/test_calculate_split_rounding_varied_percentages.1.json create mode 100644 remittance_split/test_snapshots/test/test_calculate_split_small_amount_rounding.1.json create mode 100644 remittance_split/test_snapshots/test/test_calculate_split_with_zero_categories.1.json create mode 100644 remittance_split/test_snapshots/test/test_calculate_split_zero_amount.1.json create mode 100644 remittance_split/test_snapshots/test/test_get_split_configured_values.1.json create mode 100644 remittance_split/test_snapshots/test/test_get_split_default.1.json create mode 100644 remittance_split/test_snapshots/test/test_initialize_split_invalid_does_not_overwrite.1.json create mode 100644 remittance_split/test_snapshots/test/test_initialize_split_invalid_over_100.1.json create mode 100644 remittance_split/test_snapshots/test/test_initialize_split_invalid_sum.1.json create mode 100644 remittance_split/test_snapshots/test/test_initialize_split_update_existing.1.json create mode 100644 remittance_split/test_snapshots/test/test_initialize_split_valid.1.json create mode 100644 remittance_split/test_snapshots/test/test_initialize_split_with_zero_percentages.1.json diff --git a/remittance_split/src/lib.rs b/remittance_split/src/lib.rs index 5741750..2c4b2bf 100644 --- a/remittance_split/src/lib.rs +++ b/remittance_split/src/lib.rs @@ -6,7 +6,16 @@ pub struct RemittanceSplit; #[contractimpl] impl RemittanceSplit { - /// Initialize a remittance split configuration + /// Set or update the split percentages used to allocate remittances. + /// + /// # Arguments + /// * `spending_percent` - Percent allocated to spending + /// * `savings_percent` - Percent allocated to savings + /// * `bills_percent` - Percent allocated to bills + /// * `insurance_percent` - Percent allocated to insurance + /// + /// # Returns + /// `true` when the inputs are valid and stored, `false` otherwise. pub fn initialize_split( env: Env, spending_percent: u32, @@ -14,12 +23,15 @@ impl RemittanceSplit { bills_percent: u32, insurance_percent: u32, ) -> bool { - let total = spending_percent + savings_percent + bills_percent + insurance_percent; - - if total != 100 { + if !Self::is_valid_split( + spending_percent, + savings_percent, + bills_percent, + insurance_percent, + ) { return false; } - + env.storage().instance().set( &symbol_short!("SPLIT"), &vec![ @@ -30,28 +42,320 @@ impl RemittanceSplit { insurance_percent, ], ); - + true } - - /// Get the current split configuration - pub fn get_split(env: &Env) -> Vec { + + /// Read the current split configuration. + /// + /// # Returns + /// A Vec with [spending, savings, bills, insurance] percentages. + /// If no configuration is stored, returns the default (50, 30, 15, 5). + pub fn get_split(env: Env) -> Vec { env.storage() .instance() .get(&symbol_short!("SPLIT")) - .unwrap_or_else(|| vec![env, 50, 30, 15, 5]) + .unwrap_or_else(|| vec![&env, 50, 30, 15, 5]) } - - /// Calculate split amounts from a total remittance amount + + /// Calculate split amounts from a total remittance amount. + /// + /// # Arguments + /// * `total_amount` - Total remittance amount to split + /// + /// # Returns + /// A Vec with [spending, savings, bills, insurance] amounts. + /// Returns zeros when `total_amount` is zero or negative. pub fn calculate_split(env: Env, total_amount: i128) -> Vec { - let split = Self::get_split(&env); - - let spending = (total_amount * split.get(0).unwrap() as i128) / 100; - let savings = (total_amount * split.get(1).unwrap() as i128) / 100; - let bills = (total_amount * split.get(2).unwrap() as i128) / 100; + if total_amount <= 0 { + // Skip storage read for zero/invalid inputs to save gas. + return vec![&env, 0, 0, 0, 0]; + } + + let split = Self::get_split(env.clone()); + let spending_percent = split.get(0).unwrap(); + let savings_percent = split.get(1).unwrap(); + let bills_percent = split.get(2).unwrap(); + + let spending = Self::split_amount(total_amount, spending_percent); + let savings = Self::split_amount(total_amount, savings_percent); + let bills = Self::split_amount(total_amount, bills_percent); let insurance = total_amount - spending - savings - bills; - + vec![&env, spending, savings, bills, insurance] } + + /// Validate a percentage split for bounds and sum. + fn is_valid_split( + spending_percent: u32, + savings_percent: u32, + bills_percent: u32, + insurance_percent: u32, + ) -> bool { + if spending_percent > 100 + || savings_percent > 100 + || bills_percent > 100 + || insurance_percent > 100 + { + return false; + } + + let total = spending_percent as u64 + + savings_percent as u64 + + bills_percent as u64 + + insurance_percent as u64; + total == 100 + } + + /// Compute a percentage share without risking multiplication overflow. + fn split_amount(total_amount: i128, percent: u32) -> i128 { + let percent = percent as i128; + let quotient = total_amount / 100; + let remainder = total_amount % 100; + + quotient * percent + (remainder * percent) / 100 + } } +#[cfg(test)] +mod test { + use super::*; + use soroban_sdk::{contractclient, vec, Env, Vec}; + + #[contractclient(name = "RemittanceSplitClient")] + pub trait RemittanceSplitTrait { + fn initialize_split( + env: Env, + spending_percent: u32, + savings_percent: u32, + bills_percent: u32, + insurance_percent: u32, + ) -> bool; + fn get_split(env: Env) -> Vec; + fn calculate_split(env: Env, total_amount: i128) -> Vec; + } + + fn setup() -> (Env, soroban_sdk::Address) { + let env = Env::default(); + let contract_id = env.register_contract(None, RemittanceSplit); + (env, contract_id) + } + + #[test] + fn test_initialize_split_valid() { + let (env, contract_id) = setup(); + let client = RemittanceSplitClient::new(&env, &contract_id); + + let ok = client.initialize_split(&40, &30, &20, &10); + assert!(ok); + + let split = client.get_split(); + assert_eq!(split, vec![&env, 40, 30, 20, 10]); + } + + #[test] + fn test_initialize_split_invalid_sum() { + let (env, contract_id) = setup(); + let client = RemittanceSplitClient::new(&env, &contract_id); + + let ok = client.initialize_split(&50, &30, &10, &5); + assert!(!ok); + + let split = client.get_split(); + assert_eq!(split, vec![&env, 50, 30, 15, 5]); + } + + #[test] + fn test_initialize_split_invalid_over_100() { + let (env, contract_id) = setup(); + let client = RemittanceSplitClient::new(&env, &contract_id); + + let ok = client.initialize_split(&101, &0, &0, &0); + assert!(!ok); + + let split = client.get_split(); + assert_eq!(split, vec![&env, 50, 30, 15, 5]); + } + + #[test] + fn test_initialize_split_update_existing() { + let (env, contract_id) = setup(); + let client = RemittanceSplitClient::new(&env, &contract_id); + + assert!(client.initialize_split(&60, &20, &15, &5)); + assert!(client.initialize_split(&25, &25, &25, &25)); + + let split = client.get_split(); + assert_eq!(split, vec![&env, 25, 25, 25, 25]); + } + + #[test] + fn test_initialize_split_invalid_does_not_overwrite() { + let (env, contract_id) = setup(); + let client = RemittanceSplitClient::new(&env, &contract_id); + + assert!(client.initialize_split(&60, &20, &15, &5)); + assert!(!client.initialize_split(&60, &20, &15, &10)); + + let split = client.get_split(); + assert_eq!(split, vec![&env, 60, 20, 15, 5]); + } + + #[test] + fn test_initialize_split_with_zero_percentages() { + let (env, contract_id) = setup(); + let client = RemittanceSplitClient::new(&env, &contract_id); + + let ok = client.initialize_split(&100, &0, &0, &0); + assert!(ok); + + let split = client.get_split(); + assert_eq!(split, vec![&env, 100, 0, 0, 0]); + } + + #[test] + fn test_get_split_default() { + let (env, contract_id) = setup(); + let client = RemittanceSplitClient::new(&env, &contract_id); + + let split = client.get_split(); + assert_eq!(split, vec![&env, 50, 30, 15, 5]); + } + + #[test] + fn test_get_split_configured_values() { + let (env, contract_id) = setup(); + let client = RemittanceSplitClient::new(&env, &contract_id); + + assert!(client.initialize_split(&70, &20, &5, &5)); + let split = client.get_split(); + assert_eq!(split, vec![&env, 70, 20, 5, 5]); + } + + #[test] + fn test_calculate_split_basic() { + let (env, contract_id) = setup(); + let client = RemittanceSplitClient::new(&env, &contract_id); + + assert!(client.initialize_split(&50, &30, &15, &5)); + let amounts = client.calculate_split(&1000); + assert_eq!(amounts, vec![&env, 500, 300, 150, 50]); + } + + #[test] + fn test_calculate_split_rounding_total_matches() { + let (env, contract_id) = setup(); + let client = RemittanceSplitClient::new(&env, &contract_id); + + assert!(client.initialize_split(&50, &30, &15, &5)); + let total_amount: i128 = 101; + let amounts = client.calculate_split(&total_amount); + let total = amounts.get(0).unwrap() + + amounts.get(1).unwrap() + + amounts.get(2).unwrap() + + amounts.get(3).unwrap(); + + assert_eq!(total, total_amount); + assert_eq!(amounts, vec![&env, 50, 30, 15, 6]); + } + + #[test] + fn test_calculate_split_rounding_varied_percentages() { + let (env, contract_id) = setup(); + let client = RemittanceSplitClient::new(&env, &contract_id); + + assert!(client.initialize_split(&33, &33, &33, &1)); + let total_amount: i128 = 101; + let amounts = client.calculate_split(&total_amount); + let total = amounts.get(0).unwrap() + + amounts.get(1).unwrap() + + amounts.get(2).unwrap() + + amounts.get(3).unwrap(); + + assert_eq!(total, total_amount); + assert_eq!(amounts, vec![&env, 33, 33, 33, 2]); + } + + #[test] + fn test_calculate_split_small_amount_rounding() { + let (env, contract_id) = setup(); + let client = RemittanceSplitClient::new(&env, &contract_id); + + let amounts = client.calculate_split(&1); + assert_eq!(amounts, vec![&env, 0, 0, 0, 1]); + } + + #[test] + fn test_calculate_split_zero_amount() { + let (env, contract_id) = setup(); + let client = RemittanceSplitClient::new(&env, &contract_id); + + let amounts = client.calculate_split(&0); + assert_eq!(amounts, vec![&env, 0, 0, 0, 0]); + } + + #[test] + fn test_calculate_split_negative_amount() { + let (env, contract_id) = setup(); + let client = RemittanceSplitClient::new(&env, &contract_id); + + let amounts = client.calculate_split(&-10); + assert_eq!(amounts, vec![&env, 0, 0, 0, 0]); + } + + #[test] + fn test_calculate_split_default_when_uninitialized() { + let (env, contract_id) = setup(); + let client = RemittanceSplitClient::new(&env, &contract_id); + + let amounts = client.calculate_split(&200); + assert_eq!(amounts, vec![&env, 100, 60, 30, 10]); + } + + #[test] + fn test_calculate_split_with_zero_categories() { + let (env, contract_id) = setup(); + let client = RemittanceSplitClient::new(&env, &contract_id); + + assert!(client.initialize_split(&100, &0, &0, &0)); + let amounts = client.calculate_split(&123); + assert_eq!(amounts, vec![&env, 123, 0, 0, 0]); + } + + #[test] + fn test_calculate_split_large_non_divisible_amount() { + let (env, contract_id) = setup(); + let client = RemittanceSplitClient::new(&env, &contract_id); + + let total_amount: i128 = 1_000_000_000_000_000_001; + let amounts = client.calculate_split(&total_amount); + let total = amounts.get(0).unwrap() + + amounts.get(1).unwrap() + + amounts.get(2).unwrap() + + amounts.get(3).unwrap(); + + assert_eq!(total, total_amount); + assert_eq!( + amounts, + vec![&env, 500_000_000_000_000_000, 300_000_000_000_000_000, 150_000_000_000_000_000, 50_000_000_000_000_001] + ); + } + + #[test] + fn test_calculate_split_large_amount() { + let (env, contract_id) = setup(); + let client = RemittanceSplitClient::new(&env, &contract_id); + + let total_amount: i128 = 1_000_000_000_000_000_000; + let amounts = client.calculate_split(&total_amount); + let expected = vec![ + &env, + 500_000_000_000_000_000, + 300_000_000_000_000_000, + 150_000_000_000_000_000, + 50_000_000_000_000_000, + ]; + + assert_eq!(amounts, expected); + } +} diff --git a/remittance_split/test_snapshots/test/test_calculate_split_basic.1.json b/remittance_split/test_snapshots/test/test_calculate_split_basic.1.json new file mode 100644 index 0000000..d1258fa --- /dev/null +++ b/remittance_split/test_snapshots/test/test_calculate_split_basic.1.json @@ -0,0 +1,238 @@ +{ + "generators": { + "address": 1, + "nonce": 0 + }, + "auth": [ + [], + [] + ], + "ledger": { + "protocol_version": 21, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "symbol": "SPLIT" + }, + "val": { + "vec": [ + { + "u32": 50 + }, + { + "u32": 30 + }, + { + "u32": 15 + }, + { + "u32": 5 + } + ] + } + } + ] + } + } + } + }, + "ext": "v0" + }, + 4095 + ] + ], + [ + { + "contract_code": { + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + 4095 + ] + ] + ] + }, + "events": [ + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "initialize_split" + } + ], + "data": { + "vec": [ + { + "u32": 50 + }, + { + "u32": 30 + }, + { + "u32": 15 + }, + { + "u32": 5 + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "initialize_split" + } + ], + "data": { + "bool": true + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "calculate_split" + } + ], + "data": { + "i128": { + "hi": 0, + "lo": 1000 + } + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "calculate_split" + } + ], + "data": { + "vec": [ + { + "i128": { + "hi": 0, + "lo": 500 + } + }, + { + "i128": { + "hi": 0, + "lo": 300 + } + }, + { + "i128": { + "hi": 0, + "lo": 150 + } + }, + { + "i128": { + "hi": 0, + "lo": 50 + } + } + ] + } + } + } + }, + "failed_call": false + } + ] +} \ No newline at end of file diff --git a/remittance_split/test_snapshots/test/test_calculate_split_default_when_uninitialized.1.json b/remittance_split/test_snapshots/test/test_calculate_split_default_when_uninitialized.1.json new file mode 100644 index 0000000..50a02e7 --- /dev/null +++ b/remittance_split/test_snapshots/test/test_calculate_split_default_when_uninitialized.1.json @@ -0,0 +1,153 @@ +{ + "generators": { + "address": 1, + "nonce": 0 + }, + "auth": [ + [] + ], + "ledger": { + "protocol_version": 21, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": null + } + } + } + }, + "ext": "v0" + }, + 4095 + ] + ], + [ + { + "contract_code": { + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + 4095 + ] + ] + ] + }, + "events": [ + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "calculate_split" + } + ], + "data": { + "i128": { + "hi": 0, + "lo": 200 + } + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "calculate_split" + } + ], + "data": { + "vec": [ + { + "i128": { + "hi": 0, + "lo": 100 + } + }, + { + "i128": { + "hi": 0, + "lo": 60 + } + }, + { + "i128": { + "hi": 0, + "lo": 30 + } + }, + { + "i128": { + "hi": 0, + "lo": 10 + } + } + ] + } + } + } + }, + "failed_call": false + } + ] +} \ No newline at end of file diff --git a/remittance_split/test_snapshots/test/test_calculate_split_large_amount.1.json b/remittance_split/test_snapshots/test/test_calculate_split_large_amount.1.json new file mode 100644 index 0000000..28213eb --- /dev/null +++ b/remittance_split/test_snapshots/test/test_calculate_split_large_amount.1.json @@ -0,0 +1,153 @@ +{ + "generators": { + "address": 1, + "nonce": 0 + }, + "auth": [ + [] + ], + "ledger": { + "protocol_version": 21, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": null + } + } + } + }, + "ext": "v0" + }, + 4095 + ] + ], + [ + { + "contract_code": { + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + 4095 + ] + ] + ] + }, + "events": [ + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "calculate_split" + } + ], + "data": { + "i128": { + "hi": 0, + "lo": 1000000000000000000 + } + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "calculate_split" + } + ], + "data": { + "vec": [ + { + "i128": { + "hi": 0, + "lo": 500000000000000000 + } + }, + { + "i128": { + "hi": 0, + "lo": 300000000000000000 + } + }, + { + "i128": { + "hi": 0, + "lo": 150000000000000000 + } + }, + { + "i128": { + "hi": 0, + "lo": 50000000000000000 + } + } + ] + } + } + } + }, + "failed_call": false + } + ] +} \ No newline at end of file diff --git a/remittance_split/test_snapshots/test/test_calculate_split_large_non_divisible_amount.1.json b/remittance_split/test_snapshots/test/test_calculate_split_large_non_divisible_amount.1.json new file mode 100644 index 0000000..f987e13 --- /dev/null +++ b/remittance_split/test_snapshots/test/test_calculate_split_large_non_divisible_amount.1.json @@ -0,0 +1,153 @@ +{ + "generators": { + "address": 1, + "nonce": 0 + }, + "auth": [ + [] + ], + "ledger": { + "protocol_version": 21, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": null + } + } + } + }, + "ext": "v0" + }, + 4095 + ] + ], + [ + { + "contract_code": { + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + 4095 + ] + ] + ] + }, + "events": [ + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "calculate_split" + } + ], + "data": { + "i128": { + "hi": 0, + "lo": 1000000000000000001 + } + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "calculate_split" + } + ], + "data": { + "vec": [ + { + "i128": { + "hi": 0, + "lo": 500000000000000000 + } + }, + { + "i128": { + "hi": 0, + "lo": 300000000000000000 + } + }, + { + "i128": { + "hi": 0, + "lo": 150000000000000000 + } + }, + { + "i128": { + "hi": 0, + "lo": 50000000000000001 + } + } + ] + } + } + } + }, + "failed_call": false + } + ] +} \ No newline at end of file diff --git a/remittance_split/test_snapshots/test/test_calculate_split_negative_amount.1.json b/remittance_split/test_snapshots/test/test_calculate_split_negative_amount.1.json new file mode 100644 index 0000000..f0dad8e --- /dev/null +++ b/remittance_split/test_snapshots/test/test_calculate_split_negative_amount.1.json @@ -0,0 +1,153 @@ +{ + "generators": { + "address": 1, + "nonce": 0 + }, + "auth": [ + [] + ], + "ledger": { + "protocol_version": 21, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": null + } + } + } + }, + "ext": "v0" + }, + 4095 + ] + ], + [ + { + "contract_code": { + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + 4095 + ] + ] + ] + }, + "events": [ + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "calculate_split" + } + ], + "data": { + "i128": { + "hi": -1, + "lo": 18446744073709551606 + } + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "calculate_split" + } + ], + "data": { + "vec": [ + { + "i128": { + "hi": 0, + "lo": 0 + } + }, + { + "i128": { + "hi": 0, + "lo": 0 + } + }, + { + "i128": { + "hi": 0, + "lo": 0 + } + }, + { + "i128": { + "hi": 0, + "lo": 0 + } + } + ] + } + } + } + }, + "failed_call": false + } + ] +} \ No newline at end of file diff --git a/remittance_split/test_snapshots/test/test_calculate_split_rounding_total_matches.1.json b/remittance_split/test_snapshots/test/test_calculate_split_rounding_total_matches.1.json new file mode 100644 index 0000000..ffa44ca --- /dev/null +++ b/remittance_split/test_snapshots/test/test_calculate_split_rounding_total_matches.1.json @@ -0,0 +1,238 @@ +{ + "generators": { + "address": 1, + "nonce": 0 + }, + "auth": [ + [], + [] + ], + "ledger": { + "protocol_version": 21, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "symbol": "SPLIT" + }, + "val": { + "vec": [ + { + "u32": 50 + }, + { + "u32": 30 + }, + { + "u32": 15 + }, + { + "u32": 5 + } + ] + } + } + ] + } + } + } + }, + "ext": "v0" + }, + 4095 + ] + ], + [ + { + "contract_code": { + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + 4095 + ] + ] + ] + }, + "events": [ + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "initialize_split" + } + ], + "data": { + "vec": [ + { + "u32": 50 + }, + { + "u32": 30 + }, + { + "u32": 15 + }, + { + "u32": 5 + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "initialize_split" + } + ], + "data": { + "bool": true + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "calculate_split" + } + ], + "data": { + "i128": { + "hi": 0, + "lo": 101 + } + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "calculate_split" + } + ], + "data": { + "vec": [ + { + "i128": { + "hi": 0, + "lo": 50 + } + }, + { + "i128": { + "hi": 0, + "lo": 30 + } + }, + { + "i128": { + "hi": 0, + "lo": 15 + } + }, + { + "i128": { + "hi": 0, + "lo": 6 + } + } + ] + } + } + } + }, + "failed_call": false + } + ] +} \ No newline at end of file diff --git a/remittance_split/test_snapshots/test/test_calculate_split_rounding_varied_percentages.1.json b/remittance_split/test_snapshots/test/test_calculate_split_rounding_varied_percentages.1.json new file mode 100644 index 0000000..fd98795 --- /dev/null +++ b/remittance_split/test_snapshots/test/test_calculate_split_rounding_varied_percentages.1.json @@ -0,0 +1,238 @@ +{ + "generators": { + "address": 1, + "nonce": 0 + }, + "auth": [ + [], + [] + ], + "ledger": { + "protocol_version": 21, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "symbol": "SPLIT" + }, + "val": { + "vec": [ + { + "u32": 33 + }, + { + "u32": 33 + }, + { + "u32": 33 + }, + { + "u32": 1 + } + ] + } + } + ] + } + } + } + }, + "ext": "v0" + }, + 4095 + ] + ], + [ + { + "contract_code": { + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + 4095 + ] + ] + ] + }, + "events": [ + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "initialize_split" + } + ], + "data": { + "vec": [ + { + "u32": 33 + }, + { + "u32": 33 + }, + { + "u32": 33 + }, + { + "u32": 1 + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "initialize_split" + } + ], + "data": { + "bool": true + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "calculate_split" + } + ], + "data": { + "i128": { + "hi": 0, + "lo": 101 + } + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "calculate_split" + } + ], + "data": { + "vec": [ + { + "i128": { + "hi": 0, + "lo": 33 + } + }, + { + "i128": { + "hi": 0, + "lo": 33 + } + }, + { + "i128": { + "hi": 0, + "lo": 33 + } + }, + { + "i128": { + "hi": 0, + "lo": 2 + } + } + ] + } + } + } + }, + "failed_call": false + } + ] +} \ No newline at end of file diff --git a/remittance_split/test_snapshots/test/test_calculate_split_small_amount_rounding.1.json b/remittance_split/test_snapshots/test/test_calculate_split_small_amount_rounding.1.json new file mode 100644 index 0000000..149b073 --- /dev/null +++ b/remittance_split/test_snapshots/test/test_calculate_split_small_amount_rounding.1.json @@ -0,0 +1,153 @@ +{ + "generators": { + "address": 1, + "nonce": 0 + }, + "auth": [ + [] + ], + "ledger": { + "protocol_version": 21, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": null + } + } + } + }, + "ext": "v0" + }, + 4095 + ] + ], + [ + { + "contract_code": { + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + 4095 + ] + ] + ] + }, + "events": [ + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "calculate_split" + } + ], + "data": { + "i128": { + "hi": 0, + "lo": 1 + } + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "calculate_split" + } + ], + "data": { + "vec": [ + { + "i128": { + "hi": 0, + "lo": 0 + } + }, + { + "i128": { + "hi": 0, + "lo": 0 + } + }, + { + "i128": { + "hi": 0, + "lo": 0 + } + }, + { + "i128": { + "hi": 0, + "lo": 1 + } + } + ] + } + } + } + }, + "failed_call": false + } + ] +} \ No newline at end of file diff --git a/remittance_split/test_snapshots/test/test_calculate_split_with_zero_categories.1.json b/remittance_split/test_snapshots/test/test_calculate_split_with_zero_categories.1.json new file mode 100644 index 0000000..9decbad --- /dev/null +++ b/remittance_split/test_snapshots/test/test_calculate_split_with_zero_categories.1.json @@ -0,0 +1,238 @@ +{ + "generators": { + "address": 1, + "nonce": 0 + }, + "auth": [ + [], + [] + ], + "ledger": { + "protocol_version": 21, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "symbol": "SPLIT" + }, + "val": { + "vec": [ + { + "u32": 100 + }, + { + "u32": 0 + }, + { + "u32": 0 + }, + { + "u32": 0 + } + ] + } + } + ] + } + } + } + }, + "ext": "v0" + }, + 4095 + ] + ], + [ + { + "contract_code": { + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + 4095 + ] + ] + ] + }, + "events": [ + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "initialize_split" + } + ], + "data": { + "vec": [ + { + "u32": 100 + }, + { + "u32": 0 + }, + { + "u32": 0 + }, + { + "u32": 0 + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "initialize_split" + } + ], + "data": { + "bool": true + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "calculate_split" + } + ], + "data": { + "i128": { + "hi": 0, + "lo": 123 + } + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "calculate_split" + } + ], + "data": { + "vec": [ + { + "i128": { + "hi": 0, + "lo": 123 + } + }, + { + "i128": { + "hi": 0, + "lo": 0 + } + }, + { + "i128": { + "hi": 0, + "lo": 0 + } + }, + { + "i128": { + "hi": 0, + "lo": 0 + } + } + ] + } + } + } + }, + "failed_call": false + } + ] +} \ No newline at end of file diff --git a/remittance_split/test_snapshots/test/test_calculate_split_zero_amount.1.json b/remittance_split/test_snapshots/test/test_calculate_split_zero_amount.1.json new file mode 100644 index 0000000..bab5d55 --- /dev/null +++ b/remittance_split/test_snapshots/test/test_calculate_split_zero_amount.1.json @@ -0,0 +1,153 @@ +{ + "generators": { + "address": 1, + "nonce": 0 + }, + "auth": [ + [] + ], + "ledger": { + "protocol_version": 21, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": null + } + } + } + }, + "ext": "v0" + }, + 4095 + ] + ], + [ + { + "contract_code": { + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + 4095 + ] + ] + ] + }, + "events": [ + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "calculate_split" + } + ], + "data": { + "i128": { + "hi": 0, + "lo": 0 + } + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "calculate_split" + } + ], + "data": { + "vec": [ + { + "i128": { + "hi": 0, + "lo": 0 + } + }, + { + "i128": { + "hi": 0, + "lo": 0 + } + }, + { + "i128": { + "hi": 0, + "lo": 0 + } + }, + { + "i128": { + "hi": 0, + "lo": 0 + } + } + ] + } + } + } + }, + "failed_call": false + } + ] +} \ No newline at end of file diff --git a/remittance_split/test_snapshots/test/test_get_split_configured_values.1.json b/remittance_split/test_snapshots/test/test_get_split_configured_values.1.json new file mode 100644 index 0000000..3e023f5 --- /dev/null +++ b/remittance_split/test_snapshots/test/test_get_split_configured_values.1.json @@ -0,0 +1,221 @@ +{ + "generators": { + "address": 1, + "nonce": 0 + }, + "auth": [ + [], + [] + ], + "ledger": { + "protocol_version": 21, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "symbol": "SPLIT" + }, + "val": { + "vec": [ + { + "u32": 70 + }, + { + "u32": 20 + }, + { + "u32": 5 + }, + { + "u32": 5 + } + ] + } + } + ] + } + } + } + }, + "ext": "v0" + }, + 4095 + ] + ], + [ + { + "contract_code": { + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + 4095 + ] + ] + ] + }, + "events": [ + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "initialize_split" + } + ], + "data": { + "vec": [ + { + "u32": 70 + }, + { + "u32": 20 + }, + { + "u32": 5 + }, + { + "u32": 5 + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "initialize_split" + } + ], + "data": { + "bool": true + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "get_split" + } + ], + "data": "void" + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "get_split" + } + ], + "data": { + "vec": [ + { + "u32": 70 + }, + { + "u32": 20 + }, + { + "u32": 5 + }, + { + "u32": 5 + } + ] + } + } + } + }, + "failed_call": false + } + ] +} \ No newline at end of file diff --git a/remittance_split/test_snapshots/test/test_get_split_default.1.json b/remittance_split/test_snapshots/test/test_get_split_default.1.json new file mode 100644 index 0000000..0dfed3b --- /dev/null +++ b/remittance_split/test_snapshots/test/test_get_split_default.1.json @@ -0,0 +1,136 @@ +{ + "generators": { + "address": 1, + "nonce": 0 + }, + "auth": [ + [] + ], + "ledger": { + "protocol_version": 21, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": null + } + } + } + }, + "ext": "v0" + }, + 4095 + ] + ], + [ + { + "contract_code": { + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + 4095 + ] + ] + ] + }, + "events": [ + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "get_split" + } + ], + "data": "void" + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "get_split" + } + ], + "data": { + "vec": [ + { + "u32": 50 + }, + { + "u32": 30 + }, + { + "u32": 15 + }, + { + "u32": 5 + } + ] + } + } + } + }, + "failed_call": false + } + ] +} \ No newline at end of file diff --git a/remittance_split/test_snapshots/test/test_initialize_split_invalid_does_not_overwrite.1.json b/remittance_split/test_snapshots/test/test_initialize_split_invalid_does_not_overwrite.1.json new file mode 100644 index 0000000..191debf --- /dev/null +++ b/remittance_split/test_snapshots/test/test_initialize_split_invalid_does_not_overwrite.1.json @@ -0,0 +1,284 @@ +{ + "generators": { + "address": 1, + "nonce": 0 + }, + "auth": [ + [], + [], + [] + ], + "ledger": { + "protocol_version": 21, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "symbol": "SPLIT" + }, + "val": { + "vec": [ + { + "u32": 60 + }, + { + "u32": 20 + }, + { + "u32": 15 + }, + { + "u32": 5 + } + ] + } + } + ] + } + } + } + }, + "ext": "v0" + }, + 4095 + ] + ], + [ + { + "contract_code": { + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + 4095 + ] + ] + ] + }, + "events": [ + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "initialize_split" + } + ], + "data": { + "vec": [ + { + "u32": 60 + }, + { + "u32": 20 + }, + { + "u32": 15 + }, + { + "u32": 5 + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "initialize_split" + } + ], + "data": { + "bool": true + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "initialize_split" + } + ], + "data": { + "vec": [ + { + "u32": 60 + }, + { + "u32": 20 + }, + { + "u32": 15 + }, + { + "u32": 10 + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "initialize_split" + } + ], + "data": { + "bool": false + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "get_split" + } + ], + "data": "void" + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "get_split" + } + ], + "data": { + "vec": [ + { + "u32": 60 + }, + { + "u32": 20 + }, + { + "u32": 15 + }, + { + "u32": 5 + } + ] + } + } + } + }, + "failed_call": false + } + ] +} \ No newline at end of file diff --git a/remittance_split/test_snapshots/test/test_initialize_split_invalid_over_100.1.json b/remittance_split/test_snapshots/test/test_initialize_split_invalid_over_100.1.json new file mode 100644 index 0000000..955479e --- /dev/null +++ b/remittance_split/test_snapshots/test/test_initialize_split_invalid_over_100.1.json @@ -0,0 +1,199 @@ +{ + "generators": { + "address": 1, + "nonce": 0 + }, + "auth": [ + [], + [] + ], + "ledger": { + "protocol_version": 21, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": null + } + } + } + }, + "ext": "v0" + }, + 4095 + ] + ], + [ + { + "contract_code": { + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + 4095 + ] + ] + ] + }, + "events": [ + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "initialize_split" + } + ], + "data": { + "vec": [ + { + "u32": 101 + }, + { + "u32": 0 + }, + { + "u32": 0 + }, + { + "u32": 0 + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "initialize_split" + } + ], + "data": { + "bool": false + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "get_split" + } + ], + "data": "void" + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "get_split" + } + ], + "data": { + "vec": [ + { + "u32": 50 + }, + { + "u32": 30 + }, + { + "u32": 15 + }, + { + "u32": 5 + } + ] + } + } + } + }, + "failed_call": false + } + ] +} \ No newline at end of file diff --git a/remittance_split/test_snapshots/test/test_initialize_split_invalid_sum.1.json b/remittance_split/test_snapshots/test/test_initialize_split_invalid_sum.1.json new file mode 100644 index 0000000..4a5c95e --- /dev/null +++ b/remittance_split/test_snapshots/test/test_initialize_split_invalid_sum.1.json @@ -0,0 +1,199 @@ +{ + "generators": { + "address": 1, + "nonce": 0 + }, + "auth": [ + [], + [] + ], + "ledger": { + "protocol_version": 21, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": null + } + } + } + }, + "ext": "v0" + }, + 4095 + ] + ], + [ + { + "contract_code": { + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + 4095 + ] + ] + ] + }, + "events": [ + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "initialize_split" + } + ], + "data": { + "vec": [ + { + "u32": 50 + }, + { + "u32": 30 + }, + { + "u32": 10 + }, + { + "u32": 5 + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "initialize_split" + } + ], + "data": { + "bool": false + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "get_split" + } + ], + "data": "void" + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "get_split" + } + ], + "data": { + "vec": [ + { + "u32": 50 + }, + { + "u32": 30 + }, + { + "u32": 15 + }, + { + "u32": 5 + } + ] + } + } + } + }, + "failed_call": false + } + ] +} \ No newline at end of file diff --git a/remittance_split/test_snapshots/test/test_initialize_split_update_existing.1.json b/remittance_split/test_snapshots/test/test_initialize_split_update_existing.1.json new file mode 100644 index 0000000..2a35cb3 --- /dev/null +++ b/remittance_split/test_snapshots/test/test_initialize_split_update_existing.1.json @@ -0,0 +1,284 @@ +{ + "generators": { + "address": 1, + "nonce": 0 + }, + "auth": [ + [], + [], + [] + ], + "ledger": { + "protocol_version": 21, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "symbol": "SPLIT" + }, + "val": { + "vec": [ + { + "u32": 25 + }, + { + "u32": 25 + }, + { + "u32": 25 + }, + { + "u32": 25 + } + ] + } + } + ] + } + } + } + }, + "ext": "v0" + }, + 4095 + ] + ], + [ + { + "contract_code": { + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + 4095 + ] + ] + ] + }, + "events": [ + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "initialize_split" + } + ], + "data": { + "vec": [ + { + "u32": 60 + }, + { + "u32": 20 + }, + { + "u32": 15 + }, + { + "u32": 5 + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "initialize_split" + } + ], + "data": { + "bool": true + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "initialize_split" + } + ], + "data": { + "vec": [ + { + "u32": 25 + }, + { + "u32": 25 + }, + { + "u32": 25 + }, + { + "u32": 25 + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "initialize_split" + } + ], + "data": { + "bool": true + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "get_split" + } + ], + "data": "void" + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "get_split" + } + ], + "data": { + "vec": [ + { + "u32": 25 + }, + { + "u32": 25 + }, + { + "u32": 25 + }, + { + "u32": 25 + } + ] + } + } + } + }, + "failed_call": false + } + ] +} \ No newline at end of file diff --git a/remittance_split/test_snapshots/test/test_initialize_split_valid.1.json b/remittance_split/test_snapshots/test/test_initialize_split_valid.1.json new file mode 100644 index 0000000..3477241 --- /dev/null +++ b/remittance_split/test_snapshots/test/test_initialize_split_valid.1.json @@ -0,0 +1,221 @@ +{ + "generators": { + "address": 1, + "nonce": 0 + }, + "auth": [ + [], + [] + ], + "ledger": { + "protocol_version": 21, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "symbol": "SPLIT" + }, + "val": { + "vec": [ + { + "u32": 40 + }, + { + "u32": 30 + }, + { + "u32": 20 + }, + { + "u32": 10 + } + ] + } + } + ] + } + } + } + }, + "ext": "v0" + }, + 4095 + ] + ], + [ + { + "contract_code": { + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + 4095 + ] + ] + ] + }, + "events": [ + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "initialize_split" + } + ], + "data": { + "vec": [ + { + "u32": 40 + }, + { + "u32": 30 + }, + { + "u32": 20 + }, + { + "u32": 10 + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "initialize_split" + } + ], + "data": { + "bool": true + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "get_split" + } + ], + "data": "void" + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "get_split" + } + ], + "data": { + "vec": [ + { + "u32": 40 + }, + { + "u32": 30 + }, + { + "u32": 20 + }, + { + "u32": 10 + } + ] + } + } + } + }, + "failed_call": false + } + ] +} \ No newline at end of file diff --git a/remittance_split/test_snapshots/test/test_initialize_split_with_zero_percentages.1.json b/remittance_split/test_snapshots/test/test_initialize_split_with_zero_percentages.1.json new file mode 100644 index 0000000..8fa423b --- /dev/null +++ b/remittance_split/test_snapshots/test/test_initialize_split_with_zero_percentages.1.json @@ -0,0 +1,221 @@ +{ + "generators": { + "address": 1, + "nonce": 0 + }, + "auth": [ + [], + [] + ], + "ledger": { + "protocol_version": 21, + "sequence_number": 0, + "timestamp": 0, + "network_id": "0000000000000000000000000000000000000000000000000000000000000000", + "base_reserve": 0, + "min_persistent_entry_ttl": 4096, + "min_temp_entry_ttl": 16, + "max_entry_ttl": 6312000, + "ledger_entries": [ + [ + { + "contract_data": { + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_data": { + "ext": "v0", + "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM", + "key": "ledger_key_contract_instance", + "durability": "persistent", + "val": { + "contract_instance": { + "executable": { + "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "storage": [ + { + "key": { + "symbol": "SPLIT" + }, + "val": { + "vec": [ + { + "u32": 100 + }, + { + "u32": 0 + }, + { + "u32": 0 + }, + { + "u32": 0 + } + ] + } + } + ] + } + } + } + }, + "ext": "v0" + }, + 4095 + ] + ], + [ + { + "contract_code": { + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + [ + { + "last_modified_ledger_seq": 0, + "data": { + "contract_code": { + "ext": "v0", + "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "code": "" + } + }, + "ext": "v0" + }, + 4095 + ] + ] + ] + }, + "events": [ + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "initialize_split" + } + ], + "data": { + "vec": [ + { + "u32": 100 + }, + { + "u32": 0 + }, + { + "u32": 0 + }, + { + "u32": 0 + } + ] + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "initialize_split" + } + ], + "data": { + "bool": true + } + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": null, + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_call" + }, + { + "bytes": "0000000000000000000000000000000000000000000000000000000000000001" + }, + { + "symbol": "get_split" + } + ], + "data": "void" + } + } + }, + "failed_call": false + }, + { + "event": { + "ext": "v0", + "contract_id": "0000000000000000000000000000000000000000000000000000000000000001", + "type_": "diagnostic", + "body": { + "v0": { + "topics": [ + { + "symbol": "fn_return" + }, + { + "symbol": "get_split" + } + ], + "data": { + "vec": [ + { + "u32": 100 + }, + { + "u32": 0 + }, + { + "u32": 0 + }, + { + "u32": 0 + } + ] + } + } + } + }, + "failed_call": false + } + ] +} \ No newline at end of file From 54b7d6c0e90760ff3581f26950247474d77e73b2 Mon Sep 17 00:00:00 2001 From: Emmyt24 Date: Thu, 22 Jan 2026 11:33:17 +0100 Subject: [PATCH 2/8] fix: fix build error --- Cargo.toml | 7 ++++++- rust-toolchain.toml | 4 ++++ src/main.rs | 3 +++ 3 files changed, 13 insertions(+), 1 deletion(-) create mode 100644 rust-toolchain.toml create mode 100644 src/main.rs diff --git a/Cargo.toml b/Cargo.toml index 2eb5125..711d350 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,3 +1,9 @@ +[package] +name = "remitwise-contracts" +version = "0.1.0" +edition = "2021" +publish = false + [workspace] members = [ "remittance_split", @@ -20,4 +26,3 @@ lto = true [profile.release-with-logs] inherits = "release" debug-assertions = true - diff --git a/rust-toolchain.toml b/rust-toolchain.toml new file mode 100644 index 0000000..8ebb129 --- /dev/null +++ b/rust-toolchain.toml @@ -0,0 +1,4 @@ +[toolchain] +channel = "stable" +components = ["rustfmt", "clippy"] +targets = ["wasm32-unknown-unknown", "wasm32v1-none"] diff --git a/src/main.rs b/src/main.rs new file mode 100644 index 0000000..524cbba --- /dev/null +++ b/src/main.rs @@ -0,0 +1,3 @@ +fn main() { + println!("Remitwise-Contracts is a Soroban workspace. Build a contract with: soroban contract build"); +} From b6137a08e88fdebb616100164b781f6e3e2b5d3a Mon Sep 17 00:00:00 2001 From: Emmyt24 Date: Fri, 23 Jan 2026 11:49:41 +0100 Subject: [PATCH 3/8] fix: pipeline fix --- .github/workflows/ci.yml | 13 +------------ 1 file changed, 1 insertion(+), 12 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 37cb1f6..f5d8b30 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -78,17 +78,7 @@ jobs: run: | for contract in remittance_split savings_goals bill_payments insurance; do echo "Building contract: $contract" - cd $contract - if command -v soroban &> /dev/null; then - soroban contract build --verbose || { - echo "Warning: soroban CLI build failed, using cargo directly..." - cargo build --release --target wasm32-unknown-unknown --verbose - } - else - echo "soroban CLI not available, using cargo directly..." - cargo build --release --target wasm32-unknown-unknown --verbose - fi - cd .. + cargo build --release --target wasm32-unknown-unknown --package $contract --verbose done continue-on-error: false @@ -172,4 +162,3 @@ jobs: run: | cargo audit --deny warnings continue-on-error: true - From db9fbdff48fb174728ed8bc3558f32a47e784de0 Mon Sep 17 00:00:00 2001 From: Emmyt24 Date: Fri, 23 Jan 2026 20:27:32 +0100 Subject: [PATCH 4/8] Fix extend_instance_ttl calls in remittance_split contract --- .github/workflows/ci.yml | 1 - remittance_split/src/lib.rs | 7 +++++++ 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f5d8b30..6523621 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -67,7 +67,6 @@ jobs: rustc --version cargo --version rustup target list --installed | grep wasm32-unknown-unknown || rustup target add wasm32-unknown-unknown - rustup target list --installed | grep wasm32v1-none || rustup target add wasm32v1-none || echo "Warning: wasm32v1-none target not available, will use wasm32-unknown-unknown fallback" - name: Build workspace (WASM) run: | diff --git a/remittance_split/src/lib.rs b/remittance_split/src/lib.rs index 4ac0777..88b7755 100644 --- a/remittance_split/src/lib.rs +++ b/remittance_split/src/lib.rs @@ -259,4 +259,11 @@ impl RemittanceSplit { quotient * percent + (remainder * percent) / 100 } + + /// Extend the TTL of instance storage + fn extend_instance_ttl(env: &Env) { + env.storage() + .instance() + .extend_ttl(INSTANCE_LIFETIME_THRESHOLD, INSTANCE_BUMP_AMOUNT); + } } From a53580ba5e2fb5bd7e782fd143b1106739400276 Mon Sep 17 00:00:00 2001 From: Emmyt24 Date: Fri, 23 Jan 2026 20:32:07 +0100 Subject: [PATCH 5/8] Remove unused functions from remittance_split to fix warnings --- remittance_split/src/lib.rs | 30 ------------------------------ 1 file changed, 30 deletions(-) diff --git a/remittance_split/src/lib.rs b/remittance_split/src/lib.rs index 88b7755..52dddb4 100644 --- a/remittance_split/src/lib.rs +++ b/remittance_split/src/lib.rs @@ -229,36 +229,6 @@ impl RemittanceSplit { vec![&env, spending, savings, bills, insurance] } - /// Validate a percentage split for bounds and sum. - fn is_valid_split( - spending_percent: u32, - savings_percent: u32, - bills_percent: u32, - insurance_percent: u32, - ) -> bool { - if spending_percent > 100 - || savings_percent > 100 - || bills_percent > 100 - || insurance_percent > 100 - { - return false; - } - - let total = spending_percent as u64 - + savings_percent as u64 - + bills_percent as u64 - + insurance_percent as u64; - total == 100 - } - - /// Compute a percentage share without risking multiplication overflow. - fn split_amount(total_amount: i128, percent: u32) -> i128 { - let percent = percent as i128; - let quotient = total_amount / 100; - let remainder = total_amount % 100; - - quotient * percent + (remainder * percent) / 100 - } /// Extend the TTL of instance storage fn extend_instance_ttl(env: &Env) { From aa0a395076bf79aa235aadd4a8421d5eb665480b Mon Sep 17 00:00:00 2001 From: Emmyt24 Date: Fri, 23 Jan 2026 20:59:32 +0100 Subject: [PATCH 6/8] Fix: resolve extend_instance_ttl compilation error --- remittance_split/src/lib.rs | 47 ++++++++++++++++++++++++++++++------- 1 file changed, 38 insertions(+), 9 deletions(-) diff --git a/remittance_split/src/lib.rs b/remittance_split/src/lib.rs index 52dddb4..47ed3ae 100644 --- a/remittance_split/src/lib.rs +++ b/remittance_split/src/lib.rs @@ -60,9 +60,8 @@ impl RemittanceSplit { } // Input validation: percentages must sum to 100 - let total = spending_percent + savings_percent + bills_percent + insurance_percent; - if total != 100 { - panic!("Percentages must sum to 100"); + if !Self::is_valid_split(spending_percent, savings_percent, bills_percent, insurance_percent) { + panic!("Percentages must sum to 100 and be valid"); } // Extend storage TTL @@ -140,9 +139,8 @@ impl RemittanceSplit { } // Input validation: percentages must sum to 100 - let total = spending_percent + savings_percent + bills_percent + insurance_percent; - if total != 100 { - panic!("Percentages must sum to 100"); + if !Self::is_valid_split(spending_percent, savings_percent, bills_percent, insurance_percent) { + panic!("Percentages must sum to 100 and be valid"); } // Extend storage TTL @@ -214,9 +212,9 @@ impl RemittanceSplit { let split = Self::get_split(&env); - let spending = (total_amount * split.get(0).unwrap() as i128) / 100; - let savings = (total_amount * split.get(1).unwrap() as i128) / 100; - let bills = (total_amount * split.get(2).unwrap() as i128) / 100; + let spending = Self::split_amount(total_amount, split.get(0).unwrap()); + let savings = Self::split_amount(total_amount, split.get(1).unwrap()); + let bills = Self::split_amount(total_amount, split.get(2).unwrap()); // Insurance gets the remainder to handle rounding let insurance = total_amount - spending - savings - bills; @@ -230,6 +228,37 @@ impl RemittanceSplit { } + /// Validate a percentage split for bounds and sum. + fn is_valid_split( + spending_percent: u32, + savings_percent: u32, + bills_percent: u32, + insurance_percent: u32, + ) -> bool { + if spending_percent > 100 + || savings_percent > 100 + || bills_percent > 100 + || insurance_percent > 100 + { + return false; + } + + let total = spending_percent as u64 + + savings_percent as u64 + + bills_percent as u64 + + insurance_percent as u64; + total == 100 + } + + /// Compute a percentage share without risking multiplication overflow. + fn split_amount(total_amount: i128, percent: u32) -> i128 { + let percent = percent as i128; + let quotient = total_amount / 100; + let remainder = total_amount % 100; + + quotient * percent + (remainder * percent) / 100 + } + /// Extend the TTL of instance storage fn extend_instance_ttl(env: &Env) { env.storage() From 8f040058062d850f5667bff560b449395c29f825 Mon Sep 17 00:00:00 2001 From: Emmyt24 Date: Sat, 24 Jan 2026 13:25:10 +0100 Subject: [PATCH 7/8] Fix: formatting issues for cargo fmt compliance --- remittance_split/src/lib.rs | 15 ++++++++++++--- src/main.rs | 4 +++- 2 files changed, 15 insertions(+), 4 deletions(-) diff --git a/remittance_split/src/lib.rs b/remittance_split/src/lib.rs index 47ed3ae..4b26fe9 100644 --- a/remittance_split/src/lib.rs +++ b/remittance_split/src/lib.rs @@ -60,7 +60,12 @@ impl RemittanceSplit { } // Input validation: percentages must sum to 100 - if !Self::is_valid_split(spending_percent, savings_percent, bills_percent, insurance_percent) { + if !Self::is_valid_split( + spending_percent, + savings_percent, + bills_percent, + insurance_percent, + ) { panic!("Percentages must sum to 100 and be valid"); } @@ -139,7 +144,12 @@ impl RemittanceSplit { } // Input validation: percentages must sum to 100 - if !Self::is_valid_split(spending_percent, savings_percent, bills_percent, insurance_percent) { + if !Self::is_valid_split( + spending_percent, + savings_percent, + bills_percent, + insurance_percent, + ) { panic!("Percentages must sum to 100 and be valid"); } @@ -227,7 +237,6 @@ impl RemittanceSplit { vec![&env, spending, savings, bills, insurance] } - /// Validate a percentage split for bounds and sum. fn is_valid_split( spending_percent: u32, diff --git a/src/main.rs b/src/main.rs index 524cbba..2bb51d2 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,3 +1,5 @@ fn main() { - println!("Remitwise-Contracts is a Soroban workspace. Build a contract with: soroban contract build"); + println!( + "Remitwise-Contracts is a Soroban workspace. Build a contract with: soroban contract build" + ); } From d9ccd5226ff2675c28f19e3950a4fbd9cdd32397 Mon Sep 17 00:00:00 2001 From: Emmyt24 Date: Thu, 29 Jan 2026 18:38:52 +0100 Subject: [PATCH 8/8] Add missing helper functions is_valid_split and split_amount --- remittance_split/src/lib.rs | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/remittance_split/src/lib.rs b/remittance_split/src/lib.rs index 613921d..0bf8218 100644 --- a/remittance_split/src/lib.rs +++ b/remittance_split/src/lib.rs @@ -310,6 +310,37 @@ impl RemittanceSplit { result } + /// Validate a percentage split for bounds and sum. + fn is_valid_split( + spending_percent: u32, + savings_percent: u32, + bills_percent: u32, + insurance_percent: u32, + ) -> bool { + if spending_percent > 100 + || savings_percent > 100 + || bills_percent > 100 + || insurance_percent > 100 + { + return false; + } + + let total = spending_percent as u64 + + savings_percent as u64 + + bills_percent as u64 + + insurance_percent as u64; + total == 100 + } + + /// Compute a percentage share without risking multiplication overflow. + fn split_amount(total_amount: i128, percent: u32) -> i128 { + let percent = percent as i128; + let quotient = total_amount / 100; + let remainder = total_amount % 100; + + quotient * percent + (remainder * percent) / 100 + } + /// Extend the TTL of instance storage fn extend_instance_ttl(env: &Env) { env.storage()