diff --git a/backend/jest.config.ts b/backend/jest.config.ts index a7ec450d..dd8a993e 100644 --- a/backend/jest.config.ts +++ b/backend/jest.config.ts @@ -15,5 +15,8 @@ export default { "^(\\.{1,2}/.*)\\.js$": "$1", }, testMatch: ["**/*.test.ts", "**/*.spec.ts"], - setupFilesAfterEnv: ["/src/tests/jest.setup.ts"], + // setupFilesAfterEnv: ["/src/tests/jest.setup.ts"], + + // 👇 Point to the actual location of setup.ts + setupFilesAfterEnv: ["/src/__tests__/setup.ts"], }; diff --git a/backend/src/__tests__/setup.ts b/backend/src/__tests__/setup.ts new file mode 100644 index 00000000..e6210cc5 --- /dev/null +++ b/backend/src/__tests__/setup.ts @@ -0,0 +1,20 @@ +import { db } from "../src/db/connection"; +import Redis from "ioredis"; + +let redis: Redis; + +beforeAll(async () => { + redis = new Redis(process.env.REDIS_URL); + if (db.connect) { + await db.connect(); + } +}); + +afterAll(async () => { + if (redis) { + await redis.quit(); + } + if (db.end) { + await db.end(); + } +}); diff --git a/backend/src/db/migrations/20260329_add_loan_events_indexes.sql b/backend/src/db/migrations/20260329_add_loan_events_indexes.sql new file mode 100644 index 00000000..93d1561a --- /dev/null +++ b/backend/src/db/migrations/20260329_add_loan_events_indexes.sql @@ -0,0 +1,17 @@ +-- Migration: Add missing indexes on loan_events table + +-- Index for borrower history queries +CREATE INDEX IF NOT EXISTS idx_loan_events_borrower +ON loan_events(borrower); + +-- Index for filtering by event type +CREATE INDEX IF NOT EXISTS idx_loan_events_event_type +ON loan_events(event_type); + +-- Composite index for loan detail queries +CREATE INDEX IF NOT EXISTS idx_loan_events_loan_id_event_type +ON loan_events(loan_id, event_type); + +-- Index for date range filters +CREATE INDEX IF NOT EXISTS idx_loan_events_created_at +ON loan_events(created_at); diff --git a/backend/src/db/migrations/20260329_add_unique_constraint_loan_events.sql b/backend/src/db/migrations/20260329_add_unique_constraint_loan_events.sql new file mode 100644 index 00000000..9b4d51f3 --- /dev/null +++ b/backend/src/db/migrations/20260329_add_unique_constraint_loan_events.sql @@ -0,0 +1,5 @@ +-- Migration: Add unique constraint to prevent duplicate loan events + +ALTER TABLE loan_events + ADD CONSTRAINT unique_loan_event + UNIQUE (transaction_hash, event_index); diff --git a/backend/src/services/eventIndexer.ts b/backend/src/services/eventIndexer.ts index 5008111e..c41f08d5 100644 --- a/backend/src/services/eventIndexer.ts +++ b/backend/src/services/eventIndexer.ts @@ -14,6 +14,8 @@ import { eventStreamService } from "./eventStreamService.js"; import { notificationService, type NotificationType } from "./notificationService.js"; import { sorobanService } from "./sorobanService.js"; import { updateUserScoresBulk } from "./scoresService.js"; +import { subscribeToContractEvents } from "./chainListener"; +import db from "../db"; interface SorobanRawEvent { id: string; @@ -88,6 +90,125 @@ export class EventIndexer { this.batchSize = configOrRpcUrl.batchSize ?? 100; } +init() { + // Existing LoanManager subscription... + subscribeToContractEvents('LoanManager', this.handleLoanManagerEvent.bind(this)); + + // NEW: LendingPool events + subscribeToContractEvents('LendingPool', this.handleLendingPoolEvent.bind(this)); + + // NEW: RemittanceNFT events + subscribeToContractEvents('RemittanceNFT', this.handleRemittanceNFTEvent.bind(this)); + + // NEW: MultisigGovernance events + subscribeToContractEvents('MultisigGovernance', this.handleGovernanceEvent.bind(this)); + } + + async handleLendingPoolEvent(event: any) { + switch (event.type) { + case 'Deposit': + await db('lending_pool_deposits').insert({ + userId: event.user, + amount: event.amount, + txHash: event.txHash, + blockNumber: event.blockNumber, + timestamp: new Date(), + }); + break; + case 'Withdraw': + await db('lending_pool_withdrawals').insert({ + userId: event.user, + amount: event.amount, + txHash: event.txHash, + blockNumber: event.blockNumber, + timestamp: new Date(), + }); + break; + case 'EmergencyWithdraw': + await db('lending_pool_emergency').insert({ + userId: event.user, + amount: event.amount, + txHash: event.txHash, + blockNumber: event.blockNumber, + timestamp: new Date(), + }); + break; + } + } + + async handleRemittanceNFTEvent(event: any) { + switch (event.type) { + case 'ScoreUpdated': + await db('nft_scores').insert({ + nftId: event.nftId, + newScore: event.score, + txHash: event.txHash, + blockNumber: event.blockNumber, + timestamp: new Date(), + }); + break; + case 'NFTSeized': + await db('nft_seizures').insert({ + nftId: event.nftId, + reason: event.reason, + txHash: event.txHash, + blockNumber: event.blockNumber, + timestamp: new Date(), + }); + break; + case 'NFTBurned': + await db('nft_burns').insert({ + nftId: event.nftId, + txHash: event.txHash, + blockNumber: event.blockNumber, + timestamp: new Date(), + }); + break; + case 'NFTMinted': + await db('nft_mints').insert({ + nftId: event.nftId, + owner: event.owner, + txHash: event.txHash, + blockNumber: event.blockNumber, + timestamp: new Date(), + }); + break; + } + } + + async handleGovernanceEvent(event: any) { + switch (event.type) { + case 'ProposalCreated': + await db('governance_proposals').insert({ + proposalId: event.proposalId, + creator: event.creator, + expiresAt: event.expiresAt, + txHash: event.txHash, + blockNumber: event.blockNumber, + timestamp: new Date(), + }); + break; + case 'ProposalApproved': + await db('governance_approvals').insert({ + proposalId: event.proposalId, + approver: event.approver, + txHash: event.txHash, + blockNumber: event.blockNumber, + timestamp: new Date(), + }); + break; + case 'ProposalFinalized': + await db('governance_finalized').insert({ + proposalId: event.proposalId, + executor: event.executor, + txHash: event.txHash, + blockNumber: event.blockNumber, + timestamp: new Date(), + }); + break; + } + } + async start(): Promise { if (this.running) { logger.warn("Indexer start requested while already running"); @@ -706,4 +827,24 @@ export class EventIndexer { return null; } } + async handleLoanEvent(event: any) { + try { + await db('loan_events') + .insert({ + transaction_hash: event.txHash, + event_index: event.index, + borrower: event.borrower, + loan_id: event.loanId, + event_type: event.type, + amount: event.amount, + created_at: new Date(event.timestamp), + }) + .onConflict(['transaction_hash', 'event_index']) + .ignore(); // Prevent duplicates if re-indexing + } catch (err) { + console.error(`Failed to insert loan event: ${err.message}`); + } +} + } + diff --git a/contracts/multisig_governance/src/lib.rs b/contracts/multisig_governance/src/lib.rs index 51ab21f6..f53ef3e3 100644 --- a/contracts/multisig_governance/src/lib.rs +++ b/contracts/multisig_governance/src/lib.rs @@ -576,3 +576,126 @@ impl GovernanceContract { .expect("contract not initialized (4002)") } } + +#[derive(scale::Encode, scale::Decode, Clone, Debug, PartialEq, Eq)] +#[cfg_attr(feature = "std", derive(scale_info::TypeInfo))] +pub struct Proposal { + pub id: u64, + pub creator: AccountId, + pub approvals: Vec, + pub executed: bool, + pub expires_at: u64, // NEW: ledger height expiry +} + +#[ink(storage)] +pub struct MultisigGovernance { + proposals: Mapping, + next_proposal_id: u64, + expiry_window: u64, // NEW: configurable expiry window in ledgers + admin: AccountId, +} + +impl MultisigGovernance { + #[ink(constructor)] + pub fn new(admin: AccountId, expiry_window: u64) -> Self { + Self { + proposals: Mapping::default(), + next_proposal_id: 0, + expiry_window, + admin, + } + } + + #[ink(message)] + pub fn set_expiry_window(&mut self, new_window: u64) -> Result<(), String> { + if self.env().caller() != self.admin { + return Err(String::from("Only admin can set expiry window")); + } + self.expiry_window = new_window; + Ok(()) + } + + #[ink(message)] + pub fn create_proposal(&mut self) -> u64 { + let id = self.next_proposal_id; + self.next_proposal_id += 1; + + let current_ledger = Self::current_ledger(); + let expires_at = current_ledger + self.expiry_window; + + let proposal = Proposal { + id, + creator: self.env().caller(), + approvals: Vec::new(), + executed: false, + expires_at, + }; + + self.proposals.insert(id, &proposal); + id + } + + #[ink(message)] + pub fn approve_proposal(&mut self, proposal_id: u64) -> Result<(), String> { + let mut proposal = self + .proposals + .get(proposal_id) + .ok_or("Proposal not found")?; + let current_ledger = Self::current_ledger(); + + if current_ledger > proposal.expires_at { + return Err(String::from("Proposal expired")); + } + + let caller = self.env().caller(); + if !proposal.approvals.contains(&caller) { + proposal.approvals.push(caller); + } + + self.proposals.insert(proposal_id, &proposal); + Ok(()) + } + + #[ink(message)] + pub fn finalize_proposal(&mut self, proposal_id: u64) -> Result<(), String> { + let mut proposal = self + .proposals + .get(proposal_id) + .ok_or("Proposal not found")?; + let current_ledger = Self::current_ledger(); + + if current_ledger > proposal.expires_at { + return Err(String::from("Proposal expired")); + } + + if proposal.executed { + return Err(String::from("Already executed")); + } + + // Execute logic here... + proposal.executed = true; + self.proposals.insert(proposal_id, &proposal); + Ok(()) + } + + #[ink(message)] + pub fn cancel_expired_proposal(&mut self, proposal_id: u64) -> Result<(), String> { + let proposal = self + .proposals + .get(proposal_id) + .ok_or("Proposal not found")?; + let current_ledger = Self::current_ledger(); + + if current_ledger <= proposal.expires_at { + return Err(String::from("Proposal not expired yet")); + } + + self.proposals.remove(proposal_id); + Ok(()) + } + + fn current_ledger() -> u64 { + // Placeholder: integrate with environment ledger height + Self::env().block_number() + } +}