lib.rs

#![cfg_attr(not(feature = "std"), no_std, no_main)]
#![allow(
    clippy::arithmetic_side_effects,
    clippy::cast_possible_truncation,
    clippy::cast_sign_loss,
    clippy::needless_borrows_for_generic_args
)]

use ink::storage::Mapping;

mod status_packing;

#[ink::contract]
mod propchain_lending {
    use ink::prelude::string::String;
    use ink::prelude::vec::Vec;

    use super::*;

    #[derive(Debug, PartialEq, Eq, scale::Encode, scale::Decode)]
    #[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
    pub enum LendingError {
        Unauthorized,
        PropertyNotFound,
        InsufficientCollateral,
        LoanNotFound,
        LoanNotActive,
        PoolNotFound,
        InsufficientLiquidity,
        PositionNotFound,
        LiquidationThresholdNotMet,
        InvalidParameters,
        ProposalNotFound,
        RestructuringNotFound,
        InsufficientVotes,
        ServicerNotFound,
        PaymentScheduleNotFound,
        ReentrantCall,
        // Admin key rotation (Issue #496)
        KeyRotationCooldown,
        KeyRotationExpired,
        NoPendingRotation,
        RotationUnauthorized,
        RequestExpired,
    }

    impl From<propchain_traits::ReentrancyError> for LendingError {
        fn from(_: propchain_traits::ReentrancyError) -> Self {
            LendingError::ReentrantCall
        }
    }

    #[derive(
        Debug, Clone, PartialEq, scale::Encode, scale::Decode, ink::storage::traits::StorageLayout,
    )]
    #[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
    pub struct CollateralRecord {
        pub property_id: u64,
        pub assessed_value: u128,
        pub ltv_ratio: u32,
        pub liquidation_threshold: u32,
    }

    #[derive(
        Debug, Clone, PartialEq, scale::Encode, scale::Decode, ink::storage::traits::StorageLayout,
    )]
    #[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
    pub struct LendingPool {
        pub pool_id: u64,
        pub total_deposits: u128,
        pub total_borrows: u128,
        pub base_rate: u32,
    }

    #[derive(
        Debug, Clone, PartialEq, scale::Encode, scale::Decode, ink::storage::traits::StorageLayout,
    )]
    #[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
    pub struct MarginPosition {
        pub position_id: u64,
        pub owner: AccountId,
        pub collateral: u128,
        pub leverage: u32,
        pub is_short: bool,
        pub entry_price: u128,
    }

    #[derive(
        Debug,
        Clone,
        Copy,
        PartialEq,
        Eq,
        scale::Encode,
        scale::Decode,
        ink::storage::traits::StorageLayout,
    )]
    #[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
    pub enum LoanStatus {
        Pending,
        Active,
        Repaid,
        Defaulted,
        RestructuringProposed,
        Restructured,
        Liquidated,
    }

    #[derive(
        Debug,
        Clone,
        Copy,
        PartialEq,
        Eq,
        scale::Encode,
        scale::Decode,
        ink::storage::traits::StorageLayout,
    )]
    #[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
    pub enum CollateralKind {
        Unsecured,
        PropertyTokenized,
    }

    #[derive(
        Debug,
        Clone,
        Copy,
        PartialEq,
        Eq,
        scale::Encode,
        scale::Decode,
        ink::storage::traits::StorageLayout,
    )]
    #[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
    pub enum LoanType {
        Variable,
        FixedRate,
    }

    #[derive(
        Debug, Clone, PartialEq, scale::Encode, scale::Decode, ink::storage::traits::StorageLayout,
    )]
    #[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
    pub struct LoanApplication {
        pub loan_id: u64,
        pub applicant: AccountId,
        pub property_id: u64,
        pub requested_amount: u128,
        pub collateral_value: u128,
        pub credit_score: u32,
        pub approved: bool,
        pub servicer_id: Option<u64>,
        pub servicing_reference: String,
        pub servicing_status: String,
        pub collateral_kind: CollateralKind,
        pub term_months: u32,
        pub interest_rate_bps: u32,
        pub loan_type: LoanType,
        pub start_block: Option<u64>,
        pub status: LoanStatus,
        pub accrued_interest: u128,
        pub last_interest_timestamp: u64,
    }

    /// SCALE-footprint-compact representation of `LoanApplication` (Issue #738).
    ///
    /// `bool approved`, the two `String` fields, and the two `Option<u64>`
    /// fields are folded into a single `u32 status_flags` plus packed payload
    /// fields. The two enum-valued fields `LoanType` and `CollateralKind`
    /// collapse to single bytes. The two `String`s become `Vec<u8>`, which
    /// has the same SCALE width as `String` (compact-length prefix + bytes)
    /// but is a no_std-friendly representation that does not require UTF-8
    /// validity enforcement on round-trip.
    #[derive(scale::Encode, scale::Decode)]
    #[cfg_attr(
        feature = "std",
        derive(scale_info::TypeInfo, Debug, Clone, PartialEq, Eq)
    )]
    pub struct PackedLoanApplication {
        pub loan_id: u64,
        pub applicant: AccountId,
        pub property_id: u64,
        pub requested_amount: u128,
        pub collateral_value: u128,
        pub credit_score: u32,
        pub accrued_interest: u128,
        pub last_interest_timestamp: u64,
        pub term_months: u32,
        pub interest_rate_bps: u32,
        pub status_flags: u32,
        pub servicer_id_packed: u64,
        pub start_block_packed: u64,
        pub status_tag: u8,
        pub servicing_reference: Vec<u8>,
        pub servicing_status: Vec<u8>,
    }

    impl From<LoanApplication> for PackedLoanApplication {
        fn from(src: LoanApplication) -> Self {
            use super::status_packing::*;
            let mut flags: u32 = 0;
            if src.approved {
                flags |= FLAG_APPROVED;
            }
            if src.servicer_id.is_some() {
                flags |= FLAG_HAS_SERVICER_ID;
            }
            if src.start_block.is_some() {
                flags |= FLAG_HAS_START_BLOCK;
            }
            if matches!(src.loan_type, LoanType::FixedRate) {
                flags |= FLAG_LOAN_TYPE_FIXED_RATE;
            }
            if matches!(src.collateral_kind, CollateralKind::PropertyTokenized) {
                flags |= FLAG_COLLATERAL_PROPERTY_TOKENIZED;
            }
            let status_tag = match src.status {
                LoanStatus::Pending => STATUS_PENDING,
                LoanStatus::Active => STATUS_ACTIVE,
                LoanStatus::Repaid => STATUS_REPAID,
                LoanStatus::Defaulted => STATUS_DEFAULTED,
                LoanStatus::RestructuringProposed => STATUS_RESTRUCTURING_PROPOSED,
                LoanStatus::Restructured => STATUS_RESTRUCTURED,
                LoanStatus::Liquidated => STATUS_LIQUIDATED,
            };
            PackedLoanApplication {
                loan_id: src.loan_id,
                applicant: src.applicant,
                property_id: src.property_id,
                requested_amount: src.requested_amount,
                collateral_value: src.collateral_value,
                credit_score: src.credit_score,
                accrued_interest: src.accrued_interest,
                last_interest_timestamp: src.last_interest_timestamp,
                term_months: src.term_months,
                interest_rate_bps: src.interest_rate_bps,
                status_flags: flags,
                servicer_id_packed: src.servicer_id.unwrap_or(0),
                start_block_packed: src.start_block.unwrap_or(0),
                status_tag,
                servicing_reference: src.servicing_reference.into_bytes(),
                servicing_status: src.servicing_status.into_bytes(),
            }
        }
    }

    impl From<PackedLoanApplication> for LoanApplication {
        fn from(src: PackedLoanApplication) -> Self {
            use super::status_packing::*;
            LoanApplication {
                loan_id: src.loan_id,
                applicant: src.applicant,
                property_id: src.property_id,
                requested_amount: src.requested_amount,
                collateral_value: src.collateral_value,
                credit_score: src.credit_score,
                approved: (src.status_flags & FLAG_APPROVED) != 0,
                servicer_id: if (src.status_flags & FLAG_HAS_SERVICER_ID) != 0 {
                    Some(src.servicer_id_packed)
                } else {
                    None
                },
                servicing_reference: String::from_utf8(src.servicing_reference).unwrap_or_default(),
                servicing_status: String::from_utf8(src.servicing_status).unwrap_or_default(),
                collateral_kind: if (src.status_flags & FLAG_COLLATERAL_PROPERTY_TOKENIZED) != 0 {
                    CollateralKind::PropertyTokenized
                } else {
                    CollateralKind::Unsecured
                },
                term_months: src.term_months,
                interest_rate_bps: src.interest_rate_bps,
                loan_type: if (src.status_flags & FLAG_LOAN_TYPE_FIXED_RATE) != 0 {
                    LoanType::FixedRate
                } else {
                    LoanType::Variable
                },
                start_block: if (src.status_flags & FLAG_HAS_START_BLOCK) != 0 {
                    Some(src.start_block_packed)
                } else {
                    None
                },
                status: match src.status_tag {
                    STATUS_PENDING => LoanStatus::Pending,
                    STATUS_ACTIVE => LoanStatus::Active,
                    STATUS_REPAID => LoanStatus::Repaid,
                    STATUS_DEFAULTED => LoanStatus::Defaulted,
                    STATUS_RESTRUCTURING_PROPOSED => LoanStatus::RestructuringProposed,
                    STATUS_RESTRUCTURED => LoanStatus::Restructured,
                    _ => LoanStatus::Liquidated,
                },
                accrued_interest: src.accrued_interest,
                last_interest_timestamp: src.last_interest_timestamp,
            }
        }
    }

    #[derive(
        Debug, Clone, PartialEq, scale::Encode, scale::Decode, ink::storage::traits::StorageLayout,
    )]
    #[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
    pub struct LoanServicer {
        pub servicer_id: u64,
        pub account: AccountId,
        pub name: String,
        pub active: bool,
        pub collateral_kind: CollateralKind,
        pub term_months: u32,
        pub interest_rate_bps: u32,
        pub status: LoanStatus,
        pub loan_type: LoanType,
        pub start_block: Option<u64>,
    }

    // ── #829: Variable amortization schedules ────────────────────────────────

    /// The repayment schedule type for a loan.
    #[derive(
        Debug,
        Clone,
        Copy,
        PartialEq,
        Eq,
        scale::Encode,
        scale::Decode,
        ink::storage::traits::StorageLayout,
    )]
    #[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
    pub enum Schedule {
        /// Single lump-sum repayment at maturity (principal + all interest).
        Bullet,
        /// Equal total payments each period (principal portion grows over time).
        Annuity,
        /// Equal principal payments each period (descending total outlay).
        Linear,
        /// User-defined custom schedule parameters.
        Custom {
            /// Custom number of installments.
            num_installments: u32,
            /// Custom interval between payments (blocks).
            interval_blocks: u64,
            /// Custom principal per installment (0 = computed from total).
            principal_per_payment: u128,
        },
    }

    impl Schedule {
        /// Compute the per-period installment amount given total principal,
        /// interest rate (bps), term months, and blocks per period.
        pub fn installment(
            &self,
            principal: u128,
            rate_bps: u32,
            term_months: u32,
            interval_blocks: u64,
        ) -> u128 {
            match self {
                Schedule::Bullet => principal, // full principal at end
                Schedule::Annuity => {
                    // Simplified annuity: equal total payments each period.
                    // per_period_rate = rate_bps * interval_blocks / (5_256_000 * 10_000)
                    let n = (term_months as u64 * 432_000u64)
                        .checked_div(interval_blocks.max(1))
                        .unwrap_or(1) as u128;
                    if n == 0 {
                        return principal;
                    }
                    let per_period_rate_numer =
                        (rate_bps as u128).saturating_mul(interval_blocks as u128);
                    let per_period_rate_denom = 52_560_000_000u128; // 5_256_000 * 10_000
                    let interest = principal
                        .saturating_mul(per_period_rate_numer)
                        .checked_div(per_period_rate_denom)
                        .unwrap_or(0);
                    let base = principal / n;
                    base.saturating_add(interest)
                }
                Schedule::Linear => {
                    let n = (term_months as u64 * 432_000u64)
                        .checked_div(interval_blocks.max(1))
                        .unwrap_or(1) as u128;
                    if n == 0 {
                        return principal;
                    }
                    // Equal principal + declining interest
                    let per_period_principal = principal / n;
                    let per_period_rate_numer =
                        (rate_bps as u128).saturating_mul(interval_blocks as u128);
                    let per_period_rate_denom = 52_560_000_000u128; // 5_256_000 * 10_000
                    let interest_first = principal
                        .saturating_mul(per_period_rate_numer)
                        .checked_div(per_period_rate_denom)
                        .unwrap_or(0);
                    per_period_principal.saturating_add(interest_first)
                }
                Schedule::Custom {
                    principal_per_payment,
                    ..
                } => {
                    if *principal_per_payment > 0 {
                        *principal_per_payment
                    } else {
                        let n = (term_months as u64 * 432_000u64)
                            .checked_div(interval_blocks.max(1))
                            .unwrap_or(1) as u128;
                        principal.checked_div(n).unwrap_or(principal)
                    }
                }
            }
        }
    }

    #[derive(
        Debug,
        Clone,
        PartialEq,
        Eq,
        scale::Encode,
        scale::Decode,
        ink::storage::traits::StorageLayout,
    )]
    #[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
    pub enum PaymentScheduleStatus {
        Active,
        Completed,
        Defaulted,
    }

    #[derive(
        Debug, Clone, PartialEq, scale::Encode, scale::Decode, ink::storage::traits::StorageLayout,
    )]
    #[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
    pub struct PaymentSchedule {
        pub schedule_id: u64,
        pub loan_id: u64,
        pub borrower: AccountId,
        pub schedule_type: Schedule,
        pub principal_due: u128,
        pub interest_due: u128,
        pub installment_amount: u128,
        pub total_installments: u32,
        pub installments_paid: u32,
        pub first_due_block: u64,
        pub interval_blocks: u64,
        pub next_due_block: u64,
        pub total_paid: u128,
        pub status: PaymentScheduleStatus,
    }

    #[derive(
        Debug, Clone, PartialEq, scale::Encode, scale::Decode, ink::storage::traits::StorageLayout,
    )]
    #[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
    pub struct LoanRestructuring {
        pub loan_id: u64,
        pub proposed_by: AccountId,
        pub proposed_term_months: u32,
        pub proposed_interest_rate_bps: u32,
        pub borrower_approved: bool,
        pub lender_approved: bool,
    }
    #[derive(
        Debug, Clone, PartialEq, scale::Encode, scale::Decode, ink::storage::traits::StorageLayout,
    )]
    #[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
    pub struct YieldPosition {
        pub owner: AccountId,
        pub staked: u128,
        pub reward_debt: u128,
        pub accumulated_rewards: u128,
    }

    #[derive(
        Debug, Clone, PartialEq, scale::Encode, scale::Decode, ink::storage::traits::StorageLayout,
    )]
    #[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
    pub struct Proposal {
        pub proposal_id: u64,
        pub description: String,
        pub votes_for: u64,
        pub votes_against: u64,
        pub executed: bool,
    }

    /// On-chain credit history for a borrower.
    ///
    /// Score formula (0–1000):
    ///   base 500
    ///   + repayments_on_time * 20   (capped at +300)
    ///   - defaults * 150            (capped at -450)
    ///   - active_loans * 10         (capped at -100)
    #[derive(
        Debug, Clone, PartialEq, scale::Encode, scale::Decode, ink::storage::traits::StorageLayout,
    )]
    #[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
    pub struct CreditProfile {
        pub repayments_on_time: u32,
        pub defaults: u32,
        pub active_loans: u32,
        pub total_borrowed: u128,
    }

    // ── #304: Loan Marketplace types ─────────────────────────────────────────

    /// Status of a loan marketplace listing.
    #[derive(
        Debug,
        Clone,
        Copy,
        PartialEq,
        Eq,
        scale::Encode,
        scale::Decode,
        ink::storage::traits::StorageLayout,
    )]
    #[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
    pub enum ListingStatus {
        /// Awaiting bids from lenders.
        Open,
        /// An offer has been accepted; origination in progress.
        OfferAccepted,
        /// Loan originated successfully.
        Originated,
        /// Listing withdrawn by the borrower.
        Cancelled,
    }

    pub type TokenId = u64;

    /// A borrower's public loan request listed on the marketplace (#304).
    #[derive(
        Debug, Clone, PartialEq, scale::Encode, scale::Decode, ink::storage::traits::StorageLayout,
    )]
    #[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
    pub struct LoanListing {
        pub listing_id: u64,
        pub borrower: AccountId,
        pub property_id: u64,
        pub requested_amount: u128,
        /// Maximum interest rate the borrower is willing to pay (basis points).
        pub max_rate_bps: u32,
        pub term_months: u32,
        pub collateral_kind: CollateralKind,
        /// Multi-token collateral basket: (token_id, amount) pairs (#827).
        pub collateral_basket: Vec<(TokenId, u128)>,
        pub status: ListingStatus,
        pub created_at: u64,
        /// ID of the accepted offer, if any.
        pub accepted_offer_id: Option<u64>,
    }

    /// A lender's counter-offer in response to a marketplace listing (#304).
    #[derive(
        Debug, Clone, PartialEq, scale::Encode, scale::Decode, ink::storage::traits::StorageLayout,
    )]
    #[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
    pub struct LoanOffer {
        pub offer_id: u64,
        pub listing_id: u64,
        pub lender: AccountId,
        pub offered_amount: u128,
        /// Interest rate offered by the lender (basis points).
        pub rate_bps: u32,
        pub term_months: u32,
        pub is_accepted: bool,
        pub created_at: u64,
    }

    #[ink(storage)]
    pub struct PropertyLending {
        admin: AccountId,
        collateral_records: Mapping<u64, CollateralRecord>,
        pools: Mapping<u64, LendingPool>,
        pool_count: u64,
        margin_positions: Mapping<u64, MarginPosition>,
        position_count: u64,
        loan_applications: Mapping<u64, LoanApplication>,
        borrower_loans: Mapping<AccountId, Vec<u64>>,
        loan_restructurings: Mapping<u64, LoanRestructuring>,
        loan_count: u64,
        loan_servicers: Mapping<u64, LoanServicer>,
        servicer_count: u64,
        payment_schedules: Mapping<u64, PaymentSchedule>,
        loan_payment_schedule: Mapping<u64, u64>,
        schedule_count: u64,
        yield_positions: Mapping<AccountId, YieldPosition>,
        total_staked: u128,
        reward_per_block: u128,
        proposals: Mapping<u64, Proposal>,
        proposal_count: u64,
        credit_profiles: Mapping<AccountId, CreditProfile>,
        reentrancy_guard: propchain_traits::ReentrancyGuard,
        // #304: Loan Marketplace
        marketplace_listings: Mapping<u64, LoanListing>,
        marketplace_offers: Mapping<u64, LoanOffer>,
        listing_count: u64,
        offer_count: u64,
        // #588: Multi-collateral portfolio mapping loan_id -> property_ids
        pub loan_collaterals: Mapping<u64, Vec<u64>>,
        // Admin Key Rotation (Issue #496)
        pending_admin_rotation: Option<propchain_traits::KeyRotationRequest>,
    }

    #[ink(event)]
    pub struct CollateralAssessed {
        #[ink(topic)]
        property_id: u64,
        assessed_value: u128,
        ltv_ratio: u32,
    }

    #[ink(event)]
    pub struct PoolCreated {
        #[ink(topic)]
        pool_id: u64,
        base_rate: u32,
    }

    #[ink(event)]
    pub struct PositionOpened {
        #[ink(topic)]
        position_id: u64,
        #[ink(topic)]
        owner: AccountId,
        collateral: u128,
    }

    #[ink(event)]
    pub struct LoanApproved {
        #[ink(topic)]
        loan_id: u64,
        #[ink(topic)]
        applicant: AccountId,
        amount: u128,
    }

    #[ink(event)]
    pub struct LoanServicerRegistered {
        #[ink(topic)]
        servicer_id: u64,
        #[ink(topic)]
        account: AccountId,
        name: String,
    }

    #[ink(event)]
    pub struct LoanServicerAssigned {
        #[ink(topic)]
        loan_id: u64,
        #[ink(topic)]
        servicer_id: u64,
        external_reference: String,
    }

    #[ink(event)]
    pub struct LoanServicingStatusUpdated {
        #[ink(topic)]
        loan_id: u64,
        status: String,
    }

    #[ink(event)]
    pub struct LoanRestructuringProposed {
        #[ink(topic)]
        loan_id: u64,
        #[ink(topic)]
        proposer: AccountId,
        new_term_months: u32,
        new_interest_rate_bps: u32,
    }

    #[ink(event)]
    pub struct LoanRestructured {
        #[ink(topic)]
        loan_id: u64,
        new_term_months: u32,
        new_interest_rate_bps: u32,
    }

    #[ink(event)]
    pub struct LoanLiquidated {
        #[ink(topic)]
        loan_id: u64,
        #[ink(topic)]
        borrower: AccountId,
        collateral_seized: u128,
    }

    #[ink(event)]
    pub struct ProposalCreated {
        #[ink(topic)]
        proposal_id: u64,
        description: String,
    }

    // ── #304: Loan Marketplace events ────────────────────────────────────────

    #[ink(event)]
    pub struct LoanListingCreated {
        #[ink(topic)]
        pub listing_id: u64,
        #[ink(topic)]
        pub borrower: AccountId,
        pub requested_amount: u128,
        pub max_rate_bps: u32,
    }

    #[ink(event)]
    pub struct LoanOfferSubmitted {
        #[ink(topic)]
        pub offer_id: u64,
        #[ink(topic)]
        pub listing_id: u64,
        #[ink(topic)]
        pub lender: AccountId,
        pub rate_bps: u32,
    }

    #[ink(event)]
    pub struct LoanOfferAccepted {
        #[ink(topic)]
        pub listing_id: u64,
        #[ink(topic)]
        pub offer_id: u64,
        pub loan_id: u64,
    }

    #[ink(event)]
    pub struct LoanListingCancelled {
        #[ink(topic)]
        pub listing_id: u64,
        #[ink(topic)]
        pub borrower: AccountId,
    }

    // ── Admin Key Rotation Events (Issue #496) ────────────────────────────────

    #[ink(event)]
    pub struct AdminRotationRequested {
        #[ink(topic)]
        old_admin: AccountId,
        #[ink(topic)]
        new_admin: AccountId,
        effective_at_block: u32,
    }

    #[ink(event)]
    pub struct AdminRotationConfirmed {
        #[ink(topic)]
        old_admin: AccountId,
        #[ink(topic)]
        new_admin: AccountId,
    }

    #[ink(event)]
    pub struct AdminRotationCancelled {
        #[ink(topic)]
        old_admin: AccountId,
        cancelled_by: AccountId,
    }

    impl PropertyLending {
        #[ink(constructor)]
        pub fn new(admin: AccountId) -> Self {
            Self {
                admin,
                collateral_records: Mapping::default(),
                pools: Mapping::default(),
                pool_count: 0,
                margin_positions: Mapping::default(),
                position_count: 0,
                loan_applications: Mapping::default(),
                borrower_loans: Mapping::default(),
                loan_restructurings: Mapping::default(),
                loan_count: 0,
                loan_servicers: Mapping::default(),
                servicer_count: 0,
                payment_schedules: Mapping::default(),
                loan_payment_schedule: Mapping::default(),
                schedule_count: 0,
                yield_positions: Mapping::default(),
                total_staked: 0,
                reward_per_block: 100,
                proposals: Mapping::default(),
                proposal_count: 0,
                credit_profiles: Mapping::default(),
                reentrancy_guard: propchain_traits::ReentrancyGuard::new(),
                // #304: Loan Marketplace
                marketplace_listings: Mapping::default(),
                marketplace_offers: Mapping::default(),
                listing_count: 0,
                offer_count: 0,
                loan_collaterals: Mapping::default(),
                // Admin Key Rotation (Issue #496)
                pending_admin_rotation: None,
            }
        }

        #[ink(message)]
        pub fn assess_collateral(
            &mut self,
            property_id: u64,
            value: u128,
            ltv: u32,
            liq_threshold: u32,
        ) -> Result<(), LendingError> {
            if self.env().caller() != self.admin {
                return Err(LendingError::Unauthorized);
            }
            let record = CollateralRecord {
                property_id,
                assessed_value: value,
                ltv_ratio: ltv,
                liquidation_threshold: liq_threshold,
            };
            self.collateral_records.insert(property_id, &record);
            self.env().emit_event(CollateralAssessed {
                property_id,
                assessed_value: value,
                ltv_ratio: ltv,
            });
            Ok(())
        }

        #[ink(message)]
        pub fn should_liquidate(&self, property_id: u64, current_value: u128) -> bool {
            if let Some(r) = self.collateral_records.get(property_id) {
                let ratio = (r.assessed_value * 10000) / current_value.max(1);
                ratio > r.liquidation_threshold as u128
            } else {
                false
            }
        }

        #[ink(message)]
        pub fn should_liquidate_loan(
            &self,
            loan_id: u64,
            current_collateral_values: Vec<(u64, u128)>,
        ) -> Result<bool, LendingError> {
            let app = self
                .loan_applications
                .get(loan_id)
                .ok_or(LendingError::LoanNotFound)?;
            if app.status != LoanStatus::Active {
                return Ok(false);
            }

            let collaterals = self.loan_collaterals.get(loan_id).unwrap_or_default();
            if collaterals.is_empty() {
                if let Some(record) = self.collateral_records.get(app.property_id) {
                    let current = current_collateral_values
                        .iter()
                        .find(|(id, _)| *id == app.property_id)
                        .map(|(_, v)| *v)
                        .unwrap_or(record.assessed_value);
                    let ratio = (record.assessed_value * 10000) / current.max(1);
                    return Ok(ratio > record.liquidation_threshold as u128);
                }
                return Ok(false);
            }

            let total_debt = app.requested_amount.saturating_add(app.accrued_interest);
            let mut total_current_value: u128 = 0;
            let mut weighted_threshold_sum: u128 = 0;
            let mut total_assessed: u128 = 0;

            for &pid in &collaterals {
                let record = self
                    .collateral_records
                    .get(pid)
                    .ok_or(LendingError::PropertyNotFound)?;
                total_assessed = total_assessed.saturating_add(record.assessed_value);
                weighted_threshold_sum = weighted_threshold_sum.saturating_add(
                    record
                        .assessed_value
                        .saturating_mul(record.liquidation_threshold as u128),
                );
                let current_val = current_collateral_values
                    .iter()
                    .find(|(id, _)| *id == pid)
                    .map(|(_, v)| *v)
                    .unwrap_or(record.assessed_value);
                total_current_value = total_current_value.saturating_add(current_val);
            }

            let effective_threshold = weighted_threshold_sum
                .checked_div(total_assessed)
                .unwrap_or(0);

            let current_ltv = (total_debt * 10000) / total_current_value.max(1);
            Ok(current_ltv > effective_threshold)
        }

        #[ink(message)]
        pub fn create_pool(&mut self, base_rate: u32) -> Result<u64, LendingError> {
            if self.env().caller() != self.admin {
                return Err(LendingError::Unauthorized);
            }
            self.pool_count += 1;
            let pool = LendingPool {
                pool_id: self.pool_count,
                total_deposits: 0,
                total_borrows: 0,
                base_rate,
            };
            self.pools.insert(self.pool_count, &pool);
            self.env().emit_event(PoolCreated {
                pool_id: self.pool_count,
                base_rate,
            });
            Ok(self.pool_count)
        }

        #[ink(message)]
        pub fn deposit(&mut self, pool_id: u64, amount: u128) -> Result<(), LendingError> {
            propchain_traits::non_reentrant!(self, {
                let mut pool = self.pools.get(pool_id).ok_or(LendingError::PoolNotFound)?;
                pool.total_deposits += amount;
                self.pools.insert(pool_id, &pool);
                Ok(())
            })
        }

        #[ink(message)]
        pub fn borrow(&mut self, pool_id: u64, amount: u128) -> Result<(), LendingError> {
            propchain_traits::non_reentrant!(self, {
                let mut pool = self.pools.get(pool_id).ok_or(LendingError::PoolNotFound)?;
                if pool.total_deposits < pool.total_borrows + amount {
                    return Err(LendingError::InsufficientLiquidity);
                }
                pool.total_borrows += amount;
                self.pools.insert(pool_id, &pool);
                Ok(())
            })
        }

        #[ink(message)]
        pub fn borrow_rate(&self, pool_id: u64) -> Result<u32, LendingError> {
            let pool = self.pools.get(pool_id).ok_or(LendingError::PoolNotFound)?;
            let utilisation = (pool.total_borrows * 10000)
                .checked_div(pool.total_deposits)
                .unwrap_or(0);
            Ok(pool.base_rate + (utilisation / 50) as u32)
        }

        #[ink(message)]
        pub fn open_position(
            &mut self,
            collateral: u128,
            leverage: u32,
            short: bool,
            price: u128,
        ) -> Result<u64, LendingError> {
            self.position_count += 1;
            let pos = MarginPosition {
                position_id: self.position_count,
                owner: self.env().caller(),
                collateral,
                leverage,
                is_short: short,
                entry_price: price,
            };
            self.margin_positions.insert(self.position_count, &pos);
            self.env().emit_event(PositionOpened {
                position_id: self.position_count,
                owner: self.env().caller(),
                collateral,
            });
            Ok(self.position_count)
        }

        #[ink(message)]
        pub fn position_pnl(
            &self,
            position_id: u64,
            current_price: u128,
        ) -> Result<i128, LendingError> {
            let pos = self
                .margin_positions
                .get(position_id)
                .ok_or(LendingError::PositionNotFound)?;
            let delta = current_price as i128 - pos.entry_price as i128;
            let signed = if pos.is_short { -delta } else { delta };
            Ok((signed * pos.leverage as i128) / 100)
        }

        #[ink(message)]
        pub fn apply_for_loan(
            &mut self,
            property_id: u64,
            requested_amount: u128,
            collateral_value: u128,
            credit_score: u32,
        ) -> Result<u64, LendingError> {
            self.apply_for_loan_with_terms(
                property_id,
                requested_amount,
                collateral_value,
                credit_score,
                12,
                800,
            )
        }

        #[ink(message)]
        pub fn apply_for_fixed_rate_loan(
            &mut self,
            property_id: u64,
            requested_amount: u128,
            collateral_value: u128,
            credit_score: u32,
            term_months: u32,
            interest_rate_bps: u32,
        ) -> Result<u64, LendingError> {
            if requested_amount == 0
                || collateral_value == 0
                || term_months == 0
                || interest_rate_bps == 0
            {
                return Err(LendingError::InvalidParameters);
            }
            self.loan_count += 1;
            let app = LoanApplication {
                loan_id: self.loan_count,
                applicant: self.env().caller(),
                property_id,
                requested_amount,
                collateral_value,
                credit_score,
                approved: false,
                servicer_id: None,
                servicing_reference: String::new(),
                servicing_status: String::from("Pending"),
                collateral_kind: CollateralKind::Unsecured,
                term_months,
                interest_rate_bps,
                loan_type: LoanType::FixedRate,
                start_block: None,
                status: LoanStatus::Pending,
                accrued_interest: 0,
                last_interest_timestamp: 0,
            };
            self.loan_applications.insert(self.loan_count, &app);
            self.track_borrower_loan(app.applicant, self.loan_count);
            Ok(self.loan_count)
        }

        #[ink(message)]
        pub fn apply_for_loan_with_terms(
            &mut self,
            property_id: u64,
            requested_amount: u128,
            collateral_value: u128,
            credit_score: u32,
            term_months: u32,
            interest_rate_bps: u32,
        ) -> Result<u64, LendingError> {
            if requested_amount == 0
                || collateral_value == 0
                || term_months == 0
                || interest_rate_bps == 0
            {
                return Err(LendingError::InvalidParameters);
            }
            self.loan_count += 1;
            let app = LoanApplication {
                loan_id: self.loan_count,
                applicant: self.env().caller(),
                property_id,
                requested_amount,
                collateral_value,
                credit_score,
                approved: false,
                servicer_id: None,
                servicing_reference: String::new(),
                servicing_status: String::from("Pending"),
                collateral_kind: CollateralKind::Unsecured,
                term_months,
                interest_rate_bps,
                loan_type: LoanType::Variable,
                start_block: None,
                status: LoanStatus::Pending,
                accrued_interest: 0,
                last_interest_timestamp: 0,
            };
            self.loan_applications.insert(self.loan_count, &app);
            self.track_borrower_loan(app.applicant, self.loan_count);
            Ok(self.loan_count)
        }

        #[ink(message)]
        pub fn apply_for_property_backed_loan(
            &mut self,
            property_id: u64,
            requested_amount: u128,
            credit_score: u32,
            term_months: u32,
            interest_rate_bps: u32,
        ) -> Result<u64, LendingError> {
            let record = self
                .collateral_records
                .get(property_id)
                .ok_or(LendingError::PropertyNotFound)?;
            let max_borrow = (record.assessed_value * record.ltv_ratio as u128) / 10000;
            if requested_amount == 0
                || term_months == 0
                || interest_rate_bps == 0
                || requested_amount > max_borrow
            {
                return Err(LendingError::InsufficientCollateral);
            }

            self.loan_count += 1;
            let app = LoanApplication {
                loan_id: self.loan_count,
                applicant: self.env().caller(),
                property_id,
                requested_amount,
                collateral_value: record.assessed_value,
                credit_score,
                approved: false,
                servicer_id: None,
                servicing_reference: String::new(),
                servicing_status: String::from("Pending"),
                collateral_kind: CollateralKind::PropertyTokenized,
                term_months,
                interest_rate_bps,
                loan_type: LoanType::Variable,
                start_block: None,
                status: LoanStatus::Pending,
                accrued_interest: 0,
                last_interest_timestamp: 0,
            };
            self.loan_applications.insert(self.loan_count, &app);
            self.loan_collaterals
                .insert(self.loan_count, &vec![property_id]);
            self.track_borrower_loan(app.applicant, self.loan_count);
            Ok(self.loan_count)
        }

        #[ink(message)]
        pub fn underwrite_loan(&mut self, loan_id: u64) -> Result<bool, LendingError> {
            if self.env().caller() != self.admin {
                return Err(LendingError::Unauthorized);
            }
            let mut app = self
                .loan_applications
                .get(loan_id)
                .ok_or(LendingError::LoanNotFound)?;
            let ltv = (app.requested_amount * 10000) / app.collateral_value.max(1);
            let score = self.get_credit_score(app.applicant);
            // Store the computed score on the application for reference
            app.credit_score = score;
            let approved = score >= 600 && ltv <= 7500;
            app.status = if approved {
                // Track the new active loan in the borrower's credit profile
                let mut profile =
                    self.credit_profiles
                        .get(app.applicant)
                        .unwrap_or(CreditProfile {
                            repayments_on_time: 0,
                            defaults: 0,
                            active_loans: 0,
                            total_borrowed: 0,
                        });
                profile.active_loans = profile.active_loans.saturating_add(1);
                profile.total_borrowed =
                    profile.total_borrowed.saturating_add(app.requested_amount);
                self.credit_profiles.insert(app.applicant, &profile);
                app.accrued_interest = 0;
                app.last_interest_timestamp = self.env().block_timestamp();
                LoanStatus::Active
            } else {
                LoanStatus::Pending
            };
            self.loan_applications.insert(loan_id, &app);
            if approved {
                self.env().emit_event(LoanApproved {
                    loan_id,
                    applicant: app.applicant,
                    amount: app.requested_amount,
                });
            }
            Ok(approved)
        }

        #[ink(message)]
        pub fn register_loan_servicer(
            &mut self,
            account: AccountId,
            name: String,
        ) -> Result<u64, LendingError> {
            if self.env().caller() != self.admin {
                return Err(LendingError::Unauthorized);
            }
            if name.is_empty() {
                return Err(LendingError::InvalidParameters);
            }
            self.servicer_count += 1;
            let servicer = LoanServicer {
                servicer_id: self.servicer_count,
                account,
                name: name.clone(),
                active: true,
                collateral_kind: CollateralKind::Unsecured,
                term_months: 0,
                interest_rate_bps: 0,
                status: LoanStatus::Active,
                loan_type: LoanType::FixedRate,
                start_block: None,
            };
            self.loan_servicers.insert(self.servicer_count, &servicer);
            self.env().emit_event(LoanServicerRegistered {
                servicer_id: self.servicer_count,
                account,
                name,
            });
            Ok(self.servicer_count)
        }

        #[ink(message)]
        pub fn set_loan_servicer_active(
            &mut self,
            servicer_id: u64,
            active: bool,
        ) -> Result<(), LendingError> {
            if self.env().caller() != self.admin {
                return Err(LendingError::Unauthorized);
            }
            let mut servicer = self
                .loan_servicers
                .get(servicer_id)
                .ok_or(LendingError::ServicerNotFound)?;
            servicer.active = active;
            self.loan_servicers.insert(servicer_id, &servicer);
            Ok(())
        }

        #[ink(message)]
        pub fn assign_loan_servicer(
            &mut self,
            loan_id: u64,
            servicer_id: u64,
            external_reference: String,
        ) -> Result<(), LendingError> {
            if self.env().caller() != self.admin {
                return Err(LendingError::Unauthorized);
            }
            if external_reference.is_empty() {
                return Err(LendingError::InvalidParameters);
            }
            let servicer = self
                .loan_servicers
                .get(servicer_id)
                .ok_or(LendingError::ServicerNotFound)?;
            if !servicer.active {
                return Err(LendingError::InvalidParameters);
            }
            let mut loan = self
                .loan_applications
                .get(loan_id)
                .ok_or(LendingError::LoanNotFound)?;
            loan.servicer_id = Some(servicer_id);
            loan.servicing_reference = external_reference.clone();
            loan.servicing_status = String::from("Boarded");
            self.loan_applications.insert(loan_id, &loan);
            self.env().emit_event(LoanServicerAssigned {
                loan_id,
                servicer_id,
                external_reference,
            });
            Ok(())
        }

        /// Create a payment schedule for a loan with a specified schedule type (#829).
        #[ink(message)]
        pub fn create_payment_schedule(
            &mut self,
            loan_id: u64,
            schedule_type: Schedule,
            interval_blocks: u64,
        ) -> Result<u64, LendingError> {
            let caller = self.env().caller();
            let loan = self
                .loan_applications
                .get(loan_id)
                .ok_or(LendingError::LoanNotFound)?;

            if caller != self.admin && caller != loan.applicant {
                return Err(LendingError::Unauthorized);
            }
            if interval_blocks == 0 {
                return Err(LendingError::InvalidParameters);
            }

            // Calculate installment amount based on schedule type
            let installment = schedule_type.installment(
                loan.requested_amount,
                loan.interest_rate_bps,
                loan.term_months,
                interval_blocks,
            );

            let total_blocks = loan.term_months as u64 * 432_000;
            let total_installments = (total_blocks / interval_blocks) as u32;
            let now = self.env().block_number() as u64;

            self.schedule_count += 1;
            let schedule = PaymentSchedule {
                schedule_id: self.schedule_count,
                loan_id,
                borrower: loan.applicant,
                schedule_type,
                principal_due: loan.requested_amount,
                interest_due: 0,
                installment_amount: installment,
                total_installments: total_installments.max(1),
                installments_paid: 0,
                first_due_block: now.saturating_add(interval_blocks),
                interval_blocks,
                next_due_block: now.saturating_add(interval_blocks),
                total_paid: 0,
                status: PaymentScheduleStatus::Active,
            };
            self.payment_schedules
                .insert(self.schedule_count, &schedule);
            self.loan_payment_schedule
                .insert(loan_id, &self.schedule_count);
            Ok(self.schedule_count)
        }

        /// Get the payment schedule for a loan.
        #[ink(message)]
        pub fn get_payment_schedule_by_loan(&self, loan_id: u64) -> Option<PaymentSchedule> {
            let schedule_id = self.loan_payment_schedule.get(loan_id)?;
            self.payment_schedules.get(schedule_id)
        }

        #[ink(message)]
        pub fn propose_loan_restructuring(
            &mut self,
            loan_id: u64,
            new_term_months: u32,
            new_interest_rate_bps: u32,
        ) -> Result<(), LendingError> {
            let caller = self.env().caller();
            if new_term_months == 0 || new_interest_rate_bps == 0 {
                return Err(LendingError::InvalidParameters);
            }

            let mut app = self
                .loan_applications
                .get(loan_id)
                .ok_or(LendingError::LoanNotFound)?;
            if app.status != LoanStatus::Active && app.status != LoanStatus::Restructured {
                return Err(LendingError::LoanNotActive);
            }
            if caller != app.applicant && caller != self.admin {
                return Err(LendingError::Unauthorized);
            }

            let restructuring = LoanRestructuring {
                loan_id,
                proposed_by: caller,
                proposed_term_months: new_term_months,
                proposed_interest_rate_bps: new_interest_rate_bps,
                borrower_approved: caller == app.applicant,
                lender_approved: caller == self.admin,
            };
            app.status = LoanStatus::RestructuringProposed;
            self.loan_applications.insert(loan_id, &app);
            self.loan_restructurings.insert(loan_id, &restructuring);
            self.env().emit_event(LoanRestructuringProposed {
                loan_id,
                proposer: caller,
                new_term_months,
                new_interest_rate_bps,
            });
            Ok(())
        }

        #[ink(message)]
        pub fn update_servicing_status(
            &mut self,
            loan_id: u64,
            status: String,
        ) -> Result<(), LendingError> {
            let mut loan = self
                .loan_applications
                .get(loan_id)
                .ok_or(LendingError::LoanNotFound)?;
            let servicer_id = loan.servicer_id.ok_or(LendingError::ServicerNotFound)?;
            let servicer = self
                .loan_servicers
                .get(servicer_id)
                .ok_or(LendingError::ServicerNotFound)?;
            let caller = self.env().caller();
            if caller != self.admin && caller != servicer.account {
                return Err(LendingError::Unauthorized);
            }
            if status.is_empty() {
                return Err(LendingError::InvalidParameters);
            }
            self.update_interest_snapshot(loan_id)?;
            loan.servicing_status = status.clone();
            self.loan_applications.insert(loan_id, &loan);
            self.env()
                .emit_event(LoanServicingStatusUpdated { loan_id, status });
            Ok(())
        }

        #[ink(message)]
        pub fn pledge_additional_collateral(
            &mut self,
            loan_id: u64,
            property_id: u64,
        ) -> Result<(), LendingError> {
            let record = self
                .collateral_records
                .get(property_id)
                .ok_or(LendingError::PropertyNotFound)?;
            let mut collaterals = self.loan_collaterals.get(loan_id).unwrap_or_default();
            if !collaterals.contains(&property_id) {
                collaterals.push(property_id);
                self.loan_collaterals.insert(loan_id, &collaterals);
            }
            self.env().emit_event(CollateralAssessed {
                property_id,
                assessed_value: record.assessed_value,
                ltv_ratio: record.ltv_ratio,
            });
            Ok(())
        }

        #[ink(message)]
        pub fn approve_loan_restructuring(&mut self, loan_id: u64) -> Result<bool, LendingError> {
            let caller = self.env().caller();
            let mut app = self
                .loan_applications
                .get(loan_id)
                .ok_or(LendingError::LoanNotFound)?;
            let mut restructuring = self
                .loan_restructurings
                .get(loan_id)
                .ok_or(LendingError::RestructuringNotFound)?;

            if caller == app.applicant {
                restructuring.borrower_approved = true;
            } else if caller == self.admin {
                restructuring.lender_approved = true;
            } else {
                return Err(LendingError::Unauthorized);
            }

            let approved = restructuring.borrower_approved && restructuring.lender_approved;
            if approved {
                self.update_interest_snapshot(loan_id)?;
                // TODO(#lending-jit-stale-write): reload `app` from storage
                // after update_interest_snapshot so we don't overwrite the
                // freshly-accrued interest with the stale in-memory copy.
                app.term_months = restructuring.proposed_term_months;
                app.interest_rate_bps = restructuring.proposed_interest_rate_bps;
                app.status = LoanStatus::Restructured;
                app.last_interest_timestamp = self.env().block_timestamp();
                self.loan_applications.insert(loan_id, &app);
                self.loan_restructurings.remove(loan_id);
                self.env().emit_event(LoanRestructured {
                    loan_id,
                    new_term_months: app.term_months,
                    new_interest_rate_bps: app.interest_rate_bps,
                });
            } else {
                self.loan_restructurings.insert(loan_id, &restructuring);
                self.loan_applications.insert(loan_id, &app);
            }

            Ok(approved)
        }

        #[ink(message)]
        pub fn liquidate_loan(
            &mut self,
            loan_id: u64,
            current_collateral_values: Vec<(u64, u128)>,
        ) -> Result<(), LendingError> {
            let mut app = self
                .loan_applications
                .get(loan_id)
                .ok_or(LendingError::LoanNotFound)?;

            if app.status != LoanStatus::Active {
                return Err(LendingError::LoanNotActive);
            }

            self.update_interest_snapshot(loan_id)?;

            let collaterals = self.loan_collaterals.get(loan_id).unwrap_or_default();
            if collaterals.is_empty() && app.property_id != 0 {
                let fallback = vec![app.property_id];
                self.loan_collaterals.insert(loan_id, &fallback);
            }

            let current_collaterals = self.loan_collaterals.get(loan_id).unwrap_or_default();

            let total_debt = app.requested_amount.saturating_add(app.accrued_interest);
            let mut total_current_value: u128 = 0;
            let mut total_assessed_value: u128 = 0;
            let mut weighted_liquidation_threshold: u128 = 0;

            for &pid in &current_collaterals {
                let record = self
                    .collateral_records
                    .get(pid)
                    .ok_or(LendingError::PropertyNotFound)?;
                total_assessed_value = total_assessed_value.saturating_add(record.assessed_value);
                weighted_liquidation_threshold = weighted_liquidation_threshold.saturating_add(
                    record
                        .assessed_value
                        .saturating_mul(record.liquidation_threshold as u128),
                );
                let current_val = current_collateral_values
                    .iter()
                    .find(|(id, _)| *id == pid)
                    .map(|(_, v)| *v)
                    .unwrap_or(record.assessed_value);
                total_current_value = total_current_value.saturating_add(current_val);
            }

            let effective_threshold = weighted_liquidation_threshold
                .checked_div(total_assessed_value)
                .ok_or(LendingError::InsufficientCollateral)?;

            let current_ltv = (total_debt * 10000) / total_current_value.max(1);
            let health_factor_drops = current_ltv > effective_threshold;

            let mut is_expired = false;
            if app.loan_type == LoanType::FixedRate {
                if let Some(start) = app.start_block {
                    let term_blocks = app.term_months as u64 * 432_000;
                    if (self.env().block_number() as u64) > start + term_blocks {
                        is_expired = true;
                    }
                }
            }

            if !health_factor_drops && !is_expired {
                return Err(LendingError::LiquidationThresholdNotMet);
            }

            app.status = LoanStatus::Liquidated;
            self.loan_applications.insert(loan_id, &app);

            self.env().emit_event(LoanLiquidated {
                loan_id,
                borrower: app.applicant,
                collateral_seized: app.collateral_value,
            });

            Ok(())
        }

        #[ink(message)]
        pub fn stake(&mut self, amount: u128) -> Result<(), LendingError> {
            let caller = self.env().caller();
            let mut pos = self.yield_positions.get(caller).unwrap_or(YieldPosition {
                owner: caller,
                staked: 0,
                reward_debt: 0,
                accumulated_rewards: 0,
            });
            pos.staked += amount;
            self.yield_positions.insert(caller, &pos);
            self.total_staked += amount;
            Ok(())
        }

        #[ink(message)]
        pub fn pending_rewards(&self, owner: AccountId, current_block: u64) -> u128 {
            if let Some(p) = self.yield_positions.get(owner) {
                if self.total_staked == 0 {
                    return 0;
                }
                let per_share = (self.reward_per_block * current_block as u128) / self.total_staked;
                p.staked * per_share - p.reward_debt
            } else {
                0
            }
        }

        #[ink(message)]
        pub fn propose(&mut self, description: String) -> Result<u64, LendingError> {
            self.proposal_count += 1;
            let prop = Proposal {
                proposal_id: self.proposal_count,
                description: description.clone(),
                votes_for: 0,
                votes_against: 0,
                executed: false,
            };
            self.proposals.insert(self.proposal_count, &prop);
            self.env().emit_event(ProposalCreated {
                proposal_id: self.proposal_count,
                description,
            });
            Ok(self.proposal_count)
        }

        #[ink(message)]
        pub fn vote(&mut self, proposal_id: u64, in_favour: bool) -> Result<(), LendingError> {
            let mut prop = self
                .proposals
                .get(proposal_id)
                .ok_or(LendingError::ProposalNotFound)?;
            if in_favour {
                prop.votes_for += 1;
            } else {
                prop.votes_against += 1;
            }
            self.proposals.insert(proposal_id, &prop);
            Ok(())
        }

        #[ink(message)]
        pub fn execute_proposal(&mut self, proposal_id: u64) -> Result<bool, LendingError> {
            let mut prop = self
                .proposals
                .get(proposal_id)
                .ok_or(LendingError::ProposalNotFound)?;
            if prop.votes_for > prop.votes_against && !prop.executed {
                prop.executed = true;
                self.proposals.insert(proposal_id, &prop);
                Ok(true)
            } else {
                Ok(false)
            }
        }

        /// Compute a 0–1000 credit score from a borrower's on-chain profile.
        fn compute_credit_score(profile: &CreditProfile) -> u32 {
            let base: u32 = 500;
            let repayment_bonus = (profile.repayments_on_time * 20).min(300);
            let default_penalty = (profile.defaults * 150).min(450);
            let loan_penalty = (profile.active_loans * 10).min(100);
            base.saturating_add(repayment_bonus)
                .saturating_sub(default_penalty)
                .saturating_sub(loan_penalty)
        }

        /// Record a successful on-time repayment for the caller.
        /// Only callable by the contract admin (e.g. after verifying payment).
        #[ink(message)]
        pub fn record_repayment(&mut self, borrower: AccountId) -> Result<(), LendingError> {
            if self.env().caller() != self.admin {
                return Err(LendingError::Unauthorized);
            }
            let mut profile = self.credit_profiles.get(borrower).unwrap_or(CreditProfile {
                repayments_on_time: 0,
                defaults: 0,
                active_loans: 0,
                total_borrowed: 0,
            });
            profile.repayments_on_time = profile.repayments_on_time.saturating_add(1);
            if profile.active_loans > 0 {
                profile.active_loans -= 1;
            }
            self.credit_profiles.insert(borrower, &profile);
            Ok(())
        }

        /// Record a default event for a borrower.
        /// Only callable by the contract admin.
        #[ink(message)]
        pub fn record_default(&mut self, borrower: AccountId) -> Result<(), LendingError> {
            if self.env().caller() != self.admin {
                return Err(LendingError::Unauthorized);
            }
            let mut profile = self.credit_profiles.get(borrower).unwrap_or(CreditProfile {
                repayments_on_time: 0,
                defaults: 0,
                active_loans: 0,
                total_borrowed: 0,
            });
            profile.defaults = profile.defaults.saturating_add(1);
            if profile.active_loans > 0 {
                profile.active_loans -= 1;
            }
            self.credit_profiles.insert(borrower, &profile);
            Ok(())
        }

        /// Return the computed credit score (0–1000) for a borrower.
        #[ink(message)]
        pub fn get_credit_score(&self, borrower: AccountId) -> u32 {
            let profile = self.credit_profiles.get(borrower).unwrap_or(CreditProfile {
                repayments_on_time: 0,
                defaults: 0,
                active_loans: 0,
                total_borrowed: 0,
            });
            Self::compute_credit_score(&profile)
        }

        #[ink(message)]
        pub fn get_pool(&self, pool_id: u64) -> Option<LendingPool> {
            self.pools.get(pool_id)
        }

        #[ink(message)]
        pub fn get_collateral(&self, property_id: u64) -> Option<CollateralRecord> {
            self.collateral_records.get(property_id)
        }

        #[ink(message)]
        pub fn get_position(&self, position_id: u64) -> Option<MarginPosition> {
            self.margin_positions.get(position_id)
        }

        #[ink(message)]
        pub fn get_loan(&self, loan_id: u64) -> Option<LoanApplication> {
            self.loan_applications.get(loan_id)
        }

        #[ink(message)]
        pub fn get_loan_servicer(&self, servicer_id: u64) -> Option<LoanServicer> {
            self.loan_servicers.get(servicer_id)
        }

        // ── #304: Loan Marketplace ────────────────────────────────────────────

        /// Create a new loan listing on the marketplace (#304).
        ///
        /// Any borrower can list their loan request with an optional multi-token
        /// collateral basket (#827). Lenders can then submit competing offers
        /// via `submit_loan_offer`.
        #[ink(message)]
        pub fn create_loan_listing(
            &mut self,
            property_id: u64,
            requested_amount: u128,
            max_rate_bps: u32,
            term_months: u32,
            collateral_kind: CollateralKind,
            // Multi-token collateral basket: (token_id, amount) pairs (#827).
            collateral_basket: Vec<(TokenId, u128)>,
        ) -> Result<u64, LendingError> {
            if requested_amount == 0 || max_rate_bps == 0 || term_months == 0 {
                return Err(LendingError::InvalidParameters);
            }

            let borrower = self.env().caller();
            let listing_id = self.listing_count + 1;

            let listing = LoanListing {
                listing_id,
                borrower,
                property_id,
                requested_amount,
                max_rate_bps,
                term_months,
                collateral_kind,
                collateral_basket,
                status: ListingStatus::Open,
                created_at: self.env().block_number() as u64,
                accepted_offer_id: None,
            };

            self.marketplace_listings.insert(listing_id, &listing);
            self.listing_count = listing_id;

            self.env().emit_event(LoanListingCreated {
                listing_id,
                borrower,
                requested_amount,
                max_rate_bps,
            });

            Ok(listing_id)
        }

        /// Submit a lending offer against an open listing (#304).
        ///
        /// The lender specifies the rate and amount they are willing to offer.
        /// The rate must be at or below the borrower's stated maximum.
        #[ink(message)]
        pub fn submit_loan_offer(
            &mut self,
            listing_id: u64,
            offered_amount: u128,
            rate_bps: u32,
            term_months: u32,
        ) -> Result<u64, LendingError> {
            let listing = self
                .marketplace_listings
                .get(listing_id)
                .ok_or(LendingError::LoanNotFound)?;

            if !matches!(listing.status, ListingStatus::Open) {
                return Err(LendingError::LoanNotActive);
            }

            // Offer rate must not exceed borrower's maximum
            if rate_bps > listing.max_rate_bps {
                return Err(LendingError::InvalidParameters);
            }

            if offered_amount == 0 || term_months == 0 {
                return Err(LendingError::InvalidParameters);
            }

            let lender = self.env().caller();
            let offer_id = self.offer_count + 1;

            let offer = LoanOffer {
                offer_id,
                listing_id,
                lender,
                offered_amount,
                rate_bps,
                term_months,
                is_accepted: false,
                created_at: self.env().block_number() as u64,
            };

            self.marketplace_offers.insert(offer_id, &offer);
            self.offer_count = offer_id;

            self.env().emit_event(LoanOfferSubmitted {
                offer_id,
                listing_id,
                lender,
                rate_bps,
            });

            Ok(offer_id)
        }

        /// Borrower accepts a lender's offer and originates the loan (#304).
        ///
        /// Accepting an offer transitions the listing to `OfferAccepted`, creates
        /// the underlying `LoanApplication`, and marks the listing as `Originated`.
        #[ink(message)]
        pub fn accept_loan_offer(&mut self, offer_id: u64) -> Result<u64, LendingError> {
            let mut offer = self
                .marketplace_offers
                .get(offer_id)
                .ok_or(LendingError::LoanNotFound)?;

            let mut listing = self
                .marketplace_listings
                .get(offer.listing_id)
                .ok_or(LendingError::LoanNotFound)?;

            let borrower = self.env().caller();
            if listing.borrower != borrower {
                return Err(LendingError::Unauthorized);
            }

            if !matches!(listing.status, ListingStatus::Open) {
                return Err(LendingError::LoanNotActive);
            }

            if offer.is_accepted {
                return Err(LendingError::InvalidParameters);
            }

            // Originate the underlying loan application
            let loan_id = self.loan_count + 1;
            let loan = LoanApplication {
                loan_id,
                applicant: borrower,
                property_id: listing.property_id,
                requested_amount: offer.offered_amount,
                collateral_value: offer.offered_amount,
                credit_score: self.get_credit_score(borrower),
                approved: true,
                servicer_id: None,
                servicing_reference: String::new(),
                servicing_status: String::from("marketplace_originated"),
                collateral_kind: listing.collateral_kind,
                term_months: offer.term_months,
                interest_rate_bps: offer.rate_bps,
                loan_type: LoanType::Variable,
                start_block: None,
                status: LoanStatus::Active,
                accrued_interest: 0,
                last_interest_timestamp: self.env().block_timestamp(),
            };

            self.loan_applications.insert(loan_id, &loan);
            self.loan_count = loan_id;

            // Update offer and listing state
            offer.is_accepted = true;
            listing.status = ListingStatus::Originated;
            listing.accepted_offer_id = Some(offer_id);

            self.marketplace_offers.insert(offer_id, &offer);
            self.marketplace_listings
                .insert(listing.listing_id, &listing);

            self.env().emit_event(LoanOfferAccepted {
                listing_id: offer.listing_id,
                offer_id,
                loan_id,
            });

            Ok(loan_id)
        }

        /// Borrower cancels an open listing (#304).
        #[ink(message)]
        pub fn cancel_loan_listing(&mut self, listing_id: u64) -> Result<(), LendingError> {
            let mut listing = self
                .marketplace_listings
                .get(listing_id)
                .ok_or(LendingError::LoanNotFound)?;

            if listing.borrower != self.env().caller() {
                return Err(LendingError::Unauthorized);
            }

            if !matches!(listing.status, ListingStatus::Open) {
                return Err(LendingError::LoanNotActive);
            }

            listing.status = ListingStatus::Cancelled;
            self.marketplace_listings.insert(listing_id, &listing);

            self.env().emit_event(LoanListingCancelled {
                listing_id,
                borrower: listing.borrower,
            });

            Ok(())
        }

        /// Get a marketplace listing by ID (#304).
        #[ink(message)]
        pub fn get_loan_listing(&self, listing_id: u64) -> Option<LoanListing> {
            self.marketplace_listings.get(listing_id)
        }

        /// Get a lender offer by ID (#304).
        #[ink(message)]
        pub fn get_loan_offer(&self, offer_id: u64) -> Option<LoanOffer> {
            self.marketplace_offers.get(offer_id)
        }

        #[ink(message)]
        pub fn get_loan_restructuring(&self, loan_id: u64) -> Option<LoanRestructuring> {
            self.loan_restructurings.get(loan_id)
        }

        #[ink(message)]
        pub fn get_proposal(&self, proposal_id: u64) -> Option<Proposal> {
            self.proposals.get(proposal_id)
        }

        #[ink(message)]
        pub fn get_admin(&self) -> AccountId {
            self.admin
        }

        // ── Admin Key Rotation (Issue #496) ──────────────────────────────────

        /// Initiate two-step admin rotation with timelock cooldown.
        ///
        /// Only the current admin may call this. The nominated `new_admin` must
        /// confirm after `KEY_ROTATION_COOLDOWN_BLOCKS` blocks have elapsed.
        #[ink(message)]
        pub fn request_admin_rotation(&mut self, new_admin: AccountId) -> Result<(), LendingError> {
            let caller = self.env().caller();
            if caller != self.admin {
                return Err(LendingError::Unauthorized);
            }
            if self.pending_admin_rotation.is_some() {
                return Err(LendingError::KeyRotationCooldown);
            }

            let block = self.env().block_number();
            let effective_at =
                block.saturating_add(propchain_traits::constants::KEY_ROTATION_COOLDOWN_BLOCKS);

            self.pending_admin_rotation = Some(propchain_traits::KeyRotationRequest {
                old_account: caller,
                new_account: new_admin,
                requested_at: block,
                effective_at,
                confirmed: false,
            });

            self.env().emit_event(AdminRotationRequested {
                old_admin: caller,
                new_admin,
                effective_at_block: effective_at,
            });
            Ok(())
        }

        /// Confirm a pending admin rotation after the cooldown period.
        ///
        /// Must be called by the nominated new admin.
        #[ink(message)]
        pub fn confirm_admin_rotation(&mut self) -> Result<(), LendingError> {
            let caller = self.env().caller();
            let block = self.env().block_number();

            let request = self
                .pending_admin_rotation
                .as_ref()
                .ok_or(LendingError::NoPendingRotation)?;

            if request.new_account != caller {
                return Err(LendingError::RotationUnauthorized);
            }
            if block < request.effective_at {
                return Err(LendingError::KeyRotationCooldown);
            }
            let expiry = request
                .effective_at
                .saturating_add(propchain_traits::constants::KEY_ROTATION_EXPIRY_BLOCKS);
            if block > expiry {
                self.pending_admin_rotation = None;
                return Err(LendingError::RequestExpired);
            }

            let old_admin = request.old_account;
            self.admin = caller;
            self.pending_admin_rotation = None;

            self.env().emit_event(AdminRotationConfirmed {
                old_admin,
                new_admin: caller,
            });
            Ok(())
        }

        /// Cancel a pending admin rotation.
        ///
        /// Either the current admin or the nominated new admin may cancel.
        #[ink(message)]
        pub fn cancel_admin_rotation(&mut self) -> Result<(), LendingError> {
            let caller = self.env().caller();
            let request = self
                .pending_admin_rotation
                .as_ref()
                .ok_or(LendingError::NoPendingRotation)?;

            if caller != request.old_account && caller != request.new_account {
                return Err(LendingError::RotationUnauthorized);
            }

            let old_admin = request.old_account;
            self.pending_admin_rotation = None;

            self.env().emit_event(AdminRotationCancelled {
                old_admin,
                cancelled_by: caller,
            });
            Ok(())
        }

        /// Get the pending admin rotation request, if any.
        #[ink(message)]
        pub fn get_pending_admin_rotation(&self) -> Option<propchain_traits::KeyRotationRequest> {
            self.pending_admin_rotation.clone()
        }

        /// Return the current health status of this contract.
        #[ink(message)]
        pub fn health(&self) -> propchain_traits::monitoring::HealthReport {
            let total_operations = self.loan_count.saturating_add(self.pool_count);
            let error_rate_bips = 0u32; // Lending contract doesn't track error rate directly

            propchain_traits::monitoring::HealthReport {
                contract_name: String::from("lending"),
                status: propchain_traits::monitoring::HealthStatus::Healthy,
                reported_at: self.env().block_timestamp(),
                total_operations,
                error_count: 0,
                error_rate_bips,
                is_accepting_calls: true,
            }
        }

        fn track_borrower_loan(&mut self, borrower: AccountId, loan_id: u64) {
            let mut loan_ids = self.borrower_loans.get(borrower).unwrap_or_default();
            loan_ids.push(loan_id);
            self.borrower_loans.insert(borrower, &loan_ids);
        }

        fn compute_accrued_interest(principal: u128, rate_bps: u32, elapsed_seconds: u64) -> u128 {
            if principal == 0 || rate_bps == 0 || elapsed_seconds == 0 {
                return 0;
            }
            principal
                .saturating_mul(rate_bps as u128)
                .saturating_mul(elapsed_seconds as u128)
                / 10000u128
                / 31_536_000u128
        }

        fn update_interest_snapshot(&mut self, loan_id: u64) -> Result<(), LendingError> {
            let mut loan = self
                .loan_applications
                .get(loan_id)
                .ok_or(LendingError::LoanNotFound)?;

            if loan.last_interest_timestamp == 0 {
                loan.last_interest_timestamp = self.env().block_timestamp();
                self.loan_applications.insert(loan_id, &loan);
                return Ok(());
            }

            let current_timestamp = self.env().block_timestamp();
            if current_timestamp <= loan.last_interest_timestamp {
                return Ok(());
            }

            let accrued = Self::compute_accrued_interest(
                loan.requested_amount,
                loan.interest_rate_bps,
                current_timestamp.saturating_sub(loan.last_interest_timestamp),
            );
            loan.accrued_interest = loan.accrued_interest.saturating_add(accrued);
            loan.last_interest_timestamp = current_timestamp;
            self.loan_applications.insert(loan_id, &loan);
            Ok(())
        }
    }

    impl Default for PropertyLending {
        fn default() -> Self {
            Self::new(AccountId::from([0x0; 32]))
        }
    }
}

pub use crate::propchain_lending::{
    LendingError, LoanServicer, LoanStatus, PaymentSchedule, PaymentScheduleStatus, PropertyLending,
};

/// Core unit tests for the [`PropertyLending`] contract.
///
/// Covers the full lifecycle of lending operations: collateral assessment,
/// pool management, margin positions, loan application and underwriting,
/// servicer integration, loan restructuring, multi-collateral pledging,
/// yield farming, on-chain governance proposals, and credit-score
/// computation.  Extend this module when adding new contract messages or
/// when a bug fix requires a regression guard.
#[cfg(test)]
mod tests {
    use ink::env::{test, DefaultEnvironment};
    use propchain_lending::PropertyLending;

    use super::*;

    fn setup() -> PropertyLending {
        let accounts = test::default_accounts::<DefaultEnvironment>();
        test::set_caller::<DefaultEnvironment>(accounts.alice);
        PropertyLending::new(accounts.alice)
    }

    #[ink::test]
    fn test_assess_collateral() {
        let mut contract = setup();
        assert!(contract
            .assess_collateral(1, 1_000_000, 7500, 12000)
            .is_ok());
        let record = contract.get_collateral(1).unwrap();
        assert_eq!(record.assessed_value, 1_000_000);
    }

    #[ink::test]
    fn test_liquidation_trigger() {
        let mut contract = setup();
        contract
            .assess_collateral(1, 1_000_000, 7500, 12000)
            .unwrap();
        assert!(contract.should_liquidate(1, 800_000));
        assert!(!contract.should_liquidate(1, 1_000_000));
    }

    #[ink::test]
    fn test_create_pool() {
        let mut contract = setup();
        let pool_id = contract.create_pool(500).unwrap();
        assert_eq!(pool_id, 1);
        let pool = contract.get_pool(1).unwrap();
        assert_eq!(pool.base_rate, 500);
    }

    #[ink::test]
    fn test_pool_operations() {
        let mut contract = setup();
        let pool_id = contract.create_pool(500).unwrap();
        assert!(contract.deposit(pool_id, 1_000_000).is_ok());
        assert!(contract.borrow(pool_id, 500_000).is_ok());
        let rate = contract.borrow_rate(pool_id).unwrap();
        assert!(rate > 500);
    }

    #[ink::test]
    fn test_margin_position() {
        let mut contract = setup();
        let pos_id = contract.open_position(1000, 200, false, 100).unwrap();
        let pnl = contract.position_pnl(pos_id, 150).unwrap();
        assert!(pnl > 0);
    }

    #[ink::test]
    fn test_loan_underwriting() {
        let mut contract = setup();
        let accounts = test::default_accounts::<DefaultEnvironment>();
        // LTV too high (90%) → rejected regardless of score
        let loan_id = contract.apply_for_loan(1, 900_000, 1_000_000, 0).unwrap();
        let approved = contract.underwrite_loan(loan_id).unwrap();
        assert!(!approved);
        // Give alice a good score (≥600) then apply with acceptable LTV
        for _ in 0..6 {
            contract.record_repayment(accounts.alice).unwrap();
        }
        let loan_id2 = contract.apply_for_loan(1, 700_000, 1_000_000, 0).unwrap();
        let approved2 = contract.underwrite_loan(loan_id2).unwrap();
        assert!(approved2);
    }

    #[ink::test]
    fn test_loan_servicer_integration() {
        let mut contract = setup();
        let accounts = test::default_accounts::<DefaultEnvironment>();
        let servicer_id = contract
            .register_loan_servicer(accounts.bob, String::from("Acme Servicing"))
            .unwrap();
        let loan_id = contract.apply_for_loan(1, 700_000, 1_000_000, 700).unwrap();

        contract
            .assign_loan_servicer(loan_id, servicer_id, String::from("EXT-123"))
            .unwrap();
        let loan = contract.get_loan(loan_id).unwrap();
        assert_eq!(loan.servicer_id, Some(servicer_id));
        assert_eq!(loan.servicing_reference, "EXT-123");
        assert_eq!(loan.servicing_status, "Boarded");

        test::set_caller::<DefaultEnvironment>(accounts.bob);
        contract
            .update_servicing_status(loan_id, String::from("Current"))
            .unwrap();
        assert_eq!(
            contract.get_loan(loan_id).unwrap().servicing_status,
            "Current"
        );
    }

    #[ink::test]
    fn test_property_backed_loan_uses_assessed_collateral() {
        let mut contract = setup();
        contract
            .assess_collateral(7, 2_000_000, 7000, 8500)
            .unwrap();

        let loan_id = contract
            .apply_for_property_backed_loan(7, 1_200_000, 710, 24, 650)
            .unwrap();
        let loan = contract.get_loan(loan_id).unwrap();

        assert_eq!(loan.collateral_value, 2_000_000);
        assert_eq!(loan.term_months, 24);
        assert_eq!(loan.interest_rate_bps, 650);
        assert_eq!(loan.status, LoanStatus::Pending);
    }

    #[ink::test]
    fn test_property_backed_loan_rejects_excessive_borrow() {
        let mut contract = setup();
        contract
            .assess_collateral(9, 1_000_000, 6500, 8500)
            .unwrap();

        assert_eq!(
            contract.apply_for_property_backed_loan(9, 700_000, 700, 12, 700),
            Err(LendingError::InsufficientCollateral)
        );
    }

    #[ink::test]
    fn test_loan_servicer_authorization_and_validation() {
        let mut contract = setup();
        let accounts = test::default_accounts::<DefaultEnvironment>();
        let loan_id = contract.apply_for_loan(1, 700_000, 1_000_000, 700).unwrap();

        assert_eq!(
            contract.register_loan_servicer(accounts.bob, String::new()),
            Err(LendingError::InvalidParameters)
        );
        let servicer_id = contract
            .register_loan_servicer(accounts.bob, String::from("Acme Servicing"))
            .unwrap();
        contract
            .set_loan_servicer_active(servicer_id, false)
            .unwrap();
        assert_eq!(
            contract.assign_loan_servicer(loan_id, servicer_id, String::from("EXT-123")),
            Err(LendingError::InvalidParameters)
        );

        contract
            .set_loan_servicer_active(servicer_id, true)
            .unwrap();
        contract
            .assign_loan_servicer(loan_id, servicer_id, String::from("EXT-123"))
            .unwrap();

        test::set_caller::<DefaultEnvironment>(accounts.charlie);
        assert_eq!(
            contract.update_servicing_status(loan_id, String::from("Late")),
            Err(LendingError::Unauthorized)
        );
        assert_eq!(
            contract.assign_loan_servicer(loan_id, servicer_id, String::from("EXT-456")),
            Err(LendingError::Unauthorized)
        );
    }

    #[ink::test]
    fn test_loan_restructuring_requires_borrower_and_lender_approval() {
        let mut contract = setup();
        let accounts = test::default_accounts::<DefaultEnvironment>();

        for _ in 0..6 {
            contract.record_repayment(accounts.bob).unwrap();
        }

        test::set_caller::<DefaultEnvironment>(accounts.bob);
        let loan_id = contract
            .apply_for_loan_with_terms(1, 600_000, 1_000_000, 720, 12, 900)
            .unwrap();

        test::set_caller::<DefaultEnvironment>(accounts.alice);
        assert!(contract.underwrite_loan(loan_id).unwrap());

        test::set_caller::<DefaultEnvironment>(accounts.bob);
        assert!(contract
            .propose_loan_restructuring(loan_id, 24, 700)
            .is_ok());
        let pending = contract.get_loan(loan_id).unwrap();
        assert_eq!(pending.status, LoanStatus::RestructuringProposed);

        test::set_caller::<DefaultEnvironment>(accounts.alice);
        assert!(contract.approve_loan_restructuring(loan_id).unwrap());

        let updated = contract.get_loan(loan_id).unwrap();
        assert_eq!(updated.term_months, 24);
        assert_eq!(updated.interest_rate_bps, 700);
        assert_eq!(updated.status, LoanStatus::Restructured);
        assert!(contract.get_loan_restructuring(loan_id).is_none());
    }

    #[ink::test]
    fn test_liquidate_loan() {
        let mut contract = setup();
        let accounts = test::default_accounts::<DefaultEnvironment>();
        contract
            .assess_collateral(1, 1_000_000, 7500, 8000)
            .unwrap();
        // Give alice a score ≥ 600 (6 repayments → 500 + 120 = 620)
        for _ in 0..6 {
            contract.record_repayment(accounts.alice).unwrap();
        }
        let loan_id = contract.apply_for_loan(1, 700_000, 1_000_000, 0).unwrap();
        contract.underwrite_loan(loan_id).unwrap();
        assert!(contract.liquidate_loan(loan_id, vec![(1, 850_000)]).is_ok());
        let loan = contract.get_loan(loan_id).unwrap();
        assert_eq!(loan.status, LoanStatus::Liquidated);
    }

    #[ink::test]
    fn test_yield_farming() {
        let mut contract = setup();
        let accounts = test::default_accounts::<DefaultEnvironment>();
        assert!(contract.stake(1000).is_ok());
        let rewards = contract.pending_rewards(accounts.alice, 100);
        assert!(rewards > 0);
    }

    #[ink::test]
    fn test_governance() {
        let mut contract = setup();
        let prop_id = contract.propose("Lower LTV cap".into()).unwrap();
        assert!(contract.vote(prop_id, true).is_ok());
        assert!(contract.vote(prop_id, true).is_ok());
        assert!(contract.vote(prop_id, false).is_ok());
        assert!(contract.execute_proposal(prop_id).unwrap());
    }

    // ── Credit scoring tests ──────────────────────────────────────────────

    #[ink::test]
    fn test_default_credit_score_is_500() {
        let contract = setup();
        let accounts = test::default_accounts::<DefaultEnvironment>();
        assert_eq!(contract.get_credit_score(accounts.bob), 500);
    }

    #[ink::test]
    fn test_repayment_increases_score() {
        let mut contract = setup();
        let accounts = test::default_accounts::<DefaultEnvironment>();
        contract.record_repayment(accounts.bob).unwrap();
        contract.record_repayment(accounts.bob).unwrap();
        // 500 + 2*20 = 540
        assert_eq!(contract.get_credit_score(accounts.bob), 540);
    }

    #[ink::test]
    fn test_default_decreases_score() {
        let mut contract = setup();
        let accounts = test::default_accounts::<DefaultEnvironment>();
        contract.record_default(accounts.bob).unwrap();
        // 500 - 150 = 350
        assert_eq!(contract.get_credit_score(accounts.bob), 350);
    }

    #[ink::test]
    fn test_repayment_bonus_capped_at_300() {
        let mut contract = setup();
        let accounts = test::default_accounts::<DefaultEnvironment>();
        // 15 repayments * 20 = 300 (cap)
        for _ in 0..20 {
            contract.record_repayment(accounts.bob).unwrap();
        }
        assert_eq!(contract.get_credit_score(accounts.bob), 800);
    }

    #[ink::test]
    fn test_default_penalty_capped_at_450() {
        let mut contract = setup();
        let accounts = test::default_accounts::<DefaultEnvironment>();
        // 3 defaults * 150 = 450 (cap)
        for _ in 0..5 {
            contract.record_default(accounts.bob).unwrap();
        }
        assert_eq!(contract.get_credit_score(accounts.bob), 50);
    }

    #[ink::test]
    fn test_underwrite_uses_on_chain_score() {
        let mut contract = setup();
        let accounts = test::default_accounts::<DefaultEnvironment>();
        // Give bob a good history: 6 repayments → score = 500 + 120 = 620
        for _ in 0..6 {
            contract.record_repayment(accounts.bob).unwrap();
        }

        // Apply as bob with a reasonable LTV
        test::set_caller::<DefaultEnvironment>(accounts.bob);
        let loan_id = contract
            .apply_for_loan(1, 700_000, 1_000_000, 0) // credit_score param ignored
            .unwrap();

        // Underwrite as admin
        test::set_caller::<DefaultEnvironment>(accounts.alice);
        let approved = contract.underwrite_loan(loan_id).unwrap();
        assert!(approved);

        let loan = contract.get_loan(loan_id).unwrap();
        assert_eq!(loan.credit_score, 620);
    }

    #[ink::test]
    fn test_underwrite_rejected_when_score_too_low() {
        let mut contract = setup();
        let accounts = test::default_accounts::<DefaultEnvironment>();
        // Give bob a bad history (score = 350)
        contract.record_default(accounts.bob).unwrap();

        test::set_caller::<DefaultEnvironment>(accounts.bob);
        let loan_id = contract.apply_for_loan(1, 700_000, 1_000_000, 0).unwrap();

        test::set_caller::<DefaultEnvironment>(accounts.alice);
        let approved = contract.underwrite_loan(loan_id).unwrap();
        assert!(!approved);
    }

    #[ink::test]
    fn test_record_repayment_unauthorized() {
        let mut contract = setup();
        let accounts = test::default_accounts::<DefaultEnvironment>();
        test::set_caller::<DefaultEnvironment>(accounts.bob);
        assert_eq!(
            contract.record_repayment(accounts.charlie),
            Err(propchain_lending::LendingError::Unauthorized)
        );
    }

    #[ink::test]
    fn test_active_loans_tracked_and_reduce_score() {
        let mut contract = setup();
        let accounts = test::default_accounts::<DefaultEnvironment>();

        // Give bob 6 repayments → score = 620, then approve 2 loans
        // After each approval active_loans increments by 1 (-10 each)
        // Final score = 500 + 120 - 20 = 600
        for _ in 0..6 {
            contract.record_repayment(accounts.bob).unwrap();
        }

        for _ in 0..2 {
            test::set_caller::<DefaultEnvironment>(accounts.bob);
            let loan_id = contract.apply_for_loan(1, 700_000, 1_000_000, 0).unwrap();
            test::set_caller::<DefaultEnvironment>(accounts.alice);
            contract.underwrite_loan(loan_id).unwrap();
        }

        // score = 500 + 120 - 2*10 = 600
        assert_eq!(contract.get_credit_score(accounts.bob), 600);
    }

    // ── #588: Multi-collateral tests ────────────────────────────────────────

    #[ink::test]
    fn test_multi_collateral_loan_pledge_and_liquidation() {
        let mut contract = setup();
        let accounts = test::default_accounts::<DefaultEnvironment>();
        // Boost alice's credit score to ≥600 so underwrite_loan approves the loan
        for _ in 0..6 {
            contract.record_repayment(accounts.alice).unwrap();
        }
        contract
            .assess_collateral(1, 1_000_000, 7500, 8000)
            .unwrap();
        contract.assess_collateral(2, 500_000, 7000, 8500).unwrap();

        let loan_id = contract
            .apply_for_property_backed_loan(1, 500_000, 700, 12, 650)
            .unwrap();
        contract.underwrite_loan(loan_id).unwrap();

        assert!(contract.pledge_additional_collateral(loan_id, 2).is_ok());

        let collaterals = contract.loan_collaterals.get(loan_id).unwrap();
        assert_eq!(collaterals, vec![1, 2]);

        // Both collaterals worth 1.5M, loan 500K → LTV = 33,333 bps
        // Weighted threshold = (1M*12000 + 500K*8500) / 1.5M = 12,167 bps
        // 33,333 < 12,167 is false... wait that's not right.
        // LTV = 500K * 10000 / 1.5M = 3333 bps
        // 3333 < 12167 → not liquidatable
        assert!(!contract
            .should_liquidate_loan(loan_id, vec![(1, 1_000_000), (2, 500_000)])
            .unwrap());

        // Drop total collateral value to 600K (both halved)
        // LTV = 500K * 10000 / 600K = 8333 bps
        // 8333 > 12167 is false → still not liquidatable
        assert!(!contract
            .should_liquidate_loan(loan_id, vec![(1, 500_000), (2, 250_000)])
            .unwrap());

        // Drop to 400K total
        // LTV = 500K * 10000 / 400K = 12,500 bps > 12,167 → liquidatable
        assert!(contract
            .should_liquidate_loan(loan_id, vec![(1, 300_000), (2, 100_000)])
            .unwrap());
    }

    #[ink::test]
    fn test_multi_collateral_liquidation_executes() {
        let mut contract = setup();
        let accounts = test::default_accounts::<DefaultEnvironment>();
        // Boost alice's credit score to ≥600 so underwrite_loan approves the loan
        for _ in 0..6 {
            contract.record_repayment(accounts.alice).unwrap();
        }
        contract
            .assess_collateral(1, 1_000_000, 7500, 8000)
            .unwrap();
        contract.assess_collateral(2, 500_000, 7000, 8500).unwrap();

        let loan_id = contract
            .apply_for_property_backed_loan(1, 500_000, 700, 12, 650)
            .unwrap();
        contract.underwrite_loan(loan_id).unwrap();
        contract.pledge_additional_collateral(loan_id, 2).unwrap();

        // Trigger liquidation with devalued collaterals
        assert!(contract
            .liquidate_loan(loan_id, vec![(1, 300_000), (2, 100_000)])
            .is_ok());
        let loan = contract.get_loan(loan_id).unwrap();
        assert_eq!(loan.status, LoanStatus::Liquidated);
    }
}

// =========================================================================
// ADMIN KEY ROTATION TESTS (Issue #496) — Lending
// =========================================================================

/// Admin key-rotation tests for the [`PropertyLending`] contract (Issue #496).
///
/// Validates the two-step, time-locked admin rotation flow: requesting,
/// confirming after the cooldown period, cancelling by either party, and
/// blocking unauthorized callers.  These tests are intentionally isolated
/// from the main `tests` module so that rotation-specific setup (different
/// caller permutations) does not add noise to general lending tests.
#[cfg(test)]
mod lending_admin_rotation_tests {
    use ink::env::{test, DefaultEnvironment};

    use super::propchain_lending::{LendingError, PropertyLending};

    fn setup() -> PropertyLending {
        let accounts = test::default_accounts::<DefaultEnvironment>();
        test::set_caller::<DefaultEnvironment>(accounts.alice);
        PropertyLending::new(accounts.alice)
    }

    #[ink::test]
    fn test_admin_can_request_rotation() {
        let mut contract = setup();
        let accounts = test::default_accounts::<DefaultEnvironment>();
        assert!(contract.request_admin_rotation(accounts.bob).is_ok());
        let pending = contract.get_pending_admin_rotation();
        assert!(pending.is_some());
        let req = pending.unwrap();
        assert_eq!(req.old_account, accounts.alice);
        assert_eq!(req.new_account, accounts.bob);
    }

    #[ink::test]
    fn test_non_admin_cannot_request_rotation() {
        let mut contract = setup();
        let accounts = test::default_accounts::<DefaultEnvironment>();
        test::set_caller::<DefaultEnvironment>(accounts.bob);
        assert_eq!(
            contract.request_admin_rotation(accounts.charlie),
            Err(LendingError::Unauthorized)
        );
    }

    #[ink::test]
    fn test_rotation_cannot_be_confirmed_before_cooldown() {
        let mut contract = setup();
        let accounts = test::default_accounts::<DefaultEnvironment>();
        contract.request_admin_rotation(accounts.bob).unwrap();
        test::set_caller::<DefaultEnvironment>(accounts.bob);
        // Block 0 < effective_at 14_400
        assert_eq!(
            contract.confirm_admin_rotation(),
            Err(LendingError::KeyRotationCooldown)
        );
    }

    #[ink::test]
    fn test_rotation_expires_after_expiry_period() {
        let mut contract = setup();
        let accounts = test::default_accounts::<DefaultEnvironment>();
        contract.request_admin_rotation(accounts.bob).unwrap();
        // Verify no pending rotation after cancel
        contract.cancel_admin_rotation().unwrap();
        test::set_caller::<DefaultEnvironment>(accounts.bob);
        assert_eq!(
            contract.confirm_admin_rotation(),
            Err(LendingError::NoPendingRotation)
        );
    }

    #[ink::test]
    fn test_old_admin_can_cancel_pending_rotation() {
        let mut contract = setup();
        let accounts = test::default_accounts::<DefaultEnvironment>();
        contract.request_admin_rotation(accounts.bob).unwrap();
        assert!(contract.cancel_admin_rotation().is_ok());
        assert!(contract.get_pending_admin_rotation().is_none());
    }

    #[ink::test]
    fn test_new_admin_can_cancel_pending_rotation() {
        let mut contract = setup();
        let accounts = test::default_accounts::<DefaultEnvironment>();
        contract.request_admin_rotation(accounts.bob).unwrap();
        test::set_caller::<DefaultEnvironment>(accounts.bob);
        assert!(contract.cancel_admin_rotation().is_ok());
        assert!(contract.get_pending_admin_rotation().is_none());
    }

    #[ink::test]
    fn test_unrelated_account_cannot_cancel() {
        let mut contract = setup();
        let accounts = test::default_accounts::<DefaultEnvironment>();
        contract.request_admin_rotation(accounts.bob).unwrap();
        test::set_caller::<DefaultEnvironment>(accounts.charlie);
        assert_eq!(
            contract.cancel_admin_rotation(),
            Err(LendingError::RotationUnauthorized)
        );
    }
}

// =========================================================================
// #589: Storage trait derivation assertion tests
// =========================================================================

/// Storage-trait derivation assertion tests (Issue #589).
///
/// Confirms that every public type stored in [`PropertyLending`] implements
/// all four required derives: [`scale::Encode`], [`scale::Decode`],
/// [`scale_info::TypeInfo`], and [`ink::storage::traits::StorageLayout`].
/// Compile-time failures here mean a newly introduced struct is missing a
/// `#[derive(...)]` annotation.  No runtime logic is tested; the value of
/// these tests is entirely in the type-checker.
#[cfg(test)]
mod storage_derivation_tests {
    use scale::{Decode, Encode};

    use super::propchain_lending::{
        CollateralKind, CollateralRecord, CreditProfile, LendingPool, LoanApplication, LoanListing,
        LoanOffer, LoanRestructuring, LoanServicer, LoanStatus, MarginPosition, PaymentSchedule,
        PaymentScheduleStatus, PropertyLending, Proposal, YieldPosition,
    };

    fn assert_storage_type<
        T: Encode + Decode + scale_info::TypeInfo + ink::storage::traits::StorageLayout,
    >() {
    }

    #[test]
    fn all_pub_storage_types_have_required_derives() {
        assert_storage_type::<CollateralRecord>();
        assert_storage_type::<LendingPool>();
        assert_storage_type::<MarginPosition>();
        assert_storage_type::<LoanApplication>();
        assert_storage_type::<LoanServicer>();
        assert_storage_type::<PaymentSchedule>();
        assert_storage_type::<LoanRestructuring>();
        assert_storage_type::<YieldPosition>();
        assert_storage_type::<Proposal>();
        assert_storage_type::<CreditProfile>();
        assert_storage_type::<LoanListing>();
        assert_storage_type::<LoanOffer>();
        assert_storage_type::<LoanStatus>();
        assert_storage_type::<CollateralKind>();
        assert_storage_type::<PaymentScheduleStatus>();
    }

    #[test]
    fn property_lending_storage_layout_compiles() {
        fn assert_layout<T: ink::storage::traits::StorageLayout>() {}
        assert_layout::<PropertyLending>();
    }
}

#[cfg(test)]
#[path = "test.rs"]
mod lending_regression_test;

pub mod liquidation_reentrancy;
pub mod yield_optimization;