Merge pull request #122 from NUMBER72857/feat/claim-payout-14

Feat/claim payout 14

Author: jhayniffy

contracts/niffyinsure/src/claim.rs

@@ -1,5 +1,213 @@
-// Claim lifecycle and DAO voting will be implemented here.
-//
-// Planned public functions:
-//   file_claim(env, policy_id, amount, details, image_urls)
-//   vote_on_claim(env, voter, claim_id, vote)
+use crate::{
+    storage,
+    types::{Claim, ClaimProcessed, ClaimStatus},
+    validate::Error,
+};
+use soroban_sdk::{symbol_short, token, Address, Env};
+
+pub fn process_claim(env: &Env, claim_id: u64) -> Result<(), Error> {
+    let mut claim = storage::get_claim(env, claim_id).ok_or(Error::ClaimNotFound)?;
+
+    if claim.status == ClaimStatus::Paid {
+        return Err(Error::AlreadyPaid);
+    }
+    if claim.status != ClaimStatus::Approved {
+        return Err(Error::ClaimNotApproved);
+    }
+    if claim.amount <= 0 {
+        return Err(Error::ClaimAmountZero);
+    }
+    if !is_allowed_asset(env, &claim.asset) {
+        return Err(Error::InvalidAsset);
+    }
+
+    let token_client = token::Client::new(env, &claim.asset);
+    let treasury = treasury_address(env);
+    check_treasury_balance(&token_client, &treasury, claim.amount)?;
+
+    token_client.transfer(&treasury, &claim.claimant, &claim.amount);
+
+    claim.status = ClaimStatus::Paid;
+    claim.paid_at = Some(env.ledger().timestamp());
+    storage::set_claim(env, &claim);
+    emit_claim_processed(env, &claim);
+
+    Ok(())
+}
+
+pub fn get_claim(env: &Env, claim_id: u64) -> Result<Claim, Error> {
+    storage::get_claim(env, claim_id).ok_or(Error::ClaimNotFound)
+}
+
+pub fn is_allowed_asset(env: &Env, asset: &Address) -> bool {
+    storage::is_allowed_asset(env, asset)
+}
+
+pub fn set_allowed_asset(env: &Env, asset: &Address, allowed: bool) {
+    storage::set_allowed_asset(env, asset, allowed);
+}
+
+pub fn treasury_address(env: &Env) -> Address {
+    env.current_contract_address()
+}
+
+fn check_treasury_balance(
+    token_client: &token::Client,
+    treasury: &Address,
+    amount: i128,
+) -> Result<(), Error> {
+    if token_client.balance(treasury) < amount {
+        return Err(Error::InsufficientTreasury);
+    }
+    Ok(())
+}
+
+fn emit_claim_processed(env: &Env, claim: &Claim) {
+    env.events().publish(
+        (symbol_short!("claim_paid"), claim.claim_id),
+        ClaimProcessed {
+            claim_id: claim.claim_id,
+            recipient: claim.claimant.clone(),
+            amount: claim.amount,
+            asset: claim.asset.clone(),
+        },
+    );
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::NiffyInsureClient;
+    use soroban_sdk::{testutils::Address as _, token, Address, Env, String, Vec};
+
+    fn setup() -> (
+        Env,
+        NiffyInsureClient,
+        Address,
+        token::Client,
+        token::StellarAssetClient,
+        Address,
+    ) {
+        let env = Env::default();
+        env.mock_all_auths();
+
+        let contract_id = env.register(crate::NiffyInsure, ());
+        let client = NiffyInsureClient::new(&env, &contract_id);
+
+        let admin = Address::generate(&env);
+        let token_admin = Address::generate(&env);
+        let token_id = env.register_stellar_asset_contract_v2(token_admin.clone()).address();
+        let token_client = token::Client::new(&env, &token_id);
+        let token_admin_client = token::StellarAssetClient::new(&env, &token_id);
+
+        client.initialize(&admin, &token_id);
+
+        (
+            env,
+            client,
+            contract_id,
+            token_client,
+            token_admin_client,
+            token_id,
+        )
+    }
+
+    fn approved_claim(
+        env: &Env,
+        claimant: &Address,
+        asset: &Address,
+        amount: i128,
+    ) -> Claim {
+        Claim {
+            claim_id: 1,
+            policy_id: 7,
+            claimant: claimant.clone(),
+            amount,
+            asset: asset.clone(),
+            details: String::from_str(env, "approved fire claim"),
+            image_urls: Vec::new(env),
+            status: ClaimStatus::Approved,
+            approve_votes: 2,
+            reject_votes: 0,
+            paid_at: None,
+        }
+    }
+
+    #[test]
+    fn process_claim_transfers_tokens_and_marks_claim_paid() {
+        let (env, client, contract_id, token_client, token_admin_client, token_id) = setup();
+        let claimant = Address::generate(&env);
+        let treasury = contract_id.clone();
+        let claim = approved_claim(&env, &claimant, &token_id, 5_000);
+
+        token_admin_client.mint(&treasury, &10_000);
+        storage::set_claim(&env, &claim);
+
+        let before_events = env.events().all().len();
+        client.process_claim(&claim.claim_id);
+
+        let stored = client.get_claim(&claim.claim_id);
+        assert_eq!(token_client.balance(&treasury), 5_000);
+        assert_eq!(token_client.balance(&claimant), 5_000);
+        assert_eq!(stored.status, ClaimStatus::Paid);
+        assert!(stored.paid_at.is_some());
+        assert!(env.events().all().len() > before_events);
+    }
+
+    #[test]
+    fn process_claim_reverts_when_treasury_is_short() {
+        let (env, client, contract_id, token_client, token_admin_client, token_id) = setup();
+        let claimant = Address::generate(&env);
+        let treasury = contract_id.clone();
+        let claim = approved_claim(&env, &claimant, &token_id, 5_000);
+
+        token_admin_client.mint(&treasury, &1_000);
+        storage::set_claim(&env, &claim);
+
+        let result = client.try_process_claim(&claim.claim_id);
+        assert!(result.is_err());
+
+        let stored = client.get_claim(&claim.claim_id);
+        assert_eq!(stored.status, ClaimStatus::Approved);
+        assert_eq!(stored.paid_at, None);
+        assert_eq!(token_client.balance(&treasury), 1_000);
+        assert_eq!(token_client.balance(&claimant), 0);
+    }
+
+    #[test]
+    fn process_claim_is_idempotent() {
+        let (env, client, contract_id, _token_client, token_admin_client, token_id) = setup();
+        let claimant = Address::generate(&env);
+        let treasury = contract_id.clone();
+        let claim = approved_claim(&env, &claimant, &token_id, 5_000);
+
+        token_admin_client.mint(&treasury, &10_000);
+        storage::set_claim(&env, &claim);
+
+        client.process_claim(&claim.claim_id);
+        let second = client.try_process_claim(&claim.claim_id);
+        assert!(second.is_err());
+        assert_eq!(client.get_claim(&claim.claim_id).status, ClaimStatus::Paid);
+    }
+
+    #[test]
+    fn process_claim_rejects_assets_outside_the_allowlist() {
+        let (env, client, contract_id, token_client, token_admin_client, _token_id) = setup();
+        let claimant = Address::generate(&env);
+        let treasury = contract_id.clone();
+
+        let other_admin = Address::generate(&env);
+        let other_asset = env
+            .register_stellar_asset_contract_v2(other_admin.clone())
+            .address();
+        let claim = approved_claim(&env, &claimant, &other_asset, 5_000);
+
+        token_admin_client.mint(&treasury, &10_000);
+        storage::set_claim(&env, &claim);
+
+        let result = client.try_process_claim(&claim.claim_id);
+        assert!(result.is_err());
+        assert_eq!(client.get_claim(&claim.claim_id).status, ClaimStatus::Approved);
+        assert_eq!(token_client.balance(&treasury), 10_000);
+    }
+}

contracts/niffyinsure/src/lib.rs

@@ -2,7 +2,11 @@
 
 mod claim;
 mod policy;
+<<<<<<< feat/claim-payout-14
+pub mod premium;
+=======
 mod premium;
+>>>>>>> main
 mod storage;
 mod token;
 pub mod types;
@@ -15,58 +19,114 @@ pub struct NiffyInsure;
 
 #[contractimpl]
 impl NiffyInsure {
-    /// One-time initialisation: store admin and token contract address.
-    /// Must be called immediately after deployment.
+    /// One-time initialisation: store admin and token contract address, and
+    /// seed the default premium table so quote generation is deterministic.
     pub fn initialize(env: Env, admin: Address, token: Address) {
         storage::set_admin(&env, &admin);
         storage::set_token(&env, &token);
+        storage::set_multiplier_table(&env, &premium::default_multiplier_table(&env));
+        storage::set_allowed_asset(&env, &token, true);
     }
 
     /// Pure quote path: reads config and computes premium only.
     /// This entrypoint intentionally performs no persistent writes.
     pub fn generate_premium(
         env: Env,
-        policy_type: types::PolicyType,
-        region: types::RegionTier,
-        age: u32,
-        risk_score: u32,
+        input: types::RiskInput,
+        base_amount: i128,
         include_breakdown: bool,
-    ) -> Result<types::PremiumQuote, policy::QuoteError> {
-        policy::generate_premium(
-            &env,
-            policy_type,
-            region,
-            age,
-            risk_score,
-            include_breakdown,
-        )
-    }
-
-    /// Converts quote failure codes to support-friendly messages for API layers.
+    ) -> Result<types::PremiumQuote, validate::Error> {
+        policy::generate_premium(&env, input, base_amount, include_breakdown)
+    }
+
     pub fn quote_error_message(env: Env, code: u32) -> policy::QuoteFailure {
         let err = match code {
-            1 => policy::QuoteError::InvalidAge,
-            2 => policy::QuoteError::InvalidRiskScore,
-            3 => policy::QuoteError::InvalidQuoteTtl,
-            _ => policy::QuoteError::ArithmeticOverflow,
+            1 => validate::Error::ZeroCoverage,
+            2 => validate::Error::ZeroPremium,
+            3 => validate::Error::InvalidLedgerWindow,
+            4 => validate::Error::PolicyExpired,
+            5 => validate::Error::PolicyInactive,
+            6 => validate::Error::ClaimAmountZero,
+            7 => validate::Error::ClaimExceedsCoverage,
+            8 => validate::Error::DetailsTooLong,
+            9 => validate::Error::TooManyImageUrls,
+            10 => validate::Error::ImageUrlTooLong,
+            11 => validate::Error::ReasonTooLong,
+            12 => validate::Error::ClaimAlreadyTerminal,
+            13 => validate::Error::DuplicateVote,
+            14 => validate::Error::InvalidBaseAmount,
+            15 => validate::Error::SafetyScoreOutOfRange,
+            16 => validate::Error::InvalidConfigVersion,
+            17 => validate::Error::MissingRegionMultiplier,
+            18 => validate::Error::MissingAgeMultiplier,
+            19 => validate::Error::MissingCoverageMultiplier,
+            20 => validate::Error::RegionMultiplierOutOfBounds,
+            21 => validate::Error::AgeMultiplierOutOfBounds,
+            22 => validate::Error::CoverageMultiplierOutOfBounds,
+            23 => validate::Error::SafetyDiscountOutOfBounds,
+            24 => validate::Error::Overflow,
+            25 => validate::Error::DivideByZero,
+            26 => validate::Error::InvalidQuoteTtl,
+            27 => validate::Error::NegativePremiumNotSupported,
+            28 => validate::Error::ClaimNotFound,
+            29 => validate::Error::InvalidAsset,
+            30 => validate::Error::InsufficientTreasury,
+            31 => validate::Error::AlreadyPaid,
+            _ => validate::Error::ClaimNotApproved,
         };
         policy::map_quote_error(&env, err)
     }
 
-    /// Read-only helper for monitoring state in tests / ops tooling.
+    pub fn update_multiplier_table(
+        env: Env,
+        new_table: types::MultiplierTable,
+    ) -> Result<(), validate::Error> {
+        let admin = storage::get_admin(&env);
+        admin.require_auth();
+        premium::update_multiplier_table(&env, &new_table)
+    }
+
+    pub fn get_multiplier_table(env: Env) -> types::MultiplierTable {
+        storage::get_multiplier_table(&env)
+    }
+
+    pub fn set_allowed_asset(
+        env: Env,
+        asset: Address,
+        allowed: bool,
+    ) {
+        let admin = storage::get_admin(&env);
+        admin.require_auth();
+        claim::set_allowed_asset(&env, &asset, allowed);
+    }
+
+    pub fn is_allowed_asset(env: Env, asset: Address) -> bool {
+        claim::is_allowed_asset(&env, &asset)
+    }
+
+    pub fn process_claim(env: Env, claim_id: u64) -> Result<(), validate::Error> {
+        let admin = storage::get_admin(&env);
+        admin.require_auth();
+        claim::process_claim(&env, claim_id)
+    }
+
+    pub fn get_claim(env: Env, claim_id: u64) -> Result<types::Claim, validate::Error> {
+        claim::get_claim(&env, claim_id)
+    }
+
     pub fn get_claim_counter(env: Env) -> u64 {
         storage::get_claim_counter(&env)
     }
 
-    /// Read-only helper for monitoring state in tests / ops tooling.
     pub fn get_policy_counter(env: Env, holder: Address) -> u32 {
         storage::get_policy_counter(&env, &holder)
     }
 
-    /// Read-only helper for monitoring state in tests / ops tooling.
     pub fn has_policy(env: Env, holder: Address, policy_id: u32) -> bool {
         storage::has_policy(&env, &holder, policy_id)
     }
+<<<<<<< feat/claim-payout-14
+=======
 
     // ── Policy domain ────────────────────────────────────────────────────
 
@@ -128,4 +188,5 @@ impl NiffyInsure {
     // ── Admin / treasury ─────────────────────────────────────────────────
     // drain
     // implemented in token.rs — issue: feat/admin
+>>>>>>> main
 }