Merge pull request #506 from DeFiVC/feat/add-tests-issues-480-483

feat(tests): add missing tests for issues #480-#483

Author: Levi-Ojukwu

contracts/invoice_liquidity/src/tests_multi_token.rs

@@ -2,6 +2,7 @@
 
 use super::*;
 use soroban_sdk::{
+    contract, contractimpl,
     testutils::{Address as _, Ledger},
     token::{Client as TokenClient, StellarAssetClient},
     Address, Env,
@@ -19,6 +20,7 @@ struct MockToken {
 struct MultiTokenTestEnv {
     env: Env,
     contract: InvoiceLiquidityContractClient<'static>,
+    admin: Address,
     freelancer: Address,
     payer: Address,
     lp: Address,
@@ -54,15 +56,20 @@ fn setup() -> MultiTokenTestEnv {
 
     usdc.admin_client.mint(&payer, &10_000_000_000);
     usdc.admin_client.mint(&lp, &10_000_000_000);
+    usdc.admin_client.mint(&contract_address_placeholder(&env), &1_000_000_000_000);
     eurc.admin_client.mint(&payer, &10_000_000_000);
     eurc.admin_client.mint(&lp, &10_000_000_000);
     xlm.admin_client.mint(&payer, &100_000_000_000);
     xlm.admin_client.mint(&lp, &100_000_000_000);
 
     let contract_id = env.register_contract(None, InvoiceLiquidityContract);
     let contract = InvoiceLiquidityContractClient::new(&env, &contract_id);
-    contract.initialize(&admin, &usdc.address, &xlm.address);
-    contract.add_token(&eurc.address, &6_u32); // EURC has 6 decimals
+
+    // Mint tokens to the contract for refunds
+    usdc.admin_client.mint(&contract.address, &1_000_000_000_000);
+    eurc.admin_client.mint(&contract.address, &1_000_000_000_000);
+    xlm.admin_client.mint(&contract.address, &1_000_000_000_000);
+
     contract.initialize(&admin, &usdc.address, &eurc.address, &xlm.address);
 
     let mut ledger_info = env.ledger().get();
@@ -72,6 +79,7 @@ fn setup() -> MultiTokenTestEnv {
     MultiTokenTestEnv {
         env,
         contract,
+        admin,
         freelancer,
         payer,
         lp,
@@ -81,12 +89,24 @@ fn setup() -> MultiTokenTestEnv {
     }
 }
 
+fn contract_address_placeholder(_env: &Env) -> Address {
+    // This is a placeholder - actual contract address is set during setup
+    Address::generate(_env)
+}
+
 fn due_date(env: &MultiTokenTestEnv) -> u64 {
     env.env.ledger().timestamp() + DUE_DATE_OFFSET
 }
 
 fn submit_invoice(env: &MultiTokenTestEnv, token: &MockToken, amount: i128) -> u64 {
-    env.contract.submit_invoice(        &ReferralCode::None,
+    env.contract.submit_invoice(
+        &env.freelancer,
+        &env.payer,
+        &amount,
+        &due_date(env),
+        &DISCOUNT_RATE,
+        &token.address,
+        &ReferralCode::None,
     )
 }
 
@@ -101,7 +121,7 @@ fn assert_full_lifecycle_for_token(
     amount: i128,
 ) {
     let invoice_id = submit_invoice(env, token, amount);
-    let invoice = env.contract.get_invoice(&invoice_id);
+    let invoice = env.contract.get_invoice(&invoice_id).unwrap();
     assert_eq!(
         invoice.token, token.address,
         "{token_name} invoice should persist its token"
@@ -133,7 +153,7 @@ fn assert_full_lifecycle_for_token(
         "{token_name} payer should settle the invoice amount in the same token path",
     );
     assert_eq!(
-        env.contract.get_invoice(&invoice_id).status,
+        env.contract.get_invoice(&invoice_id).unwrap().status,
         InvoiceStatus::Paid,
         "{token_name} invoice should finish the lifecycle as Paid",
     );
@@ -162,7 +182,14 @@ fn test_submit_with_unapproved_token_is_rejected() {
     let env = setup();
     let rogue = register_mock_token(&env.env);
 
-    let result = env.contract.try_submit_invoice(try_        &ReferralCode::None,
+    let result = env.contract.try_submit_invoice(
+        &env.freelancer,
+        &env.payer,
+        &(1_000_000_000_i128),
+        &due_date(&env),
+        &DISCOUNT_RATE,
+        &rogue.address,
+        &ReferralCode::None,
     );
 
     assert_eq!(result, Err(Ok(ContractError::Unauthorized)));
@@ -171,26 +198,24 @@ fn test_submit_with_unapproved_token_is_rejected() {
 #[test]
 fn test_admin_removing_token_mid_flight_does_not_break_existing_invoice_settlement() {
     let env = setup();
-    let amount = 42_500_000;
+    let amount = 42_500_000_i128;
     let invoice_id = submit_invoice(&env, &env.eurc, amount);
 
     env.contract.remove_token(&env.eurc.address);
 
-    env.contract.fund_invoice(&env.lp, &invoice_id, &amount);
-    env.contract.mark_paid(&invoice_id, &amount);
     env.contract.fund_invoice(&env.lp, &invoice_id, &amount, &false);
-    env.contract.mark_paid(&invoice_id, &INVOICE_AMOUNT);
+    env.contract.mark_paid(&invoice_id, &amount);
 
-    let invoice = env.contract.get_invoice(&invoice_id);
+    let invoice = env.contract.get_invoice(&invoice_id).unwrap();
     assert_eq!(invoice.status, InvoiceStatus::Paid);
     assert_eq!(invoice.token, env.eurc.address);
 }
 
 #[test]
 fn test_same_lp_can_settle_invoices_independently_across_different_tokens() {
     let env = setup();
-    let usdc_amount = 15_000_000;
-    let eurc_amount = 9_500_000;
+    let usdc_amount = 15_000_000_i128;
+    let eurc_amount = 9_500_000_i128;
 
     let usdc_invoice = submit_invoice(&env, &env.usdc, usdc_amount);
     let eurc_invoice = submit_invoice(&env, &env.eurc, eurc_amount);
@@ -206,11 +231,11 @@ fn test_same_lp_can_settle_invoices_independently_across_different_tokens() {
     env.contract.mark_paid(&usdc_invoice, &usdc_amount);
 
     assert_eq!(
-        env.contract.get_invoice(&usdc_invoice).status,
+        env.contract.get_invoice(&usdc_invoice).unwrap().status,
         InvoiceStatus::Paid
     );
     assert_eq!(
-        env.contract.get_invoice(&eurc_invoice).status,
+        env.contract.get_invoice(&eurc_invoice).unwrap().status,
         InvoiceStatus::Funded
     );
     assert_eq!(
@@ -225,7 +250,7 @@ fn test_same_lp_can_settle_invoices_independently_across_different_tokens() {
     env.contract.mark_paid(&eurc_invoice, &eurc_amount);
 
     assert_eq!(
-        env.contract.get_invoice(&eurc_invoice).status,
+        env.contract.get_invoice(&eurc_invoice).unwrap().status,
         InvoiceStatus::Paid
     );
     assert_eq!(
@@ -237,8 +262,8 @@ fn test_same_lp_can_settle_invoices_independently_across_different_tokens() {
 #[test]
 fn test_amounts_preserve_precision_for_6_and_7_decimal_token_paths() {
     let env = setup();
-    let eurc_amount = 12_345_678;
-    let xlm_amount = 123_456_789;
+    let eurc_amount = 12_345_678_i128;
+    let xlm_amount = 123_456_789_i128;
 
     let eurc_invoice = submit_invoice(&env, &env.eurc, eurc_amount);
     let xlm_invoice = submit_invoice(&env, &env.xlm, xlm_amount);
@@ -278,28 +303,20 @@ fn test_amounts_preserve_precision_for_6_and_7_decimal_token_paths() {
 #[test]
 fn test_cross_token_mismatch_is_physically_impossible_as_token_is_locked() {
     let env = setup();
-    let eurc_amount = 50_000_000;
+    let eurc_amount = 50_000_000_i128;
     let invoice_id = submit_invoice(&env, &env.eurc, eurc_amount);
 
-    // LP has 10,000,000,000 USDC and 10,000,000,000 EURC from setup()
-    // If LP tries to fund EURC invoice, they MUST have EURC.
-    // The contract uses invoice.token (EURC) regardless of what the LP "thinks" they are sending.
-    
-    // We can't really "mis-fund" because the contract logic is:
-    // token = token_client(env, &invoice.token)
-    // token.transfer(...)
-    
-    // So the test is more about verifying that the contract correctly uses the invoice's locked token.
-    env.contract.fund_invoice(&env.lp, &invoice_id, &eurc_amount);
-    let invoice = env.contract.get_invoice(&invoice_id);
+    env.contract
+        .fund_invoice(&env.lp, &invoice_id, &eurc_amount, &false);
+    let invoice = env.contract.get_invoice(&invoice_id).unwrap();
     assert_eq!(invoice.token, env.eurc.address);
     assert_eq!(invoice.status, InvoiceStatus::Funded);
 }
 
 #[test]
 fn test_eurc_token_support_is_wired_in_config() {
     let env = setup();
-    let config = env.contract.get_config();
+    let config = env.contract.get_config().unwrap();
     assert_eq!(config.usdc_sac_address, env.usdc.address);
     assert_eq!(config.eurc_sac_address, env.eurc.address);
     assert_eq!(config.xlm_sac_address, env.xlm.address);
@@ -308,25 +325,23 @@ fn test_eurc_token_support_is_wired_in_config() {
 #[test]
 fn test_eurc_lifecycle() {
     let env = setup();
-    let amount = 50_000_000; // 50 EURC
+    let amount = 50_000_000_i128; // 50 EURC
     let id = submit_invoice(&env, &env.eurc, amount);
 
     let freelancer_before = env.eurc.client.balance(&env.freelancer);
     let lp_before = env.eurc.client.balance(&env.lp);
     let payer_before = env.eurc.client.balance(&env.payer);
 
-    // Fund
-    env.contract.fund_invoice(&env.lp, &id, &amount);
-    
+    env.contract.fund_invoice(&env.lp, &id, &amount, &false);
+
     let discount = expected_discount(amount);
     assert_eq!(
         env.eurc.client.balance(&env.freelancer) - freelancer_before,
         amount - discount
     );
 
-    // Pay
     env.contract.mark_paid(&id, &amount);
-    
+
     assert_eq!(
         env.eurc.client.balance(&env.lp) - lp_before,
         discount
@@ -335,5 +350,122 @@ fn test_eurc_lifecycle() {
         payer_before - env.eurc.client.balance(&env.payer),
         amount
     );
-    assert_eq!(env.contract.get_invoice(&id).status, InvoiceStatus::Paid);
+    assert_eq!(env.contract.get_invoice(&id).unwrap().status, InvoiceStatus::Paid);
+}
+
+// ================================================================
+// Tests for fee-on-transfer token rejection (Issue #482)
+// ================================================================
+
+#[contract]
+struct FeeOnTransferToken;
+
+#[contractimpl]
+impl FeeOnTransferToken {
+    pub fn initialize(_env: Env, _admin: Address) {}
+
+    pub fn balance(_env: Env, _id: Address) -> i128 {
+        0
+    }
+
+    pub fn transfer(env: Env, from: Address, to: Address, amount: i128) -> Result<i128, ()> {
+        from.require_auth();
+        // Simulate fee-on-transfer: only transfer 99% of the amount
+        let fee = amount / 100;
+        let received = amount - fee;
+
+        // Transfer the reduced amount
+        let token_client = token::Client::new(&env, &env.current_contract_address());
+        token_client.transfer(&from, &to, &received);
+
+        Ok(received)
+    }
+
+    pub fn mint(_env: Env, _to: Address, _amount: i128) {}
+}
+
+#[test]
+fn test_add_token_rejects_fee_on_transfer_token() {
+    let env = Env::default();
+    env.mock_all_auths();
+
+    let admin = Address::generate(&env);
+    let usdc_admin = Address::generate(&env);
+    let usdc_contract_id = env.register_stellar_asset_contract_v2(usdc_admin.clone());
+    let usdc_address = usdc_contract_id.address();
+
+    let eurc_admin = Address::generate(&env);
+    let eurc_contract_id = env.register_stellar_asset_contract_v2(eurc_admin);
+    let eurc_address = eurc_contract_id.address();
+
+    let xlm_admin = Address::generate(&env);
+    let xlm_contract_id = env.register_stellar_asset_contract_v2(xlm_admin);
+    let xlm_address = xlm_contract_id.address();
+
+    let contract_id = env.register_contract(None, InvoiceLiquidityContract);
+    let contract = InvoiceLiquidityContractClient::new(&env, &contract_id);
+    contract.initialize(&admin, &usdc_address, &eurc_address, &xlm_address);
+
+    // Register a fee-on-transfer token
+    let fee_token_admin = Address::generate(&env);
+    let fee_token_contract = env.register_stellar_asset_contract_v2(fee_token_admin.clone());
+    let fee_token_address = fee_token_contract.address();
+
+    // Mint tokens to admin for the test
+    let fee_token_client = TokenClient::new(&env, &fee_token_address);
+    let fee_token_admin_client = StellarAssetClient::new(&env, &fee_token_address);
+    fee_token_admin_client.mint(&admin, &1_000_000);
+
+    // Try to add the fee-on-transfer token
+    let result = contract.try_add_token(&fee_token_address, &6_u32);
+
+    // Should fail with FeeOnTransferToken error
+    assert_eq!(result, Err(Ok(ContractError::FeeOnTransferToken)));
+}
+
+#[test]
+fn test_add_token_normal_token_succeeds() {
+    let env = Env::default();
+    env.mock_all_auths();
+
+    let admin = Address::generate(&env);
+    let usdc_admin = Address::generate(&env);
+    let usdc_contract_id = env.register_stellar_asset_contract_v2(usdc_admin.clone());
+    let usdc_address = usdc_contract_id.address();
+
+    let eurc_admin = Address::generate(&env);
+    let eurc_contract_id = env.register_stellar_asset_contract_v2(eurc_admin);
+    let eurc_address = eurc_contract_id.address();
+
+    let xlm_admin = Address::generate(&env);
+    let xlm_contract_id = env.register_stellar_asset_contract_v2(xlm_admin);
+    let xlm_address = xlm_contract_id.address();
+
+    let contract_id = env.register_contract(None, InvoiceLiquidityContract);
+    let contract = InvoiceLiquidityContractClient::new(&env, &contract_id);
+    contract.initialize(&admin, &usdc_address, &eurc_address, &xlm_address);
+
+    // Register a normal token
+    let normal_token_admin = Address::generate(&env);
+    let normal_token_contract = env.register_stellar_asset_contract_v2(normal_token_admin.clone());
+    let normal_token_address = normal_token_contract.address();
+
+    // Mint tokens to admin for the test
+    let normal_token_client = TokenClient::new(&env, &normal_token_address);
+    let normal_token_admin_client = StellarAssetClient::new(&env, &normal_token_address);
+    normal_token_admin_client.mint(&admin, &1_000_000);
+
+    // Add the normal token - should succeed
+    let result = contract.try_add_token(&normal_token_address, &6_u32);
+    assert!(result.is_ok());
+
+    // Verify token was added
+    let config = contract.get_config().unwrap();
+    // Token should be approved
+    let is_approved: bool = env
+        .storage()
+        .persistent()
+        .get(&crate::storage::DataKey::ApprovedToken(normal_token_address.clone()))
+        .unwrap_or(false);
+    assert!(is_approved);
 }