feat(client): add fast client-accounts lookup by client number or mobile number

GET /v1/clientaccounts/{identifier} -- a single client's full deposit + share
picture (Savings, Fixed Deposit, Recurring Deposit, Current, Share), looked
up by client number or mobile number rather than the internal client id, so
a teller with only the slip in front of them (or a third-party caller with
only a mobile number) needs no separate client-search step first. Meant to
answer "is there a problem here" (e.g. a share purchase that would exceed a
product's issuable shares) BEFORE a manager approves something, not after.

Deliberately its own lightweight resource rather than a reuse of the
existing GET /clients/{clientId}/accounts (AccountSummaryCollectionData):
that endpoint's row mappers each carry six LEFT JOINs to m_appuser for a
full submitted/approved/rejected/activated/closed audit trail per account,
which this caller doesn't need. One UNION ALL query (SB/FD/RD from
m_savings_account split by deposit_type_enum, CD from its own
m_current_account table, Share from m_share_account), each leg filtering on
an indexed client_id -- fewer joins and one round trip is what actually
makes this fast, not a different query engine.

Identifier resolution tries m_client.account_no first (what a teller has),
then mobile_no (what a third-party caller more often has) -- both unique
indexed columns, so neither path costs more than a single index lookup.

Reachable two ways: an ordinary logged-in Fineract user exactly as with any
other endpoint, or a third-party caller via the new X-Api-Key mechanism
(see the ApiClientCredentialService commit) -- one key now valid across
every tenant, so the response echoes back tenantId/tenantName and the
identifier that was searched, and a not-found error names the bank actually
searched. Without that, "no client found" from the wrong bank (a stale or
mistyped Fineract-Platform-TenantId header) was indistinguishable from a
genuinely unknown client.

Every date field is serialized as a plain ISO string, never a raw
java.time.LocalDate: this Gson instance has no java.time adapter registered,
and reflectively touching LocalDate's private fields is blocked outright by
the JVM module system (java.base does not open java.time to an unnamed
module) -- passing one through untouched turns the whole response into a
500.

cleanup_duplicate_vouchers.sql

@@ -0,0 +1,68 @@
+-- Removes the duplicate vouchers left behind by the double-count bug.
+--
+-- Until 2026-09-03 the cashier deposit and clerk withdrawal registers did not wrap their inner
+-- savings command in VoucherService.withOwnVoucher(...), so one counter transaction raised two
+-- vouchers over the same money: the register's own (CASHIER_DEPOSIT_REQUEST / CLERK_WITHDRAWAL_
+-- REQUEST) and a second one from the savings command (SAVINGS_TRANSACTION). The cashier's Received
+-- and Payment reports counted both, doubling the day's cash.
+--
+-- The code is fixed, so no new duplicates are created. This clears the ones already recorded.
+--
+-- WHICH ONE IS DELETED: the SAVINGS_TRANSACTION voucher. The register's voucher is the keeper --
+-- it is the one the register owns, attaches its DR/CR lines to, and stamps onto
+-- m_savings_account_transaction.voucher_no. Deleting the register's voucher instead would break
+-- that link and orphan the request row.
+--
+-- Run:  psql -h localhost -U postgres -d fineract_default -v ON_ERROR_STOP=1 -f cleanup_duplicate_vouchers.sql
+
+BEGIN;
+
+-- The duplicates: a SAVINGS_TRANSACTION voucher whose transaction is already claimed by a
+-- register voucher. Matching through savings_txn_id rather than by date or amount so that two
+-- genuinely separate transactions of the same value on the same day are never confused.
+CREATE TEMP TABLE dup_vouchers ON COMMIT DROP AS
+SELECT sav.voucher_no
+  FROM m_voucher sav
+  JOIN m_voucher reg
+    ON reg.savings_txn_id = sav.reference_id
+   AND reg.reference_type IN ('CLERK_WITHDRAWAL_REQUEST', 'CASHIER_DEPOSIT_REQUEST')
+ WHERE sav.reference_type = 'SAVINGS_TRANSACTION'
+   AND sav.voucher_type IN ('DEPOSIT', 'WITHDRAWAL');
+
+-- Refuse to run if anything else has attached itself to a voucher about to be deleted: a
+-- verification or an attachment means someone acted on that slip, and it must be looked at by hand
+-- rather than removed silently.
+DO $$
+DECLARE
+    blocked INT;
+BEGIN
+    SELECT COUNT(*) INTO blocked
+      FROM (SELECT voucher_no FROM m_voucher_verification
+             WHERE voucher_no IN (SELECT voucher_no FROM dup_vouchers)
+            UNION ALL
+            SELECT voucher_no FROM m_voucher_attachment
+             WHERE voucher_no IN (SELECT voucher_no FROM dup_vouchers)) x;
+    IF blocked > 0 THEN
+        RAISE EXCEPTION 'Aborting: % duplicate voucher(s) carry a verification or attachment. Review these by hand.', blocked;
+    END IF;
+END $$;
+
+-- Likewise refuse if a savings transaction is stamped with a voucher about to be deleted. It should
+-- carry the register's number, not the duplicate's; if it does not, the pair needs looking at.
+DO $$
+DECLARE
+    stamped INT;
+BEGIN
+    SELECT COUNT(*) INTO stamped FROM m_savings_account_transaction
+     WHERE voucher_no IN (SELECT voucher_no FROM dup_vouchers);
+    IF stamped > 0 THEN
+        RAISE EXCEPTION 'Aborting: % savings transaction(s) are stamped with a duplicate voucher number.', stamped;
+    END IF;
+END $$;
+
+SELECT voucher_no AS "about to delete" FROM dup_vouchers ORDER BY voucher_no;
+
+DELETE FROM m_voucher_line WHERE voucher_no IN (SELECT voucher_no FROM dup_vouchers);
+DELETE FROM m_voucher      WHERE voucher_no IN (SELECT voucher_no FROM dup_vouchers);
+
+COMMIT;

database_migration_facility_charge_auto_seed.sql

@@ -127,14 +127,6 @@ SELECT 'Inter-Bank Cap Charge', 'INR', 0.00, 2, 3, 1, 0, 1, 0, 0, 0,
        (SELECT id FROM acc_gl_account WHERE classification_enum = 4 AND usage_enum = 1 AND disabled = 0 ORDER BY id LIMIT 1)
 WHERE NOT EXISTS (SELECT 1 FROM m_charge WHERE name = 'Inter-Bank Cap Charge' AND is_deleted = 0);
 
-INSERT IGNORE INTO m_charge
-    (name, currency_code, amount, charge_applies_to_enum, charge_time_enum,
-     charge_calculation_enum, is_penalty, is_active, is_deleted,
-     is_free_withdrawal, is_payment_type, income_or_liability_account_id)
-SELECT 'Withdrawal Facility Charge', 'INR', 5.00, 2, 3, 1, 0, 1, 0, 0, 0,
-       (SELECT id FROM acc_gl_account WHERE classification_enum = 4 AND usage_enum = 1 AND disabled = 0 ORDER BY id LIMIT 1)
-WHERE NOT EXISTS (SELECT 1 FROM m_charge WHERE name = 'Withdrawal Facility Charge' AND is_deleted = 0);
-
 INSERT IGNORE INTO m_charge
     (name, currency_code, amount, charge_applies_to_enum, charge_time_enum,
      charge_calculation_enum, is_penalty, is_active, is_deleted,
@@ -168,6 +160,5 @@ VALUES
     ('NEFT_FACILITY',       'NEFT Facility Charge',         5.00, 3, 2, (SELECT id FROM m_charge WHERE name = 'NEFT Facility Charge'        AND is_deleted = 0 LIMIT 1)),
     ('RTGS_FACILITY',       'RTGS Facility Charge',        25.00, 3, 2, (SELECT id FROM m_charge WHERE name = 'RTGS Facility Charge'        AND is_deleted = 0 LIMIT 1)),
     ('INTER_BANK_TOTAL_CAP','Inter-Bank Cap Charge',        0.00, 3, 2, (SELECT id FROM m_charge WHERE name = 'Inter-Bank Cap Charge'       AND is_deleted = 0 LIMIT 1)),
-    ('WITHDRAWAL_FACILITY', 'Withdrawal Facility Charge',   5.00, 3, 2, (SELECT id FROM m_charge WHERE name = 'Withdrawal Facility Charge'  AND is_deleted = 0 LIMIT 1)),
     ('DEPOSIT_FACILITY_KYC','Deposit KYC Charge',           5.00, 3, 2, (SELECT id FROM m_charge WHERE name = 'Deposit KYC Charge'          AND is_deleted = 0 LIMIT 1)),
     ('VIRTUAL_DEBIT_CARD',  'Virtual Debit Card Charge',  199.00, 3, 2, (SELECT id FROM m_charge WHERE name = 'Virtual Debit Card Charge'   AND is_deleted = 0 LIMIT 1));

database_migration_facility_charges.sql

@@ -17,7 +17,6 @@ ALTER TABLE m_current_product_facility_config
     ADD COLUMN IF NOT EXISTS neft_facility_charge_id        BIGINT NULL,
     ADD COLUMN IF NOT EXISTS rtgs_facility_charge_id        BIGINT NULL,
     ADD COLUMN IF NOT EXISTS inter_bank_total_cap_charge_id BIGINT NULL,
-    ADD COLUMN IF NOT EXISTS withdrawal_facility_charge_id  BIGINT NULL,
     ADD COLUMN IF NOT EXISTS deposit_facility_kyc_charge_id BIGINT NULL,
     ADD COLUMN IF NOT EXISTS virtual_debit_card_charge_id   BIGINT NULL;
 
@@ -36,7 +35,6 @@ ALTER TABLE m_current_product_facility_config
     ADD CONSTRAINT fk_cpfc_neft_charge         FOREIGN KEY (neft_facility_charge_id)        REFERENCES m_charge(id),
     ADD CONSTRAINT fk_cpfc_rtgs_charge         FOREIGN KEY (rtgs_facility_charge_id)        REFERENCES m_charge(id),
     ADD CONSTRAINT fk_cpfc_ibtc_charge         FOREIGN KEY (inter_bank_total_cap_charge_id) REFERENCES m_charge(id),
-    ADD CONSTRAINT fk_cpfc_wd_charge           FOREIGN KEY (withdrawal_facility_charge_id)  REFERENCES m_charge(id),
     ADD CONSTRAINT fk_cpfc_dep_charge          FOREIGN KEY (deposit_facility_kyc_charge_id) REFERENCES m_charge(id),
     ADD CONSTRAINT fk_cpfc_vdc_charge          FOREIGN KEY (virtual_debit_card_charge_id)   REFERENCES m_charge(id);
 
@@ -55,7 +53,6 @@ ALTER TABLE m_savings_product_facility_config
     ADD COLUMN IF NOT EXISTS neft_facility_charge_id        BIGINT NULL,
     ADD COLUMN IF NOT EXISTS rtgs_facility_charge_id        BIGINT NULL,
     ADD COLUMN IF NOT EXISTS inter_bank_total_cap_charge_id BIGINT NULL,
-    ADD COLUMN IF NOT EXISTS withdrawal_facility_charge_id  BIGINT NULL,
     ADD COLUMN IF NOT EXISTS deposit_facility_kyc_charge_id BIGINT NULL,
     ADD COLUMN IF NOT EXISTS virtual_debit_card_charge_id   BIGINT NULL;
 
@@ -74,6 +71,5 @@ ALTER TABLE m_savings_product_facility_config
     ADD CONSTRAINT fk_spfc_neft_charge         FOREIGN KEY (neft_facility_charge_id)        REFERENCES m_charge(id),
     ADD CONSTRAINT fk_spfc_rtgs_charge         FOREIGN KEY (rtgs_facility_charge_id)        REFERENCES m_charge(id),
     ADD CONSTRAINT fk_spfc_ibtc_charge         FOREIGN KEY (inter_bank_total_cap_charge_id) REFERENCES m_charge(id),
-    ADD CONSTRAINT fk_spfc_wd_charge           FOREIGN KEY (withdrawal_facility_charge_id)  REFERENCES m_charge(id),
     ADD CONSTRAINT fk_spfc_dep_charge          FOREIGN KEY (deposit_facility_kyc_charge_id) REFERENCES m_charge(id),
     ADD CONSTRAINT fk_spfc_vdc_charge          FOREIGN KEY (virtual_debit_card_charge_id)   REFERENCES m_charge(id);

fineract-accounting/src/main/java/org/apache/fineract/accounting/producttoaccountmapping/serialization/ProductToGLAccountMappingFromApiJsonDeserializer.java

@@ -181,10 +181,14 @@ public final class ProductToGLAccountMappingFromApiJsonDeserializer {
             baseDataValidator.reset().parameter(SavingProductAccountingParams.SAVINGS_REFERENCE.getValue()).value(savingsReferenceAccountId)
                     .notNull().integerGreaterThanZero();
 
-            final Long transfersInSuspenseAccountId = this.fromApiJsonHelper
-                    .extractLongNamed(SavingProductAccountingParams.TRANSFERS_SUSPENSE.getValue(), element);
-            baseDataValidator.reset().parameter(SavingProductAccountingParams.TRANSFERS_SUSPENSE.getValue())
-                    .value(transfersInSuspenseAccountId).notNull().integerGreaterThanZero();
+            // Transfers In Suspense is not offered by every savings product UI, so it is validated only
+            // when the client actually sends it. Omitting it leaves the mapping unset rather than failing.
+            if (this.fromApiJsonHelper.parameterExists(SavingProductAccountingParams.TRANSFERS_SUSPENSE.getValue(), element)) {
+                final Long transfersInSuspenseAccountId = this.fromApiJsonHelper
+                        .extractLongNamed(SavingProductAccountingParams.TRANSFERS_SUSPENSE.getValue(), element);
+                baseDataValidator.reset().parameter(SavingProductAccountingParams.TRANSFERS_SUSPENSE.getValue())
+                        .value(transfersInSuspenseAccountId).notNull().integerGreaterThanZero();
+            }
 
             final Long interestOnSavingsAccountId = this.fromApiJsonHelper
                     .extractLongNamed(SavingProductAccountingParams.INTEREST_ON_SAVINGS.getValue(), element);
@@ -210,20 +214,29 @@ public final class ProductToGLAccountMappingFromApiJsonDeserializer {
             }
 
             if (!accountType.equals(DepositAccountType.RECURRING_DEPOSIT) && !accountType.equals(DepositAccountType.FIXED_DEPOSIT)) {
-                final Long overdraftAccount = this.fromApiJsonHelper
-                        .extractLongNamed(SavingProductAccountingParams.OVERDRAFT_PORTFOLIO_CONTROL.getValue(), element);
-                baseDataValidator.reset().parameter(SavingProductAccountingParams.OVERDRAFT_PORTFOLIO_CONTROL.getValue())
-                        .value(overdraftAccount).notNull().integerGreaterThanZero();
+                // Overdraft Control / Income From Interest / Write Off apply to overdraft-capable products
+                // only, so they are validated when supplied rather than demanded from every savings product.
+                if (this.fromApiJsonHelper.parameterExists(SavingProductAccountingParams.OVERDRAFT_PORTFOLIO_CONTROL.getValue(),
+                        element)) {
+                    final Long overdraftAccount = this.fromApiJsonHelper
+                            .extractLongNamed(SavingProductAccountingParams.OVERDRAFT_PORTFOLIO_CONTROL.getValue(), element);
+                    baseDataValidator.reset().parameter(SavingProductAccountingParams.OVERDRAFT_PORTFOLIO_CONTROL.getValue())
+                            .value(overdraftAccount).notNull().integerGreaterThanZero();
+                }
 
-                final Long incomeFromInterest = this.fromApiJsonHelper
-                        .extractLongNamed(SavingProductAccountingParams.INCOME_FROM_INTEREST.getValue(), element);
-                baseDataValidator.reset().parameter(SavingProductAccountingParams.INCOME_FROM_INTEREST.getValue()).value(incomeFromInterest)
-                        .notNull().integerGreaterThanZero();
+                if (this.fromApiJsonHelper.parameterExists(SavingProductAccountingParams.INCOME_FROM_INTEREST.getValue(), element)) {
+                    final Long incomeFromInterest = this.fromApiJsonHelper
+                            .extractLongNamed(SavingProductAccountingParams.INCOME_FROM_INTEREST.getValue(), element);
+                    baseDataValidator.reset().parameter(SavingProductAccountingParams.INCOME_FROM_INTEREST.getValue())
+                            .value(incomeFromInterest).notNull().integerGreaterThanZero();
+                }
 
-                final Long writtenOff = this.fromApiJsonHelper.extractLongNamed(SavingProductAccountingParams.LOSSES_WRITTEN_OFF.getValue(),
-                        element);
-                baseDataValidator.reset().parameter(SavingProductAccountingParams.LOSSES_WRITTEN_OFF.getValue()).value(writtenOff).notNull()
-                        .integerGreaterThanZero();
+                if (this.fromApiJsonHelper.parameterExists(SavingProductAccountingParams.LOSSES_WRITTEN_OFF.getValue(), element)) {
+                    final Long writtenOff = this.fromApiJsonHelper
+                            .extractLongNamed(SavingProductAccountingParams.LOSSES_WRITTEN_OFF.getValue(), element);
+                    baseDataValidator.reset().parameter(SavingProductAccountingParams.LOSSES_WRITTEN_OFF.getValue()).value(writtenOff)
+                            .notNull().integerGreaterThanZero();
+                }
             }
 
         }

fineract-core/src/main/java/org/apache/fineract/accounting/common/AccountingConstants.java

@@ -437,6 +437,7 @@ public final class AccountingConstants {
         OPENING_BALANCES_TRANSFER_CONTRA(300, "openingBalancesTransferContra", GLAccountType.EQUITY), //
         ASSET_FUND_SOURCE(103, "fundSource", GLAccountType.ASSET), //
         PAYABLE_DIVIDENDS(201, "payableDividends", GLAccountType.LIABILITY), //
+        DIVIDEND_PAID(202, "dividendPaid", GLAccountType.LIABILITY), //
         RESERVE_FOR_DIVIDEND(301, "reserveForDividend", GLAccountType.EQUITY), //
         DIVIDEND_FORFEITED_INCOME(400, "dividendForfeitedIncome", GLAccountType.INCOME); //
 

fineract-core/src/main/java/org/apache/fineract/commands/service/CommandWrapperBuilder.java

@@ -2905,6 +2905,15 @@ public class CommandWrapperBuilder {
         return this;
     }
 
+    public CommandWrapperBuilder paymentFixedDepositAccount(final Long accountId) {
+        this.actionName = "PAYMENT";
+        this.entityName = "FIXEDDEPOSITACCOUNT";
+        this.entityId = accountId;
+        this.savingsId = accountId;
+        this.href = "/fixeddepositaccounts/" + accountId + "?command=payment";
+        return this;
+    }
+
     public CommandWrapperBuilder fixedDepositAccountInterestCalculation(final Long accountId) {
         this.actionName = "CALCULATEINTEREST";
         this.entityName = "FIXEDDEPOSITACCOUNT";
@@ -3111,6 +3120,14 @@ public class CommandWrapperBuilder {
         return this;
     }
 
+    public CommandWrapperBuilder updateFacilityChargeMapping(final Long mappingId) {
+        this.actionName = "UPDATE";
+        this.entityName = "FACILITYCHARGEMAPPING";
+        this.entityId = mappingId;
+        this.href = "/facilitychargemappings/" + mappingId;
+        return this;
+    }
+
     public CommandWrapperBuilder deleteOfficeToGLAccountMapping(final Long mappingId) {
         this.actionName = "DELETE";
         this.entityName = "FINANCIALACTIVITYACCOUNT";

fineract-core/src/main/java/org/apache/fineract/infrastructure/core/data/DataValidatorBuilder.java

@@ -130,6 +130,19 @@ public class DataValidatorBuilder {
         this.dataValidationErrors.add(error);
     }
 
+    /**
+     * Like {@link #failWithCode(String, Object...)}, but the caller's own message is what's actually shown to the
+     * user (that method always renders the generic "Failed data validation due to: {errorCode}." regardless of the
+     * args passed to it).
+     */
+    public void failWithCodeAndMessage(final String errorCode, final String defaultUserMessage,
+            final Object... defaultUserMessageArgs) {
+        String validationErrorCode = "validation.msg." + this.resource + "." + this.parameter + "." + errorCode;
+        final ApiParameterError error = ApiParameterError.parameterError(validationErrorCode, defaultUserMessage, this.parameter,
+                this.value, defaultUserMessageArgs);
+        this.dataValidationErrors.add(error);
+    }
+
     public void failWithCodeNoParameterAddedToErrorCode(final String errorCode, final Object... defaultUserMessageArgs) {
         String validationErrorCode = "validation.msg." + this.resource + "." + errorCode;
         String defaultEnglishMessage = "Failed data validation due to: " + errorCode + ".";

fineract-core/src/main/java/org/apache/fineract/infrastructure/jobs/service/JobName.java

@@ -39,7 +39,10 @@ public enum JobName {
     GENERATE_LOANLOSS_PROVISIONING("Generate Loan Loss Provisioning"), //
     POST_DIVIDENTS_FOR_SHARES("Post Dividends For Shares"), //
     FORFEIT_UNCLAIMED_DIVIDENDS("Forfeit Unclaimed Dividends"), //
+    POST_SHARE_ENTRY_FEE_TO_PROFIT("Post Share Entry Fee To Profit"), //
     UPDATE_SAVINGS_DORMANT_ACCOUNTS("Update Savings Dormant Accounts"), //
+    APPLY_KYC_EXPIRY_RESTRICTIONS("Apply KYC Expiry Restrictions"), //
+    SAVINGS_DAILY_INTEREST("Savings Daily Interest Accrual And Posting"), //
     ADD_PERIODIC_ACCRUAL_ENTRIES_FOR_LOANS_WITH_INCOME_POSTED_AS_TRANSACTIONS(
             "Add Accrual Transactions For Loans With Income Posted As Transactions"), //
     EXECUTE_REPORT_MAILING_JOBS("Execute Report Mailing Jobs"), //

fineract-core/src/main/java/org/apache/fineract/portfolio/accountdetails/data/SavingsAccountSummaryData.java

@@ -72,11 +72,26 @@ public class SavingsAccountSummaryData {
     // differentiate deposit accounts Savings, FD and RD accounts
     private final EnumOptionData depositType;
 
+    /**
+     * For a Fixed Deposit, the stable customer-facing FD number: the account number of the first account in the renewal
+     * chain, which stays the same across every renewal even though each term is its own account row. Equals accountNo
+     * for an FD that has never been renewed, and is null for non-deposit accounts.
+     */
+    private final String fdAccountNumber;
+    /**
+     * Which renewal cycle of that FD this row is: 0 for the originally opened account, 1 for the first renewal, and so
+     * on. Lets a client's account list collapse a renewal chain into one FD instead of listing each term separately.
+     */
+    private final Integer renewalCycleNo;
+
     public SavingsAccountSummaryData(final Long id, final String accountNo, final String externalId, final Long productId,
             final String productName, final String shortProductName, final SavingsAccountStatusEnumData status, final CurrencyData currency,
             final BigDecimal accountBalance, final BigDecimal onHoldFunds, final BigDecimal savingsAmountOnHold,
             final BigDecimal availableBalance, final EnumOptionData accountType, final SavingsAccountApplicationTimelineData timeline,
-            final EnumOptionData depositType, final SavingsAccountSubStatusEnumData subStatus, final LocalDate lastActiveTransactionDate) {
+            final EnumOptionData depositType, final SavingsAccountSubStatusEnumData subStatus, final LocalDate lastActiveTransactionDate,
+            final String fdAccountNumber, final Integer renewalCycleNo) {
+        this.fdAccountNumber = fdAccountNumber;
+        this.renewalCycleNo = renewalCycleNo;
         this.id = id;
         this.accountNo = accountNo;
         this.externalId = externalId;

fineract-core/src/main/java/org/apache/fineract/portfolio/client/api/ClientApiConstants.java

@@ -162,6 +162,15 @@ public class ClientApiConstants {
     public static final String ageDaysParamName = "ageDays";
     public static final String nationalityIdParamName = "nationalityId";
     public static final String isMinorParamName = "isMinor";
+    /**
+     * Below this age a client is treated as a minor: guardian mapping required and a restricted KYC/OVD
+     * document set. Must stay in step with MINOR_AGE_THRESHOLD in the web app's client-age util -- the
+     * KYC template endpoint is authoritative for the document list, so a mismatch would serve an adult
+     * list (with mandatory PAN) for a client the UI classifies as a minor.
+     */
+    public static final int MINOR_AGE_THRESHOLD = 10;
+    /** At or above this age a client qualifies for senior-citizen deposit rates. */
+    public static final int SENIOR_CITIZEN_AGE_THRESHOLD = 60;
     public static final String guardianClientIdParamName = "guardianClientId";
     public static final String guardianClientDisplayNameParamName = "guardianClientDisplayName";
     public static final String guardianRelationParamName = "guardianRelation";

fineract-core/src/main/java/org/apache/fineract/portfolio/client/domain/ClientKyc.java

@@ -484,6 +484,14 @@ public class ClientKyc extends AbstractAuditableWithUTCDateTimeCustom<Long> {
             actualChanges.put(riskParam, newValue);
             recordOverwrite(riskParam, this.riskCategory);
             this.riskCategory = newValue;
+
+            // The re-KYC cycle is a property of the risk category, so moving the category moves the
+            // due date with it — otherwise a customer raised to High keeps a Low customer's ten-year
+            // renewal and is never called back in for the two-yearly review the rating requires.
+            final LocalDate newExpiry = recalculateExpiryForRiskCategory();
+            if (newExpiry != null) {
+                actualChanges.put("expiryDate", newExpiry);
+            }
         }
 
         // remarks is the audit justification itself, so a change to it is deliberately not recorded
@@ -677,6 +685,34 @@ public class ClientKyc extends AbstractAuditableWithUTCDateTimeCustom<Long> {
         }
     }
 
+    /**
+     * Re-dates the re-KYC due date after the risk category moves.
+     *
+     * The cycle length belongs to the category the customer is in <em>now</em> (Low 10, Medium 8,
+     * High 2), and it is counted from the day of the change rather than from the original
+     * verification. A customer moved to High in year two of a Low rating is then due in two years'
+     * time, not immediately — dating it from {@code verifiedOn} would push most of the book into
+     * an overdue queue the moment a re-rating ran.
+     *
+     * <p>Only a verified KYC carries an expiry: an unverified record has nothing to renew, and
+     * {@link #markVerified} sets the date when it is first verified.
+     *
+     * @return the new expiry date, or {@code null} if the record carries no expiry
+     */
+    private LocalDate recalculateExpiryForRiskCategory() {
+        if (this.verifiedOn == null) {
+            return null;
+        }
+
+        final KycRiskCategory risk = KycRiskCategory.fromInt(this.riskCategory);
+        if (risk.getReKycYears() <= 0) {
+            return this.expiryDate;
+        }
+
+        this.expiryDate = DateUtils.getLocalDateOfTenant().plusYears(risk.getReKycYears());
+        return this.expiryDate;
+    }
+
     /** Called when verification fails. */
     public void markRejected(final String remarks) {
         this.kycStatus = ClientKycStatus.REJECTED.getValue();
@@ -798,6 +834,9 @@ public class ClientKyc extends AbstractAuditableWithUTCDateTimeCustom<Long> {
      */
     public void escalateRiskCategory(Integer newCategory) {
         this.riskCategory = newCategory;
+        // An auto-escalation moves the rating for the same reason an officer would, so it moves the
+        // re-KYC due date on the same terms — see recalculateExpiryForRiskCategory().
+        recalculateExpiryForRiskCategory();
     }
 
     public String getPanNumber() {

fineract-core/src/main/java/org/apache/fineract/portfolio/client/domain/ClientKycRepository.java

@@ -18,6 +18,7 @@
  */
 package org.apache.fineract.portfolio.client.domain;
 
+import java.time.LocalDate;
 import java.util.List;
 import java.util.Optional;
 import org.springframework.data.jpa.repository.JpaRepository;
@@ -48,6 +49,18 @@ public interface ClientKycRepository extends JpaRepository<ClientKyc, Long> {
     @Query("SELECT k FROM ClientKyc k WHERE k.kycStatus = :status")
     List<ClientKyc> findAllByStatus(@Param("status") Integer status);
 
+    /**
+     * KYC records whose periodic re-KYC due date has passed, oldest first.
+     *
+     * <p>Only records that carry an expiry are considered: an expiry is set when the KYC is first
+     * verified, so one without a date has never been verified and has no renewal cycle to lapse.
+     * A rejected record is excluded for the same reason — it is not a lapsed KYC, it is one that
+     * never took effect, and restricting an account over it would punish the wrong thing.
+     */
+    @Query("SELECT k FROM ClientKyc k WHERE k.expiryDate IS NOT NULL AND k.expiryDate <= :asOn "
+            + "AND k.kycStatus <> :rejectedStatus ORDER BY k.expiryDate ASC")
+    List<ClientKyc> findLapsedAsOn(@Param("asOn") LocalDate asOn, @Param("rejectedStatus") Integer rejectedStatus);
+
     // ── Pre-KYC uniqueness probes ───────────────────────────────────────────
     // Why: stop a second client from being created with the same PAN / Aadhaar / GSTIN BEFORE the
     // external KYC API is called, so we don't burn vendor calls on duplicate-identity records. PAN

fineract-core/src/main/java/org/apache/fineract/portfolio/client/domain/KycExpiryStage.java

@@ -0,0 +1,106 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.portfolio.client.domain;
+
+/**
+ * How far an account has travelled down the restriction ladder after its periodic re-KYC lapsed.
+ *
+ * <p>
+ * RBI's Master Direction on KYC does not treat an overdue re-KYC as grounds to shut a customer out.
+ * The 2021 amendment (DOR.AML.REC.13/14.01.001/2021-22) is explicit that an account is not to be
+ * closed merely because periodic KYC is pending, and that any restriction follows notice and a fair
+ * opportunity to comply. The ladder therefore leaves the account untouched for a grace period,
+ * stops debits before it stops anything else, and never reaches closure on its own — closure stays
+ * a manual decision with its own notice.
+ *
+ * <p>
+ * The day counts are bank policy rather than a regulatory figure — the Direction requires "adequate
+ * notice" without fixing a number — so they are declared here once and read from here everywhere.
+ */
+public enum KycExpiryStage {
+
+    /**
+     * Inside the grace window. Nothing is restricted; the customer is being chased.
+     */
+    GRACE(0),
+
+    /**
+     * Debits stopped, credits still accepted. The first actual restriction, and the one that brings
+     * the customer into the branch without putting their incoming money at risk.
+     */
+    PARTIAL_FREEZE(90),
+
+    /**
+     * Both directions restricted, barring the credits that must always be let through.
+     */
+    INOPERATIVE(180);
+
+    /** Days past the expiry date at which this stage begins. */
+    private final int fromDaysOverdue;
+
+    KycExpiryStage(final int fromDaysOverdue) {
+        this.fromDaysOverdue = fromDaysOverdue;
+    }
+
+    public int getFromDaysOverdue() {
+        return fromDaysOverdue;
+    }
+
+    /**
+     * The stage an account sits at, given how far past its re-KYC due date it is.
+     *
+     * @param daysOverdue
+     *            days since the expiry date; zero or negative means the KYC has not lapsed
+     * @return the stage, or {@code null} where the KYC is still current and nothing applies
+     */
+    public static KycExpiryStage fromDaysOverdue(final long daysOverdue) {
+        if (daysOverdue < 0) {
+            return null;
+        }
+        if (daysOverdue >= INOPERATIVE.fromDaysOverdue) {
+            return INOPERATIVE;
+        }
+        if (daysOverdue >= PARTIAL_FREEZE.fromDaysOverdue) {
+            return PARTIAL_FREEZE;
+        }
+        return GRACE;
+    }
+
+    public boolean isGrace() {
+        return this == GRACE;
+    }
+
+    public boolean isPartialFreeze() {
+        return this == PARTIAL_FREEZE;
+    }
+
+    public boolean isInoperative() {
+        return this == INOPERATIVE;
+    }
+
+    /** Whether debits should be stopped at this stage. */
+    public boolean blocksDebits() {
+        return this == PARTIAL_FREEZE || this == INOPERATIVE;
+    }
+
+    /** Whether ordinary credits should be stopped at this stage. */
+    public boolean blocksCredits() {
+        return this == INOPERATIVE;
+    }
+}

fineract-core/src/main/java/org/apache/fineract/portfolio/savings/DepositAccountOnClosureType.java

@@ -31,7 +31,8 @@ public enum DepositAccountOnClosureType {
     WITHDRAW_DEPOSIT(100, "depositAccountClosureType.withdrawDeposit"), //
     TRANSFER_TO_SAVINGS(200, "depositAccountClosureType.transferToSavings"), //
     REINVEST_PRINCIPAL_AND_INTEREST(300, "depositAccountClosureType.reinvestPrincipalAndInterest"), //
-    REINVEST_PRINCIPAL_ONLY(400, "depositAccountClosureType.reinvestPrincipalOnly"); //
+    REINVEST_PRINCIPAL_ONLY(400, "depositAccountClosureType.reinvestPrincipalOnly"), //
+    PARTIAL_REINVEST(500, "depositAccountClosureType.partialReinvest"); //
 
     private final Integer value;
     private final String code;
@@ -51,6 +52,7 @@ public enum DepositAccountOnClosureType {
             case 200 -> TRANSFER_TO_SAVINGS;
             case 300 -> REINVEST_PRINCIPAL_AND_INTEREST;
             case 400 -> REINVEST_PRINCIPAL_ONLY;
+            case 500 -> PARTIAL_REINVEST;
             default -> INVALID;
         };
     }
@@ -85,6 +87,10 @@ public enum DepositAccountOnClosureType {
         return this.equals(INVALID);
     }
 
+    public boolean isPartialReinvest() {
+        return this.equals(PARTIAL_REINVEST);
+    }
+
     // TODO: do we really need this?!?
     public static Object[] integerValues() {
         return Arrays.stream(values()).filter(value -> !INVALID.equals(value)).map(value -> value.value).toList().toArray();

fineract-core/src/main/java/org/apache/fineract/portfolio/savings/DepositsApiConstants.java

@@ -208,6 +208,7 @@ public final class DepositsApiConstants {
     public static final String onAccountClosureIdParamName = "onAccountClosureId";
     public static final String transferDescriptionParamName = "transferDescription";
     public static final String toSavingsAccountIdParamName = "toSavingsAccountId";
+    public static final String reinvestAmountParamName = "reinvestAmount";
     public static final String savingsAccounts = "savingsAccounts";
     public static final String maturityInstructionIdParamName = "maturityInstructionId";
     public static final String transferToSavingsIdParamName = "transferToSavingsId";
@@ -588,6 +589,10 @@ public final class DepositsApiConstants {
         fixedDepositResponseData.add(SavingsApiConstants.jointHoldersParamName);
         fixedDepositResponseData.add(SavingsApiConstants.nominationFacilityParamName);
         fixedDepositResponseData.add(SavingsApiConstants.autoDebitFacilityParamName);
+        // FD Special's engine-computed monthly interest schedule (see FixedDepositAccountsApiResource#retrieveOne)
+        fixedDepositResponseData.add("projectedInterestSchedule");
+        fixedDepositResponseData.add("totalProjectedInterest");
+        fixedDepositResponseData.add("totalValueAtMaturity");
         return fixedDepositResponseData;
     }
 

fineract-core/src/main/java/org/apache/fineract/portfolio/savings/SavingsApiConstants.java

@@ -92,6 +92,9 @@ public class SavingsApiConstants {
     public static final String statusParamName = "status";
     public static final String subStatusParamName = "subStatus";
     public static final String reasonForBlockParamName = "reasonForBlock";
+    /** "CASH" (default, a manual/staff-placed lien) or "CLEARING" (money still moving through the
+     *  clearing process — a not-yet-realized cheque/DD deposit, or a presented cheque not yet settled). */
+    public static final String holdCategoryParamName = "holdCategory";
     public static final String clientIdParamName = "clientId";
     public static final String isRetailAccountParamName = "isRetailAccount";
     public static final String autogenerateTransactionIdParamName = "autogenerateTransactionId";
@@ -226,6 +229,7 @@ public class SavingsApiConstants {
     public static final String endDateParamName = "endDate";
     public static final String introducerRequiredParamName = "introducerRequired";
     public static final String shareLinkingEnabledParamName = "shareLinkingEnabled";
+    public static final String shareAccountIdParamName = "shareAccountId";
     public static final String nominationFacilityParamName = "nominationFacility";
     public static final String dormancyAlertParamName = "dormancyAlert";
     public static final String interestCalculateSelectorParamName = "interestCalculateSelector";
@@ -254,7 +258,6 @@ public class SavingsApiConstants {
     public static final String neftFacilityParamName = "neftFacility";
     public static final String rtgsFacilityParamName = "rtgsFacility";
     public static final String interBankTotalCapFacilityParamName = "interBankTotalCapFacility";
-    public static final String withdrawalFacilityParamName = "withdrawalFacility";
     public static final String depositFacilityKycParamName = "depositFacilityKyc";
     public static final String virtualDebitCardParamName = "virtualDebitCard";
 

fineract-core/src/main/java/org/apache/fineract/portfolio/savings/data/SavingsAccountData.java

@@ -157,6 +157,8 @@ public final class SavingsAccountData implements Serializable {
     private LocalDate endDate;
     private Boolean introducerRequired;
     private Boolean shareLinkingEnabled;
+    private Long shareAccountId;
+    private String shareAccountNo;
     private Boolean nominationFacility;
     private Boolean dormancyAlert;
     private Boolean isDormancyTrackingActiveFromProduct;
@@ -217,6 +219,21 @@ public final class SavingsAccountData implements Serializable {
     private BigDecimal interestPosting;
     private BigDecimal overdraftPosting;
 
+    /**
+     * True when this deposit pays its interest out to a linked savings account every period (FD Special).
+     * Such interest never stays in the account, so it must never compound -- every period earns on the
+     * principal alone. Transient because it is only read by the batch interest-posting engine.
+     */
+    private transient boolean transferInterestToLinkedAccount;
+
+    public void setTransferInterestToLinkedAccount(final boolean transferInterestToLinkedAccount) {
+        this.transferInterestToLinkedAccount = transferInterestToLinkedAccount;
+    }
+
+    public boolean isTransferInterestToLinkedAccount() {
+        return this.transferInterestToLinkedAccount;
+    }
+
     public static SavingsAccountData importInstanceIndividual(Long clientId, Long productId, Long fieldOfficerId, LocalDate submittedOnDate,
             BigDecimal nominalAnnualInterestRate, EnumOptionData interestCompoundingPeriodTypeEnum,
             EnumOptionData interestPostingPeriodTypeEnum, EnumOptionData interestCalculationTypeEnum,

fineract-core/src/main/java/org/apache/fineract/portfolio/savings/service/SavingsEnumerations.java

@@ -797,6 +797,10 @@ public final class SavingsEnumerations {
                 optionData = new EnumOptionData(DepositAccountOnClosureType.REINVEST_PRINCIPAL_ONLY.getValue().longValue(),
                         DepositAccountOnClosureType.REINVEST_PRINCIPAL_ONLY.getCode(), "Re-Invest Principal Only");
             break;
+            case PARTIAL_REINVEST:
+                optionData = new EnumOptionData(DepositAccountOnClosureType.PARTIAL_REINVEST.getValue().longValue(),
+                        DepositAccountOnClosureType.PARTIAL_REINVEST.getCode(), "Partial Re-Invest");
+            break;
         }
         return optionData;
     }

fineract-current-product/src/main/java/org/apache/fineract/portfolio/currentaccount/domain/CurrentAccountFacilityConfig.java

@@ -77,9 +77,6 @@ public class CurrentAccountFacilityConfig extends AbstractPersistableCustom<Long
     @Column(name = "inter_bank_total_cap_facility", nullable = false)
     private boolean interBankTotalCapFacility = false;
 
-    @Column(name = "withdrawal_facility", nullable = false)
-    private boolean withdrawalFacility = false;
-
     @Column(name = "deposit_facility_kyc", nullable = false)
     private boolean depositFacilityKyc = false;
 
@@ -120,7 +117,6 @@ public class CurrentAccountFacilityConfig extends AbstractPersistableCustom<Long
         if (config.has("neftFacility")) setNeftFacility(config.get("neftFacility").getAsBoolean());
         if (config.has("rtgsFacility")) setRtgsFacility(config.get("rtgsFacility").getAsBoolean());
         if (config.has("interBankTotalCapFacility")) setInterBankTotalCapFacility(config.get("interBankTotalCapFacility").getAsBoolean());
-        if (config.has("withdrawalFacility")) setWithdrawalFacility(config.get("withdrawalFacility").getAsBoolean());
         if (config.has("depositFacilityKyc")) setDepositFacilityKyc(config.get("depositFacilityKyc").getAsBoolean());
         if (config.has("virtualDebitCard")) setVirtualDebitCard(config.get("virtualDebitCard").getAsBoolean());
         if (config.has("internetBanking")) setInternetBanking(config.get("internetBanking").getAsBoolean());

fineract-current-product/src/main/java/org/apache/fineract/portfolio/currentaccount/domain/CurrentAccountPendingEdit.java

@@ -136,9 +136,6 @@ public class CurrentAccountPendingEdit extends AbstractPersistableCustom<Long> {
     @Column(name = "inter_bank_total_cap_facility")
     private Boolean interBankTotalCapFacility;
 
-    @Column(name = "withdrawal_facility")
-    private Boolean withdrawalFacility;
-
     @Column(name = "deposit_facility_kyc")
     private Boolean depositFacilityKyc;
 

fineract-current-product/src/main/java/org/apache/fineract/portfolio/currentproduct/domain/CurrentProductAssembler.java

@@ -378,7 +378,6 @@ public class CurrentProductAssembler {
         config.setNeftFacility(facilityConfigJson.has("neftFacility") ? facilityConfigJson.get("neftFacility").getAsBoolean() : false);
         config.setRtgsFacility(facilityConfigJson.has("rtgsFacility") ? facilityConfigJson.get("rtgsFacility").getAsBoolean() : false);
         config.setInterBankTotalCapFacility(facilityConfigJson.has("interBankTotalCapFacility") ? facilityConfigJson.get("interBankTotalCapFacility").getAsBoolean() : false);
-        config.setWithdrawalFacility(facilityConfigJson.has("withdrawalFacility") ? facilityConfigJson.get("withdrawalFacility").getAsBoolean() : false);
         config.setDepositFacilityKyc(facilityConfigJson.has("depositFacilityKyc") ? facilityConfigJson.get("depositFacilityKyc").getAsBoolean() : false);
         config.setVirtualDebitCard(facilityConfigJson.has("virtualDebitCard") ? facilityConfigJson.get("virtualDebitCard").getAsBoolean() : false);
         return config;

fineract-current-product/src/main/java/org/apache/fineract/portfolio/currentproduct/domain/CurrentProductFacilityConfig.java

@@ -75,9 +75,6 @@ public class CurrentProductFacilityConfig extends AbstractPersistableCustom<Long
     @Column(name = "inter_bank_total_cap_facility")
     private Boolean interBankTotalCapFacility = false;
 
-    @Column(name = "withdrawal_facility")
-    private Boolean withdrawalFacility = false;
-
     @Column(name = "deposit_facility_kyc")
     private Boolean depositFacilityKyc = false;
 
@@ -125,8 +122,6 @@ public class CurrentProductFacilityConfig extends AbstractPersistableCustom<Long
     public void setRtgsFacility(Boolean v) { this.rtgsFacility = v != null ? v : false; }
     public Boolean getInterBankTotalCapFacility() { return interBankTotalCapFacility; }
     public void setInterBankTotalCapFacility(Boolean v) { this.interBankTotalCapFacility = v != null ? v : false; }
-    public Boolean getWithdrawalFacility() { return withdrawalFacility; }
-    public void setWithdrawalFacility(Boolean v) { this.withdrawalFacility = v != null ? v : false; }
     public Boolean getDepositFacilityKyc() { return depositFacilityKyc; }
     public void setDepositFacilityKyc(Boolean v) { this.depositFacilityKyc = v != null ? v : false; }
     public Boolean getVirtualDebitCard() { return virtualDebitCard; }
@@ -147,7 +142,6 @@ public class CurrentProductFacilityConfig extends AbstractPersistableCustom<Long
         this.neftFacility = other.getNeftFacility();
         this.rtgsFacility = other.getRtgsFacility();
         this.interBankTotalCapFacility = other.getInterBankTotalCapFacility();
-        this.withdrawalFacility = other.getWithdrawalFacility();
         this.depositFacilityKyc = other.getDepositFacilityKyc();
         this.virtualDebitCard = other.getVirtualDebitCard();
     }

fineract-current-product/src/main/java/org/apache/fineract/portfolio/currentproduct/service/CurrentProductReadPlatformServiceImpl.java

@@ -117,7 +117,6 @@ public class CurrentProductReadPlatformServiceImpl implements CurrentProductRead
                     facilityConfigMap.put("neftFacility", facilityConfig.getNeftFacility());
                     facilityConfigMap.put("rtgsFacility", facilityConfig.getRtgsFacility());
                     facilityConfigMap.put("interBankTotalCapFacility", facilityConfig.getInterBankTotalCapFacility());
-                    facilityConfigMap.put("withdrawalFacility", facilityConfig.getWithdrawalFacility());
                     facilityConfigMap.put("depositFacilityKyc", facilityConfig.getDepositFacilityKyc());
                     facilityConfigMap.put("virtualDebitCard", facilityConfig.getVirtualDebitCard());
                     product.setAccountFacilityConfig(facilityConfigMap);

fineract-provider/src/main/java/org/apache/fineract/accounting/dividendpaidreport/api/DividendYearwiseReportApiResource.java

@@ -0,0 +1,185 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.accounting.dividendpaidreport.api;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.core.MediaType;
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import lombok.RequiredArgsConstructor;
+import org.apache.fineract.infrastructure.security.service.PlatformSecurityContext;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Component;
+
+/**
+ * Every declared dividend, financial year by financial year: how much was declared, how much members have collected,
+ * how much is still unclaimed, and how much has come back to profit.
+ *
+ * The GL accounts are shared across years, so their balances only ever give running totals — "how much of FY 2026-27 is
+ * still unclaimed" cannot be read off Dividend Payable. This walks the declarations themselves instead: locks carry the
+ * per-member entitlement and their status says what became of it, which is the authoritative record. The GL is where the
+ * money moved; the locks are what it moved for.
+ *
+ * The columns mirror the money's actual path, which begins and ends in the same place:
+ *
+ * <pre>
+ *   declare          Dr Bank Profit        Cr Dividend Payable
+ *   member claims    Dr Dividend Payable   Cr Dividend Paid  →  Cr Sponsor DD Payable
+ *   3 yrs unclaimed  Dr Dividend Payable   Cr Bank Profit
+ * </pre>
+ *
+ * So for a closed year, claimed + forfeited + rounding residue should account for the whole declaration; anything left
+ * is what is still sitting unclaimed and still within its three-year window.
+ */
+@Path("/v1/accounting/dividend-yearwise-report")
+@Component
+@Tag(name = "Dividend Year-wise Report", description = "Declared, claimed, unclaimed and forfeited dividend per financial year.")
+@RequiredArgsConstructor
+public class DividendYearwiseReportApiResource {
+
+    private static final String RESOURCE_NAME_FOR_PERMISSIONS = "DIVIDEND_SHAREPRODUCT";
+
+    private final JdbcTemplate jdbcTemplate;
+    private final PlatformSecurityContext context;
+    private final Gson gson = new GsonBuilder().serializeNulls().create();
+
+    @GET
+    @Produces(MediaType.APPLICATION_JSON)
+    public String report() {
+        this.context.authenticatedUser().validateHasReadPermission(RESOURCE_NAME_FOR_PERMISSIONS);
+
+        // A declaration is labelled by the financial year its period CLOSES in, which is how a member
+        // and an auditor both refer to it: a period ending 31-Mar-2027 is FY 2026-27. Locks are joined
+        // through the per-member detail rather than counted off the declaration, because a lock is only
+        // created for a member who actually had something to collect.
+        // Declared amounts and lock outcomes are aggregated separately before being joined by year.
+        // Summing the declaration amount across a join to its locks would multiply it by the number
+        // of members it was split between.
+        final List<Map<String, Object>> rows = jdbcTemplate.queryForList("""
+                WITH fy AS (
+                    SELECT d.id,
+                           CASE WHEN EXTRACT(MONTH FROM d.dividend_period_end_date) >= 4
+                                THEN EXTRACT(YEAR FROM d.dividend_period_end_date)
+                                ELSE EXTRACT(YEAR FROM d.dividend_period_end_date) - 1 END AS fy_start,
+                           d.amount
+                    FROM m_share_product_dividend_pay_out d
+                ),
+                declared AS (
+                    SELECT fy_start, COUNT(*) AS declaration_count, SUM(amount) AS declared_amount
+                    FROM fy GROUP BY fy_start
+                ),
+                outcomes AS (
+                    SELECT fy.fy_start,
+                           COALESCE(SUM(CASE WHEN l.status = 'CLAIMED'   THEN l.amount ELSE 0 END), 0) AS claimed_amount,
+                           COUNT(l.id) FILTER (WHERE l.status = 'CLAIMED')   AS claimed_count,
+                           COALESCE(SUM(CASE WHEN l.status = 'UNCLAIMED' THEN l.amount ELSE 0 END), 0) AS unclaimed_amount,
+                           COUNT(l.id) FILTER (WHERE l.status = 'UNCLAIMED') AS unclaimed_count,
+                           COALESCE(SUM(CASE WHEN l.status = 'FORFEITED' THEN l.amount ELSE 0 END), 0) AS forfeited_amount,
+                           COUNT(l.id) FILTER (WHERE l.status = 'FORFEITED') AS forfeited_count,
+                           MIN(l.release_due_date) FILTER (WHERE l.status = 'UNCLAIMED') AS earliest_release_due
+                    FROM fy
+                    LEFT JOIN m_share_account_dividend_details sad ON sad.dividend_pay_out_id = fy.id
+                    LEFT JOIN m_share_dividend_lock l ON l.dividend_detail_id = sad.id
+                    GROUP BY fy.fy_start
+                )
+                SELECT d.fy_start, d.declaration_count, d.declared_amount,
+                       COALESCE(o.claimed_amount, 0) AS claimed_amount, COALESCE(o.claimed_count, 0) AS claimed_count,
+                       COALESCE(o.unclaimed_amount, 0) AS unclaimed_amount, COALESCE(o.unclaimed_count, 0) AS unclaimed_count,
+                       COALESCE(o.forfeited_amount, 0) AS forfeited_amount, COALESCE(o.forfeited_count, 0) AS forfeited_count,
+                       o.earliest_release_due
+                FROM declared d
+                LEFT JOIN outcomes o ON o.fy_start = d.fy_start
+                ORDER BY d.fy_start DESC
+                """);
+
+        // Rounding residue is tracked per declaration rather than per lock — it never belonged to a
+        // member, so no lock was ever created for it. Pulled separately and matched by year.
+        final Map<String, BigDecimal> residueByYear = new LinkedHashMap<>();
+        for (final Map<String, Object> row : jdbcTemplate.queryForList("""
+                SELECT CASE WHEN EXTRACT(MONTH FROM period_end_date) >= 4
+                            THEN EXTRACT(YEAR FROM period_end_date)
+                            ELSE EXTRACT(YEAR FROM period_end_date) - 1 END AS fy_start,
+                       COALESCE(SUM(residue_amount), 0) AS residue
+                FROM m_share_dividend_rounding_residue
+                GROUP BY fy_start
+                """)) {
+            residueByYear.put(financialYearLabel(((Number) row.get("fy_start")).intValue()), (BigDecimal) row.get("residue"));
+        }
+
+        final List<Map<String, Object>> years = new ArrayList<>();
+        BigDecimal totalDeclared = BigDecimal.ZERO;
+        BigDecimal totalClaimed = BigDecimal.ZERO;
+        BigDecimal totalUnclaimed = BigDecimal.ZERO;
+        BigDecimal totalForfeited = BigDecimal.ZERO;
+
+        for (final Map<String, Object> row : rows) {
+            final String financialYear = financialYearLabel(((Number) row.get("fy_start")).intValue());
+            final BigDecimal declared = (BigDecimal) row.get("declared_amount");
+            final BigDecimal claimed = (BigDecimal) row.get("claimed_amount");
+            final BigDecimal unclaimed = (BigDecimal) row.get("unclaimed_amount");
+            final BigDecimal forfeited = (BigDecimal) row.get("forfeited_amount");
+            final BigDecimal residue = residueByYear.getOrDefault(financialYear, BigDecimal.ZERO);
+
+            final Map<String, Object> entry = new LinkedHashMap<>();
+            entry.put("financialYear", financialYear);
+            entry.put("declarationCount", row.get("declaration_count"));
+            entry.put("declaredAmount", declared);
+            entry.put("claimedAmount", claimed);
+            entry.put("claimedCount", row.get("claimed_count"));
+            entry.put("unclaimedAmount", unclaimed);
+            entry.put("unclaimedCount", row.get("unclaimed_count"));
+            entry.put("forfeitedAmount", forfeited);
+            entry.put("forfeitedCount", row.get("forfeited_count"));
+            entry.put("roundingResidueAmount", residue);
+            // What has already gone back to profit for this year: forfeited entitlements plus the
+            // rounding residue swept at declaration time.
+            entry.put("returnedToProfitAmount", forfeited.add(residue));
+            // When this year's oldest unclaimed lock forfeits — the date the remaining unclaimed
+            // amount starts returning to profit.
+            entry.put("earliestReleaseDueDate",
+                    row.get("earliest_release_due") == null ? null : String.valueOf(row.get("earliest_release_due")));
+            years.add(entry);
+
+            totalDeclared = totalDeclared.add(declared);
+            totalClaimed = totalClaimed.add(claimed);
+            totalUnclaimed = totalUnclaimed.add(unclaimed);
+            totalForfeited = totalForfeited.add(forfeited);
+        }
+
+        final Map<String, Object> response = new LinkedHashMap<>();
+        response.put("years", years);
+        response.put("totalDeclared", totalDeclared);
+        response.put("totalClaimed", totalClaimed);
+        response.put("totalUnclaimed", totalUnclaimed);
+        response.put("totalForfeited", totalForfeited);
+        return gson.toJson(response);
+    }
+
+    private String financialYearLabel(final int startYear) {
+        return startYear + "-" + String.format("%02d", (startYear + 1) % 100);
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/accounting/journalentry/service/AccountingProcessorHelper.java

@@ -1263,6 +1263,11 @@ public class AccountingProcessorHelper {
                     accountMapping = paymentChannelSpecificAccountMapping;
                 }
             }
+
+            if (accountMapping == null) {
+                throw new ProductToGLAccountMappingNotFoundException(PortfolioProductType.SAVING, savingsProductId,
+                        CashAccountsForSavings.fromInt(accountMappingTypeId).toString());
+            }
             glAccount = accountMapping.getGlAccount();
         }
         return glAccount;

fineract-provider/src/main/java/org/apache/fineract/accounting/journalentry/service/JournalEntryWritePlatformServiceJpaRepositoryImpl.java

@@ -24,6 +24,7 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
+import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -104,6 +105,8 @@ import org.apache.fineract.portfolio.loanaccount.domain.LoanTransactionRepositor
 import org.apache.fineract.portfolio.loanproduct.service.LoanEnumerations;
 import org.apache.fineract.portfolio.paymentdetail.domain.PaymentDetail;
 import org.apache.fineract.portfolio.paymentdetail.service.PaymentDetailWritePlatformService;
+import org.apache.fineract.portfolio.voucher.service.VoucherLine;
+import org.apache.fineract.portfolio.voucher.service.VoucherService;
 import org.apache.fineract.useradministration.domain.AppUser;
 import org.springframework.dao.DataIntegrityViolationException;
 import org.springframework.dao.NonTransientDataAccessException;
@@ -136,6 +139,7 @@ public class JournalEntryWritePlatformServiceJpaRepositoryImpl implements Journa
     private final ExternalAssetOwnerRepository externalAssetOwnerRepository;
     private final LoanAmortizationAllocationMappingRepository loanAmortizationAllocationMappingRepository;
     private final LoanTransactionRepository loanTransactionRepository;
+    private final VoucherService voucherService;
 
     @Transactional
     @Override
@@ -232,14 +236,73 @@ public class JournalEntryWritePlatformServiceJpaRepositoryImpl implements Journa
 
             }
 
+            // Raise the voucher from the entries that were actually written, rather than from the
+            // command: an accounting rule can supply a side the request never named, so reading
+            // back by transaction id is the only view that matches what the ledger now holds.
+            final String voucherNo = raiseJournalVoucher(transactionId);
+            if (voucherNo != null) {
+                changes.put("voucherNo", voucherNo);
+            }
+
             return new CommandProcessingResultBuilder().withCommandId(command.commandId()).withOfficeId(officeId)
-                    .withTransactionId(transactionId).build();
+                    .withTransactionId(transactionId).with(changes).build();
         } catch (final JpaSystemException | DataIntegrityViolationException dve) {
             final Throwable throwable = dve.getMostSpecificCause();
             throw handleJournalEntryDataIntegrityIssues(throwable, dve);
         }
     }
 
+    /**
+     * Records a manual journal in the voucher register and returns its number.
+     *
+     * The sides are read back from the entries just written rather than taken from the request,
+     * because an accounting rule can contribute a debit or credit the caller never named; only the
+     * persisted rows show what the ledger actually holds.
+     *
+     * A failure here does not fail the journal. The entries are already posted and correct, and
+     * refusing them because the register could not be written would reject a sound accounting
+     * transaction over its paperwork. The problem is logged and the journal stands without a
+     * voucher, which reads as a gap in the register rather than as a missing ledger entry.
+     */
+    private String raiseJournalVoucher(final String transactionId) {
+        // A register that posts its ledger movement through this command raises its own voucher,
+        // naming the member and the instrument. Raising a journal one beside it would put the same
+        // money in the register twice.
+        if (!this.voucherService.shouldRaiseVoucher()) {
+            return null;
+        }
+
+        try {
+            final List<JournalEntry> entries = this.glJournalEntryRepository
+                    .findUnReversedManualJournalEntriesByTransactionId(transactionId);
+            if (CollectionUtils.isEmpty(entries)) {
+                return null;
+            }
+
+            final List<VoucherLine> lines = new ArrayList<>();
+            for (final JournalEntry entry : entries) {
+                final GLAccount account = entry.getGlAccount();
+                final Long accountId = account == null ? null : account.getId();
+                final String name = account == null ? null : account.getName();
+                final String code = account == null ? null : account.getGlCode();
+
+                final VoucherLine line = entry.isDebitEntry() ? VoucherLine.debitGl(accountId, name, code, entry.getAmount())
+                        : VoucherLine.creditGl(accountId, name, code, entry.getAmount());
+                lines.add(entry.getDescription() == null ? line : line.withDescription(entry.getDescription()));
+            }
+
+            // Debits first, so the voucher prints the way a slip is read.
+            lines.sort(Comparator.comparing(VoucherLine::isDebit).reversed());
+
+            final AppUser currentUser = this.context.authenticatedUser();
+            return this.voucherService.createVoucherWithLines(VoucherService.TYPE_JOURNAL, VoucherService.REF_JOURNAL_ENTRY, null,
+                    transactionId, currentUser, VoucherService.PREFIX_JOURNAL, lines);
+        } catch (final RuntimeException e) {
+            log.error("Could not raise a voucher for journal transaction {}", transactionId, e);
+            return null;
+        }
+    }
+
     private void validateDebitOrCreditArrayForExistingGLAccount(final GLAccount glaccount,
             final SingleDebitOrCreditEntryCommand[] creditOrDebits) {
         /**

fineract-provider/src/main/java/org/apache/fineract/accounting/journalentry/starter/AccountingJournalEntryConfiguration.java

@@ -52,6 +52,7 @@ import org.apache.fineract.portfolio.charge.domain.ChargeRepositoryWrapper;
 import org.apache.fineract.portfolio.loanaccount.domain.LoanAmortizationAllocationMappingRepository;
 import org.apache.fineract.portfolio.loanaccount.domain.LoanTransactionRepository;
 import org.apache.fineract.portfolio.paymentdetail.service.PaymentDetailWritePlatformService;
+import org.apache.fineract.portfolio.voucher.service.VoucherService;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
@@ -98,12 +99,13 @@ public class AccountingJournalEntryConfiguration {
             ConfigurationReadPlatformService configurationReadPlatformService, AccountingService accountingService,
             ExternalAssetOwnerRepository externalAssetOwnerRepository,
             LoanAmortizationAllocationMappingRepository loanAmortizationAllocationMappingRepository,
-            LoanTransactionRepository loanTransactionRepository) {
+            LoanTransactionRepository loanTransactionRepository, VoucherService voucherService) {
         return new JournalEntryWritePlatformServiceJpaRepositoryImpl(glClosureRepository, glAccountRepository, glJournalEntryRepository,
                 officeRepositoryWrapper, accountingProcessorForLoanFactory, accountingProcessorForSavingsFactory,
                 accountingProcessorForSharesFactory, helper, fromApiJsonDeserializer, accountingRuleRepository,
                 glAccountReadPlatformService, organisationCurrencyRepository, context, paymentDetailWritePlatformService,
                 financialActivityAccountRepositoryWrapper, accountingProcessorForClientTransactions, configurationReadPlatformService,
-                accountingService, externalAssetOwnerRepository, loanAmortizationAllocationMappingRepository, loanTransactionRepository);
+                accountingService, externalAssetOwnerRepository, loanAmortizationAllocationMappingRepository, loanTransactionRepository,
+                voucherService);
     }
 }

fineract-provider/src/main/java/org/apache/fineract/accounting/profitandloss/api/DistributableProfitApiResource.java

@@ -0,0 +1,264 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.accounting.profitandloss.api;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.QueryParam;
+import jakarta.ws.rs.WebApplicationException;
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.Response;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.sql.Date;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import lombok.RequiredArgsConstructor;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Component;
+
+/**
+ * How much profit is available to fund a share dividend, for a given period.
+ *
+ * This is not what sizes a dividend — that is the declared rate on members' paid-up capital. It is what the society has
+ * to pay it with: the profit standing in the Bank Profit (Non-Distributable) GL, less every dividend already declared
+ * for another share product over the same period, since they all draw on the same balance.
+ *
+ * The statutory reserve and education fund are not deducted here. They are appropriated on the profit-distribution
+ * screen before any dividend is declared, so the balance this reads has already had them taken out; deducting them a
+ * second time would hold back money that has already left the account.
+ *
+ * Held in one place so the declaration screen and the declaration-time validation cannot disagree about the ceiling.
+ */
+@Path("/v1/accounting/distributable-profit")
+@Component
+@Tag(name = "Distributable Profit", description = "Profit available to fund a share dividend, less dividends already declared against the same period.")
+@RequiredArgsConstructor
+public class DistributableProfitApiResource {
+
+    /**
+     * The year's closed-out profit, which is what a dividend may be declared against; kept in step with
+     * IncomeProfitTransferService.PROFIT_GL_CODE.
+     *
+     * Deliberately not plain Bank Profit — that holds what earlier declarations left behind, and reading it here would
+     * offer profit already distributed once for distribution again.
+     */
+    private static final String PROFIT_GL_CODE = "BANKPROFITND01";
+
+    private static final String CONFIG_MAXIMUM_RATE = "dividend-maximum-rate-percentage";
+
+    private final JdbcTemplate jdbcTemplate;
+    private final Gson gson = new GsonBuilder().serializeNulls().create();
+
+    @GET
+    @Produces(MediaType.APPLICATION_JSON)
+    public String getDistributableProfit(@QueryParam("fromDate") final String fromDate, @QueryParam("toDate") final String toDate,
+            @QueryParam("excludeProductId") final Long excludeProductId) {
+        if (fromDate == null || fromDate.isBlank() || toDate == null || toDate.isBlank()) {
+            throw apiError(400, "fromDate and toDate (yyyy-MM-dd) are both required");
+        }
+        final Date from;
+        final Date to;
+        try {
+            from = Date.valueOf(fromDate);
+            to = Date.valueOf(toDate);
+        } catch (final IllegalArgumentException e) {
+            throw apiError(400, "fromDate and toDate must be in yyyy-MM-dd format");
+        }
+        if (to.before(from)) {
+            throw apiError(400, "toDate must not be before fromDate");
+        }
+
+        // A dividend is normally declared for a whole, closed financial year, and then the audited
+        // profit in Bank Profit is the figure to use. A period that is not a full financial year can
+        // only be an interim declaration, which necessarily runs against the still-open P&L.
+        final String financialYear = financialYearOf(from.toLocalDate());
+        final LocalDate[] fyRange = financialYearRange(financialYear);
+        final boolean coversWholeFinancialYear = !from.toLocalDate().isAfter(fyRange[0]) && !to.toLocalDate().isBefore(fyRange[1]);
+
+        final BigDecimal closedProfit = coversWholeFinancialYear ? closedProfitForFinancialYear(financialYear) : null;
+        final boolean yearClosed = closedProfit != null;
+        final BigDecimal netProfit = yearClosed ? closedProfit : netProfitForPeriod(from, to);
+
+        final BigDecimal maximumRatePercentage = configuredPercentage(CONFIG_MAXIMUM_RATE);
+
+        // The statutory reserve and education fund are NOT deducted here. They are appropriated on
+        // the profit-distribution screen before any dividend is declared, so the profit this reads
+        // has already had them taken out — subtracting them again would hold back money that is no
+        // longer in the account. A loss-making period funds nothing, so it collapses to zero rather
+        // than a negative figure a caller could read as a credit.
+        final BigDecimal distributableProfit = netProfit.signum() > 0 ? netProfit : BigDecimal.ZERO;
+
+        final List<Map<String, Object>> existingDeclarations = declarationsOverlapping(from, to, excludeProductId);
+        BigDecimal alreadyDeclared = BigDecimal.ZERO;
+        for (final Map<String, Object> declaration : existingDeclarations) {
+            alreadyDeclared = alreadyDeclared.add((BigDecimal) declaration.get("amount"));
+        }
+
+        // An over-declaration that already happened (or appropriation rates raised after the fact)
+        // must not present as negative headroom, which a caller could read as a credit.
+        final BigDecimal availableForDeclaration = distributableProfit.subtract(alreadyDeclared).max(BigDecimal.ZERO);
+
+        final Map<String, Object> response = new LinkedHashMap<>();
+        response.put("fromDate", fromDate);
+        response.put("toDate", toDate);
+        response.put("financialYear", financialYear);
+        response.put("coversWholeFinancialYear", coversWholeFinancialYear);
+        response.put("yearClosed", yearClosed);
+        // Names the figure so the screen can say where it came from — the closed books, or a P&L
+        // that is still moving — rather than showing a bare number the officer has to interpret.
+        response.put("profitSource", yearClosed ? "BANK_PROFIT_GL" : "OPEN_PROFIT_AND_LOSS");
+        response.put("netProfit", netProfit);
+        response.put("distributableProfit", distributableProfit);
+        response.put("alreadyDeclared", alreadyDeclared);
+        response.put("availableForDeclaration", availableForDeclaration);
+        response.put("maximumRatePercentage", maximumRatePercentage);
+        response.put("existingDeclarations", existingDeclarations);
+        return gson.toJson(response);
+    }
+
+    /**
+     * The year's profit as the books actually record it, once the year has been closed.
+     *
+     * A dividend is declared out of the AUDITED profit of a completed financial year, and that figure lives in the
+     * Bank Profit equity GL after year-end closing moves every income and expense GL into it. Reading it here — rather
+     * than re-deriving income-less-expense — means the dividend can never disagree with the closed books: if a
+     * closing entry was adjusted, reversed, or posted late, the dividend ceiling moves with it.
+     *
+     * Returns null when the year has not been closed, which the caller reports as a blocking condition rather than
+     * silently falling back to the live P&L. Distributing against an unclosed year would be distributing a profit
+     * figure that is still moving.
+     */
+    private BigDecimal closedProfitForFinancialYear(final String financialYear) {
+        final Integer closedCount = jdbcTemplate.queryForObject(
+                "SELECT COUNT(*) FROM m_income_profit_transfer WHERE financial_year = ?", Integer.class, financialYear);
+        if (closedCount == null || closedCount == 0) {
+            return null;
+        }
+        final LocalDate[] range = financialYearRange(financialYear);
+        final BigDecimal balance = jdbcTemplate.queryForObject("""
+                SELECT COALESCE(SUM(CASE WHEN je.type_enum = 1 THEN je.amount ELSE -je.amount END), 0)
+                FROM acc_gl_journal_entry je
+                JOIN acc_gl_account a ON a.id = je.account_id
+                WHERE a.gl_code = ? AND je.reversed = false AND je.entry_date BETWEEN ? AND ?
+                """, BigDecimal.class, PROFIT_GL_CODE, java.sql.Date.valueOf(range[0]), java.sql.Date.valueOf(range[1]));
+        return balance == null ? BigDecimal.ZERO : balance;
+    }
+
+    /** "2026-27" -> 1 April 2026 to 31 March 2027. */
+    private LocalDate[] financialYearRange(final String financialYear) {
+        try {
+            final int startYear = Integer.parseInt(financialYear.substring(0, 4));
+            return new LocalDate[] { LocalDate.of(startYear, 4, 1), LocalDate.of(startYear + 1, 3, 31) };
+        } catch (final RuntimeException e) {
+            throw apiError(400, "financialYear must look like 2026-27. Received: " + financialYear);
+        }
+    }
+
+    /** The Indian financial year a date falls in, as a "YYYY-YY" label. */
+    private String financialYearOf(final LocalDate date) {
+        final int startYear = date.getMonthValue() >= 4 ? date.getYear() : date.getYear() - 1;
+        return startYear + "-" + String.format("%02d", (startYear + 1) % 100);
+    }
+
+    /**
+     * Same income-less-expense computation as {@link ProfitAndLossApiResource}, over posted, non-reversed journal
+     * entries only. Used only for the interim case — a period inside a year that has not been closed yet.
+     */
+    private BigDecimal netProfitForPeriod(final Date from, final Date to) {
+        final Map<String, Object> row = jdbcTemplate.queryForMap("""
+                SELECT
+                    COALESCE(SUM(CASE WHEN a.classification_enum = 4 AND je.type_enum = 1 THEN je.amount
+                                       WHEN a.classification_enum = 4 AND je.type_enum = 2 THEN -je.amount
+                                       ELSE 0 END), 0) AS total_income,
+                    COALESCE(SUM(CASE WHEN a.classification_enum = 5 AND je.type_enum = 2 THEN je.amount
+                                       WHEN a.classification_enum = 5 AND je.type_enum = 1 THEN -je.amount
+                                       ELSE 0 END), 0) AS total_expense
+                FROM acc_gl_journal_entry je
+                JOIN acc_gl_account a ON a.id = je.account_id
+                WHERE je.reversed = false
+                  AND je.entry_date BETWEEN ? AND ?
+                """, from, to);
+        final BigDecimal totalIncome = (BigDecimal) row.get("total_income");
+        final BigDecimal totalExpense = (BigDecimal) row.get("total_expense");
+        return totalIncome.subtract(totalExpense);
+    }
+
+    /**
+     * Every dividend already declared against a period overlapping this one, across ALL share products — the profit is
+     * society-wide, so a second product's declaration competes for the same balance as the first.
+     *
+     * excludeProductId lets the declaration screen leave out the product being declared for, whose own overlapping
+     * declaration is separately blocked outright.
+     */
+    private List<Map<String, Object>> declarationsOverlapping(final Date from, final Date to, final Long excludeProductId) {
+        final StringBuilder sql = new StringBuilder("""
+                SELECT d.id AS declaration_id, d.product_id, p.name AS product_name, d.amount,
+                       d.dividend_period_start_date, d.dividend_period_end_date, d.status
+                FROM m_share_product_dividend_pay_out d
+                JOIN m_share_product p ON p.id = d.product_id
+                WHERE d.dividend_period_start_date <= ? AND d.dividend_period_end_date >= ?
+                """);
+        final List<Object> params = new ArrayList<>(List.of(to, from));
+        if (excludeProductId != null) {
+            sql.append(" AND d.product_id <> ? ");
+            params.add(excludeProductId);
+        }
+        sql.append(" ORDER BY d.dividend_period_start_date, d.id");
+
+        final List<Map<String, Object>> declarations = new ArrayList<>();
+        for (final Map<String, Object> row : jdbcTemplate.queryForList(sql.toString(), params.toArray())) {
+            final Map<String, Object> declaration = new LinkedHashMap<>();
+            declaration.put("declarationId", row.get("declaration_id"));
+            declaration.put("productId", row.get("product_id"));
+            declaration.put("productName", row.get("product_name"));
+            declaration.put("amount", row.get("amount"));
+            declaration.put("periodStartDate", String.valueOf(row.get("dividend_period_start_date")));
+            declaration.put("periodEndDate", String.valueOf(row.get("dividend_period_end_date")));
+            declaration.put("status", row.get("status"));
+            declarations.add(declaration);
+        }
+        return declarations;
+    }
+
+    /**
+     * A missing or disabled configuration row means the society does not make that appropriation (or has no ceiling),
+     * which is 0 — not a failure. Only an enabled row with a value applies.
+     */
+    private BigDecimal configuredPercentage(final String configurationName) {
+        final List<Map<String, Object>> rows = jdbcTemplate
+                .queryForList("SELECT value FROM c_configuration WHERE name = ? AND enabled = true", configurationName);
+        if (rows.isEmpty() || rows.get(0).get("value") == null) {
+            return BigDecimal.ZERO;
+        }
+        return new BigDecimal(String.valueOf(rows.get(0).get("value")));
+    }
+
+    private WebApplicationException apiError(final int httpStatus, final String message) {
+        return new WebApplicationException(
+                Response.status(httpStatus).entity(gson.toJson(Map.of("message", message))).type(MediaType.APPLICATION_JSON).build());
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/accounting/yearend/api/IncomeProfitTransferApiResource.java

@@ -0,0 +1,180 @@
+package org.apache.fineract.accounting.yearend.api;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import jakarta.ws.rs.Consumes;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.POST;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.QueryParam;
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.Response;
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import lombok.RequiredArgsConstructor;
+import org.apache.fineract.accounting.yearend.service.IncomeProfitTransferService;
+import org.apache.fineract.infrastructure.core.exception.PlatformDataIntegrityException;
+import org.apache.fineract.infrastructure.security.service.PlatformSecurityContext;
+import org.apache.fineract.useradministration.domain.AppUser;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * Financial year-end closing of the share entry fee into the Bank Profit equity GL.
+ *
+ * <p>
+ * {@code GET} reports how much is waiting to be posted for the year and what has been posted before; {@code POST}
+ * performs the closing. The scheduled job {@code Post Share Entry Fee To Profit} runs the same service on 31 March, so
+ * this endpoint is the manual equivalent — useful when the job did not run, or the accountant wants to close early.
+ */
+@Path("/v1/accounting/incomeprofittransfer")
+@Component
+@RequiredArgsConstructor
+@Consumes({ MediaType.APPLICATION_JSON })
+@Produces({ MediaType.APPLICATION_JSON })
+public class IncomeProfitTransferApiResource {
+
+    private final PlatformSecurityContext context;
+    private final JdbcTemplate jdbcTemplate;
+    private final IncomeProfitTransferService service;
+    private final Gson gson = new Gson();
+
+    // ══════════════════════════════════════════════════════════════════════
+    // GET — how much is waiting to be posted, and what has been posted before
+    // ══════════════════════════════════════════════════════════════════════
+    @GET
+    public Response preview(@QueryParam("incomeGlCode") final String incomeGlCodeParam,
+            @QueryParam("financialYear") final String financialYearParam) {
+
+        this.context.authenticatedUser();
+
+        final String incomeGlCode = incomeGlCodeParam == null || incomeGlCodeParam.isBlank()
+                ? IncomeProfitTransferService.DEFAULT_INCOME_GL_CODE
+                : incomeGlCodeParam.trim();
+        final Map<String, Object> incomeGl = service.loadGlByCode(incomeGlCode);
+        final Map<String, Object> profitGl = service.loadGlByCode(IncomeProfitTransferService.PROFIT_GL_CODE);
+
+        final String financialYear = financialYearParam == null || financialYearParam.isBlank() ? service.currentFinancialYear()
+                : financialYearParam.trim();
+        final LocalDate[] range = service.financialYearRange(financialYear);
+
+        final Long incomeGlId = toLong(incomeGl.get("id"));
+        final BigDecimal pending = service.balanceOf(incomeGlId, range);
+        final int entryCount = service.entryCountOf(incomeGlId, range);
+
+        final List<Map<String, Object>> history = jdbcTemplate
+                .queryForList("SELECT t.id, t.financial_year, t.amount, t.entry_count, t.posted_on_date, t.posted_by_name, "
+                        + " t.gl_transaction_id, g.gl_code AS income_gl_code, g.name AS income_gl_name "
+                        + " FROM m_income_profit_transfer t JOIN acc_gl_account g ON g.id = t.income_gl_id "
+                        + " WHERE t.income_gl_id = ? ORDER BY t.financial_year DESC, t.id DESC", incomeGlId);
+
+        final boolean alreadyPosted = history.stream().anyMatch(h -> financialYear.equals(h.get("financial_year")));
+
+        final Map<String, Object> out = new LinkedHashMap<>();
+        out.put("financialYear", financialYear);
+        out.put("fromDate", range[0].toString());
+        out.put("toDate", range[1].toString());
+        out.put("incomeGlCode", incomeGl.get("gl_code"));
+        out.put("incomeGlName", incomeGl.get("name"));
+        out.put("profitGlCode", profitGl.get("gl_code"));
+        out.put("profitGlName", profitGl.get("name"));
+        out.put("pendingAmount", pending);
+        out.put("entryCount", entryCount);
+        out.put("alreadyPosted", alreadyPosted);
+        out.put("postedHistory", history);
+        out.put("totalPostedToProfit", history.stream().map(h -> (BigDecimal) h.get("amount")).reduce(BigDecimal.ZERO, BigDecimal::add));
+        return Response.ok(gson.toJson(out)).build();
+    }
+
+    // ══════════════════════════════════════════════════════════════════════
+    // POST — close the income GL into Bank Profit
+    // ══════════════════════════════════════════════════════════════════════
+    @POST
+    @Transactional
+    public Response post(final String body) {
+
+        final AppUser currentUser = this.context.authenticatedUser();
+        currentUser.validateHasPermissionTo("CREATE_JOURNALENTRY");
+
+        final JsonObject json = parseBody(body);
+        final String incomeGlCode = getString(json, "incomeGlCode") == null ? IncomeProfitTransferService.DEFAULT_INCOME_GL_CODE
+                : getString(json, "incomeGlCode").trim();
+        final String financialYear = getString(json, "financialYear") == null ? service.currentFinancialYear()
+                : getString(json, "financialYear").trim();
+
+        // strict = true: a manual posting reports "already closed" or "nothing to post" as an
+        // error, so the user is told why nothing happened.
+        final Map<String, Object> result = service.postToProfit(incomeGlCode, financialYear, currentUser.getId(), currentUser.getUsername(),
+                sanitiseNote(getString(json, "note")), true);
+
+        return Response.ok(gson.toJson(result)).build();
+    }
+
+    // ══════════════════════════════════════════════════════════════════════
+    // POST /close-year — close the WHOLE P&L into Bank Profit
+    // ══════════════════════════════════════════════════════════════════════
+
+    /**
+     * Closes every income and expense GL for the year, so Bank Profit ends up holding the year's real net profit.
+     *
+     * This is the full year-end close; the endpoint above closes one named income GL and remains for the narrower
+     * share-entry-fee case. The share dividend declaration reads Bank Profit as the year's profit, so it is this that
+     * has to have run — after a single-GL posting the rest of the profit is still sitting in the income accounts.
+     */
+    @POST
+    @Path("/close-year")
+    @Transactional
+    public Response closeYear(final String body) {
+
+        final AppUser currentUser = this.context.authenticatedUser();
+        currentUser.validateHasPermissionTo("CREATE_JOURNALENTRY");
+
+        final JsonObject json = parseBody(body);
+        final String financialYear = getString(json, "financialYear") == null ? service.currentFinancialYear()
+                : getString(json, "financialYear").trim();
+
+        // strict = true: a manual close reports "nothing left to close" as an error, so the user is
+        // told why nothing happened rather than getting a silent success.
+        final Map<String, Object> result = service.closeAllToProfit(financialYear, currentUser.getId(), currentUser.getUsername(),
+                sanitiseNote(getString(json, "note")), true);
+
+        return Response.ok(gson.toJson(result)).build();
+    }
+
+    // ══════════════════════════════════════════════════════════════════════
+    // Helpers
+    // ══════════════════════════════════════════════════════════════════════
+
+    private JsonObject parseBody(final String body) {
+        if (body == null || body.isBlank()) {
+            return new JsonObject();
+        }
+        try {
+            return JsonParser.parseString(body).getAsJsonObject();
+        } catch (RuntimeException e) {
+            throw new PlatformDataIntegrityException("error.msg.incomeprofit.request.invalid", "Request body must be valid JSON.");
+        }
+    }
+
+    private String sanitiseNote(final String raw) {
+        if (raw == null || raw.isBlank()) {
+            return null;
+        }
+        final String trimmed = raw.trim();
+        return trimmed.length() > 490 ? trimmed.substring(0, 490) : trimmed;
+    }
+
+    private String getString(final JsonObject json, final String field) {
+        return json.has(field) && !json.get(field).isJsonNull() ? json.get(field).getAsString() : null;
+    }
+
+    private Long toLong(final Object o) {
+        return o instanceof Number ? ((Number) o).longValue() : null;
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/accounting/yearend/jobs/postshareentryfeetoprofit/PostShareEntryFeeToProfitConfig.java

@@ -0,0 +1,60 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.accounting.yearend.jobs.postshareentryfeetoprofit;
+
+import org.apache.fineract.accounting.yearend.service.IncomeProfitTransferService;
+import org.apache.fineract.infrastructure.jobs.service.JobName;
+import org.springframework.batch.core.Job;
+import org.springframework.batch.core.Step;
+import org.springframework.batch.core.job.builder.JobBuilder;
+import org.springframework.batch.core.launch.support.RunIdIncrementer;
+import org.springframework.batch.core.repository.JobRepository;
+import org.springframework.batch.core.step.builder.StepBuilder;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.transaction.PlatformTransactionManager;
+
+@Configuration
+public class PostShareEntryFeeToProfitConfig {
+
+    @Autowired
+    private JobRepository jobRepository;
+    @Autowired
+    private PlatformTransactionManager transactionManager;
+    @Autowired
+    private IncomeProfitTransferService incomeProfitTransferService;
+
+    @Bean
+    protected Step postShareEntryFeeToProfitStep() {
+        return new StepBuilder(JobName.POST_SHARE_ENTRY_FEE_TO_PROFIT.name(), jobRepository)
+                .tasklet(postShareEntryFeeToProfitTasklet(), transactionManager).build();
+    }
+
+    @Bean
+    public Job postShareEntryFeeToProfitJob() {
+        return new JobBuilder(JobName.POST_SHARE_ENTRY_FEE_TO_PROFIT.name(), jobRepository).start(postShareEntryFeeToProfitStep())
+                .incrementer(new RunIdIncrementer()).build();
+    }
+
+    @Bean
+    public PostShareEntryFeeToProfitTasklet postShareEntryFeeToProfitTasklet() {
+        return new PostShareEntryFeeToProfitTasklet(incomeProfitTransferService);
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/accounting/yearend/jobs/postshareentryfeetoprofit/PostShareEntryFeeToProfitTasklet.java

@@ -0,0 +1,61 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.accounting.yearend.jobs.postshareentryfeetoprofit;
+
+import java.util.Map;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.fineract.accounting.yearend.service.IncomeProfitTransferService;
+import org.springframework.batch.core.StepContribution;
+import org.springframework.batch.core.scope.context.ChunkContext;
+import org.springframework.batch.core.step.tasklet.Tasklet;
+import org.springframework.batch.repeat.RepeatStatus;
+
+/**
+ * Year-end closing of the share entry fee: on 31 March the balance of Share Entry Fee Income is posted to the Bank
+ * Profit equity GL, leaving the income account at nil for the new year.
+ *
+ * <p>
+ * Runs unattended, so a no-op (already closed for the year, or no fee collected) is a normal outcome and is logged
+ * rather than failing the job. Only a genuine posting failure is raised.
+ */
+@Slf4j
+@RequiredArgsConstructor
+public class PostShareEntryFeeToProfitTasklet implements Tasklet {
+
+    /** Fineract's system user id, used because a scheduled run has no logged-in user. */
+    private static final long SYSTEM_USER_ID = 1L;
+
+    private final IncomeProfitTransferService incomeProfitTransferService;
+
+    @Override
+    public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
+        final String financialYear = incomeProfitTransferService.currentFinancialYear();
+
+        // Closes the WHOLE P&L, not just the share entry fee it was originally written for. Bank Profit
+        // is now what the share dividend declaration reads as "the year's profit", and a partial close
+        // would leave most of the profit still sitting in the income GLs — understating what may be
+        // distributed. Per-GL guards inside closeAllToProfit make a re-run safe.
+        final Map<String, Object> result = incomeProfitTransferService.closeAllToProfit(financialYear, SYSTEM_USER_ID, "system",
+                "Automatic year-end closing", false);
+
+        log.info("Year-end closing for {}: {}", financialYear, result.get("message"));
+        return RepeatStatus.FINISHED;
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/accounting/yearend/service/IncomeProfitTransferService.java

@@ -0,0 +1,377 @@
+package org.apache.fineract.accounting.yearend.service;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.ZoneOffset;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.fineract.infrastructure.core.exception.PlatformDataIntegrityException;
+import org.apache.fineract.infrastructure.core.service.DateUtils;
+import org.springframework.dao.EmptyResultDataAccessException;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * Closes an income GL into the Bank Profit equity GL at financial year end.
+ *
+ * <pre>
+ *   Dr  Share Entry Fee Income (10.4)   = balance for the year
+ *   Cr  Bank Profit (BANKPROFIT01)
+ * </pre>
+ *
+ * Debiting the income account brings it back to nil so the new year starts clean; the credit accumulates in equity as
+ * retained profit.
+ *
+ * <p>
+ * Shared by the scheduled year-end job and the manual posting endpoint, so both paths post identical entries and are
+ * protected by the same "once per year" guard. The caller supplies the acting user id because the job runs without a
+ * logged-in user.
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class IncomeProfitTransferService {
+
+    // Fineract convention: 1 = CREDIT, 2 = DEBIT.
+    private static final int DEBIT = 2;
+    private static final int CREDIT = 1;
+
+    /** Equity GL that accumulates profit. */
+    /**
+     * The year's profit is closed into the Non-Distributable account, not plain Bank Profit.
+     *
+     * A dividend is declared against this balance; whatever the members do not receive moves across to Bank Profit once
+     * the declaration is approved. Closing into Bank Profit directly would mix the year just ended with earlier years'
+     * leftovers, and the next declaration would be sized on profit that had already been through a distribution
+     * decision — offering the same money for distribution twice.
+     */
+    public static final String PROFIT_GL_CODE = "BANKPROFITND01";
+
+    /** Income GL closed to profit by the year-end job — the share entry fee. */
+    public static final String DEFAULT_INCOME_GL_CODE = "10.4";
+
+    private final JdbcTemplate jdbcTemplate;
+
+    /**
+     * Posts the year-end transfer. Returns a summary of what was posted, or a summary with {@code posted = false} when
+     * there was nothing to do (already closed, or a nil balance) — those are normal outcomes for a scheduled run, not
+     * errors.
+     *
+     * @param strict
+     *            when true (manual posting) a no-op raises an error so the user sees why; when false (scheduled job) it
+     *            returns quietly.
+     */
+    @Transactional
+    public Map<String, Object> postToProfit(final String incomeGlCode, final String financialYear, final Long userId, final String userName,
+            final String note, final boolean strict) {
+
+        final Map<String, Object> incomeGl = loadGlByCode(incomeGlCode);
+        final Map<String, Object> profitGl = loadGlByCode(PROFIT_GL_CODE);
+        final Long incomeGlId = toLong(incomeGl.get("id"));
+        final Long profitGlId = toLong(profitGl.get("id"));
+
+        final LocalDate[] range = financialYearRange(financialYear);
+        final Long officeId = headOfficeId();
+
+        final Map<String, Object> out = new LinkedHashMap<>();
+        out.put("financialYear", financialYear);
+        out.put("incomeGlCode", incomeGl.get("gl_code"));
+        out.put("incomeGlName", incomeGl.get("name"));
+        out.put("profitGlCode", profitGl.get("gl_code"));
+        out.put("profitGlName", profitGl.get("name"));
+
+        final Integer existing = jdbcTemplate.queryForObject(
+                "SELECT COUNT(*) FROM m_income_profit_transfer WHERE financial_year = ? AND income_gl_id = ? AND office_id = ?",
+                Integer.class, financialYear, incomeGlId, officeId);
+        if (existing != null && existing > 0) {
+            if (strict) {
+                throw new PlatformDataIntegrityException("error.msg.incomeprofit.already.posted",
+                        incomeGl.get("name") + " has already been closed to profit for " + financialYear + ".");
+            }
+            out.put("posted", false);
+            out.put("reason", "Already closed for " + financialYear);
+            return out;
+        }
+
+        final BigDecimal balance = balanceOf(incomeGlId, range);
+        if (balance.compareTo(BigDecimal.ZERO) <= 0) {
+            if (strict) {
+                throw new PlatformDataIntegrityException("error.msg.incomeprofit.nothing.to.post",
+                        "There is no income in " + incomeGl.get("name") + " to close for " + financialYear + ".");
+            }
+            out.put("posted", false);
+            out.put("reason", "No income to close for " + financialYear);
+            return out;
+        }
+
+        final int entryCount = entryCountOf(incomeGlId, range);
+        final String currencyCode = resolveCurrency(incomeGlId);
+        final LocalDateTime now = LocalDateTime.now(DateUtils.getDateTimeZoneOfTenant());
+        final LocalDate postingDate = range[1];
+        final String txnId = "YEPROFIT-" + System.nanoTime();
+        final String desc = "Year-end closing " + financialYear + " — " + incomeGl.get("name") + " to profit"
+                + (note != null ? " | " + note : "");
+
+        insertEntry(officeId, incomeGlId, DEBIT, balance, txnId, postingDate, userId, now, currencyCode, desc);
+        insertEntry(officeId, profitGlId, CREDIT, balance, txnId, postingDate, userId, now, currencyCode,
+                "Profit for " + financialYear + " from " + incomeGl.get("name"));
+
+        jdbcTemplate.update(
+                "INSERT INTO m_income_profit_transfer "
+                        + "(financial_year, income_gl_id, profit_gl_id, office_id, from_date, to_date, amount, entry_count, "
+                        + " currency_code, gl_transaction_id, posted_on_date, posted_by_user, posted_by_name, note) "
+                        + "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
+                financialYear, incomeGlId, profitGlId, officeId, java.sql.Date.valueOf(range[0]), java.sql.Date.valueOf(range[1]), balance,
+                entryCount, currencyCode, txnId, java.sql.Date.valueOf(postingDate), userId, userName, note);
+
+        log.info("Year-end profit posting: {} {} from {} to {} for {}", balance, currencyCode, incomeGl.get("name"), profitGl.get("name"),
+                financialYear);
+
+        out.put("posted", true);
+        out.put("amountPostedToProfit", balance);
+        out.put("entryCount", entryCount);
+        out.put("postedOnDate", postingDate.toString());
+        out.put("glTransactionId", txnId);
+        out.put("currency", currencyCode);
+        out.put("message", balance + " " + currencyCode + " posted to " + profitGl.get("name") + " for " + financialYear + ".");
+        return out;
+    }
+
+    /**
+     * Closes EVERY income and expense GL into Bank Profit for the year, leaving the equity GL holding the year's real
+     * net profit.
+     *
+     * <pre>
+     *   each income GL:    Dr  Income GL      Cr  Bank Profit     (income raises profit)
+     *   each expense GL:   Dr  Bank Profit    Cr  Expense GL      (expense reduces profit)
+     * </pre>
+     *
+     * {@link #postToProfit} closes one named income GL and is what the legacy share-entry-fee job calls; this closes
+     * the whole P&L, which is what an actual year-end close is. Anything reading Bank Profit as "the year's profit" —
+     * the share dividend declaration in particular — depends on this having run, because a partial close leaves the
+     * profit split across two places and understates it.
+     *
+     * Each GL still gets its own m_income_profit_transfer row, so the same "once per year per GL" guard applies: a
+     * re-run after new GL accounts appear closes only the ones not yet closed, and never double-posts one that was.
+     * Accounts with a nil balance are skipped rather than posted as zero entries.
+     */
+    @Transactional
+    public Map<String, Object> closeAllToProfit(final String financialYear, final Long userId, final String userName, final String note,
+            final boolean strict) {
+
+        final Map<String, Object> profitGl = loadGlByCode(PROFIT_GL_CODE);
+        final Long profitGlId = toLong(profitGl.get("id"));
+        final LocalDate[] range = financialYearRange(financialYear);
+        final Long officeId = headOfficeId();
+
+        // 4 = INCOME, 5 = EXPENSE (GLAccountType). Disabled accounts are excluded: they can hold a
+        // historical balance but must not attract new postings.
+        final List<Map<String, Object>> plAccounts = jdbcTemplate.queryForList(
+                "SELECT id, gl_code, name, classification_enum FROM acc_gl_account "
+                        + " WHERE classification_enum IN (4, 5) AND disabled = false ORDER BY classification_enum, gl_code");
+
+        final List<Map<String, Object>> closed = new ArrayList<>();
+        final List<Map<String, Object>> skipped = new ArrayList<>();
+        BigDecimal totalIncome = BigDecimal.ZERO;
+        BigDecimal totalExpense = BigDecimal.ZERO;
+
+        for (final Map<String, Object> gl : plAccounts) {
+            final Long glId = toLong(gl.get("id"));
+            final boolean isIncome = ((Number) gl.get("classification_enum")).intValue() == 4;
+
+            final Integer existing = jdbcTemplate.queryForObject(
+                    "SELECT COUNT(*) FROM m_income_profit_transfer WHERE financial_year = ? AND income_gl_id = ? AND office_id = ?",
+                    Integer.class, financialYear, glId, officeId);
+            if (existing != null && existing > 0) {
+                skipped.add(skipRow(gl, "Already closed for " + financialYear));
+                continue;
+            }
+
+            // balanceOf returns credit-less-debit. For an income GL that is the income earned; for an
+            // expense GL the natural balance is a debit, so the same figure comes back negative and
+            // is flipped here to read as a positive expense.
+            final BigDecimal rawBalance = balanceOf(glId, range);
+            final BigDecimal balance = isIncome ? rawBalance : rawBalance.negate();
+            if (balance.compareTo(BigDecimal.ZERO) <= 0) {
+                skipped.add(skipRow(gl, "Nothing to close for " + financialYear));
+                continue;
+            }
+
+            final int entryCount = entryCountOf(glId, range);
+            final String currencyCode = resolveCurrency(glId);
+            final LocalDateTime now = LocalDateTime.now(DateUtils.getDateTimeZoneOfTenant());
+            final LocalDate postingDate = range[1];
+            final String txnId = "YECLOSE-" + financialYear + "-" + gl.get("gl_code") + "-" + System.nanoTime();
+            final String descr = "Year-end closing " + financialYear + " — " + gl.get("name") + " to profit"
+                    + (note != null ? " | " + note : "");
+
+            if (isIncome) {
+                insertEntry(officeId, glId, DEBIT, balance, txnId, postingDate, userId, now, currencyCode, descr);
+                insertEntry(officeId, profitGlId, CREDIT, balance, txnId, postingDate, userId, now, currencyCode,
+                        "Profit for " + financialYear + " from " + gl.get("name"));
+                totalIncome = totalIncome.add(balance);
+            } else {
+                insertEntry(officeId, glId, CREDIT, balance, txnId, postingDate, userId, now, currencyCode, descr);
+                insertEntry(officeId, profitGlId, DEBIT, balance, txnId, postingDate, userId, now, currencyCode,
+                        "Expense for " + financialYear + " from " + gl.get("name"));
+                totalExpense = totalExpense.add(balance);
+            }
+
+            jdbcTemplate.update("INSERT INTO m_income_profit_transfer "
+                    + "(financial_year, income_gl_id, profit_gl_id, office_id, from_date, to_date, amount, entry_count, "
+                    + " currency_code, gl_transaction_id, posted_on_date, posted_by_user, posted_by_name, note) "
+                    + "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)", financialYear, glId, profitGlId, officeId,
+                    java.sql.Date.valueOf(range[0]), java.sql.Date.valueOf(range[1]), balance, entryCount, currencyCode, txnId,
+                    java.sql.Date.valueOf(postingDate), userId, userName, note);
+
+            final Map<String, Object> row = new LinkedHashMap<>();
+            row.put("glCode", gl.get("gl_code"));
+            row.put("glName", gl.get("name"));
+            row.put("type", isIncome ? "INCOME" : "EXPENSE");
+            row.put("amount", balance);
+            row.put("entryCount", entryCount);
+            row.put("glTransactionId", txnId);
+            closed.add(row);
+        }
+
+        if (closed.isEmpty() && strict) {
+            throw new PlatformDataIntegrityException("error.msg.incomeprofit.nothing.to.close",
+                    "There is nothing left to close to profit for " + financialYear + ".");
+        }
+
+        final BigDecimal netProfit = totalIncome.subtract(totalExpense);
+        log.info("Year-end close {}: income {}, expense {}, net profit {} posted to {}", financialYear, totalIncome, totalExpense,
+                netProfit, profitGl.get("name"));
+
+        final Map<String, Object> out = new LinkedHashMap<>();
+        out.put("financialYear", financialYear);
+        out.put("fromDate", range[0].toString());
+        out.put("toDate", range[1].toString());
+        out.put("profitGlCode", profitGl.get("gl_code"));
+        out.put("profitGlName", profitGl.get("name"));
+        out.put("totalIncomeClosed", totalIncome);
+        out.put("totalExpenseClosed", totalExpense);
+        out.put("netProfitPosted", netProfit);
+        out.put("accountsClosed", closed);
+        out.put("accountsSkipped", skipped);
+        out.put("message", closed.size() + " account(s) closed to " + profitGl.get("name") + " for " + financialYear + "; net profit "
+                + netProfit + ".");
+        return out;
+    }
+
+    private Map<String, Object> skipRow(final Map<String, Object> gl, final String reason) {
+        final Map<String, Object> row = new LinkedHashMap<>();
+        row.put("glCode", gl.get("gl_code"));
+        row.put("glName", gl.get("name"));
+        row.put("reason", reason);
+        return row;
+    }
+
+    /**
+     * The year's profit as it stands in the Bank Profit equity GL — what a dividend may be declared out of once the
+     * year has been closed.
+     *
+     * Only entries dated inside the financial year count, so each year's profit is separable rather than being one
+     * ever-growing equity balance. Returns zero (not an error) when the year has not been closed yet; callers decide
+     * whether that is a blocking condition.
+     */
+    public BigDecimal profitForFinancialYear(final String financialYear) {
+        final LocalDate[] range = financialYearRange(financialYear);
+        final Map<String, Object> profitGl = loadGlByCode(PROFIT_GL_CODE);
+        final BigDecimal balance = jdbcTemplate.queryForObject(
+                "SELECT COALESCE(SUM(CASE WHEN type_enum = ? THEN amount ELSE -amount END), 0) "
+                        + " FROM acc_gl_journal_entry WHERE account_id = ? AND reversed = false AND entry_date BETWEEN ? AND ?",
+                BigDecimal.class, CREDIT, toLong(profitGl.get("id")), java.sql.Date.valueOf(range[0]), java.sql.Date.valueOf(range[1]));
+        return balance == null ? BigDecimal.ZERO : balance;
+    }
+
+    /** Whether the year's P&L has been closed into Bank Profit at all. */
+    public boolean isYearClosed(final String financialYear) {
+        final Integer count = jdbcTemplate.queryForObject("SELECT COUNT(*) FROM m_income_profit_transfer WHERE financial_year = ?",
+                Integer.class, financialYear);
+        return count != null && count > 0;
+    }
+
+    /** Net credit balance sitting in the income GL for the year. */
+    public BigDecimal balanceOf(final Long incomeGlId, final LocalDate[] range) {
+        final BigDecimal balance = jdbcTemplate.queryForObject(
+                "SELECT COALESCE(SUM(CASE WHEN type_enum = ? THEN amount ELSE -amount END), 0) "
+                        + " FROM acc_gl_journal_entry WHERE account_id = ? AND reversed = false " + "   AND entry_date BETWEEN ? AND ?",
+                BigDecimal.class, CREDIT, incomeGlId, java.sql.Date.valueOf(range[0]), java.sql.Date.valueOf(range[1]));
+        return balance == null ? BigDecimal.ZERO : balance;
+    }
+
+    /** How many fee postings made up that balance. */
+    public int entryCountOf(final Long incomeGlId, final LocalDate[] range) {
+        final Integer count = jdbcTemplate.queryForObject(
+                "SELECT COUNT(*) FROM acc_gl_journal_entry WHERE account_id = ? AND reversed = false "
+                        + " AND type_enum = ? AND entry_date BETWEEN ? AND ?",
+                Integer.class, incomeGlId, CREDIT, java.sql.Date.valueOf(range[0]), java.sql.Date.valueOf(range[1]));
+        return count == null ? 0 : count;
+    }
+
+    /** Indian financial year label for today, e.g. "2026-27" for 19 Aug 2026. */
+    public String currentFinancialYear() {
+        final LocalDate today = DateUtils.getBusinessLocalDate();
+        final int startYear = today.getMonthValue() >= 4 ? today.getYear() : today.getYear() - 1;
+        return startYear + "-" + String.format("%02d", (startYear + 1) % 100);
+    }
+
+    /** 1 April to 31 March for a "YYYY-YY" label. */
+    public LocalDate[] financialYearRange(final String financialYear) {
+        try {
+            final int startYear = Integer.parseInt(financialYear.substring(0, 4));
+            return new LocalDate[] { LocalDate.of(startYear, 4, 1), LocalDate.of(startYear + 1, 3, 31) };
+        } catch (RuntimeException e) {
+            throw new PlatformDataIntegrityException("error.msg.incomeprofit.year.invalid",
+                    "financialYear must look like 2026-27. Received: " + financialYear);
+        }
+    }
+
+    public Map<String, Object> loadGlByCode(final String glCode) {
+        try {
+            return jdbcTemplate.queryForMap("SELECT id, gl_code, name, classification_enum FROM acc_gl_account WHERE gl_code = ?", glCode);
+        } catch (EmptyResultDataAccessException e) {
+            throw new PlatformDataIntegrityException("error.msg.incomeprofit.gl.not.found", "GL account " + glCode + " does not exist.");
+        }
+    }
+
+    public Long headOfficeId() {
+        return jdbcTemplate.queryForObject("SELECT id FROM m_office ORDER BY hierarchy LIMIT 1", Long.class);
+    }
+
+    private String resolveCurrency(final Long glAccountId) {
+        try {
+            final String code = jdbcTemplate.queryForObject(
+                    "SELECT currency_code FROM acc_gl_journal_entry WHERE account_id = ? ORDER BY id DESC LIMIT 1", String.class,
+                    glAccountId);
+            return code == null ? "INR" : code;
+        } catch (EmptyResultDataAccessException e) {
+            return "INR";
+        }
+    }
+
+    private void insertEntry(final Long officeId, final Long glAccountId, final int typeEnum, final BigDecimal amount, final String txnId,
+            final LocalDate entryDate, final Long userId, final LocalDateTime now, final String currencyCode, final String description) {
+        jdbcTemplate.update(
+                "INSERT INTO acc_gl_journal_entry " + "(account_id, office_id, currency_code, transaction_id, reversed, manual_entry, "
+                        + " entry_date, type_enum, amount, description, "
+                        + " created_by, last_modified_by, created_date, lastmodified_date, "
+                        + " is_running_balance_calculated, office_running_balance, "
+                        + " organization_running_balance, submitted_on_date, transaction_date, " + " created_on_utc, last_modified_on_utc) "
+                        + "VALUES (?,?,?,?,false,true,?,?,?,?,?,?,?,?,false,0,0,?,?,?,?)",
+                glAccountId, officeId, currencyCode, txnId, java.sql.Date.valueOf(entryDate), typeEnum, amount, description, userId, userId,
+                now, now, java.sql.Date.valueOf(entryDate), java.sql.Date.valueOf(entryDate), now.atOffset(ZoneOffset.UTC),
+                now.atOffset(ZoneOffset.UTC));
+    }
+
+    private Long toLong(final Object o) {
+        return o instanceof Number ? ((Number) o).longValue() : null;
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/infrastructure/core/config/SecurityConfig.java

@@ -163,6 +163,15 @@ public class SecurityConfig {
                     // packages here without a Fineract Bearer token; security is enforced by the
                     // envelope's RSA signature/encryption (NpciCryptoUtil) inside the handler.
                     .requestMatchers(API_MATCHER.matcher(HttpMethod.POST, "/api/*/npci/**")).permitAll()
+                    // Client account summary, third-party callers — a partner integration calls this
+                    // with an X-Api-Key header instead of a Fineract username/password (issued via
+                    // POST /v1/apiclients, super-user only). Same posture as IMPS/NPCI above: the
+                    // outer gate stays open for this one narrow GET path, and
+                    // ClientAllAccountsApiResource#retrieveByClientNo is what actually authenticates
+                    // the caller (ApiClientCredentialService checks the key's hash, active flag and
+                    // IP allowlist) — a request with no key and no Fineract login still gets nothing,
+                    // it just fails inside the handler instead of at this filter.
+                    .requestMatchers(API_MATCHER.matcher(HttpMethod.GET, "/api/*/clientaccounts/**")).permitAll()
                     // Login OTP — same posture as PAN/GSTIN public verification: provider-credentialed,
                     // no Fineract auth required.
                     .requestMatchers(API_MATCHER.matcher(HttpMethod.POST, "/api/*/login/otp/generate")).permitAll()

fineract-provider/src/main/java/org/apache/fineract/infrastructure/security/apiclient/ApiClientAdminApiResource.java

@@ -0,0 +1,109 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.infrastructure.security.apiclient;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonElement;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.ws.rs.Consumes;
+import jakarta.ws.rs.DELETE;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.POST;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.PathParam;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.WebApplicationException;
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.Response;
+import java.util.List;
+import java.util.Map;
+import lombok.RequiredArgsConstructor;
+import org.apache.fineract.infrastructure.core.serialization.FromJsonHelper;
+import org.apache.fineract.infrastructure.security.service.PlatformSecurityContext;
+import org.apache.fineract.useradministration.domain.AppUser;
+import org.springframework.stereotype.Component;
+
+/**
+ * Admin-only management of the third-party API keys {@link ApiClientCredentialService} authenticates.
+ * This resource itself requires a normal Fineract login, same as everything else -- ordinary
+ * username/password, restricted to a super user (ALL_FUNCTIONS). Only the endpoints that use a minted
+ * key to skip login (e.g. GET /v1/clientaccounts) are the ones exempted in SecurityConfig; issuing that
+ * key in the first place is not something to hand to just anyone.
+ */
+@Path("/v1/apiclients")
+@Component
+@Tag(name = "API Client Keys", description = "Admin management of third-party API keys used by endpoints that skip Fineract login.")
+@RequiredArgsConstructor
+public class ApiClientAdminApiResource {
+
+    private final PlatformSecurityContext context;
+    private final ApiClientCredentialService credentialService;
+    private final FromJsonHelper fromJsonHelper;
+    private final Gson gson = new GsonBuilder().serializeNulls().create();
+
+    @POST
+    @Consumes(MediaType.APPLICATION_JSON)
+    @Produces(MediaType.APPLICATION_JSON)
+    public String create(final String body) {
+        final AppUser user = requireSuperUser();
+        final JsonElement root = fromJsonHelper.parse(body);
+        final String clientName = fromJsonHelper.extractStringNamed("clientName", root);
+        final String allowedIps = fromJsonHelper.extractStringNamed("allowedIps", root);
+
+        final Map<String, Object> result = credentialService.createClient(clientName, allowedIps, user.getId());
+        return gson.toJson(result);
+    }
+
+    @GET
+    @Produces(MediaType.APPLICATION_JSON)
+    public String list() {
+        requireSuperUser();
+        final List<Map<String, Object>> clients = credentialService.listClients();
+        return gson.toJson(clients);
+    }
+
+    @DELETE
+    @Path("/{id}")
+    @Produces(MediaType.APPLICATION_JSON)
+    public String deactivate(@PathParam("id") final Long id) {
+        requireSuperUser();
+        credentialService.setActive(id, false);
+        return gson.toJson(Map.of("resourceId", id, "isActive", false));
+    }
+
+    @POST
+    @Path("/{id}/reactivate")
+    @Produces(MediaType.APPLICATION_JSON)
+    public String reactivate(@PathParam("id") final Long id) {
+        requireSuperUser();
+        credentialService.setActive(id, true);
+        return gson.toJson(Map.of("resourceId", id, "isActive", true));
+    }
+
+    private AppUser requireSuperUser() {
+        final AppUser user = context.authenticatedUser();
+        if (!user.hasAnyPermission("ALL_FUNCTIONS")) {
+            throw new WebApplicationException(Response.status(403)
+                    .entity("{\"message\":\"Only a super user can manage third-party API keys.\"}").type(MediaType.APPLICATION_JSON)
+                    .build());
+        }
+        return user;
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/infrastructure/security/apiclient/ApiClientCredentialService.java

@@ -0,0 +1,243 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.infrastructure.security.apiclient;
+
+import jakarta.annotation.PostConstruct;
+import jakarta.ws.rs.WebApplicationException;
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.Response;
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.time.Instant;
+import java.util.Arrays;
+import java.util.Base64;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import javax.sql.DataSource;
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.fineract.infrastructure.core.service.ThreadLocalContextUtil;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Component;
+
+/**
+ * Authenticates third-party callers of endpoints that are meant to be reachable WITHOUT a Fineract user
+ * login -- an {@code X-Api-Key} header instead of a username/password. Same posture already used in this
+ * fork for the IMPS and NPCI receivers ({@code SecurityConfig}: those paths are {@code permitAll()} at
+ * the Spring Security layer, and the handler itself verifies the caller's credential): the outer gate
+ * stays open for the specific path, and this class is the thing that actually decides "yes" or "no".
+ *
+ * {@code m_api_client} lives in the tenant-STORE database ({@code fineract_tenants}), reached here via
+ * the {@code hikariTenantDataSource}-qualified {@link DataSource} -- the same bean
+ * {@code TenantDatabaseUpgradeService} uses to manage that database -- rather than the ordinary
+ * tenant-routed {@code JdbcTemplate} every other resource in this fork injects. That is deliberate, not
+ * an oversight: a key is a caller's identity, independent of which bank's data a given request is asking
+ * for, so one minted key must keep working against every tenant that exists now AND every one
+ * provisioned later. A copy of this table inside each bank's own tenant database would need a manual
+ * re-insert on every new bank, and every key would still need one row per tenant -- exactly what storing
+ * it centrally, once, avoids. {@code Fineract-Platform-TenantId} keeps doing what it always did (routes
+ * the REST of the request, e.g. {@code ClientAllAccountsApiResource}'s own client/account lookups, to
+ * the right bank's database) -- this class only ever touches the one central table.
+ *
+ * Security properties, deliberately:
+ * <ul>
+ * <li>Only a SHA-256 hash of the key is ever stored ({@code m_api_client.api_key_hash}). A leaked
+ * database backup can never be turned back into a usable credential -- the same reason Fineract itself
+ * never stores a user's plaintext password.</li>
+ * <li>The raw key is shown to the caller (well, the admin minting it) exactly once, at creation. It is
+ * not retrievable afterwards, by design -- if it's lost, the only recourse is to mint a new one and
+ * deactivate the old.</li>
+ * <li>{@code authenticate()} raises the SAME 401 message ("Invalid or inactive API key.") whether the key
+ * doesn't exist, is deactivated, or the caller's IP isn't on its allowlist -- so a probing attacker
+ * cannot use the response to tell a wrong key apart from a valid-but-blocked one.</li>
+ * <li>The IP allowlist is a plain comma-separated exact-match list, not CIDR ranges -- adequate for a
+ * small, known set of partner integrations; if a partner calls from a rotating pool of addresses, leave
+ * {@code allowedIps} null for that key rather than trying to enumerate every address.</li>
+ * </ul>
+ */
+@Component
+@RequiredArgsConstructor
+public class ApiClientCredentialService {
+
+    private static final String GENERIC_AUTH_FAILURE = "Invalid or inactive API key.";
+    // Enough random bytes that guessing is infeasible (256 bits) -- the same order of magnitude as a
+    // session token, appropriate for a credential that never expires on its own.
+    private static final int KEY_ENTROPY_BYTES = 32;
+
+    @Qualifier("hikariTenantDataSource")
+    private final DataSource tenantStoreDataSource;
+    private final SecureRandom secureRandom = new SecureRandom();
+
+    // Built once from the qualified DataSource in @PostConstruct rather than injected directly as a
+    // JdbcTemplate: @RequiredArgsConstructor only wires constructor parameters straight from fields,
+    // and JdbcTemplate itself isn't a bean registered under this qualifier -- only the DataSource is.
+    private JdbcTemplate tenantStoreJdbc;
+
+    @PostConstruct
+    void init() {
+        this.tenantStoreJdbc = new JdbcTemplate(tenantStoreDataSource);
+    }
+
+    /**
+     * Validates a raw {@code X-Api-Key} header value. On success, returns the registered client's
+     * display name (for the caller to log/attribute the request to) and records this call -- including
+     * which tenant it was made against -- as the key's most recent use. On any failure, throws a clean
+     * 401; the caller never gets far enough to tell a wrong key from a deactivated one or a blocked IP.
+     */
+    public String authenticate(final String rawApiKey, final String callerIp) {
+        if (StringUtils.isBlank(rawApiKey)) {
+            throw unauthorized();
+        }
+        final String hash = sha256Hex(rawApiKey);
+        final List<Map<String, Object>> rows = tenantStoreJdbc.queryForList("""
+                SELECT id, client_name, is_active, allowed_ips FROM m_api_client WHERE api_key_hash = ?
+                """, hash);
+        if (rows.isEmpty()) {
+            throw unauthorized();
+        }
+        final Map<String, Object> row = rows.get(0);
+        if (!Boolean.TRUE.equals(row.get("is_active"))) {
+            throw unauthorized();
+        }
+        final String allowedIps = (String) row.get("allowed_ips");
+        if (StringUtils.isNotBlank(allowedIps) && !isIpAllowed(allowedIps, callerIp)) {
+            throw unauthorized();
+        }
+
+        final Long id = ((Number) row.get("id")).longValue();
+        tenantStoreJdbc.update("UPDATE m_api_client SET last_used_at = ?, last_used_ip = ?, last_used_tenant = ? WHERE id = ?",
+                java.sql.Timestamp.from(Instant.now()), callerIp, currentTenantId(), id);
+
+        return (String) row.get("client_name");
+    }
+
+    private boolean isIpAllowed(final String allowedIps, final String callerIp) {
+        if (StringUtils.isBlank(callerIp)) {
+            return false;
+        }
+        return Arrays.stream(allowedIps.split(",")).map(String::trim).anyMatch(ip -> ip.equalsIgnoreCase(callerIp));
+    }
+
+    /**
+     * Admin operation: mints a new key and returns it in the response -- the ONLY time the raw value
+     * is ever available. {@code allowedIps} may be null/blank for no IP restriction. The resulting key
+     * authenticates against every tenant, regardless of which one the admin minting it happened to be
+     * logged into.
+     */
+    public Map<String, Object> createClient(final String clientName, final String allowedIps, final Long createdByUserId) {
+        if (StringUtils.isBlank(clientName)) {
+            throw badRequest("clientName is required.");
+        }
+        final String rawKey = generateRawKey();
+        final String hash = sha256Hex(rawKey);
+        final String prefix = rawKey.substring(0, Math.min(12, rawKey.length()));
+
+        final Long id = tenantStoreJdbc.queryForObject("""
+                INSERT INTO m_api_client (client_name, api_key_hash, api_key_prefix, allowed_ips, created_by, created_by_tenant)
+                VALUES (?,?,?,?,?,?)
+                RETURNING id
+                """, Long.class, clientName, hash, prefix, StringUtils.isBlank(allowedIps) ? null : allowedIps, createdByUserId,
+                currentTenantId());
+
+        final Map<String, Object> result = new LinkedHashMap<>();
+        result.put("id", id);
+        result.put("clientName", clientName);
+        result.put("apiKey", rawKey);
+        result.put("warning", "This is the only time the full API key is shown. Store it now -- it cannot be retrieved again.");
+        return result;
+    }
+
+    public List<Map<String, Object>> listClients() {
+        return tenantStoreJdbc.queryForList("""
+                SELECT id, client_name, api_key_prefix, is_active, allowed_ips,
+                       created_date, created_by_tenant, deactivated_date, last_used_at, last_used_ip, last_used_tenant
+                  FROM m_api_client ORDER BY created_date DESC
+                """);
+    }
+
+    public void setActive(final Long id, final boolean active) {
+        final int updated = tenantStoreJdbc.update(
+                "UPDATE m_api_client SET is_active = ?, deactivated_date = ? WHERE id = ?", active,
+                active ? null : java.sql.Timestamp.from(Instant.now()), id);
+        if (updated == 0) {
+            throw notFound("No API client with id " + id);
+        }
+    }
+
+    private String currentTenantId() {
+        try {
+            return ThreadLocalContextUtil.getTenant().getTenantIdentifier();
+        } catch (final RuntimeException e) {
+            // Defensive only: every request through SecurityConfig's matcher chain has a tenant
+            // resolved before it reaches here (see TenantAwareBasicAuthenticationFilter), so this
+            // should be unreachable in practice.
+            return null;
+        }
+    }
+
+    private String generateRawKey() {
+        final byte[] bytes = new byte[KEY_ENTROPY_BYTES];
+        secureRandom.nextBytes(bytes);
+        // URL-safe, no padding: safe to put directly in a header value with no further encoding.
+        return "cbsx_" + Base64.getUrlEncoder().withoutPadding().encodeToString(bytes);
+    }
+
+    private String sha256Hex(final String raw) {
+        try {
+            final MessageDigest digest = MessageDigest.getInstance("SHA-256");
+            final byte[] hashBytes = digest.digest(raw.getBytes(StandardCharsets.UTF_8));
+            final StringBuilder hex = new StringBuilder(hashBytes.length * 2);
+            for (final byte b : hashBytes) {
+                hex.append(String.format("%02x", b));
+            }
+            return hex.toString();
+        } catch (final NoSuchAlgorithmException e) {
+            // SHA-256 is a mandatory JCE algorithm on every JVM distribution Fineract supports --
+            // this can only mean a broken JVM install, not a recoverable runtime condition.
+            throw new IllegalStateException("SHA-256 is unavailable in this JVM", e);
+        }
+    }
+
+    private WebApplicationException unauthorized() {
+        // Naming the tenant the caller sent is safe here -- it is the header value they themselves
+        // put on the request, not something this check reveals to them -- and it turns "why did my
+        // key fail" from a guess into something checkable: was this call even reaching the bank the
+        // caller thought it was?
+        final String tenantId = currentTenantId();
+        final String message = tenantId != null ? GENERIC_AUTH_FAILURE + " (tenant: " + tenantId + ")" : GENERIC_AUTH_FAILURE;
+        return jsonError(401, message);
+    }
+
+    private WebApplicationException badRequest(final String message) {
+        return jsonError(400, message);
+    }
+
+    private WebApplicationException notFound(final String message) {
+        return jsonError(404, message);
+    }
+
+    private WebApplicationException jsonError(final int status, final String message) {
+        final String body = "{\"httpStatusCode\":\"" + status + "\",\"message\":\"" + message.replace("\"", "'") + "\"}";
+        return new WebApplicationException(Response.status(status).entity(body).type(MediaType.APPLICATION_JSON).build());
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/portfolio/accountdetails/service/AccountDetailsReadPlatformServiceJpaRepositoryImpl.java

@@ -357,9 +357,14 @@ public class AccountDetailsReadPlatformServiceJpaRepositoryImpl implements Accou
             accountsSummary.append("curr.name as currencyName, curr.internationalized_name_code as currencyNameCode, ");
             accountsSummary.append("curr.display_symbol as currencyDisplaySymbol, ");
             accountsSummary.append("sa.product_id as productId, p.name as productName, p.short_name as shortProductName, ");
-            accountsSummary.append("sa.deposit_type_enum as depositType ");
+            accountsSummary.append("sa.deposit_type_enum as depositType, ");
+            // Renewal-chain identity for Fixed Deposits: the stable customer-facing FD number and
+            // this row's cycle within the chain, so a client's account list can collapse a renewed
+            // FD into one entry rather than listing every term as a separate account.
+            accountsSummary.append("dtp.fd_account_number as fdAccountNumber, dtp.renewal_cycle_no as renewalCycleNo ");
             accountsSummary.append("from m_savings_account sa ");
             accountsSummary.append("join m_savings_product as p on p.id = sa.product_id ");
+            accountsSummary.append("left join m_deposit_account_term_and_preclosure dtp on dtp.savings_account_id = sa.id ");
             accountsSummary.append("join m_currency curr on curr.code = sa.currency_code ");
             accountsSummary.append("left join m_appuser sbu on sbu.id = sa.submittedon_userid ");
             accountsSummary.append("left join m_appuser rbu on rbu.id = sa.rejectedon_userid ");
@@ -453,9 +458,15 @@ public class AccountDetailsReadPlatformServiceJpaRepositoryImpl implements Accou
                     approvedByUsername, approvedByFirstname, approvedByLastname, activatedOnDate, activatedByUsername, activatedByFirstname,
                     activatedByLastname, closedOnDate, closedByUsername, closedByFirstname, closedByLastname);
 
+            // Null for a savings/current account and for an FD opened before this column existed;
+            // callers fall back to accountNo, so an FD that has never been renewed still reads as
+            // its own FD number.
+            final String fdAccountNumber = rs.getString("fdAccountNumber");
+            final Integer renewalCycleNo = JdbcSupport.getInteger(rs, "renewalCycleNo");
+
             return new SavingsAccountSummaryData(id, accountNo, externalId, productId, productName, shortProductName, status, currency,
                     accountBalance, onHoldFunds, onHoldAmount, availableBalance, accountTypeData, timeline, depositTypeData, subStatus,
-                    lastActiveTransactionDate);
+                    lastActiveTransactionDate, fdAccountNumber, renewalCycleNo);
         }
     }
 
@@ -567,8 +578,10 @@ public class AccountDetailsReadPlatformServiceJpaRepositoryImpl implements Accou
 
             final EnumOptionData depositTypeData = SavingsEnumerations.depositType(400);
 
+            // Current accounts have no deposit term, so no FD renewal chain to report.
             return new SavingsAccountSummaryData(id, accountNo, externalId, productId, productName, shortProductName, status, currency,
-                    accountBalance, onHoldFunds, null, accountBalance, accountTypeData, timeline, depositTypeData, subStatus, activatedOnDate);
+                    accountBalance, onHoldFunds, null, accountBalance, accountTypeData, timeline, depositTypeData, subStatus, activatedOnDate,
+                    null, null);
         }
     }
 

fineract-provider/src/main/java/org/apache/fineract/portfolio/accountregister/api/AccountRegisterApiResource.java

@@ -0,0 +1,299 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.portfolio.accountregister.api;
+
+import com.google.gson.Gson;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.QueryParam;
+import jakarta.ws.rs.core.MediaType;
+import java.math.BigDecimal;
+import java.sql.Date;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import lombok.RequiredArgsConstructor;
+import org.apache.fineract.infrastructure.core.exception.PlatformDataIntegrityException;
+import org.apache.fineract.infrastructure.core.service.DateUtils;
+import org.apache.fineract.infrastructure.security.service.PlatformSecurityContext;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Component;
+
+/**
+ * Account register for one date: which accounts were opened and which were closed that day, with
+ * each account's balance as it stood on that date alongside what it holds now.
+ *
+ * The dated balance is read from the running balance stamped on the last transaction up to that
+ * date, rather than recomputed from the account's current figure — a current balance tells you
+ * nothing about what the account held three weeks ago.
+ */
+@Path("/v1/accountregister")
+@Component
+@RequiredArgsConstructor
+@Produces({ MediaType.APPLICATION_JSON })
+public class AccountRegisterApiResource {
+
+    private final JdbcTemplate jdbcTemplate;
+    private final PlatformSecurityContext context;
+    private final Gson gson = new Gson();
+
+    @GET
+    public String register(@QueryParam("date") final String dateParam, @QueryParam("section") final String section) {
+        this.context.authenticatedUser();
+
+        final LocalDate asOn;
+        if (dateParam != null && !dateParam.isBlank()) {
+            try {
+                asOn = LocalDate.parse(dateParam);
+            } catch (final java.time.format.DateTimeParseException e) {
+                throw new PlatformDataIntegrityException("error.msg.accountregister.date.invalid",
+                        "Date must be in yyyy-MM-dd format.");
+            }
+        } else {
+            asOn = LocalDate.now(DateUtils.getDateTimeZoneOfTenant());
+        }
+
+        final String want = section == null || section.isBlank() ? "ALL" : section.toUpperCase();
+        final List<Map<String, Object>> rows = new ArrayList<>();
+
+        if (matches(want, "SAVINGS") || matches(want, "FD") || matches(want, "RD")) {
+            rows.addAll(depositAccounts(asOn, want));
+        }
+        if (matches(want, "SHARE")) {
+            rows.addAll(shareAccounts(asOn));
+        }
+
+        // Opened and closed counts come from the rows themselves rather than separate COUNT queries,
+        // so the totals can never disagree with the list they summarise.
+        int opened = 0;
+        int closed = 0;
+        BigDecimal balanceOnDate = BigDecimal.ZERO;
+        BigDecimal currentBalance = BigDecimal.ZERO;
+        for (final Map<String, Object> r : rows) {
+            if (Boolean.TRUE.equals(r.get("openedOnDate"))) {
+                opened++;
+            }
+            if (Boolean.TRUE.equals(r.get("closedOnDate"))) {
+                closed++;
+            }
+            balanceOnDate = balanceOnDate.add(dec(r.get("balanceOnDate")));
+            currentBalance = currentBalance.add(dec(r.get("currentBalance")));
+        }
+
+        final Map<String, Object> out = new LinkedHashMap<>();
+        out.put("date", asOn.toString());
+        out.put("section", want);
+        out.put("accounts", rows);
+        out.put("count", rows.size());
+        out.put("openedCount", opened);
+        out.put("closedCount", closed);
+        out.put("totalBalanceOnDate", balanceOnDate);
+        out.put("totalCurrentBalance", currentBalance);
+        return gson.toJson(out);
+    }
+
+    private static boolean matches(final String want, final String section) {
+        return "ALL".equals(want) || want.equals(section);
+    }
+
+    private static BigDecimal dec(final Object o) {
+        return o instanceof BigDecimal b ? b : BigDecimal.ZERO;
+    }
+
+    /**
+     * Savings, fixed and recurring deposit accounts. All three live in m_savings_account, told
+     * apart by deposit_type_enum: 100 savings, 200 fixed, 300 recurring.
+     *
+     * Accounts submitted after the date are excluded — on that date they did not exist, and listing
+     * them would make a register of a past day describe a present one.
+     */
+    private List<Map<String, Object>> depositAccounts(final LocalDate asOn, final String want) {
+        final Date date = Date.valueOf(asOn);
+
+        final StringBuilder typeFilter = new StringBuilder();
+        if (!"ALL".equals(want)) {
+            final int type = switch (want) {
+                case "SAVINGS" -> 100;
+                case "FD" -> 200;
+                case "RD" -> 300;
+                default -> 0;
+            };
+            if (type > 0) {
+                typeFilter.append(" AND sa.deposit_type_enum = ").append(type);
+            }
+        }
+
+        final List<Map<String, Object>> rows = jdbcTemplate.queryForList("""
+                SELECT sa.id, sa.account_no, sa.deposit_type_enum, sa.status_enum,
+                       sa.activatedon_date, sa.closedon_date, sa.submittedon_date,
+                       sa.account_balance_derived,
+                       c.display_name AS client_name,
+                       p.name AS product_name,
+                       (SELECT t.running_balance_derived
+                          FROM m_savings_account_transaction t
+                         WHERE t.savings_account_id = sa.id
+                           AND COALESCE(t.is_reversed, false) = false
+                           AND t.transaction_date <= ?
+                         ORDER BY t.transaction_date DESC, t.id DESC
+                         LIMIT 1) AS balance_on_date
+                  FROM m_savings_account sa
+                  LEFT JOIN m_client c ON c.id = sa.client_id
+                  LEFT JOIN m_savings_product p ON p.id = sa.product_id
+                 WHERE (sa.submittedon_date IS NULL OR sa.submittedon_date <= ?)
+                """ + typeFilter + """
+                 ORDER BY sa.deposit_type_enum, sa.account_no
+                """, date, date);
+
+        final List<Map<String, Object>> out = new ArrayList<>();
+        for (final Map<String, Object> r : rows) {
+            final Map<String, Object> m = new LinkedHashMap<>();
+            final int depositType = num(r.get("deposit_type_enum"));
+            m.put("accountId", r.get("id"));
+            m.put("accountNo", r.get("account_no"));
+            m.put("section", depositType == 200 ? "FD" : depositType == 300 ? "RD" : "SAVINGS");
+            m.put("clientName", r.get("client_name"));
+            m.put("productName", r.get("product_name"));
+            m.put("status", savingsStatus(num(r.get("status_enum"))));
+            m.put("openedOn", str(r.get("activatedon_date")));
+            m.put("closedOn", str(r.get("closedon_date")));
+            m.put("openedOnDate", sameDay(r.get("activatedon_date"), asOn));
+            m.put("closedOnDate", sameDay(r.get("closedon_date"), asOn));
+            // No transaction up to that date means the account had nothing in it yet, not that the
+            // balance is unknown.
+            m.put("balanceOnDate", r.get("balance_on_date") == null ? BigDecimal.ZERO : r.get("balance_on_date"));
+            m.put("currentBalance", r.get("account_balance_derived") == null
+                    ? BigDecimal.ZERO : r.get("account_balance_derived"));
+            out.add(m);
+        }
+        return out;
+    }
+
+    /**
+     * Share accounts. Their transactions carry no running balance the way savings ones do, but they
+     * are individually dated, so the holding on a given date is the shares purchased up to that
+     * date less those redeemed — which is a real dated figure, not the current one relabelled.
+     */
+    private List<Map<String, Object>> shareAccounts(final LocalDate asOn) {
+        final Date date = Date.valueOf(asOn);
+
+        final List<Map<String, Object>> rows = jdbcTemplate.queryForList("""
+                SELECT sa.id, sa.account_no, sa.status_enum, sa.activated_date, sa.closed_date,
+                       sa.total_approved_shares,
+                       c.display_name AS client_name,
+                       p.name AS product_name,
+                       (SELECT COALESCE(SUM(CASE WHEN t.type_enum = 500 THEN t.total_shares * t.unit_price
+                                                 WHEN t.type_enum = 600 THEN -(t.total_shares * t.unit_price)
+                                                 ELSE 0 END), 0)
+                          FROM m_share_account_transactions t
+                         WHERE t.account_id = sa.id AND t.is_active = true
+                           AND t.status_enum = 300
+                           AND t.type_enum IN (500, 600)) AS share_value,
+                       -- Purchases less redemptions dated on or before the register's date. Charge
+                       -- rows (type 700) are excluded: an entry fee is not share capital. Only
+                       -- approved purchases count (status 300) — a rejected application leaves its
+                       -- row behind still flagged active, and counting it credited a member with
+                       -- shares they were never issued.
+                       (SELECT COALESCE(SUM(CASE WHEN t.type_enum = 500 THEN t.total_shares * t.unit_price
+                                                 WHEN t.type_enum = 600 THEN -(t.total_shares * t.unit_price)
+                                                 ELSE 0 END), 0)
+                          FROM m_share_account_transactions t
+                         WHERE t.account_id = sa.id AND t.is_active = true
+                           AND t.status_enum = 300
+                           AND t.type_enum IN (500, 600)
+                           AND t.transaction_date <= ?) AS value_on_date,
+                       (SELECT COALESCE(SUM(CASE WHEN t.type_enum = 500 THEN t.total_shares
+                                                 WHEN t.type_enum = 600 THEN -t.total_shares
+                                                 ELSE 0 END), 0)
+                          FROM m_share_account_transactions t
+                         WHERE t.account_id = sa.id AND t.is_active = true
+                           AND t.status_enum = 300
+                           AND t.type_enum IN (500, 600)
+                           AND t.transaction_date <= ?) AS shares_on_date
+                  FROM m_share_account sa
+                  LEFT JOIN m_client c ON c.id = sa.client_id
+                  LEFT JOIN m_share_product p ON p.id = sa.product_id
+                 WHERE (sa.submitted_date IS NULL OR sa.submitted_date <= ?)
+                 ORDER BY sa.account_no
+                """, date, date, date);
+
+        final List<Map<String, Object>> out = new ArrayList<>();
+        for (final Map<String, Object> r : rows) {
+            final Map<String, Object> m = new LinkedHashMap<>();
+            m.put("accountId", r.get("id"));
+            m.put("accountNo", r.get("account_no"));
+            m.put("section", "SHARE");
+            m.put("clientName", r.get("client_name"));
+            m.put("productName", r.get("product_name"));
+            m.put("status", shareStatus(num(r.get("status_enum"))));
+            m.put("openedOn", str(r.get("activated_date")));
+            m.put("closedOn", str(r.get("closed_date")));
+            m.put("openedOnDate", sameDay(r.get("activated_date"), asOn));
+            m.put("closedOnDate", sameDay(r.get("closed_date"), asOn));
+            m.put("balanceOnDate", r.get("value_on_date") == null ? BigDecimal.ZERO : r.get("value_on_date"));
+            m.put("currentBalance", r.get("share_value") == null ? BigDecimal.ZERO : r.get("share_value"));
+            // Shares as at the date, not the approved figure — an account can hold fewer than were
+            // approved once some have been redeemed.
+            m.put("sharesHeld", r.get("shares_on_date"));
+            out.add(m);
+        }
+        return out;
+    }
+
+    private static boolean sameDay(final Object dbDate, final LocalDate asOn) {
+        return dbDate != null && asOn.toString().equals(dbDate.toString());
+    }
+
+    private static String str(final Object o) {
+        return o == null ? null : o.toString();
+    }
+
+    private static int num(final Object o) {
+        return o instanceof Number n ? n.intValue() : 0;
+    }
+
+    private static String savingsStatus(final int status) {
+        return switch (status) {
+            case 100 -> "SUBMITTED";
+            case 200 -> "APPROVED";
+            case 300 -> "ACTIVE";
+            case 400 -> "WITHDRAWN";
+            case 500 -> "REJECTED";
+            case 600 -> "CLOSED";
+            case 700 -> "TRANSFER IN PROGRESS";
+            case 800 -> "TRANSFER ON HOLD";
+            case 900 -> "PREMATURELY CLOSED";
+            default -> "UNKNOWN";
+        };
+    }
+
+    private static String shareStatus(final int status) {
+        return switch (status) {
+            case 100 -> "SUBMITTED";
+            case 200 -> "APPROVED";
+            case 300 -> "ACTIVE";
+            case 400 -> "WITHDRAWN";
+            case 500 -> "REJECTED";
+            case 600 -> "CLOSED";
+            default -> "UNKNOWN";
+        };
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/portfolio/accounts/constants/ShareAccountApiConstants.java

@@ -113,6 +113,37 @@ public interface ShareAccountApiConstants {
      *  outstanding balance. */
     String linkedloanid_paramname = "linkedLoanId";
 
+    /**
+     * Where the money for an additional-share tranche comes from — {@code CASH} or {@code SAVINGS}.
+     *
+     * Both routes leave the money in the Share Sundry (SHARES_SUSPENSE) holding account, so
+     * approving the tranche posts the same Dr Sundry / Cr Share Capital pair either way. They
+     * differ only in how it got there: CASH means the cashier already took it at the counter
+     * against a voucher, SAVINGS means the member's own savings account is debited on submit.
+     */
+    String fundingsource_paramname = "fundingSource";
+
+    String FUNDING_SOURCE_CASH = "CASH";
+
+    String FUNDING_SOURCE_SAVINGS = "SAVINGS";
+
+    /**
+     * The Share Sundry receipt funding a CASH tranche, from {@code m_share_advance_collection}.
+     *
+     * Recorded against the tranche so one voucher cannot be spent twice, and so the approver can
+     * see which receipt the money they are releasing came in on.
+     */
+    String advancecollectionid_paramname = "advanceCollectionId";
+
+    /**
+     * The remaining vouchers funding a CASH tranche, when one receipt does not cover it.
+     *
+     * A member paying in instalments — ₹600 today, the ₹400 balance tomorrow — has several receipts
+     * against one request. The first leads in {@link #advancecollectionid_paramname}; these are the
+     * rest, and their combined total is what has to cover the shares.
+     */
+    String additionalcollectionids_paramname = "additionalCollectionIds";
+
     Set<String> supportedParameters = Collections.unmodifiableSet(new HashSet<>(Arrays.asList(locale_paramname, dateformat_paramname,
             id_paramname, clientid_paramname, productid_paramname, submitteddate_paramname, approveddate_paramname, externalid_paramname,
             resolutionnumber_paramname, currency_paramname, digitsafterdecimal_paramname, inmultiplesof_paramname,

fineract-provider/src/main/java/org/apache/fineract/portfolio/aml/service/AmlFundTransferEvaluationService.java

@@ -30,6 +30,7 @@ import org.apache.fineract.portfolio.client.domain.ClientRepositoryWrapper;
 import org.apache.fineract.portfolio.fundtransfer.domain.FundTransfer;
 import org.apache.fineract.portfolio.fundtransfer.domain.FundTransferStatus;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 
 /**
@@ -42,7 +43,9 @@ import org.springframework.transaction.annotation.Transactional;
 @Service
 @RequiredArgsConstructor
 @Slf4j
-@Transactional
+// REQUIRES_NEW for the same reason as AmlRuleEvaluationServiceImpl: a failed alert write must not
+// be able to mark the caller's transfer transaction rollback-only and undo a settled transfer.
+@Transactional(propagation = Propagation.REQUIRES_NEW)
 public class AmlFundTransferEvaluationService {
 
     private static final int STRUCTURING_WINDOW_DAYS = 30;

fineract-provider/src/main/java/org/apache/fineract/portfolio/aml/service/AmlRuleEvaluationServiceImpl.java

@@ -31,11 +31,20 @@ import org.apache.fineract.portfolio.aml.domain.AmlTransactionRuleRepository;
 import org.apache.fineract.portfolio.client.domain.ClientKyc;
 import org.apache.fineract.portfolio.client.domain.ClientKycRepository;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 
+/**
+ * REQUIRES_NEW rather than the default REQUIRED: AML monitoring is a passive observer of a
+ * transaction that has already succeeded. Joining the caller's transaction would let a failed
+ * alert insert mark it rollback-only, destroying the customer's deposit/withdrawal/transfer at
+ * commit time - and the callers' catch blocks cannot rescue that, because the damage is done to
+ * the shared transaction rather than thrown to them. A private transaction keeps AML failure
+ * contained to AML.
+ */
 @Service
 @RequiredArgsConstructor
-@Transactional
+@Transactional(propagation = Propagation.REQUIRES_NEW)
 public class AmlRuleEvaluationServiceImpl implements AmlRuleEvaluationService {
 
     private static final int MEDIUM_RISK = 2;

fineract-provider/src/main/java/org/apache/fineract/portfolio/aml/service/ClientRiskEscalationServiceImpl.java

@@ -64,9 +64,13 @@ public class ClientRiskEscalationServiceImpl implements ClientRiskEscalationServ
             return;
         }
 
+        // Moves the re-KYC due date onto the new category's cycle as well, so the customer is
+        // called back in on the schedule the escalated rating requires.
         kyc.escalateRiskCategory(nextCategory);
         historyRepository.save(ClientRiskCategoryHistory.autoEscalation(client, previousCategory, nextCategory, strCase,
                 context.authenticatedUser(), LocalDateTime.now()));
+        log.info("Client {} auto-escalated from risk category {} to {} on the {}rd cumulative STR case; re-KYC now due {}",
+                client.getId(), previousCategory, nextCategory, cumulativeCases, kyc.getExpiryDate());
     }
 
     private Integer nextCategory(Integer currentCategory) {

fineract-provider/src/main/java/org/apache/fineract/portfolio/cashierdeposit/api/CashierDepositRequestApiResource.java

@@ -54,7 +54,10 @@ import org.apache.fineract.commands.service.PortfolioCommandSourceWritePlatformS
 import org.apache.fineract.infrastructure.core.data.CommandProcessingResult;
 import org.apache.fineract.infrastructure.core.serialization.FromJsonHelper;
 import org.apache.fineract.infrastructure.security.service.PlatformSecurityContext;
+import org.apache.fineract.portfolio.voucher.service.VoucherLine;
 import org.apache.fineract.portfolio.voucher.service.VoucherService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.apache.fineract.useradministration.domain.AppUser;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.stereotype.Component;
@@ -67,8 +70,13 @@ import com.google.common.base.Splitter;
 @Component
 @Tag(name = "Cashier Deposit Requests", description = "Maker-checker deposit request workflow: cashier submits, bank manager approves.")
 @RequiredArgsConstructor
+@lombok.extern.slf4j.Slf4j
 public class CashierDepositRequestApiResource {
 
+    // Named LOG rather than declared with @Slf4j: buildActivityLog uses a local "log" for the
+    // activity JsonArray, and a field of the same name reads as that variable at a glance.
+    private static final Logger LOG = LoggerFactory.getLogger(CashierDepositRequestApiResource.class);
+
     private final JdbcTemplate jdbcTemplate;
     private final FromJsonHelper fromJsonHelper;
     private final PlatformSecurityContext context;
@@ -161,7 +169,7 @@ public class CashierDepositRequestApiResource {
         // reject() will delete these records so the vault position is reversed.
         if (denominationData != null && !denominationData.isBlank()) {
             savePendingDenomination(denominationData, newId, savingsAccountId, accountNo, clientId,
-                currentUser.getId(), currentUser.getUsername());
+                currentUser.getId(), currentUser.getUsername(), paymentTypeName);
         }
 
         return gson.toJson(Map.of("resourceId", newId, "status", "PENDING", "voucherNo", voucherNo));
@@ -394,6 +402,20 @@ public class CashierDepositRequestApiResource {
             txnId = isCurrentAccount
                 ? executeCurrentAccountDeposit(savingsAccountId, amount, ptId, txnDateStr, description)
                 : executeSavingsDeposit(savingsAccountId, amount, ptId, txnDateStr, description);
+            if (!isCurrentAccount && txnId != null) {
+                // approve() is one @Transactional block, so an uncaught exception here would roll back
+                // the deposit that was just posted along with it -- every Cheque/DD approval that ever
+                // hit an edge case in the new hold-placement logic would fail entirely, where before
+                // this feature existed it always succeeded. Catching it keeps the Clearing Hold strictly
+                // best-effort: the deposit approval this whole endpoint exists for must never depend on
+                // it, only benefit from it when it works.
+                try {
+                    placeClearingHoldIfInstrumentDeposit(savingsAccountId, ptId, amount, txnDateStr);
+                } catch (final RuntimeException e) {
+                    log.warn("Could not place a Clearing Hold for cashier deposit request {} (savings account {}): {}", id,
+                        savingsAccountId, e.getMessage(), e);
+                }
+            }
         }
 
         // Link voucher to the created savings txn and stamp voucher_no on it.
@@ -406,6 +428,10 @@ public class CashierDepositRequestApiResource {
             }
         }
 
+        // The sides of the slip, recorded now rather than at submission: which accounts the money
+        // actually moved between is only settled once the request is approved and posted.
+        addDepositVoucherLines(record, savingsAccountId, amount);
+
         final String updatedLog = buildActivityLog(
             (String) record.get("activity_log"), "APPROVED", currentUser.getUsername(), null
         );
@@ -540,6 +566,62 @@ public class CashierDepositRequestApiResource {
 
     // ── helpers ──────────────────────────────────────────────────────────────────
 
+    /**
+     * Records the two sides of an approved deposit on its voucher.
+     *
+     * A deposit is money arriving at the counter, so cash is debited and whatever receives it is
+     * credited — a member's savings account, or a GL account when the deposit was raised against
+     * one. The credited side is read from the request, because that is what the cashier actually
+     * filled in and what the member signed for.
+     *
+     * A failure here does not fail the approval. The deposit is already posted and the member's
+     * balance already raised; refusing that over its slip would take a correct transaction back for
+     * a paperwork reason. The problem is logged, and the voucher keeps its number without sides.
+     */
+    private void addDepositVoucherLines(final Map<?, ?> record, final Long savingsAccountId, final BigDecimal amount) {
+        final String voucherNo = (String) record.get("voucher_no");
+        if (voucherNo == null || voucherNo.isBlank()) {
+            return;
+        }
+
+        try {
+            final boolean isGl = "GL".equalsIgnoreCase((String) record.get("account_type"));
+            final String accountNo = (String) record.get("account_no");
+
+            // Cash reaching the counter. For a GL deposit the contra is the cash/vault account the
+            // request named; for a member deposit it is the cashier's own till, which the deposit
+            // register does not carry a GL id for — the line still names it, without an id.
+            final Object contraObj = record.get("contra_gl_id");
+            final Long contraGlId = contraObj != null ? ((Number) contraObj).longValue() : null;
+            final Map<String, Object> contra = glAccountForVoucher(contraGlId);
+            final VoucherLine debit = VoucherLine.debitGl(contraGlId, (String) contra.getOrDefault("name", "Cash in Hand"),
+                    (String) contra.get("gl_code"), amount);
+
+            final VoucherLine credit;
+            if (isGl) {
+                final Object glObj = record.get("gl_account_id");
+                final Long glAccountId = glObj != null ? ((Number) glObj).longValue() : null;
+                final Map<String, Object> gl = glAccountForVoucher(glAccountId);
+                credit = VoucherLine.creditGl(glAccountId, (String) gl.get("name"), (String) gl.get("gl_code"), amount);
+            } else {
+                credit = VoucherLine.creditSavings(savingsAccountId, (String) record.get("client_name"), accountNo, amount);
+            }
+
+            voucherService.addLines(voucherNo, List.of(debit, credit));
+        } catch (final RuntimeException e) {
+            LOG.error("Could not record voucher lines for deposit request voucher {}", voucherNo, e);
+        }
+    }
+
+    /** Name and code of a GL account, for printing on a voucher. Empty rather than absent if unmapped. */
+    private Map<String, Object> glAccountForVoucher(final Long glAccountId) {
+        if (glAccountId == null) {
+            return Map.of();
+        }
+        return jdbcTemplate.queryForList("SELECT name, gl_code FROM acc_gl_account WHERE id = ?", glAccountId).stream().findFirst()
+                .orElse(Map.of());
+    }
+
     private Map<?, ?> loadRecord(final Long id) {
         final List<Map<String, Object>> rows = jdbcTemplate.queryForList("""
                 SELECT id, voucher_no, account_no, account_type, savings_account_id,
@@ -582,10 +664,64 @@ public class CashierDepositRequestApiResource {
             .withJson(payload.toString())
             .build();
 
-        final CommandProcessingResult result = commandsSourceWritePlatformService.logCommandSource(commandRequest);
+        // The deposit register raised its own voucher at submission and attaches the till and
+        // member sides to it on approval, so the savings command must not raise a second one over
+        // the same money -- exactly as the GL branch of this register already does below. Without
+        // this, one deposit appears twice on the cashier's received report and doubles the day's
+        // cash taken in.
+        final CommandProcessingResult result = voucherService
+            .withOwnVoucher(() -> commandsSourceWritePlatformService.logCommandSource(commandRequest));
         return result.getResourceId() != null ? result.getResourceId().toString() : null;
     }
 
+    /**
+     * A Cheque/DD deposit is credited to the ledger immediately (same as cash) but is not really the
+     * branch's own money yet -- it still has to clear. Real-world CBS practice is to hold that amount
+     * until the instrument clears rather than let it sit withdrawable, so this places an automatic
+     * Clearing Hold for the full deposited amount right after a Cheque/DD deposit posts. Cash and
+     * electronic-transfer payment types (NEFT/RTGS/IMPS/UPI) are untouched -- cash is available on the
+     * spot, and an electronic transfer has already settled by the time it's entered here.
+     */
+    private void placeClearingHoldIfInstrumentDeposit(final Long savingsAccountId, final Object paymentTypeId, final BigDecimal amount,
+            final String txnDateStr) {
+        if (paymentTypeId == null) {
+            return;
+        }
+        final Long ptId = ((Number) paymentTypeId).longValue();
+        // m_payment_type's display name column is "value", not "name" (the mistake that broke this
+        // in testing) -- name() collisions with other tables made this easy to get wrong once and not
+        // notice until it actually ran against the real schema.
+        final List<String> names = jdbcTemplate.query("SELECT value FROM m_payment_type WHERE id = ?",
+            (rs, rowNum) -> rs.getString("value"), ptId);
+        if (names.isEmpty()) {
+            return;
+        }
+        final String name = names.get(0).toLowerCase();
+        final boolean isInstrumentDeposit = name.contains("cheque") || name.contains("check") || name.equals("dd")
+            || name.contains("demand draft");
+        if (!isInstrumentDeposit) {
+            return;
+        }
+
+        final String today = LocalDate.now(DateUtils.getDateTimeZoneOfTenant()).format(DateTimeFormatter.ofPattern("dd MMMM yyyy"));
+        final String date = txnDateStr != null && !txnDateStr.isBlank() ? formatForFineract(txnDateStr) : today;
+
+        final JsonObject payload = new JsonObject();
+        payload.addProperty("locale", "en");
+        payload.addProperty("dateFormat", "dd MMMM yyyy");
+        payload.addProperty("transactionDate", date);
+        payload.addProperty("transactionAmount", amount);
+        payload.addProperty("reasonForBlock", "Pending clearing — " + names.get(0) + " deposit");
+        payload.addProperty("holdCategory", "CLEARING");
+        payload.addProperty("lienAllowed", false);
+
+        final CommandWrapper commandRequest = new CommandWrapperBuilder()
+            .holdAmount(savingsAccountId)
+            .withJson(payload.toString())
+            .build();
+        commandsSourceWritePlatformService.logCommandSource(commandRequest);
+    }
+
     private String executeCurrentAccountDeposit(
             final Long currentAccountId, final BigDecimal amount,
             final Object paymentTypeId, final String txnDateStr, final String note) {
@@ -610,7 +746,11 @@ public class CashierDepositRequestApiResource {
             .withJson(payload.toString())
             .build();
 
-        final CommandProcessingResult result = commandsSourceWritePlatformService.logCommandSource(commandRequest);
+        // Suppressed for the same reason as the savings path above. Current accounts raise no
+        // voucher of their own today, so this changes nothing now; it is here so that the day one
+        // is added, this register does not silently start double-counting again.
+        final CommandProcessingResult result = voucherService
+            .withOwnVoucher(() -> commandsSourceWritePlatformService.logCommandSource(commandRequest));
         return result.getResourceId() != null ? result.getResourceId().toString() : null;
     }
 
@@ -685,7 +825,10 @@ public class CashierDepositRequestApiResource {
             .withJson(payload.toString())
             .build();
 
-        final CommandProcessingResult result = commandsSourceWritePlatformService.logCommandSource(commandRequest);
+        // The deposit register raises its own voucher, naming the member and their account; the
+        // journal command must not raise a second one over the same money.
+        final CommandProcessingResult result = voucherService
+            .withOwnVoucher(() -> commandsSourceWritePlatformService.logCommandSource(commandRequest));
         return result.getTransactionId() != null ? result.getTransactionId() : null;
     }
 
@@ -699,7 +842,7 @@ public class CashierDepositRequestApiResource {
     // approve() updates txn_id to real Fineract id; reject() deletes these records.
     private void savePendingDenomination(final String denominationData,
             final Long requestId, final Long savingsAccountId, final String accountNo,
-            final Long clientId, final Long cashierId, final String cashierUsername) {
+            final Long clientId, final Long cashierId, final String cashierUsername, final String paymentTypeName) {
         final JsonObject denomMap;
         try {
             denomMap = gson.fromJson(denominationData, JsonObject.class);
@@ -729,12 +872,12 @@ public class CashierDepositRequestApiResource {
             jdbcTemplate.update("""
                 INSERT INTO m_savings_txn_denomination
                 (txn_id, savings_account_id, account_no, client_id, denomination_id,
-                 denomination_value, count, total_amount, txn_date, txn_type, officer_id, officer_username)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, CURRENT_DATE, 'DEPOSIT', ?, ?)
+                 denomination_value, count, total_amount, txn_date, txn_type, officer_id, officer_username, payment_type)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, CURRENT_DATE, 'DEPOSIT', ?, ?, ?)
                 """,
                 requestId, savingsAccountId, accountNo, clientId, denomId,
                 value, count, BigDecimal.valueOf((long) value * count),
-                cashierId, cashierUsername
+                cashierId, cashierUsername, paymentTypeName
             );
         }
     }

fineract-provider/src/main/java/org/apache/fineract/portfolio/cashreport/api/CashReportApiResource.java

@@ -13,8 +13,10 @@ import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.apache.fineract.infrastructure.security.service.PlatformSecurityContext;
 import org.apache.fineract.portfolio.cashreport.service.CashierRoleHelper;
+import org.apache.fineract.portfolio.cashreport.service.VaultPositionService;
 import org.apache.fineract.portfolio.denominationmaster.service.DenominationBreakdownWriter;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.stereotype.Component;
@@ -23,6 +25,7 @@ import org.apache.fineract.infrastructure.core.service.DateUtils;
 @Path("/v1/cashreports")
 @Component
 @RequiredArgsConstructor
+@Slf4j
 @Produces({ MediaType.APPLICATION_JSON })
 public class CashReportApiResource {
 
@@ -30,13 +33,307 @@ public class CashReportApiResource {
     private final PlatformSecurityContext context;
     private final DenominationBreakdownWriter denominationBreakdownWriter;
     private final CashierRoleHelper cashierRoleHelper;
+    private final VaultPositionService vaultPositionService;
     private final Gson gson = new Gson();
 
+    /**
+     * Excludes reversed counter transactions from a cash figure.
+     *
+     * m_savings_txn_denomination has no reversal marker of its own -- the notes counted at the
+     * counter are recorded once and never revisited -- so a reversed deposit or withdrawal left its
+     * breakdown behind and went on inflating the drawer for good. Every other leg of the cash
+     * position (vault transfers, settlements, inter-cashier legs, exchanges) already guards against
+     * its own reversal flag; this is the same guard for the counter, read off the transaction the
+     * breakdown belongs to.
+     *
+     * NOT EXISTS rather than a join, so a breakdown whose transaction cannot be found -- the DD
+     * register keys its rows by its own request id, not a savings transaction -- is kept rather than
+     * silently dropped.
+     */
+    private static final String COUNTER_NOT_REVERSED = "AND NOT EXISTS ("
+            + "  SELECT 1 FROM m_savings_account_transaction rt "
+            + "   WHERE rt.id = std.txn_id AND rt.is_reversed = true) ";
+
+    /**
+     * Day book — every voucher raised on one date, in one list, newest first.
+     *
+     * Pulls the three registers that carry a voucher: cashier deposits (CR), clerk withdrawals (DR)
+     * and the clerk disbursement register (DR, or CR for a collection). Each row carries its
+     * voucher number, side, amount, account, party and status, so the cashier can reconcile a day
+     * without opening three separate screens.
+     *
+     * Dated on the business date the voucher belongs to rather than the row's creation timestamp:
+     * deposits and withdrawals carry an explicit txn_date, and the disbursement register — which
+     * has no such column — falls back to the date it was submitted on.
+     */
+    @GET
+    @Path("day-book")
+    public String dayBook(@QueryParam("date") final String date, @QueryParam("side") final String side,
+            @QueryParam("status") final String status) {
+
+        final String txnDate = (date != null && !date.isBlank()) ? date : LocalDate.now(DateUtils.getDateTimeZoneOfTenant()).toString();
+
+        final List<Map<String, Object>> rows = new ArrayList<>();
+
+        // Each register is left-joined to the verification table and to an attachment count, so a
+        // row already carries its physical-check verdict and whether a slip was scanned in — the
+        // screen never has to fire a follow-up call per voucher.
+        final String verifyJoin = """
+                 LEFT JOIN m_voucher_verification vv ON vv.voucher_no = r.voucher_no
+                 LEFT JOIN (SELECT voucher_no, COUNT(*) AS n FROM m_voucher_attachment GROUP BY voucher_no)
+                        va ON va.voucher_no = r.voucher_no
+                """;
+        final String verifyCols = """
+                       vv.status AS verify_status, vv.slip_amount, vv.remarks AS verify_remarks,
+                       vv.verified_by_name, vv.verified_at,
+                       vv.resolution_status, vv.resolution_notes, vv.resolved_by_name, vv.resolved_at,
+                       COALESCE(va.n, 0) AS attachment_count
+                """;
+
+        // Cashier deposits — money in, so the credit side.
+        rows.addAll(jdbcTemplate.query("""
+                SELECT r.voucher_no,
+                       -- Same rule as the withdrawal register below: an approved deposit is cash in
+                       -- the drawer, a pending one is a request nobody has taken money for yet.
+                       CASE WHEN r.status IN ('APPROVED', 'COMPLETED') THEN 'CASHIER' ELSE 'CLERK' END AS section,
+                       'CR' AS side, 'DEPOSIT' AS kind, r.account_no, r.account_type,
+                       r.client_name AS party, r.amount, r.payment_type_name, r.description, r.status,
+                       r.cashier_name AS handled_by, r.manager_name AS approved_by, r.txn_id,
+                       r.submitted_at, r.actioned_at,
+                """ + verifyCols + """
+                  FROM m_cashier_deposit_request r
+                """ + verifyJoin + """
+                 WHERE COALESCE(r.txn_date, CAST(r.submitted_at AS DATE)) = CAST(? AS DATE)
+                """, this::mapDayBookRow, txnDate));
+
+        // Clerk withdrawals — money out, so the debit side.
+        rows.addAll(jdbcTemplate.query("""
+                SELECT r.voucher_no,
+                       -- Filed by what happened to the money, not by who typed the request. Once the
+                       -- notes are handed over it is the cashier's drawer that is short, so the row
+                       -- belongs in their section; while it is still pending or was rejected no cash
+                       -- has moved and it is the clerk's outstanding request.
+                       CASE WHEN r.status IN ('WITHDRAWN', 'COMPLETED') THEN 'CASHIER' ELSE 'CLERK' END AS section,
+                       'DR' AS side, 'WITHDRAWAL' AS kind, r.account_no, r.account_type,
+                       r.client_name AS party, r.amount, r.payment_type_name, r.description, r.status,
+                       COALESCE(paid.officer_username, r.clerk_name) AS handled_by,
+                       r.manager_name AS approved_by, r.tok_no AS txn_id,
+                       r.submitted_at, r.actioned_at,
+                """ + verifyCols + """
+                  FROM m_clerk_withdrawal_request r
+                """ + verifyJoin + """
+                  -- A withdrawal is raised by a clerk but the notes leave a cashier's drawer, so it
+                  -- is filed under whoever's cash actually moved. Sectioning it by the maker put
+                  -- every counter payment in the clerk's column and left the cashier's own section
+                  -- short by exactly what they had paid out -- the one figure their drawer is
+                  -- checked against. The payer is read from the denomination breakdown, which is
+                  -- written when the cash is handed over, and the By column names them too.
+                  LEFT JOIN LATERAL (
+                       SELECT d.officer_username FROM m_savings_txn_denomination d
+                        WHERE r.txn_id ~ '^[0-9]+$' AND d.txn_id = CAST(r.txn_id AS BIGINT)
+                          AND d.officer_username IS NOT NULL
+                        LIMIT 1) paid ON TRUE
+                 WHERE COALESCE(r.txn_date, CAST(r.submitted_at AS DATE)) = CAST(? AS DATE)
+                """, this::mapDayBookRow, txnDate));
+
+        // Account closures — a full-balance payout, so the debit side. Its own register rather than
+        // the withdrawal one: a closure carries no clerk-entered amount (the figure is whatever
+        // close() computes at approval) and the cash handed over is the ROUNDED
+        // cashier_disbursed_amount, which is what a cash book has to agree with, not the
+        // paisa-exact closing_amount posted to the member's ledger.
+        //
+        // Only CLOSED rows, unlike the registers above: a closure becomes a cash-book event when the
+        // cashier actually hands the notes over, and not before. A PENDING or APPROVED closure has
+        // taken nothing out of the drawer yet, and a REJECTED one never will — listing those would
+        // put rows with no cash behind them (a rejected closure has no amount at all) into the
+        // teller's day book. And the day they belong to is the day the cash left, so this filters on
+        // disbursed_at, falling back to closure_date for a nil-balance closure that had no cashier
+        // step to reach.
+        rows.addAll(jdbcTemplate.query("""
+                SELECT r.voucher_no, 'DR' AS side, 'CLOSURE' AS kind, r.account_no,
+                       'SAVINGS' AS account_type, r.client_name AS party,
+                       COALESCE(r.cashier_disbursed_amount, r.closing_amount) AS amount,
+                       r.payment_type_name, r.description, r.status,
+                       COALESCE(r.disbursed_by, r.clerk_name) AS handled_by,
+                       r.manager_name AS approved_by, r.tok_no AS txn_id,
+                       r.submitted_at, r.actioned_at,
+                """ + verifyCols + """
+                  FROM m_clerk_closure_request r
+                """ + verifyJoin + """
+                 WHERE r.status = 'CLOSED'
+                   AND COALESCE(CAST(r.disbursed_at AS DATE), r.closure_date) = CAST(? AS DATE)
+                """, this::mapDayBookRow, txnDate));
+
+        // Disbursement register: a collection pulls money into the GL (CR); a disbursement or a
+        // bank transfer moves it out (DR) — matching how the voucher itself was numbered.
+        rows.addAll(jdbcTemplate.query("""
+                SELECT r.voucher_no, 'CLERK' AS section,
+                       CASE WHEN r.request_type = 'COLLECTION' THEN 'CR' ELSE 'DR' END AS side,
+                       r.request_type AS kind, r.gl_account_no AS account_no, 'GL' AS account_type,
+                       r.gl_account_name AS party, r.dr_amount AS amount, r.payment_type_name,
+                       r.description, r.status, r.clerk_name AS handled_by,
+                       r.manager_name AS approved_by, NULL AS txn_id, r.submitted_at, r.actioned_at,
+                """ + verifyCols + """
+                  FROM m_clerk_disbursement_request r
+                """ + verifyJoin + """
+                 WHERE CAST(r.submitted_at AS DATE) = CAST(? AS DATE)
+                """, this::mapDayBookRow, txnDate));
+
+        // Cash taken at the counter for a Demand Draft — a receipt, so the credit side.
+        //
+        // The Sponsor DD register is not one of the three above and has no voucher_no of its own, so
+        // the day book showed nothing for it: a cashier who took ₹111.80 in notes for a draft saw a
+        // day book with an empty CR column and no sign of the money. The voucher is joined the other
+        // way round, from m_voucher.reference_id, which is where the link actually lives.
+        //
+        // Only the cash-funded drafts appear, and only those the cashier took the notes for
+        // directly: an account-debit or cheque draft never crosses the counter, and one funded from
+        // a cashier deposit request is already listed above under that register's own row.
+        rows.addAll(jdbcTemplate.query("""
+                SELECT v.voucher_no, 'CASHIER' AS section, 'CR' AS side, 'DD CASH' AS kind,
+                       NULL AS account_no, 'GL' AS account_type,
+                       COALESCE(r.walkin_purchaser_name, r.beneficiary_name) AS party,
+                       r.face_value + COALESCE(r.charges_amount, 0) + COALESCE(r.gst_amount, 0) AS amount,
+                       'CASH' AS payment_type_name,
+                       CONCAT('DD for ', r.beneficiary_name) AS description,
+                       r.status, mk.username AS handled_by, ck.username AS approved_by,
+                       CAST(r.id AS VARCHAR) AS txn_id,
+                       r.created_date AS submitted_at, r.checker_date AS actioned_at,
+                """ + verifyCols + """
+                  FROM m_sponsor_dd_issue_request r
+                  LEFT JOIN m_appuser mk ON mk.id = r.maker_id
+                  LEFT JOIN m_appuser ck ON ck.id = r.checker_id
+                  LEFT JOIN m_voucher v ON v.reference_type = 'SPONSOR_DD_ISSUE_REQUEST'
+                                       AND v.reference_id = r.id AND v.voucher_no LIKE 'CR/%'
+                """ + verifyJoin.replace("r.voucher_no", "v.voucher_no") + """
+                 WHERE r.payment_method = 'CASH' AND r.cashier_deposit_request_id IS NULL
+                   AND COALESCE(r.issued_date, CAST(r.created_date AS DATE)) = CAST(? AS DATE)
+                """, this::mapDayBookRow, txnDate));
+
+        // Filtering and ordering happen here rather than in SQL: three separate queries cannot be
+        // ordered as one result set, and the row count for a single day is small.
+        final String sideFilter = side == null || side.isBlank() || "ALL".equalsIgnoreCase(side) ? null : side.toUpperCase();
+        final String statusFilter = status == null || status.isBlank() || "ALL".equalsIgnoreCase(status) ? null : status.toUpperCase();
+
+        final List<Map<String, Object>> filtered = new ArrayList<>();
+        BigDecimal creditTotal = BigDecimal.ZERO;
+        BigDecimal debitTotal = BigDecimal.ZERO;
+
+        for (final Map<String, Object> row : rows) {
+            if (sideFilter != null && !sideFilter.equals(row.get("side"))) {
+                continue;
+            }
+            if (statusFilter != null && !statusFilter.equalsIgnoreCase((String) row.get("status"))) {
+                continue;
+            }
+            filtered.add(row);
+
+            // Only approved money is real money: a pending or rejected voucher must not inflate the
+            // day's totals, even though it still belongs in the listing. The source registers don't
+            // share one terminal status string: deposits and disbursements land on APPROVED, a clerk
+            // withdrawal's finished state is WITHDRAWN, and an account closure's is CLOSED -- missing
+            // any of them meant a completed transaction moved real money out yet never showed up in
+            // the DR total at all. A closure is one row that moves APPROVED -> CLOSED, so counting
+            // both states cannot double-count it; only 'CLOSED' is unique to that register.
+            final String rowStatus = (String) row.get("status");
+            if ("APPROVED".equalsIgnoreCase(rowStatus) || "COMPLETED".equalsIgnoreCase(rowStatus)
+                    || "WITHDRAWN".equalsIgnoreCase(rowStatus) || "CLOSED".equalsIgnoreCase(rowStatus)) {
+                final BigDecimal amount = (BigDecimal) row.get("amount");
+                if (amount != null) {
+                    if ("CR".equals(row.get("side"))) {
+                        creditTotal = creditTotal.add(amount);
+                    } else {
+                        debitTotal = debitTotal.add(amount);
+                    }
+                }
+            }
+        }
+
+        filtered.sort((a, b) -> {
+            final Object left = b.get("submittedAt");
+            final Object right = a.get("submittedAt");
+            if (left == null && right == null) {
+                return 0;
+            }
+            if (left == null) {
+                return -1;
+            }
+            if (right == null) {
+                return 1;
+            }
+            return left.toString().compareTo(right.toString());
+        });
+
+        final Map<String, Object> result = new LinkedHashMap<>();
+        result.put("date", txnDate);
+        result.put("rows", filtered);
+        result.put("count", filtered.size());
+        // Counter figures: the credit and debit the customer side of the day adds up to.
+        result.put("creditTotal", creditTotal);
+        result.put("debitTotal", debitTotal);
+        result.put("netTotal", creditTotal.subtract(debitTotal));
+        return gson.toJson(result);
+    }
+
+    private Map<String, Object> mapDayBookRow(final java.sql.ResultSet rs, final int rowNum) throws java.sql.SQLException {
+        final Map<String, Object> row = new LinkedHashMap<>();
+        row.put("voucherNo", rs.getString("voucher_no"));
+        // Which part of the day's work this row belongs to. The registers do not divide along
+        // maker lines -- a clerk raises a withdrawal that a cashier pays out -- so the section says
+        // where the entry came from, not who typed it.
+        row.put("section", rs.getString("section"));
+        row.put("side", rs.getString("side"));
+        row.put("kind", rs.getString("kind"));
+        row.put("accountNo", rs.getString("account_no"));
+        row.put("accountType", rs.getString("account_type"));
+        row.put("party", rs.getString("party"));
+        row.put("amount", rs.getBigDecimal("amount"));
+        row.put("paymentTypeName", rs.getString("payment_type_name"));
+        row.put("description", rs.getString("description"));
+        row.put("status", rs.getString("status"));
+        row.put("handledBy", rs.getString("handled_by"));
+        row.put("approvedBy", rs.getString("approved_by"));
+        row.put("txnId", rs.getString("txn_id"));
+
+        // Physical-slip check. verifyStatus is null until someone actually looks at the paper.
+        row.put("verifyStatus", rs.getString("verify_status"));
+        row.put("slipAmount", rs.getBigDecimal("slip_amount"));
+        row.put("verifyRemarks", rs.getString("verify_remarks"));
+        row.put("verifiedByName", rs.getString("verified_by_name"));
+        final java.sql.Timestamp verifiedAt = rs.getTimestamp("verified_at");
+        row.put("verifiedAt", verifiedAt == null ? null : verifiedAt.toLocalDateTime().toString());
+
+        // How the exception ended, if it has. Without this the day book keeps showing a closed
+        // exception as though it were still open — the flag never clears on screen.
+        row.put("resolutionStatus", rs.getString("resolution_status"));
+        row.put("resolutionNotes", rs.getString("resolution_notes"));
+        row.put("resolvedByName", rs.getString("resolved_by_name"));
+        final java.sql.Timestamp resolvedAt = rs.getTimestamp("resolved_at");
+        row.put("resolvedAt", resolvedAt == null ? null : resolvedAt.toLocalDateTime().toString());
+        row.put("attachmentCount", rs.getInt("attachment_count"));
+        // Emitted as plain ISO strings: Gson serialises java.sql.Timestamp into a locale-shaped
+        // form the browser cannot parse reliably.
+        final java.sql.Timestamp submitted = rs.getTimestamp("submitted_at");
+        final java.sql.Timestamp actioned = rs.getTimestamp("actioned_at");
+        row.put("submittedAt", submitted == null ? null : submitted.toLocalDateTime().toString());
+        row.put("actionedAt", actioned == null ? null : actioned.toLocalDateTime().toString());
+        return row;
+    }
     @GET
     @Path("closing")
     public String closing(@QueryParam("date") String date) {
         final String txnDate = (date != null && !date.isBlank()) ? date : LocalDate.now(DateUtils.getDateTimeZoneOfTenant()).toString();
 
+        // A closing report for a cashier is that one drawer, so it is scoped the way `excess` and
+        // `cashierPosition` already are; a head cashier or admin gets null and still sees the branch.
+        final Long scopedCashierId = cashierRoleHelper.getCashierIdForFiltering();
+
+        // The predicate goes through m_appuser because m_savings_txn_denomination records the acting
+        // user in officer_id, not the m_cashiers row -- the same join the position query uses.
+        final String cashierFilter = scopedCashierId != null ? "AND std.officer_id IN ("
+                + "  SELECT au.id FROM m_appuser au "
+                + "  JOIN m_cashiers mc ON mc.staff_id = au.staff_id WHERE mc.id = ?) " : "";
+
         // Single query — conditional aggregation for deposit, withdrawal, net per denomination
         final String sql = "SELECT std.denomination_id, std.denomination_value, COALESCE(dm.kind, 'note') AS kind, "
                 + "SUM(CASE WHEN std.txn_type = 'DEPOSIT' THEN std.count ELSE 0 END) AS deposit_count, "
@@ -45,10 +342,16 @@ public class CashReportApiResource {
                 + "SUM(CASE WHEN std.txn_type = 'WITHDRAWAL' THEN std.total_amount ELSE 0 END) AS withdrawal_amount "
                 + "FROM m_savings_txn_denomination std "
                 + "LEFT JOIN m_denomination_master dm ON dm.id = std.denomination_id "
-                + "WHERE std.txn_date = CAST(? AS DATE) "
+                + "WHERE std.txn_date = CAST(? AS DATE) " + cashierFilter + COUNTER_NOT_REVERSED
                 + "GROUP BY std.denomination_id, std.denomination_value, dm.kind "
                 + "ORDER BY std.denomination_value DESC, dm.kind";
 
+        final List<Object> args = new ArrayList<>();
+        args.add(txnDate);
+        if (scopedCashierId != null) {
+            args.add(scopedCashierId);
+        }
+
         final List<Map<String, Object>> rows = jdbcTemplate.query(sql, (rs, rowNum) -> {
             long depositCount = rs.getLong("deposit_count");
             long withdrawalCount = rs.getLong("withdrawal_count");
@@ -65,7 +368,7 @@ public class CashReportApiResource {
             row.put("netCount", depositCount - withdrawalCount);
             row.put("netAmount", depositAmount.subtract(withdrawalAmount));
             return row;
-        }, txnDate);
+        }, args.toArray());
 
         BigDecimal depositTotal = BigDecimal.ZERO;
         BigDecimal withdrawalTotal = BigDecimal.ZERO;
@@ -75,6 +378,7 @@ public class CashReportApiResource {
         }
 
         // Cash exchange rows — separate section (denomination swap, net monetary = 0)
+        final String exchangeCashierFilter = scopedCashierId != null ? "AND ce.cashier_id = ? " : "";
         final String exchangeSql = "SELECT ced.denomination_id, ced.denomination_value, COALESCE(dm.kind, 'note') AS kind, "
                 + "SUM(CASE WHEN ced.direction = 'RECEIVED' THEN ced.count ELSE 0 END) AS received_count, "
                 + "SUM(CASE WHEN ced.direction = 'RECEIVED' THEN ced.total_amount ELSE 0 END) AS received_amount, "
@@ -84,10 +388,16 @@ public class CashReportApiResource {
                 + "JOIN m_cash_exchange ce ON ce.id = ced.exchange_id "
                 + "LEFT JOIN m_denomination_master dm ON dm.id = ced.denomination_id "
                 + "WHERE ce.exchange_date = CAST(? AS DATE) "
-                + "AND (ce.is_reversed IS NULL OR ce.is_reversed = false) "
+                + "AND (ce.is_reversed IS NULL OR ce.is_reversed = false) " + exchangeCashierFilter
                 + "GROUP BY ced.denomination_id, ced.denomination_value, dm.kind "
                 + "ORDER BY ced.denomination_value DESC, dm.kind";
 
+        final List<Object> exArgs = new ArrayList<>();
+        exArgs.add(txnDate);
+        if (scopedCashierId != null) {
+            exArgs.add(scopedCashierId);
+        }
+
         final List<Map<String, Object>> exchangeRows = jdbcTemplate.query(exchangeSql, (rs, rowNum) -> {
             long receivedCount = rs.getLong("received_count");
             long givenCount = rs.getLong("given_count");
@@ -104,18 +414,96 @@ public class CashReportApiResource {
             row.put("netCount", receivedCount - givenCount);
             row.put("netAmount", receivedAmount.subtract(givenAmount));
             return row;
-        }, txnDate);
+        }, exArgs.toArray());
+
+        // Cash taken over the counter for a Demand Draft.
+        //
+        // A cash DD asks for a denomination breakdown but does not insist on one, so most are
+        // recorded with none at all -- and the whole of this report is built from breakdowns. The
+        // money is real: the ledger holds it (Cash at Vault is debited when the notes are taken)
+        // and the cashier is holding the notes, yet the drawer figure omitted every rupee of it.
+        //
+        // Counted from the request itself rather than from a breakdown, so it appears whether or not
+        // the notes were itemised. Excluded are DDs funded through a cashier deposit request: that
+        // register counted the same notes already, and adding them here would count them twice.
+        final String ddCashierFilter = scopedCashierId != null ? "AND dd.maker_id IN ("
+                + "  SELECT au.id FROM m_appuser au "
+                + "  JOIN m_cashiers mc ON mc.staff_id = au.staff_id WHERE mc.id = ?) " : "";
+        final String ddSql = "SELECT COALESCE(SUM(dd.face_value + COALESCE(dd.charges_amount, 0) "
+                + "+ COALESCE(dd.gst_amount, 0)), 0) AS cash_total, COUNT(*) AS cash_count "
+                + "FROM m_sponsor_dd_issue_request dd "
+                + "WHERE dd.payment_method = 'CASH' AND dd.cashier_deposit_request_id IS NULL "
+                + "AND dd.status <> 'REJECTED' "
+                + "AND COALESCE(dd.issued_date, CAST(dd.created_date AS DATE)) = CAST(? AS DATE) " + ddCashierFilter;
+
+        final List<Object> ddArgs = new ArrayList<>();
+        ddArgs.add(txnDate);
+        if (scopedCashierId != null) {
+            ddArgs.add(scopedCashierId);
+        }
+
+        BigDecimal ddCashTotal = BigDecimal.ZERO;
+        long ddCashCount = 0;
+        try {
+            final Map<String, Object> ddRow = jdbcTemplate.queryForMap(ddSql, ddArgs.toArray());
+            ddCashTotal = (BigDecimal) ddRow.get("cash_total");
+            ddCashCount = ((Number) ddRow.get("cash_count")).longValue();
+        } catch (final RuntimeException e) {
+            // A tenant without the Sponsor DD tables still gets its closing report.
+            log.warn("Could not read cash Demand Draft receipts for {}", txnDate, e);
+        }
 
         Map<String, Object> result = new LinkedHashMap<>();
         result.put("date", txnDate);
         result.put("rows", rows);
+        // The denomination-wise total, which is what the rows below add up to.
         result.put("depositTotal", depositTotal);
         result.put("withdrawalTotal", withdrawalTotal);
-        result.put("netTotal", depositTotal.subtract(withdrawalTotal));
+        // Reported separately as well, so a screen can show where the difference comes from rather
+        // than presenting a deposit total its own rows do not explain.
+        result.put("ddCashTotal", ddCashTotal);
+        result.put("ddCashCount", ddCashCount);
+        result.put("depositTotalWithDd", depositTotal.add(ddCashTotal));
+        result.put("netTotal", depositTotal.add(ddCashTotal).subtract(withdrawalTotal));
         result.put("exchangeRows", exchangeRows);
+        result.put("cashierId", scopedCashierId);
+        result.put("scopedToCashier", scopedCashierId != null);
+
+        // Opening and closing cash in the drawer.
+        //
+        // netTotal above is only the day's counter movement, which is not what the cashier is
+        // holding. A closing figure has to carry the previous balance forward, so it is derived from
+        // the cumulative position -- vault allocations, settlements, inter-cashier legs and
+        // exchanges as well as the counter work -- read once as of the day before and once as of the
+        // day itself. The gap between the two is the day's entire cash movement, a wider figure than
+        // deposits minus withdrawals, which is why both are reported rather than one derived from
+        // the other: when they differ, the difference is vault and inter-cashier traffic.
+        //
+        // Only a cashier-scoped call can answer this. A branch-wide opening balance belongs to the
+        // branch day register, not to this report.
+        if (scopedCashierId != null) {
+            final BigDecimal openingBalance = positionTotalAsOf(scopedCashierId,
+                    LocalDate.parse(txnDate).minusDays(1).toString());
+            final BigDecimal closingBalance = positionTotalAsOf(scopedCashierId, txnDate);
+            result.put("openingBalance", openingBalance);
+            result.put("closingBalance", closingBalance);
+            result.put("cashMovement", closingBalance.subtract(openingBalance));
+        }
         return gson.toJson(result);
     }
 
+    /**
+     * What one cashier is holding at the end of a given date, in rupees.
+     *
+     * Reuses {@link #buildPositionForCashier} rather than re-summing the eight legs, so the closing
+     * report and the position screen can never disagree about the same drawer.
+     */
+    private BigDecimal positionTotalAsOf(Long cashierId, String asOfDate) {
+        final Map<String, Object> position = buildPositionForCashier(cashierId, asOfDate);
+        final Object total = position.get("totalAmount");
+        return total instanceof BigDecimal ? (BigDecimal) total : BigDecimal.ZERO;
+    }
+
     @GET
     @Path("excess")
     public String excess(@QueryParam("threshold") BigDecimal threshold,
@@ -360,6 +748,30 @@ public class CashReportApiResource {
         return gson.toJson(buildPositionForCashier(cashierId, dateFilter));
     }
 
+    /**
+     * GET /cashreports/vault-position?tellerId=X&asOfDate=yyyy-MM-dd
+     * Denomination-wise stock a vault (teller) is currently holding — "how much of what does the
+     * bank have", as opposed to cashier-position which answers the same question for a cashier.
+     * See {@link VaultPositionService} for how the anchor is chosen.
+     */
+    @GET
+    @Path("vault-position")
+    public String vaultPosition(@QueryParam("tellerId") final Long tellerId,
+            @QueryParam("asOfDate") final String asOfDate) {
+        final String dateFilter = (asOfDate != null && !asOfDate.isBlank()) ? asOfDate
+                : LocalDate.now(DateUtils.getDateTimeZoneOfTenant()).toString();
+
+        if (tellerId == null) {
+            final List<Long> tellerIds = jdbcTemplate.queryForList("SELECT id FROM m_tellers ORDER BY id", Long.class);
+            final List<Map<String, Object>> all = new ArrayList<>();
+            for (final Long id : tellerIds) {
+                all.add(vaultPositionService.buildPositionForVault(id, dateFilter));
+            }
+            return gson.toJson(all);
+        }
+        return gson.toJson(vaultPositionService.buildPositionForVault(tellerId, dateFilter));
+    }
+
     /**
      * GET /cashreports/cashier-morning?cashierId=X&date=YYYY-MM-DD
      * Returns denomination-wise cash received by the cashier from vault on the given date
@@ -438,7 +850,7 @@ public class CashReportApiResource {
                 + "WHERE std.txn_type = 'DEPOSIT' AND std.txn_date <= CAST(? AS DATE) "
                 + "AND std.officer_id IN ("
                 + "  SELECT au.id FROM m_appuser au "
-                + "  JOIN m_cashiers mc ON mc.staff_id = au.staff_id WHERE mc.id = ?) "
+                + "  JOIN m_cashiers mc ON mc.staff_id = au.staff_id WHERE mc.id = ?) " + COUNTER_NOT_REVERSED
                 + "GROUP BY std.denomination_id, std.denomination_value, dm.kind";
 
         // Settlements back to vault
@@ -464,7 +876,7 @@ public class CashReportApiResource {
                 + "WHERE std.txn_type = 'WITHDRAWAL' AND std.txn_date <= CAST(? AS DATE) "
                 + "AND std.officer_id IN ("
                 + "  SELECT au.id FROM m_appuser au "
-                + "  JOIN m_cashiers mc ON mc.staff_id = au.staff_id WHERE mc.id = ?) "
+                + "  JOIN m_cashiers mc ON mc.staff_id = au.staff_id WHERE mc.id = ?) " + COUNTER_NOT_REVERSED
                 + "GROUP BY std.denomination_id, std.denomination_value, dm.kind";
 
         // Exchange IN: customer gave denomination to cashier (RECEIVED direction)
@@ -597,9 +1009,44 @@ public class CashReportApiResource {
             baseParams = new Object[] { txnDate };
         }
 
-        // Base grouped query (reused for count, totals, and paged data)
+        // Base grouped query (reused for count, totals, and paged data). The two LEFT JOINs resolve
+        // the real, formatted voucher number (e.g. "CR/001/2908/0001") stamped on the deposit/
+        // withdrawal request at approval time -- std.txn_id on its own is only the internal savings
+        // transaction id (e.g. "4"), never what was actually printed on the voucher.
+        //
+        // A GL-type deposit's own txn_id is a hex string (e.g. "a29ff54dc88f", from a journal-entry
+        // reference) rather than a plain decimal savings-transaction id, but std.txn_id is always
+        // stored as the DECIMAL parse of whatever id it was given -- so for a GL row it holds the
+        // hex string's numeric value (178807899015311), not the hex string itself, and a plain
+        // string-equality join against cdr.txn_id can never match it. The second half of each OR
+        // below re-derives that same decimal value from the hex string to match it -- guarded to
+        // only run on strings that are actually hex (so an ordinary decimal txn_id, which never
+        // contains a-f, is never sent through the hex cast at all).
         final String baseGroupSql = "FROM m_savings_txn_denomination std "
                 + "LEFT JOIN m_client mc ON mc.id = std.client_id "
+                // A GL-type row (no client_id) carries the GL account's own code in account_no
+                // rather than a savings/current account number, so its "name" has to come from the
+                // chart of accounts, not from a client that was never party to the transaction.
+                + "LEFT JOIN acc_gl_account gla ON std.client_id IS NULL AND gla.gl_code = std.account_no "
+                // Scoped to std.txn_type: without it, a deposit's hex txn_id and a withdrawal's
+                // decimal txn_id can coincidentally hex-decode to the exact same number (confirmed
+                // live -- a2a0888f2bcf and a genuine withdrawal reference both resolved to
+                // 178810369551311), and an unscoped join matched the withdrawal row to that unrelated
+                // deposit's voucher, which COALESCE then preferred over the withdrawal's own real one.
+                + "LEFT JOIN m_cashier_deposit_request cdr ON std.txn_type = 'DEPOSIT' AND "
+                + "  (cdr.txn_id = CAST(std.txn_id AS VARCHAR) "
+                + "  OR (cdr.txn_id ~ '^[0-9a-fA-F]{1,16}$' AND cdr.txn_id ~ '[a-fA-F]' "
+                + "      AND ('x' || lpad(cdr.txn_id, 16, '0'))::bit(64)::bigint = std.txn_id)) "
+                + "LEFT JOIN m_clerk_withdrawal_request cwr ON std.txn_type = 'WITHDRAWAL' AND "
+                + "  (cwr.txn_id = CAST(std.txn_id AS VARCHAR) "
+                + "  OR (cwr.txn_id ~ '^[0-9a-fA-F]{1,16}$' AND cwr.txn_id ~ '[a-fA-F]' "
+                + "      AND ('x' || lpad(cwr.txn_id, 16, '0'))::bit(64)::bigint = std.txn_id)) "
+                // An account closure also writes its hand-over as a 'WITHDRAWAL' denomination row
+                // (the column records which way cash moved), but its request lives in its own
+                // register -- without this join the closure's real voucher number is never found and
+                // the report falls back to showing the bare savings-transaction id instead.
+                + "LEFT JOIN m_clerk_closure_request ccr ON std.txn_type = 'WITHDRAWAL' AND "
+                + "  ccr.txn_id = CAST(std.txn_id AS VARCHAR) "
                 + "WHERE std.txn_date = CAST(? AS DATE) "
                 + officerFilter
                 + " GROUP BY std.txn_id, std.account_no, mc.display_name, std.cif_no ";
@@ -620,9 +1067,10 @@ public class CashReportApiResource {
 
         // 2. Paged data query
         final String dataSql = "SELECT "
-                + "  std.txn_id AS voucher_no, "
+                + "  COALESCE(MAX(cdr.voucher_no), MAX(cwr.voucher_no), MAX(ccr.voucher_no), "
+                + "           CAST(std.txn_id AS VARCHAR)) AS voucher_no, "
                 + "  std.account_no AS ac_no, "
-                + "  COALESCE(mc.display_name, std.cif_no, '') AS ac_name, "
+                + "  COALESCE(mc.display_name, std.cif_no, MAX(gla.name), '') AS ac_name, "
                 + "  MAX(std.txn_date) AS txn_date, "
                 + "  TO_CHAR(MAX(std.created_at), 'HH24:MI:SS') AS txn_time, "
                 + "  MAX(std.officer_username) AS teller_name, "
@@ -642,7 +1090,7 @@ public class CashReportApiResource {
 
         final List<Map<String, Object>> pageItems = jdbcTemplate.query(dataSql, (rs, rowNum) -> {
             final Map<String, Object> row = new LinkedHashMap<>();
-            row.put("voucherNo", rs.getLong("voucher_no"));
+            row.put("voucherNo", rs.getString("voucher_no"));
             row.put("acNo", rs.getString("ac_no"));
             row.put("acName", rs.getString("ac_name"));
             row.put("txnDate", rs.getString("txn_date"));

fineract-provider/src/main/java/org/apache/fineract/portfolio/cashreport/service/VaultPositionService.java

@@ -0,0 +1,169 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.portfolio.cashreport.service;
+
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import lombok.RequiredArgsConstructor;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.RowMapper;
+import org.springframework.stereotype.Component;
+
+/**
+ * Denomination-wise cash a vault (teller) is currently holding.
+ *
+ * Anchored on the most recent business day (on or before the target date) whose branch day
+ * register recorded a vault-only opening breakdown ({@code OPENING_VAULT}, tagged with this exact
+ * teller), then walked forward by everything settled into this vault and handed out of it since.
+ * Vault-only rows exist separately from the branch-total {@code OPENING}/{@code CLOSING} rows
+ * (which mix the vault with whatever every cashier under it is holding) precisely so this anchor
+ * never includes cash that still physically sits with a cashier — mixing the two double-counts
+ * whatever a cashier settles back later, once already folded into the branch total, again as the
+ * settlement itself. A day recorded before vault-only tracking existed has no {@code OPENING_VAULT}
+ * row at all; the branch-total {@code OPENING} is used for it as a last resort so an old anchor
+ * still returns something rather than zero.
+ */
+@Component
+@RequiredArgsConstructor
+public class VaultPositionService {
+
+    private final JdbcTemplate jdbcTemplate;
+
+    // Row mapper: returns Object[]{Long denomId, Integer denomValue, String kind, Long count}
+    private static final RowMapper<Object[]> DENOM_ROW = (rs, r) -> new Object[] { rs.getLong("denomination_id"),
+            rs.getInt("denomination_value"), rs.getString("kind"), rs.getLong("total_count") };
+
+    public Map<String, Object> buildPositionForVault(final Long tellerId, final String dateFilter) {
+        final Map<String, Object> result = new LinkedHashMap<>();
+        result.put("tellerId", tellerId);
+        result.put("asOfDate", dateFilter);
+
+        String tellerName = null;
+        Long officeId = null;
+        try {
+            final Map<String, Object> teller = jdbcTemplate.queryForMap("SELECT name, office_id FROM m_tellers WHERE id = ?",
+                    tellerId);
+            tellerName = (String) teller.get("name");
+            officeId = ((Number) teller.get("office_id")).longValue();
+        } catch (final Exception ignored) {
+            // intentionally ignored
+        }
+        result.put("tellerName", tellerName);
+
+        if (officeId == null) {
+            result.put("hasBreakdown", false);
+            result.put("totalAmount", BigDecimal.ZERO);
+            result.put("denominations", new ArrayList<>());
+            return result;
+        }
+
+        // Prefer a vault-scoped anchor: it already reflects only this vault's own cash, carried
+        // forward day to day, with no cashier's held cash folded in. Fall back to the old
+        // branch-combined OPENING leg only when this office has no vault-scoped row at all on or
+        // before the target date (a day closed before vault-only tracking existed).
+        List<Map<String, Object>> anchorRows = jdbcTemplate.queryForList("""
+                SELECT r.id AS register_id, r.business_date FROM m_branch_day_register r
+                 WHERE r.office_id = ? AND r.business_date <= CAST(? AS DATE)
+                   AND EXISTS (SELECT 1 FROM m_branch_day_register_detail d
+                                WHERE d.register_id = r.id AND d.leg = 'OPENING_VAULT' AND d.teller_id = ?)
+                 ORDER BY r.business_date DESC LIMIT 1
+                """, officeId, dateFilter, tellerId);
+        String anchorLeg = "OPENING_VAULT";
+        if (anchorRows.isEmpty()) {
+            anchorLeg = "OPENING";
+            anchorRows = jdbcTemplate.queryForList("""
+                    SELECT r.id AS register_id, r.business_date FROM m_branch_day_register r
+                     WHERE r.office_id = ? AND r.business_date <= CAST(? AS DATE)
+                       AND EXISTS (SELECT 1 FROM m_branch_day_register_detail d
+                                    WHERE d.register_id = r.id AND d.leg = 'OPENING')
+                     ORDER BY r.business_date DESC LIMIT 1
+                    """, officeId, dateFilter);
+        }
+
+        if (anchorRows.isEmpty()) {
+            result.put("hasBreakdown", false);
+            result.put("totalAmount", BigDecimal.ZERO);
+            result.put("denominations", new ArrayList<>());
+            return result;
+        }
+
+        final Long registerId = ((Number) anchorRows.get(0).get("register_id")).longValue();
+        final String anchorDate = anchorRows.get(0).get("business_date").toString();
+
+        final Map<Long, long[]> balance = new LinkedHashMap<>();
+
+        addToBalance(balance, jdbcTemplate.query("""
+                SELECT denomination_id, denomination_value, COALESCE(dm.kind, 'note') AS kind, count AS total_count
+                  FROM m_branch_day_register_detail d LEFT JOIN m_denomination_master dm ON dm.id = d.denomination_id
+                 WHERE d.register_id = ? AND d.leg = ? AND (d.teller_id IS NULL OR d.teller_id = ?)
+                """, DENOM_ROW, registerId, anchorLeg, tellerId), 1);
+
+        addToBalance(balance, jdbcTemplate.query("""
+                SELECT csd.denomination_id, csd.denomination_value, COALESCE(dm.kind, 'note') AS kind, SUM(csd.count) AS total_count
+                  FROM m_cash_settlement_detail csd JOIN m_cash_settlement cs ON cs.id = csd.settlement_id
+                  LEFT JOIN m_denomination_master dm ON dm.id = csd.denomination_id
+                 WHERE cs.to_teller_id = ? AND (cs.is_reversed IS NULL OR cs.is_reversed = false)
+                   AND cs.settlement_date >= CAST(? AS DATE) AND cs.settlement_date <= CAST(? AS DATE)
+                 GROUP BY csd.denomination_id, csd.denomination_value, dm.kind
+                """, DENOM_ROW, tellerId, anchorDate, dateFilter), 1);
+
+        addToBalance(balance, jdbcTemplate.query("""
+                SELECT ctd.denomination_id, ctd.denomination_value, COALESCE(dm.kind, 'note') AS kind, SUM(ctd.count) AS total_count
+                  FROM m_cash_transfer_detail ctd JOIN m_cash_transfer ct ON ct.id = ctd.transfer_id
+                  LEFT JOIN m_denomination_master dm ON dm.id = ctd.denomination_id
+                 WHERE ct.from_teller_id = ? AND (ct.is_reversed IS NULL OR ct.is_reversed = false)
+                   AND ct.transfer_date >= CAST(? AS DATE) AND ct.transfer_date <= CAST(? AS DATE)
+                 GROUP BY ctd.denomination_id, ctd.denomination_value, dm.kind
+                """, DENOM_ROW, tellerId, anchorDate, dateFilter), -1);
+
+        final List<Map<String, Object>> rows = new ArrayList<>();
+        balance.entrySet().stream().sorted((a, b) -> Long.compare(b.getValue()[0], a.getValue()[0])).forEach(e -> {
+            final Map<String, Object> row = new LinkedHashMap<>();
+            row.put("denominationId", e.getKey());
+            row.put("denominationValue", (int) e.getValue()[0]);
+            row.put("kind", e.getValue()[1] == 1L ? "coin" : "note");
+            row.put("count", e.getValue()[2]);
+            row.put("amount", BigDecimal.valueOf(e.getValue()[0] * e.getValue()[2]));
+            rows.add(row);
+        });
+
+        final BigDecimal totalAmount = rows.stream().map(r -> (BigDecimal) r.get("amount")).reduce(BigDecimal.ZERO,
+                BigDecimal::add);
+
+        result.put("hasBreakdown", true);
+        result.put("anchorDate", anchorDate);
+        result.put("totalAmount", totalAmount);
+        result.put("denominations", rows);
+        return result;
+    }
+
+    private void addToBalance(final Map<Long, long[]> balance, final List<Object[]> rows, final int sign) {
+        for (final Object[] row : rows) {
+            final Long denomId = (Long) row[0];
+            final int denomValue = (Integer) row[1];
+            final long kindFlag = "coin".equalsIgnoreCase((String) row[2]) ? 1L : 0L;
+            final long count = (Long) row[3];
+            final long[] entry = balance.computeIfAbsent(denomId, k -> new long[] { denomValue, kindFlag, 0L });
+            entry[2] += count * sign;
+        }
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/portfolio/cashsettlement/api/CashSettlementApiResource.java

@@ -22,6 +22,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.apache.fineract.infrastructure.core.exception.PlatformDataIntegrityException;
 import org.apache.fineract.portfolio.cashreport.service.CashierRoleHelper;
 import org.springframework.jdbc.core.JdbcTemplate;
@@ -31,6 +32,8 @@ import org.apache.fineract.portfolio.cashsettlement.domain.CashSettlementDetail;
 import org.apache.fineract.portfolio.cashsettlement.domain.CashSettlementDetailRepository;
 import org.apache.fineract.portfolio.cashsettlement.domain.CashSettlementRepository;
 import org.apache.fineract.portfolio.teller.service.GlDispatchService;
+import org.apache.fineract.portfolio.voucher.service.VoucherLine;
+import org.apache.fineract.portfolio.voucher.service.VoucherService;
 import org.apache.fineract.useradministration.domain.AppUser;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.PlatformTransactionManager;
@@ -41,6 +44,7 @@ import org.apache.fineract.infrastructure.core.service.DateUtils;
 @Path("/v1/cashsettlement")
 @Component
 @RequiredArgsConstructor
+@Slf4j
 @Consumes({ MediaType.APPLICATION_JSON })
 @Produces({ MediaType.APPLICATION_JSON })
 public class CashSettlementApiResource {
@@ -52,6 +56,7 @@ public class CashSettlementApiResource {
     private final PlatformTransactionManager transactionManager;
     private final JdbcTemplate jdbcTemplate;
     private final CashierRoleHelper cashierRoleHelper;
+    private final VoucherService voucherService;
     private final Gson gson = new Gson();
 
     @POST

fineract-provider/src/main/java/org/apache/fineract/portfolio/cashtransfer/api/CashTransferApiResource.java

@@ -98,6 +98,8 @@ public class CashTransferApiResource {
                     "At least one denomination with a positive count is required.");
         }
 
+        validateVaultHasSufficientCash(fromTellerId, total, denominations, transferDate);
+
         CashTransfer header = new CashTransfer();
         header.setTransferDate(transferDate);
         header.setFromParty(fromParty);
@@ -264,6 +266,127 @@ public class CashTransferApiResource {
         return total;
     }
 
+    /**
+     * A vault can only hand out cash it is actually holding — in total, and note-by-note. The
+     * branch's business day carries an opening_cash figure forward each day (see
+     * BranchDayRegisterApiResource#lastClosingCash), so the vault's available balance for "today" is
+     * that opening figure, plus anything a cashier has already settled back into this same vault
+     * today, minus whatever this vault has already handed out to any cashier today. Reversed
+     * transfers/settlements don't count.
+     *
+     * No open business day for the vault's office means there is no opening_cash to check against, so
+     * the transfer is blocked outright rather than silently allowed against an unknown balance.
+     */
+    private void validateVaultHasSufficientCash(final Long fromTellerId, final BigDecimal requestedAmount,
+            final JsonArray denominations, final LocalDate transferDate) {
+        final Long officeId;
+        try {
+            officeId = jdbcTemplate.queryForObject("SELECT office_id FROM m_tellers WHERE id = ?", Long.class, fromTellerId);
+        } catch (Exception e) {
+            throw new PlatformDataIntegrityException("error.msg.cashtransfer.teller.not.found",
+                    "Vault/teller " + fromTellerId + " was not found.");
+        }
+
+        final LocalDate businessDate = transferDate != null ? transferDate : LocalDate.now(DateUtils.getDateTimeZoneOfTenant());
+        final java.sql.Date sqlBusinessDate = java.sql.Date.valueOf(businessDate);
+
+        final List<Long> registerIds = jdbcTemplate.query("""
+                SELECT id FROM m_branch_day_register
+                 WHERE office_id = ? AND business_date = ? AND closed_at IS NULL
+                """, (rs, n) -> rs.getLong(1), officeId, sqlBusinessDate);
+        if (registerIds.isEmpty()) {
+            throw new PlatformDataIntegrityException("error.msg.cashtransfer.branchday.not.open",
+                    "The business day for this branch is not open for " + businessDate
+                            + ". Open the business day before allocating cash to a cashier.");
+        }
+        final Long registerId = registerIds.get(0);
+
+        final BigDecimal openingCash = jdbcTemplate.queryForObject(
+                "SELECT COALESCE(opening_cash, 0) FROM m_branch_day_register WHERE id = ?", BigDecimal.class, registerId);
+
+        final BigDecimal handedOutToday = jdbcTemplate.queryForObject("""
+                SELECT COALESCE(SUM(transfer_amount), 0) FROM m_cash_transfer
+                 WHERE from_teller_id = ? AND transfer_date = ? AND COALESCE(is_reversed, false) = false
+                """, BigDecimal.class, fromTellerId, sqlBusinessDate);
+
+        final BigDecimal settledBackToday = jdbcTemplate.queryForObject("""
+                SELECT COALESCE(SUM(settlement_amount), 0) FROM m_cash_settlement
+                 WHERE to_teller_id = ? AND settlement_date = ? AND COALESCE(is_reversed, false) = false
+                """, BigDecimal.class, fromTellerId, sqlBusinessDate);
+
+        final BigDecimal available = openingCash.add(settledBackToday).subtract(handedOutToday);
+        if (requestedAmount.compareTo(available) > 0) {
+            throw new PlatformDataIntegrityException("error.msg.cashtransfer.insufficient.vault.cash",
+                    "Insufficient vault cash: available " + available + ", requested " + requestedAmount + ".");
+        }
+
+        validateVaultHasSufficientDenominations(registerId, fromTellerId, denominations, sqlBusinessDate);
+    }
+
+    /**
+     * The total-amount check above can pass while a specific note/coin still runs short — a vault
+     * holding ₹1,00,000 entirely in ₹500 notes cannot hand out ₹50,000 in ₹10 notes even though the
+     * total is well within its balance. This checks each requested denomination against what the
+     * vault's own opening breakdown (m_branch_day_register_detail, leg='OPENING') plus today's
+     * settlements-in minus today's transfers-out actually holds of that specific denomination.
+     *
+     * A day opened with a plain lump sum and no breakdown recorded has nothing to check a
+     * denomination against, so this is skipped rather than blocking every transfer on a day that
+     * simply never captured one.
+     */
+    private void validateVaultHasSufficientDenominations(final Long registerId, final Long fromTellerId,
+            final JsonArray denominations, final java.sql.Date businessDate) {
+        final List<Object[]> openingRows = jdbcTemplate.query("""
+                SELECT denomination_id, denomination_value, count FROM m_branch_day_register_detail
+                 WHERE register_id = ? AND leg = 'OPENING'
+                """, (rs, n) -> new Object[] { rs.getLong(1), rs.getInt(2), rs.getInt(3) }, registerId);
+        if (openingRows.isEmpty()) {
+            return;
+        }
+
+        final Map<Long, Integer> available = new java.util.HashMap<>();
+        for (final Object[] row : openingRows) {
+            available.merge((Long) row[0], (Integer) row[2], Integer::sum);
+        }
+
+        final List<Object[]> settledRows = jdbcTemplate.query("""
+                SELECT csd.denomination_id, SUM(csd.count) FROM m_cash_settlement_detail csd
+                  JOIN m_cash_settlement cs ON cs.id = csd.settlement_id
+                 WHERE cs.to_teller_id = ? AND cs.settlement_date = ? AND COALESCE(cs.is_reversed, false) = false
+                 GROUP BY csd.denomination_id
+                """, (rs, n) -> new Object[] { rs.getLong(1), rs.getLong(2) }, fromTellerId, businessDate);
+        for (final Object[] row : settledRows) {
+            available.merge((Long) row[0], ((Long) row[1]).intValue(), Integer::sum);
+        }
+
+        final List<Object[]> handedOutRows = jdbcTemplate.query("""
+                SELECT ctd.denomination_id, SUM(ctd.count) FROM m_cash_transfer_detail ctd
+                  JOIN m_cash_transfer ct ON ct.id = ctd.transfer_id
+                 WHERE ct.from_teller_id = ? AND ct.transfer_date = ? AND COALESCE(ct.is_reversed, false) = false
+                 GROUP BY ctd.denomination_id
+                """, (rs, n) -> new Object[] { rs.getLong(1), rs.getLong(2) }, fromTellerId, businessDate);
+        for (final Object[] row : handedOutRows) {
+            available.merge((Long) row[0], -((Long) row[1]).intValue(), Integer::sum);
+        }
+
+        for (final JsonElement el : denominations) {
+            final JsonObject item = el.getAsJsonObject();
+            final int count = item.has("count") && !item.get("count").isJsonNull() ? item.get("count").getAsInt() : 0;
+            if (count <= 0 || !item.has("denominationId") || item.get("denominationId").isJsonNull()) {
+                continue;
+            }
+            final long denominationId = item.get("denominationId").getAsLong();
+            final int denominationValue = item.has("denominationValue") && !item.get("denominationValue").isJsonNull()
+                    ? item.get("denominationValue").getAsInt() : 0;
+            final int availableCount = available.getOrDefault(denominationId, 0);
+            if (count > availableCount) {
+                throw new PlatformDataIntegrityException("error.msg.cashtransfer.insufficient.vault.denomination",
+                        "Insufficient stock of denomination " + denominationValue + ": vault has " + availableCount
+                                + ", requested " + count + ".");
+            }
+        }
+    }
+
     private boolean hasPositiveCount(JsonArray items) {
         for (JsonElement el : items) {
             JsonObject item = el.getAsJsonObject();

fineract-provider/src/main/java/org/apache/fineract/portfolio/cashtransfer/api/ShareAdvanceCollectionApiResource.java

@@ -0,0 +1,883 @@
+package org.apache.fineract.portfolio.cashtransfer.api;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import jakarta.ws.rs.Consumes;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.POST;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.PathParam;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.QueryParam;
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.Response;
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.ZoneOffset;
+import java.time.format.DateTimeParseException;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import lombok.RequiredArgsConstructor;
+import org.apache.fineract.commands.domain.CommandWrapper;
+import org.apache.fineract.commands.service.CommandWrapperBuilder;
+import org.apache.fineract.commands.service.PortfolioCommandSourceWritePlatformService;
+import org.apache.fineract.infrastructure.core.exception.PlatformDataIntegrityException;
+import org.apache.fineract.infrastructure.core.service.DateUtils;
+import org.apache.fineract.infrastructure.security.service.PlatformSecurityContext;
+import org.apache.fineract.useradministration.domain.AppUser;
+import org.springframework.dao.EmptyResultDataAccessException;
+import org.springframework.dao.IncorrectResultSizeDataAccessException;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * Share Advance Collection API — cash taken from a member BEFORE any share account exists.
+ *
+ * The cooperative's counter flow is: money first, share account afterwards. This resource covers both halves of that
+ * flow.
+ *
+ * <p>
+ * <b>1. Collect</b> — {@code POST /v1/shareadvancecollection}
+ *
+ * <pre>
+ *   Dr  Cash at Vault      (SHARES_REFERENCE)  = amount
+ *   Cr  Share Sundry       (SHARES_SUSPENSE)   = amount
+ * </pre>
+ *
+ * The money sits in the Share Sundry liability against a receipt number naming the member, so the unapplied rows in
+ * {@code m_share_advance_collection} always reconcile to the Sundry balance. No share account is involved yet.
+ *
+ * <p>
+ * <b>2. Apply</b> — {@code POST /v1/shareadvancecollection/{id}/apply}
+ *
+ * <pre>
+ *   Dr  Share Sundry       (SHARES_SUSPENSE)   = everything collected
+ *   Cr  Share Capital      (SHARES_EQUITY)     = share amount
+ *   Cr  Income from Fees   (INCOME_FROM_FEES)  = charge amount  (only when a charge applies)
+ *   Cr  Savings            (via deposit cmd)   = over-payment    (only when the member paid more)
+ * </pre>
+ *
+ * Applying clears the liability, issues the share capital, marks the account's charges paid and sets
+ * {@code collection_applied}, which is what reveals the purchase transaction in the passbook and transactions views.
+ * Account creation, approval and activation post no GL of their own — all share accounting happens here.
+ *
+ * <p>
+ * <b>When the cash does not match</b>
+ *
+ * <p>
+ * A member paying at the counter rarely hands over the exact figure, so neither case is treated as an error to be
+ * argued with at the window:
+ *
+ * <ul>
+ * <li><b>Short</b> — blocked. Share capital cannot be part-issued, so the clerk takes the balance on a further receipt
+ * and applies the receipts together: one settlement, several receipts, all marked applied.</li>
+ * <li><b>Over</b> — allowed, and the difference is credited to the member's linked savings account through Fineract's
+ * own deposit command, so it reaches their passbook rather than resting in a suspense GL that no record can attribute
+ * back to them.</li>
+ * </ul>
+ */
+@Path("/v1/shareadvancecollection")
+@Component
+@RequiredArgsConstructor
+@Consumes({ MediaType.APPLICATION_JSON })
+@Produces({ MediaType.APPLICATION_JSON })
+public class ShareAdvanceCollectionApiResource {
+
+    // ── acc_gl_journal_entry.type_enum ─────────────────────────────────────
+    // Fineract convention: 1 = CREDIT (Cr), 2 = DEBIT (Dr).
+    private static final int DEBIT = 2;
+    private static final int CREDIT = 1;
+
+    // ── CashAccountsForShares financial_account_type ───────────────────────
+    private static final int FA_SHARES_REFERENCE = 1;
+    private static final int FA_SHARES_SUSPENSE = 2;
+    private static final int FA_INCOME_FROM_FEES = 3;
+    private static final int FA_SHARES_EQUITY = 4;
+
+    // ── acc_product_mapping.product_type for shares ────────────────────────
+    private static final int PRODUCT_TYPE_SHARES = 4;
+
+    // ── m_share_account.status_enum ───────────────────────────────────────
+    private static final int STATUS_ACTIVE = 300;
+
+
+    private final PlatformSecurityContext context;
+    private final JdbcTemplate jdbcTemplate;
+    private final PortfolioCommandSourceWritePlatformService commandsSourceWritePlatformService;
+    private final Gson gson = new Gson();
+
+    // ══════════════════════════════════════════════════════════════════════
+    // POST — Take cash from a member with no share account yet
+    // ══════════════════════════════════════════════════════════════════════
+    @POST
+    @Transactional
+    public Response collect(final String body) {
+
+        final AppUser currentUser = this.context.authenticatedUser();
+        currentUser.validateHasPermissionTo("CREATE_JOURNALENTRY");
+
+        final JsonObject json = parseBody(body);
+        final Long clientId = getLong(json, "clientId");
+        final BigDecimal amount = getBigDecimal(json, "amount");
+        final String note = sanitiseNote(getString(json, "note"));
+        final LocalDate entryDate = parseDate(getString(json, "transactionDate"));
+
+        if (clientId == null) {
+            throw new PlatformDataIntegrityException("error.msg.shareadvance.clientid.required", "clientId is required.");
+        }
+        if (amount == null || amount.compareTo(BigDecimal.ZERO) <= 0) {
+            throw new PlatformDataIntegrityException("error.msg.shareadvance.amount.invalid", "amount must be greater than zero.");
+        }
+
+        final Map<String, Object> client = loadClient(clientId);
+        final Long officeId = toLong(client.get("office_id"));
+        final String clientName = (String) client.get("display_name");
+
+        // The share product drives the GL mapping. Collection happens before an account exists,
+        // so the product is supplied by the caller or defaults to the only mapped share product.
+        final Long productId = resolveProductId(getLong(json, "productId"));
+        final String currencyCode = resolveCurrency(productId);
+
+        final Long glReference = requireGl(productId, FA_SHARES_REFERENCE, "Cash at Vault (Share Reference)");
+        final Long glSuspense = requireGl(productId, FA_SHARES_SUSPENSE, "Share Sundry (Suspense)");
+
+        final long userId = currentUser.getId();
+        final LocalDateTime now = LocalDateTime.now(DateUtils.getDateTimeZoneOfTenant());
+        final String txnId = "SHADV-" + System.nanoTime();
+        final String receiptNo = nextReceiptNo();
+
+        final String desc = "Share advance collected from " + clientName + " | Receipt " + receiptNo + (note != null ? " | " + note : "");
+
+        insertEntry(officeId, glReference, DEBIT, amount, txnId, entryDate, null, userId, now, currencyCode, desc);
+        insertEntry(officeId, glSuspense, CREDIT, amount, txnId, entryDate, null, userId, now, currencyCode,
+                "Share advance held in Sundry | Receipt " + receiptNo);
+
+        jdbcTemplate.update(
+                "INSERT INTO m_share_advance_collection "
+                        + "(receipt_no, client_id, office_id, collection_date, amount, currency_code, status, "
+                        + " gl_transaction_id, collected_by_user, collected_by_name, note) " + "VALUES (?,?,?,?,?,?,'UNAPPLIED',?,?,?,?)",
+                receiptNo, clientId, officeId, java.sql.Date.valueOf(entryDate), amount, currencyCode, txnId, userId,
+                currentUser.getUsername(), note);
+
+        final Long id = jdbcTemplate.queryForObject("SELECT id FROM m_share_advance_collection WHERE receipt_no = ?", Long.class,
+                receiptNo);
+
+        final Map<String, Object> out = new LinkedHashMap<>();
+        out.put("collectionId", id);
+        out.put("receiptNo", receiptNo);
+        out.put("clientId", clientId);
+        out.put("clientName", clientName);
+        out.put("amount", amount);
+        out.put("currency", currencyCode);
+        out.put("status", "UNAPPLIED");
+        out.put("glTransactionId", txnId);
+        out.put("message", "Cash received and held in Share Sundry. Quote receipt " + receiptNo + " when the share account is created.");
+        return Response.ok(gson.toJson(out)).build();
+    }
+
+    // ══════════════════════════════════════════════════════════════════════
+    // GET — Unapplied receipts, optionally for one client
+    // ══════════════════════════════════════════════════════════════════════
+    @GET
+    public Response listUnapplied(@QueryParam("clientId") final Long clientId) {
+        this.context.authenticatedUser();
+
+        final StringBuilder sql = new StringBuilder("SELECT c.id, c.receipt_no, c.voucher_no, c.client_id,"
+                + " cl.display_name AS client_name, " + " c.collection_date, c.amount, c.currency_code, c.status, c.note "
+                + " FROM m_share_advance_collection c JOIN m_client cl ON cl.id = c.client_id " + " WHERE c.status = 'UNAPPLIED' ");
+        if (clientId != null) {
+            sql.append(" AND c.client_id = ").append(clientId);
+        }
+        sql.append(" ORDER BY c.collection_date, c.id");
+
+        final List<Map<String, Object>> rows = jdbcTemplate.queryForList(sql.toString());
+        final Map<String, Object> out = new LinkedHashMap<>();
+        out.put("unappliedCollections", rows);
+        out.put("totalUnapplied", rows.stream().map(r -> (BigDecimal) r.get("amount")).reduce(BigDecimal.ZERO, BigDecimal::add));
+        return Response.ok(gson.toJson(out)).build();
+    }
+
+    // ══════════════════════════════════════════════════════════════════════
+    // GET — One unapplied receipt by the voucher number quoted by the member
+    // ══════════════════════════════════════════════════════════════════════
+    // The voucher arrives as a query parameter because numbers are formatted CR/2108/0001:
+    // as a path segment the encoded slashes (%2F) are rejected by Spring Security's strict
+    // firewall with a 400 before the request reaches this resource. The older
+    // /by-voucher/{voucherNo} path is kept for receipt numbers, which carry no slashes.
+    @GET
+    @Path("/by-voucher")
+    public Response findByVoucherParam(@QueryParam("voucherNo") final String voucherNo,
+            @QueryParam("clientId") final Long clientIdHint, @QueryParam("glAccountNo") final String glAccountNoOverride) {
+        if (voucherNo == null || voucherNo.isBlank()) {
+            throw new PlatformDataIntegrityException("error.msg.shareadvance.voucher.required",
+                    "A voucher or receipt number is required.");
+        }
+        return findByVoucher(voucherNo, clientIdHint, glAccountNoOverride);
+    }
+
+    @GET
+    @Path("/by-voucher/{voucherNo}")
+    public Response findByVoucher(@PathParam("voucherNo") final String voucherNo, @QueryParam("clientId") final Long clientIdHint,
+            @QueryParam("glAccountNo") final String glAccountNoOverride) {
+        this.context.authenticatedUser();
+
+        // Matched on voucher_no or receipt_no so a pre-voucher receipt number still resolves.
+        final List<Map<String, Object>> rows = jdbcTemplate
+                .queryForList("SELECT c.id, c.receipt_no, c.voucher_no, c.client_id, cl.display_name AS client_name,"
+                        + " c.collection_date, c.amount, c.currency_code, c.status, c.note," + " c.applied_share_account_id "
+                        + " FROM m_share_advance_collection c JOIN m_client cl ON cl.id = c.client_id "
+                        + " WHERE c.voucher_no = ? OR c.receipt_no = ? ORDER BY c.id DESC", voucherNo, voucherNo);
+
+        if (rows.isEmpty()) {
+            // Cash is normally taken through the cashier's Transaction Entry deposit into the GL
+            // account the counter deposited it to, which lives in m_cashier_deposit_request. Adopt
+            // that approved deposit as a collection so the member's voucher resolves here. Which GL
+            // account to look in is never guessed from product configuration — the counter selects it
+            // by hand every time, since a product mapping can silently go missing or point at the
+            // wrong account and a plain voucher lookup should never depend on that being right.
+            final Map<String, Object> adopted = adoptApprovedDeposit(voucherNo, clientIdHint, glAccountNoOverride);
+            if (adopted != null) {
+                return Response.ok(gson.toJson(adopted)).build();
+            }
+            throw new PlatformDataIntegrityException("error.msg.shareadvance.voucher.notfound", "No share collection found for voucher "
+                    + voucherNo + " in GL account " + glAccountNoOverride + ". Check the voucher number, the GL account, and confirm the "
+                    + "deposit has been approved by a manager.");
+        }
+
+        final Map<String, Object> row = rows.get(0);
+        if (!"UNAPPLIED".equals(row.get("status"))) {
+            throw new PlatformDataIntegrityException("error.msg.shareadvance.voucher.already.applied",
+                    "Voucher " + voucherNo + " is already " + row.get("status") + " and cannot be applied again.");
+        }
+        return Response.ok(gson.toJson(row)).build();
+    }
+
+    // ══════════════════════════════════════════════════════════════════════
+    // GET — GL accounts selectable for a by-voucher lookup
+    // ══════════════════════════════════════════════════════════════════════
+    /**
+     * Every active, postable GL account, for the GL account picker on the Apply Collection screen.
+     *
+     * Deliberately not filtered to whatever a share product's own Share Suspense mapping happens to
+     * point at today — that mapping is exactly what this lookup no longer trusts, since it can go
+     * missing or wrong without anyone noticing until a voucher search fails at the counter. The person
+     * applying a receipt picks the account the deposit actually went to, every time.
+     */
+    @GET
+    @Path("/glaccounts")
+    public Response glAccounts() {
+        this.context.authenticatedUser();
+        final List<Map<String, Object>> rows = jdbcTemplate.queryForList(
+                "SELECT id, gl_code, name FROM acc_gl_account WHERE disabled = false AND account_usage = 1 ORDER BY gl_code");
+        final Map<String, Object> out = new LinkedHashMap<>();
+        out.put("glAccounts", rows);
+        return Response.ok(gson.toJson(out)).build();
+    }
+
+    // ══════════════════════════════════════════════════════════════════════
+    // GET — What a share account needs before a collection can be applied
+    // ══════════════════════════════════════════════════════════════════════
+    /**
+     * Share value plus any outstanding entry fee for one share account -- shown up front on the Apply
+     * Collection screen so the person at the counter knows the full amount to collect (and that it may
+     * come in as more than one receipt, e.g. one for the share value and a separate one for the fee)
+     * before a search ever comes up short, rather than learning it only from an error after the fact.
+     */
+    @GET
+    @Path("/requirement")
+    public Response requirement(@QueryParam("shareAccountId") final Long shareAccountId) {
+        this.context.authenticatedUser();
+        if (shareAccountId == null) {
+            throw new PlatformDataIntegrityException("error.msg.shareadvance.accountid.required", "shareAccountId is required.");
+        }
+        final Map<String, Object> acct = loadAccount(shareAccountId);
+        final BigDecimal shareAmount = shareValueOf(shareAccountId);
+        final BigDecimal chargeAmount = outstandingChargeOf(shareAccountId);
+        final Map<String, Object> out = new LinkedHashMap<>();
+        out.put("accountNo", acct.get("account_no"));
+        out.put("shareAmount", shareAmount);
+        out.put("chargeAmount", chargeAmount);
+        out.put("required", shareAmount.add(chargeAmount));
+        return Response.ok(gson.toJson(out)).build();
+    }
+
+    // ══════════════════════════════════════════════════════════════════════
+    // POST — Apply a receipt to an activated share account
+    // ══════════════════════════════════════════════════════════════════════
+    @POST
+    @Path("/{collectionId}/apply")
+    @Transactional
+    public Response apply(@PathParam("collectionId") final Long collectionId, final String body) {
+
+        final AppUser currentUser = this.context.authenticatedUser();
+        currentUser.validateHasPermissionTo("CREATE_JOURNALENTRY");
+
+        final JsonObject json = parseBody(body);
+        final Long shareAccountId = getLong(json, "shareAccountId");
+        if (shareAccountId == null) {
+            throw new PlatformDataIntegrityException("error.msg.shareadvance.accountid.required", "shareAccountId is required.");
+        }
+
+        // A member who pays in instalments has more than one receipt against the same application:
+        // ₹4,500 today, the ₹500 balance tomorrow. Neither settles the account on its own, so they
+        // are applied together as one settlement. The path receipt leads; any others come in the
+        // body. These are the SHARE-side receipts only -- money that actually sat in Sundry and
+        // genuinely needs to move out of it into Share Capital.
+        final List<Long> collectionIds = new java.util.ArrayList<>();
+        collectionIds.add(collectionId);
+        for (final Long additionalId : getLongList(json, "additionalCollectionIds")) {
+            if (!collectionIds.contains(additionalId)) {
+                collectionIds.add(additionalId);
+            }
+        }
+
+        // A separately-verified entry-fee receipt, when the member's fee was collected as its own
+        // receipt into whatever GL account the cashier actually deposited it to -- NOT into Sundry.
+        // This id proves the fee was paid; it never contributes to the Sundry leg below, and no GL
+        // entry moves its money, because it was never sitting in Sundry to begin with. Omit it (leave
+        // null) when the fee was paid as part of the same Sundry receipt(s) as the share value --
+        // that legacy, single-receipt case still needs the fee amount swept out of Sundry below.
+        final Long chargeCollectionId = getLong(json, "chargeCollectionId");
+
+        final List<Map<String, Object>> collections = new java.util.ArrayList<>();
+        for (final Long id : collectionIds) {
+            final Map<String, Object> row = loadCollection(id);
+            if (!"UNAPPLIED".equals(row.get("status"))) {
+                throw new PlatformDataIntegrityException("error.msg.shareadvance.already.applied",
+                        "Receipt " + row.get("receipt_no") + " is already " + row.get("status") + ".");
+            }
+            collections.add(row);
+        }
+
+        Map<String, Object> chargeColl = null;
+        if (chargeCollectionId != null) {
+            chargeColl = loadCollection(chargeCollectionId);
+            if (!"UNAPPLIED".equals(chargeColl.get("status"))) {
+                throw new PlatformDataIntegrityException("error.msg.shareadvance.already.applied",
+                        "Entry fee receipt " + chargeColl.get("receipt_no") + " is already " + chargeColl.get("status") + ".");
+            }
+        }
+
+        final Map<String, Object> coll = collections.get(0);
+
+        final Map<String, Object> acct = loadAccount(shareAccountId);
+
+        // Every receipt belongs to the member: applying one to someone else's account would move
+        // one member's money into another's share capital. Checked per receipt, since a settlement
+        // can now carry several.
+        final Long acctClientId = toLong(acct.get("client_id"));
+        for (final Map<String, Object> row : collections) {
+            if (!toLong(row.get("client_id")).equals(acctClientId)) {
+                throw new PlatformDataIntegrityException("error.msg.shareadvance.client.mismatch", "Receipt " + row.get("receipt_no")
+                        + " belongs to a different member than share account " + acct.get("account_no") + ".");
+            }
+        }
+        if (chargeColl != null && !toLong(chargeColl.get("client_id")).equals(acctClientId)) {
+            throw new PlatformDataIntegrityException("error.msg.shareadvance.client.mismatch", "Entry fee receipt "
+                    + chargeColl.get("receipt_no") + " belongs to a different member than share account " + acct.get("account_no") + ".");
+        }
+
+        final int statusEnum = toInt(acct.get("status_enum"));
+        if (statusEnum != STATUS_ACTIVE) {
+            throw new PlatformDataIntegrityException("error.msg.shareadvance.account.not.active",
+                    "Share account " + acct.get("account_no") + " must be Active before a collection can be applied.");
+        }
+        if (Boolean.TRUE.equals(acct.get("collection_applied"))) {
+            throw new PlatformDataIntegrityException("error.msg.shareadvance.account.already.settled",
+                    "Share account " + acct.get("account_no") + " has already been settled.");
+        }
+
+        // Share value the account was opened for, and any entry fee attached to it.
+        final BigDecimal shareAmount = shareValueOf(shareAccountId);
+        final BigDecimal chargeAmount = outstandingChargeOf(shareAccountId);
+
+        // When the fee is being verified as its own receipt, the Sundry-side receipts only need to
+        // cover the share value -- the fee is proved paid separately below, and its money is never
+        // expected to be part of what came out of Sundry. Without a separate fee receipt, the fee is
+        // assumed bundled into the same Sundry receipt(s) as the share value, exactly as before.
+        final BigDecimal requiredForShareReceipts = chargeColl != null ? shareAmount : shareAmount.add(chargeAmount);
+
+        BigDecimal receiptAmount = BigDecimal.ZERO;
+        final StringBuilder receiptNos = new StringBuilder();
+        for (final Map<String, Object> row : collections) {
+            receiptAmount = receiptAmount.add((BigDecimal) row.get("amount"));
+            if (receiptNos.length() > 0) {
+                receiptNos.append(" + ");
+            }
+            receiptNos.append(row.get("receipt_no"));
+        }
+
+        // Short is blocked: share capital cannot be part-issued — the member either bought those
+        // shares or did not — so settling for less would leave the account short by an amount owed
+        // by nobody. The clerk collects the balance on another receipt and applies both together.
+        if (receiptAmount.compareTo(requiredForShareReceipts) < 0) {
+            final BigDecimal shortfall = requiredForShareReceipts.subtract(receiptAmount);
+            throw new PlatformDataIntegrityException("error.msg.shareadvance.amount.short",
+                    "Receipt " + receiptNos + " totals " + receiptAmount + " but share account " + acct.get("account_no") + " requires "
+                            + requiredForShareReceipts + ". Collect the remaining " + shortfall
+                            + " from the member, then apply both receipts together.");
+        }
+
+        // The fee receipt, when given, must cover the fee on its own -- checked separately from the
+        // share-side shortfall above, since the two are no longer one combined pot.
+        if (chargeColl != null && chargeAmount.compareTo(BigDecimal.ZERO) > 0) {
+            final BigDecimal chargeReceiptAmount = (BigDecimal) chargeColl.get("amount");
+            if (chargeReceiptAmount.compareTo(chargeAmount) < 0) {
+                final BigDecimal shortfall = chargeAmount.subtract(chargeReceiptAmount);
+                throw new PlatformDataIntegrityException("error.msg.shareadvance.charge.amount.short",
+                        "Entry fee receipt " + chargeColl.get("receipt_no") + " totals " + chargeReceiptAmount + " but share account "
+                                + acct.get("account_no") + " requires " + chargeAmount + " for the entry fee. Collect the remaining "
+                                + shortfall + " from the member.");
+            }
+        }
+
+        // Over-payment is allowed through rather than turning a member away over a rounded-up note.
+        // The difference is credited to their linked savings account below. Only the share-side
+        // excess is handled here -- an over-payment on a separately-verified fee receipt would need
+        // its own GL leg to fund the savings credit, which this flow does not post (that receipt's
+        // money is left exactly where the cashier already put it), so it is left uncollected rather
+        // than silently unbalancing the ledger.
+        final BigDecimal excessAmount = receiptAmount.subtract(requiredForShareReceipts);
+        final Long savingsAccountId = toLong(acct.get("savings_account_id"));
+        if (excessAmount.compareTo(BigDecimal.ZERO) > 0 && savingsAccountId == null) {
+            throw new PlatformDataIntegrityException("error.msg.shareadvance.excess.no.savings",
+                    "Receipt " + receiptNos + " totals " + receiptAmount + " but share account " + acct.get("account_no")
+                            + " requires only " + requiredForShareReceipts + ". The extra " + excessAmount
+                            + " must be credited to the member's savings account, but none is linked to this share account. Link one, or "
+                            + "collect the exact amount.");
+        }
+
+        final Long officeId = toLong(acct.get("office_id"));
+        final Long productId = toLong(acct.get("product_id"));
+        final String currencyCode = (String) acct.get("currency_code");
+
+        final Long glSuspense = requireGl(productId, FA_SHARES_SUSPENSE, "Share Sundry (Suspense)");
+        final Long glEquity = requireGl(productId, FA_SHARES_EQUITY, "Share Capital (Equity)");
+
+        final long userId = currentUser.getId();
+        final LocalDateTime now = LocalDateTime.now(DateUtils.getDateTimeZoneOfTenant());
+        final LocalDate entryDate = parseDate(getString(json, "transactionDate"));
+        final String txnId = "SHAPP-" + System.nanoTime();
+        final String accountNo = (String) acct.get("account_no");
+
+        // Dr Sundry for the share-side receipts, including any over-payment on them — the liability
+        // those receipts created is cleared in full. A verified fee receipt is deliberately excluded:
+        // it was never in Sundry, so nothing here should debit Sundry for it.
+        insertEntry(officeId, glSuspense, DEBIT, receiptAmount, txnId, entryDate, shareAccountId, userId, now, currencyCode,
+                "Share application settled from Sundry | Receipt " + receiptNos + " | " + accountNo);
+
+        // Cr Share Capital for the share value.
+        insertEntry(officeId, glEquity, CREDIT, shareAmount, txnId, entryDate, shareAccountId, userId, now, currencyCode,
+                "Share capital issued for " + accountNo);
+
+        // Cr Income from Fees for the entry fee, but only when it was NOT verified as its own receipt
+        // above -- that money already sits in whichever GL the cashier deposited it to (often the fee
+        // income account itself), so moving it again here would double it. When it was bundled into
+        // the same Sundry receipt(s) as the share value (chargeColl == null), it genuinely still needs
+        // to move, exactly as before.
+        if (chargeAmount.compareTo(BigDecimal.ZERO) > 0) {
+            if (chargeColl == null) {
+                // Resolved from the share product's "Income from Fees" mapping, which points at the
+                // Share Entry Fee Income GL — changing that mapping redirects the fee without a code change.
+                final Long glIncome = requireGl(productId, FA_INCOME_FROM_FEES, "Share Entry Fee Income");
+                insertEntry(officeId, glIncome, CREDIT, chargeAmount, txnId, entryDate, shareAccountId, userId, now, currencyCode,
+                        "Share entry fee for " + accountNo);
+            }
+            jdbcTemplate.update("UPDATE m_share_account_charge SET is_paid_derived = true, amount_paid_derived = amount, "
+                    + " amount_outstanding_derived = 0 WHERE account_id = ? AND is_active = true", shareAccountId);
+        }
+
+        // The over-payment goes back to the member as a savings deposit rather than a bare journal
+        // entry, so it lands in their passbook and running balance the way any counter deposit
+        // would. Posted through Fineract's own deposit command, which writes its own Cr Savings
+        // Control leg — the Dr side is the Sundry debit above, which covered the whole receipt.
+        Long excessSavingsTransactionId = null;
+        if (excessAmount.compareTo(BigDecimal.ZERO) > 0) {
+            excessSavingsTransactionId = executeSavingsDeposit(savingsAccountId, excessAmount, entryDate,
+                    "Excess on share application receipt " + receiptNos + " for share account " + accountNo);
+        }
+
+        // Stamp the originating cashier deposits so the same vouchers cannot be applied twice.
+        // Matched on voucher_no alone -- voucher numbers are unique across the whole cashier deposit
+        // table regardless of which GL account they were posted to, so no GL account lookup is needed
+        // here either. Covers the fee receipt's own deposit too, when one was verified.
+        for (final Map<String, Object> row : collections) {
+            if (row.get("voucher_no") != null) {
+                jdbcTemplate.update(
+                        "UPDATE m_cashier_deposit_request SET share_account_id = ?, share_applied_on = ?, "
+                                + " share_applied_txn_id = ? WHERE voucher_no = ? AND share_account_id IS NULL",
+                        shareAccountId, java.sql.Date.valueOf(entryDate), txnId, row.get("voucher_no"));
+            }
+        }
+        if (chargeColl != null && chargeColl.get("voucher_no") != null) {
+            jdbcTemplate.update(
+                    "UPDATE m_cashier_deposit_request SET share_account_id = ?, share_applied_on = ?, "
+                            + " share_applied_txn_id = ? WHERE voucher_no = ? AND share_account_id IS NULL",
+                    shareAccountId, java.sql.Date.valueOf(entryDate), txnId, chargeColl.get("voucher_no"));
+        }
+
+        // Every receipt in this settlement is marked applied, not just the one in the path — they
+        // were all consumed by it, and an unmarked one would still show as money awaiting use. The fee
+        // receipt is marked applied too, even though it posted no GL entry of its own.
+        for (final Long id : collectionIds) {
+            jdbcTemplate.update(
+                    "UPDATE m_share_advance_collection SET status = 'APPLIED', applied_share_account_id = ?, "
+                            + " applied_on_date = ?, applied_gl_transaction_id = ? WHERE id = ?",
+                    shareAccountId, java.sql.Date.valueOf(entryDate), txnId, id);
+        }
+        if (chargeCollectionId != null) {
+            jdbcTemplate.update(
+                    "UPDATE m_share_advance_collection SET status = 'APPLIED', applied_share_account_id = ?, "
+                            + " applied_on_date = ?, applied_gl_transaction_id = ? WHERE id = ?",
+                    shareAccountId, java.sql.Date.valueOf(entryDate), txnId, chargeCollectionId);
+        }
+
+        // Reveals the purchase transaction in the passbook and transactions views.
+        jdbcTemplate.update("UPDATE m_share_account SET collection_applied = true WHERE id = ?", shareAccountId);
+
+        final Map<String, Object> out = new LinkedHashMap<>();
+        out.put("collectionId", collectionId);
+        out.put("collectionIds", collectionIds);
+        out.put("receiptNo", receiptNos.toString());
+        out.put("shareAccountId", shareAccountId);
+        out.put("accountNo", accountNo);
+        out.put("shareAmount", shareAmount);
+        out.put("chargeAmount", chargeAmount);
+        out.put("chargeReceiptVerifiedSeparately", chargeColl != null);
+        out.put("totalApplied", requiredForShareReceipts);
+        out.put("totalCollected", receiptAmount);
+        out.put("glTransactionId", txnId);
+        out.put("status", "APPLIED");
+        // Told at the counter, while the member is still there, rather than left to be noticed on
+        // a statement later.
+        out.put("excessAmount", excessAmount);
+        if (excessSavingsTransactionId != null) {
+            out.put("excessSavingsTransactionId", excessSavingsTransactionId);
+            out.put("excessMessage", "The member paid " + excessAmount + " more than this application required. It has been credited to "
+                    + "their savings account.");
+        }
+        return Response.ok(gson.toJson(out)).build();
+    }
+
+    // ══════════════════════════════════════════════════════════════════════
+    // Helpers
+    // ══════════════════════════════════════════════════════════════════════
+
+    /**
+     * Adopts an approved cashier deposit into the Share Sundry GL as a share advance collection.
+     *
+     * The cashier's Transaction Entry deposit already posted Dr Cash / Cr Share Sundry and was approved by a manager,
+     * so the money is genuinely in Sundry — it simply has no collection row yet. This creates that row on first lookup
+     * so the voucher resolves and can be applied.
+     *
+     * A deposit made straight to the Sundry GL carries no member, so the member is taken from the share account the
+     * clerk is settling ({@code clientIdHint}). The amount still has to match the account exactly at apply time, which
+     * is what keeps the money tied to the right member.
+     *
+     * @param glAccountNoOverride
+     *            required -- the GL account number the deposit was posted to, selected by the counter
+     *            rather than resolved from any product's accounting configuration, so a broken or
+     *            missing product mapping can never make a genuine voucher unreachable.
+     * @return the newly created collection row, or null when no approved deposit matches.
+     */
+    private Map<String, Object> adoptApprovedDeposit(final String voucherNo, final Long clientIdHint, final String glAccountNoOverride) {
+        if (glAccountNoOverride == null || glAccountNoOverride.isBlank()) {
+            throw new PlatformDataIntegrityException("error.msg.shareadvance.gl.account.required",
+                    "Select the GL account this voucher was deposited to, then search again.");
+        }
+        final String shareSundryAccountNo = glAccountNoOverride.trim();
+        final List<Map<String, Object>> deposits = jdbcTemplate
+                .queryForList(
+                        "SELECT d.id, d.voucher_no, d.client_id, d.amount, d.status, d.txn_date, d.txn_id,"
+                                + " d.office_id, d.currency_code, d.cashier_id, d.cashier_name, d.share_account_id"
+                                + " FROM m_cashier_deposit_request d"
+                                + " WHERE d.voucher_no = ? AND d.account_no = ? AND d.status = 'APPROVED'" + " ORDER BY d.id DESC",
+                        voucherNo, shareSundryAccountNo);
+
+        if (deposits.isEmpty()) {
+            return null;
+        }
+        final Map<String, Object> dep = deposits.get(0);
+
+        if (toLong(dep.get("share_account_id")) != null) {
+            throw new PlatformDataIntegrityException("error.msg.shareadvance.voucher.already.applied",
+                    "Voucher " + voucherNo + " has already been applied to a share account.");
+        }
+
+        // Prefer the member recorded on the deposit; fall back to the account being settled.
+        final Long clientId = dep.get("client_id") != null ? toLong(dep.get("client_id")) : clientIdHint;
+        if (clientId == null) {
+            throw new PlatformDataIntegrityException("error.msg.shareadvance.voucher.no.client",
+                    "Voucher " + voucherNo + " was deposited straight to the Share Sundry GL without a member,"
+                            + " so it cannot be matched. Re-enter the deposit against the member.");
+        }
+
+        final Long officeId = dep.get("office_id") != null ? toLong(dep.get("office_id")) : loadClientOfficeId(clientId);
+        final String currency = dep.get("currency_code") != null ? (String) dep.get("currency_code") : "INR";
+        final LocalDate collectionDate = dep.get("txn_date") instanceof java.sql.Date ? ((java.sql.Date) dep.get("txn_date")).toLocalDate()
+                : LocalDate.now(DateUtils.getDateTimeZoneOfTenant());
+
+        final String receiptNo = nextReceiptNo();
+        jdbcTemplate.update(
+                "INSERT INTO m_share_advance_collection "
+                        + "(receipt_no, voucher_no, client_id, office_id, collection_date, amount, currency_code, status, "
+                        + " gl_transaction_id, collected_by_user, collected_by_name, note) " + "VALUES (?,?,?,?,?,?,?,'UNAPPLIED',?,?,?,?)",
+                receiptNo, voucherNo, clientId, officeId, java.sql.Date.valueOf(collectionDate), dep.get("amount"), currency,
+                dep.get("txn_id"), toLong(dep.get("cashier_id")), dep.get("cashier_name"),
+                "Adopted from cashier deposit voucher " + voucherNo);
+
+        return jdbcTemplate.queryForMap(
+                "SELECT c.id, c.receipt_no, c.voucher_no, c.client_id, cl.display_name AS client_name,"
+                        + " c.collection_date, c.amount, c.currency_code, c.status, c.note, c.applied_share_account_id"
+                        + " FROM m_share_advance_collection c JOIN m_client cl ON cl.id = c.client_id" + " WHERE c.receipt_no = ?",
+                receiptNo);
+    }
+
+    private Long loadClientOfficeId(final Long clientId) {
+        return jdbcTemplate.queryForObject("SELECT office_id FROM m_client WHERE id = ?", Long.class, clientId);
+    }
+
+    /** Share value the account was opened for: the pending/approved purchase transaction. */
+    private BigDecimal shareValueOf(final Long shareAccountId) {
+        final BigDecimal total = jdbcTemplate
+                .queryForObject("SELECT COALESCE(SUM(total_shares * unit_price), 0) FROM m_share_account_transactions "
+                        + " WHERE account_id = ? AND is_active = true AND type_enum = 500", BigDecimal.class, shareAccountId);
+        return total == null ? BigDecimal.ZERO : total;
+    }
+
+    /** Entry fee still outstanding on the account, zero when no charge was attached. */
+    private BigDecimal outstandingChargeOf(final Long shareAccountId) {
+        // Driven by the money still owed rather than the is_paid_derived flag alone: accounts
+        // created before the flat-charge fix carry the flag set to true while the full amount is
+        // still outstanding, and those charges must still be settled by the collection.
+        final BigDecimal total = jdbcTemplate.queryForObject(
+                "SELECT COALESCE(SUM(GREATEST(COALESCE(amount_outstanding_derived, 0), 0)), 0) " + " FROM m_share_account_charge "
+                        + " WHERE account_id = ? AND is_active = true " + "   AND COALESCE(amount_outstanding_derived, 0) > 0",
+                BigDecimal.class, shareAccountId);
+        return total == null ? BigDecimal.ZERO : total;
+    }
+
+    private Map<String, Object> loadCollection(final Long id) {
+        try {
+            return jdbcTemplate.queryForMap("SELECT * FROM m_share_advance_collection WHERE id = ?", id);
+        } catch (EmptyResultDataAccessException e) {
+            throw new PlatformDataIntegrityException("error.msg.shareadvance.not.found",
+                    "Share advance collection " + id + " does not exist.");
+        }
+    }
+
+    private Map<String, Object> loadClient(final Long clientId) {
+        try {
+            return jdbcTemplate.queryForMap("SELECT id, office_id, display_name FROM m_client WHERE id = ?", clientId);
+        } catch (EmptyResultDataAccessException e) {
+            throw new PlatformDataIntegrityException("error.msg.shareadvance.client.not.found", "Client " + clientId + " does not exist.");
+        }
+    }
+
+    private Map<String, Object> loadAccount(final Long shareAccountId) {
+        try {
+            return jdbcTemplate.queryForMap("SELECT sa.id, sa.account_no, sa.client_id, sa.product_id, sa.status_enum, "
+                    + " sa.currency_code, sa.collection_applied, sa.savings_account_id, c.office_id "
+                    + " FROM m_share_account sa JOIN m_client c ON c.id = sa.client_id WHERE sa.id = ?", shareAccountId);
+        } catch (EmptyResultDataAccessException e) {
+            throw new PlatformDataIntegrityException("error.msg.shareadvance.account.not.found",
+                    "Share account " + shareAccountId + " does not exist.");
+        }
+    }
+
+    /**
+     * Uses the caller's product when given, else the single mapped share product.
+     *
+     * The mapping table is joined to m_share_product because acc_product_mapping can hold rows for product ids that are
+     * not share products (stale rows left by deleted products), and counting those would make auto-detection fail even
+     * when only one real share product is mapped.
+     */
+    private Long resolveProductId(final Long requested) {
+        if (requested != null) {
+            return requested;
+        }
+        final List<Long> ids = jdbcTemplate.queryForList("SELECT DISTINCT m.product_id FROM acc_product_mapping m "
+                + " JOIN m_share_product p ON p.id = m.product_id WHERE m.product_type = ?", Long.class, PRODUCT_TYPE_SHARES);
+        if (ids.isEmpty()) {
+            throw new PlatformDataIntegrityException("error.msg.shareadvance.product.not.mapped",
+                    "No share product has GL mappings configured.");
+        }
+        if (ids.size() > 1) {
+            throw new PlatformDataIntegrityException("error.msg.shareadvance.productid.required",
+                    "productId is required: " + ids.size() + " share products have GL mappings.");
+        }
+        return ids.get(0);
+    }
+
+    private String resolveCurrency(final Long productId) {
+        try {
+            final String code = jdbcTemplate.queryForObject("SELECT currency_code FROM m_share_product WHERE id = ?", String.class,
+                    productId);
+            return code == null ? "INR" : code;
+        } catch (EmptyResultDataAccessException e) {
+            return "INR";
+        }
+    }
+
+    private Long requireGl(final Long productId, final int financialAccountType, final String label) {
+        final Long glId = resolveGl(productId, financialAccountType);
+        if (glId == null) {
+            throw new PlatformDataIntegrityException("error.msg.shareadvance.gl.not.mapped",
+                    label + " GL is not mapped for share product " + productId + ".");
+        }
+        return glId;
+    }
+
+    private Long resolveGl(final Long productId, final int financialAccountType) {
+        try {
+            return jdbcTemplate.queryForObject(
+                    "SELECT gl_account_id FROM acc_product_mapping "
+                            + " WHERE product_id = ? AND product_type = ? AND financial_account_type = ? AND charge_id IS NULL",
+                    Long.class, productId, PRODUCT_TYPE_SHARES, financialAccountType);
+        } catch (IncorrectResultSizeDataAccessException e) {
+            return null;
+        }
+    }
+
+    private String nextReceiptNo() {
+        final Long seq = jdbcTemplate.queryForObject("SELECT COALESCE(MAX(id), 0) + 1 FROM m_share_advance_collection", Long.class);
+        return String.format("SHADV%06d", seq == null ? 1 : seq);
+    }
+
+    private void insertEntry(final Long officeId, final Long glAccountId, final int typeEnum, final BigDecimal amount, final String txnId,
+            final LocalDate entryDate, final Long shareAccountId, final long userId, final LocalDateTime now, final String currencyCode,
+            final String description) {
+        jdbcTemplate.update(
+                "INSERT INTO acc_gl_journal_entry " + "(account_id, office_id, currency_code, transaction_id, reversed, manual_entry, "
+                        + " entry_date, type_enum, amount, description, entity_id, "
+                        + " created_by, last_modified_by, created_date, lastmodified_date, "
+                        + " is_running_balance_calculated, office_running_balance, "
+                        + " organization_running_balance, submitted_on_date, transaction_date, " + " created_on_utc, last_modified_on_utc) "
+                        + "VALUES (?,?,?,?,false,true,?,?,?,?,?,?,?,?,?,false,0,0,?,?,?,?)",
+                glAccountId, officeId, currencyCode, txnId, java.sql.Date.valueOf(entryDate), typeEnum, amount, description, shareAccountId,
+                userId, userId, now, now, java.sql.Date.valueOf(entryDate), java.sql.Date.valueOf(entryDate), toUtc(now), toUtc(now));
+    }
+
+    /**
+     * A tenant-local timestamp converted to the real UTC instant, for the {@code *_on_utc} columns.
+     *
+     * {@code atOffset(ZoneOffset.UTC)} would only relabel it — stamping 18:34 IST as "18:34 UTC", which reads back as
+     * 00:04 the next day and made an evening posting appear as just after midnight. The instant has to be resolved in
+     * the tenant's own zone first, which is the zone {@code now} was taken in.
+     */
+    private java.time.OffsetDateTime toUtc(final LocalDateTime tenantLocalTime) {
+        return tenantLocalTime.atZone(DateUtils.getDateTimeZoneOfTenant()).toOffsetDateTime()
+                .withOffsetSameInstant(ZoneOffset.UTC);
+    }
+
+    private JsonObject parseBody(final String body) {
+        if (body == null || body.isBlank()) {
+            throw new PlatformDataIntegrityException("error.msg.shareadvance.request.empty", "Request body is required.");
+        }
+        try {
+            return JsonParser.parseString(body).getAsJsonObject();
+        } catch (Exception e) {
+            throw new PlatformDataIntegrityException("error.msg.shareadvance.request.invalid", "Request body must be valid JSON.");
+        }
+    }
+
+    private LocalDate parseDate(final String raw) {
+        if (raw == null || raw.isBlank()) {
+            return LocalDate.now(DateUtils.getDateTimeZoneOfTenant());
+        }
+        try {
+            return LocalDate.parse(raw);
+        } catch (DateTimeParseException e) {
+            throw new PlatformDataIntegrityException("error.msg.shareadvance.date.invalid",
+                    "transactionDate must be in YYYY-MM-DD format. Received: " + raw);
+        }
+    }
+
+    private String sanitiseNote(final String raw) {
+        if (raw == null || raw.isBlank()) {
+            return null;
+        }
+        final String trimmed = raw.trim();
+        return trimmed.length() > 490 ? trimmed.substring(0, 490) : trimmed;
+    }
+
+    private String getString(final JsonObject json, final String field) {
+        return json.has(field) && !json.get(field).isJsonNull() ? json.get(field).getAsString() : null;
+    }
+
+    private Long getLong(final JsonObject json, final String field) {
+        return json.has(field) && !json.get(field).isJsonNull() ? json.get(field).getAsLong() : null;
+    }
+
+    private BigDecimal getBigDecimal(final JsonObject json, final String field) {
+        return json.has(field) && !json.get(field).isJsonNull() ? json.get(field).getAsBigDecimal() : null;
+    }
+
+    /** Further receipts making up one settlement. Empty when the caller sent a single receipt. */
+    private List<Long> getLongList(final JsonObject json, final String field) {
+        final List<Long> values = new java.util.ArrayList<>();
+        if (!json.has(field) || json.get(field).isJsonNull() || !json.get(field).isJsonArray()) {
+            return values;
+        }
+        for (final com.google.gson.JsonElement element : json.get(field).getAsJsonArray()) {
+            if (!element.isJsonNull()) {
+                values.add(element.getAsLong());
+            }
+        }
+        return values;
+    }
+
+    /**
+     * Credits an over-payment to the member's savings account.
+     *
+     * Routed through Fineract's own savings deposit command rather than a direct journal entry, so the money appears in
+     * the member's passbook, statement and running balance exactly as an over-the-counter deposit does. A bare GL entry
+     * would move the balance in the ledger while leaving the member's own account history silent about it.
+     */
+    private Long executeSavingsDeposit(final Long savingsAccountId, final BigDecimal amount, final LocalDate txnDate, final String note) {
+        final JsonObject payload = new JsonObject();
+        payload.addProperty("locale", "en");
+        payload.addProperty("dateFormat", "yyyy-MM-dd");
+        payload.addProperty("transactionDate", txnDate.toString());
+        payload.addProperty("transactionAmount", amount);
+        payload.addProperty("paymentTypeId", resolveExcessPaymentTypeId());
+        payload.addProperty("note", note);
+
+        final CommandWrapper cmd = new CommandWrapperBuilder().savingsAccountDeposit(savingsAccountId).withJson(payload.toString())
+                .build();
+        return this.commandsSourceWritePlatformService.logCommandSource(cmd).getResourceId();
+    }
+
+    /**
+     * The payment type this deposit is recorded under.
+     *
+     * Reuses the share settlement type seeded for the savings-debit route, since this is the same kind of movement in
+     * the opposite direction — an internal transfer between a share application and the member's savings, not cash
+     * over the counter. Falls back to any active type so an over-payment is never blocked by a missing seed row.
+     */
+    private Long resolveExcessPaymentTypeId() {
+        final List<Long> byName = jdbcTemplate.queryForList(
+                "SELECT id FROM m_payment_type WHERE value = 'Share Application Settlement' ORDER BY id LIMIT 1", Long.class);
+        if (!byName.isEmpty()) {
+            return byName.get(0);
+        }
+        final List<Long> any = jdbcTemplate.queryForList("SELECT id FROM m_payment_type ORDER BY id LIMIT 1", Long.class);
+        if (any.isEmpty()) {
+            throw new PlatformDataIntegrityException("error.msg.shareadvance.no.payment.type",
+                    "No payment type is configured, so the over-payment cannot be credited to the member's savings account.");
+        }
+        return any.get(0);
+    }
+
+    private Long toLong(final Object o) {
+        return o instanceof Number ? ((Number) o).longValue() : null;
+    }
+
+    private int toInt(final Object o) {
+        return o instanceof Number ? ((Number) o).intValue() : 0;
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/portfolio/cashtransfer/api/ShareCollectionApiResource.java

@@ -375,8 +375,20 @@ public class ShareCollectionApiResource {
                 userId, userId, now, now,
                 java.sql.Date.valueOf(entryDate),
                 java.sql.Date.valueOf(entryDate),
-                now.atOffset(ZoneOffset.UTC),
-                now.atOffset(ZoneOffset.UTC));
+                toUtc(now),
+                toUtc(now));
+    }
+
+    /**
+     * A tenant-local timestamp converted to the real UTC instant, for the {@code *_on_utc} columns.
+     *
+     * {@code atOffset(ZoneOffset.UTC)} would only relabel it — stamping 18:34 IST as "18:34 UTC", which reads back as
+     * 00:04 the next day and made an evening posting appear as just after midnight. The instant has to be resolved in
+     * the tenant's own zone first, which is the zone {@code now} was taken in.
+     */
+    private java.time.OffsetDateTime toUtc(final LocalDateTime tenantLocalTime) {
+        return tenantLocalTime.atZone(DateUtils.getDateTimeZoneOfTenant()).toOffsetDateTime()
+                .withOffsetSameInstant(ZoneOffset.UTC);
     }
 
     private Map<String, Object> glEntryMap(final String account, final String type,

fineract-provider/src/main/java/org/apache/fineract/portfolio/chequebook/service/ChequeBookIssuanceChargeService.java

@@ -35,6 +35,9 @@ import org.apache.fineract.infrastructure.core.data.CommandProcessingResult;
 import org.apache.fineract.infrastructure.core.domain.FineractRequestContextHolder;
 import org.apache.fineract.infrastructure.core.exception.GeneralPlatformDomainRuleException;
 import org.apache.fineract.infrastructure.core.service.DateUtils;
+import org.apache.fineract.infrastructure.security.service.PlatformSecurityContext;
+import org.apache.fineract.portfolio.voucher.service.VoucherLine;
+import org.apache.fineract.portfolio.voucher.service.VoucherService;
 import org.apache.fineract.organisation.monetary.domain.Money;
 import org.apache.fineract.organisation.office.domain.Office;
 import org.apache.fineract.portfolio.charge.domain.Charge;
@@ -89,6 +92,12 @@ public class ChequeBookIssuanceChargeService {
     private final FineractRequestContextHolder fineractRequestContextHolder;
     private final SavingsAccountTransactionSummaryWrapper savingsAccountTransactionSummaryWrapper;
     private final SavingsHelper savingsHelper;
+    private final PlatformSecurityContext context;
+    private final VoucherService voucherService;
+
+    /** A cheque book issuance charge, keyed by its m_cheque_book id. */
+    private static final String REF_CHEQUEBOOK_CHARGE = "CHEQUEBOOK_CHARGE";
+
 
     /** The configured charge, if the admin has set one up — absent means "no charge configured yet." */
     private FacilityChargeMapping resolveMapping() {
@@ -244,6 +253,7 @@ public class ChequeBookIssuanceChargeService {
 
         postChargeJournalEntry(office.getId(), charge.getCurrencyCode(), today, ownAccountGlId, incomeGlId, chargeAmount, chequeBookId,
                 accountId);
+        raiseChargeVoucher(accountType, accountId, ownAccountGlId, incomeGlId, chargeAmount, chequeBookId);
         log.info("Deducted cheque book issuance charge {} from {} account {} for book {}", chargeAmount, accountType, accountId,
                 chequeBookId);
     }
@@ -278,6 +288,47 @@ public class ChequeBookIssuanceChargeService {
         this.currentAccountRepository.saveAndFlush(account);
     }
 
+    /**
+     * Records a cheque book issuance charge in the voucher register.
+     *
+     * The account is debited and the charge's income account credited — the society's fee, taken
+     * from the customer. The debit names the customer and their account number even though it posts
+     * against the product's control GL, so the slip reads as the customer's own.
+     *
+     * A failure here does not fail the charge. The money is already taken and the ledger already
+     * posted; reversing that over a slip would undo a correct deduction for a paperwork reason. The
+     * problem is logged and the charge stands.
+     */
+    private void raiseChargeVoucher(final ChequeAccountType accountType, final Long accountId, final Long ownAccountGlId,
+            final Long incomeGlId, final BigDecimal chargeAmount, final Long chequeBookId) {
+        try {
+            final Map<String, Object> holder = accountHolderForVoucher(accountType, accountId);
+            final Map<String, Object> incomeGl = this.voucherService.glAccount(incomeGlId);
+            final String narration = "Cheque book issuance charge - book #" + chequeBookId;
+
+            this.voucherService.createVoucherWithLines(VoucherService.TYPE_WITHDRAWAL, REF_CHEQUEBOOK_CHARGE, chequeBookId,
+                    this.context.authenticatedUser(), VoucherService.PREFIX_DEBIT,
+                    List.of(VoucherLine
+                            .debitGl(ownAccountGlId, (String) holder.get("party"), (String) holder.get("account_no"), chargeAmount)
+                            .withDescription(narration),
+                            VoucherLine
+                                    .creditGl(incomeGlId, (String) incomeGl.get("name"), (String) incomeGl.get("gl_code"), chargeAmount)
+                                    .withDescription(narration)));
+        } catch (final RuntimeException e) {
+            log.error("Could not raise a voucher for cheque book {} issuance charge", chequeBookId, e);
+        }
+    }
+
+    /** The customer and account number a charge is taken from, for printing on a voucher. */
+    private Map<String, Object> accountHolderForVoucher(final ChequeAccountType accountType, final Long accountId) {
+        final String sql = accountType == ChequeAccountType.SAVINGS
+                ? "SELECT sa.account_no, c.display_name AS party FROM m_savings_account sa "
+                        + "LEFT JOIN m_client c ON c.id = sa.client_id WHERE sa.id = ?"
+                : "SELECT ca.account_no, c.display_name AS party FROM m_current_account ca "
+                        + "LEFT JOIN m_client c ON c.id = ca.client_id WHERE ca.id = ?";
+        return this.jdbcTemplate.queryForList(sql, accountId).stream().findFirst().orElse(Map.of());
+    }
+
     /** Same shape as {@code getSavingsControlGlId}/{@code getCurrentControlGlId} in ClerkDisbursementRequestApiResource. */
     private Long getSavingsControlGlId(final Long savingsAccountId) {
         final List<Map<String, Object>> rows = this.jdbcTemplate.queryForList("SELECT apm.gl_account_id FROM m_savings_account sa "
@@ -320,7 +371,10 @@ public class ChequeBookIssuanceChargeService {
 
         final CommandWrapper cmd = new CommandWrapperBuilder().createJournalEntry().withJson(payload.toString()).build();
         this.fineractRequestContextHolder.setAttribute(SynchronousCommandProcessingService.COMMAND_SOURCE_ID, null);
-        final CommandProcessingResult result = this.commandsSourceWritePlatformService.logCommandSource(cmd);
+        // The charge raises its own voucher, naming the account charged and the fee; the journal
+        // command must not raise a second one over the same money.
+        final CommandProcessingResult result = this.voucherService
+                .withOwnVoucher(() -> this.commandsSourceWritePlatformService.logCommandSource(cmd));
         if (result == null) {
             log.warn("GL journal entry for cheque book {} issuance charge did not return a result.", chequeBookId);
             return;

fineract-provider/src/main/java/org/apache/fineract/portfolio/clearing/api/ClearingGlConfigApiResource.java

@@ -0,0 +1,133 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.portfolio.clearing.api;
+
+import com.google.gson.Gson;
+import jakarta.ws.rs.Consumes;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.PUT;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.PathParam;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.core.MediaType;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import lombok.RequiredArgsConstructor;
+import org.apache.fineract.infrastructure.core.exception.PlatformDataIntegrityException;
+import org.apache.fineract.infrastructure.core.serialization.FromJsonHelper;
+import org.apache.fineract.infrastructure.security.service.PlatformSecurityContext;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Component;
+
+/**
+ * Admin screen backing API for {@code m_clearing_gl_config}: which GL account backs each clearing
+ * role (CTS inward/outward suspense, NACH suspense, RTGS settlement, ...). The rows themselves are
+ * fixed — created by earlier migrations — so, like Facility Charge Mappings, this only ever reads
+ * them and updates which GL account one points at.
+ */
+@Path("/v1/clearingglconfig")
+@Component
+@RequiredArgsConstructor
+@Produces({ MediaType.APPLICATION_JSON })
+public class ClearingGlConfigApiResource {
+
+    private final JdbcTemplate jdbcTemplate;
+    private final PlatformSecurityContext context;
+    private final FromJsonHelper fromJsonHelper;
+    private final Gson gson = new Gson();
+
+    @GET
+    public String retrieveAll() {
+        this.context.authenticatedUser().validateHasReadPermission("CLEARINGGLCONFIG");
+        final List<Map<String, Object>> rows = jdbcTemplate.queryForList("""
+                SELECT c.id, c.config_key, c.description, c.gl_account_id, a.name AS gl_account_name, a.gl_code
+                  FROM m_clearing_gl_config c LEFT JOIN acc_gl_account a ON a.id = c.gl_account_id
+                 ORDER BY c.config_key
+                """);
+        final List<Map<String, Object>> out = new ArrayList<>();
+        for (final Map<String, Object> row : rows) {
+            out.add(toResult(row));
+        }
+        return gson.toJson(out);
+    }
+
+    @GET
+    @Path("template")
+    public String template() {
+        this.context.authenticatedUser().validateHasReadPermission("CLEARINGGLCONFIG");
+        final List<Map<String, Object>> accounts = jdbcTemplate.queryForList("""
+                SELECT id, name, gl_code FROM acc_gl_account
+                 WHERE disabled = false AND manual_journal_entries_allowed = true
+                 ORDER BY name
+                """);
+        final List<Map<String, Object>> options = new ArrayList<>();
+        for (final Map<String, Object> a : accounts) {
+            final Map<String, Object> o = new LinkedHashMap<>();
+            o.put("id", a.get("id"));
+            o.put("name", a.get("name"));
+            o.put("glCode", a.get("gl_code"));
+            options.add(o);
+        }
+        return gson.toJson(Map.of("glAccountOptions", options));
+    }
+
+    @PUT
+    @Path("{configKey}")
+    @Consumes({ MediaType.APPLICATION_JSON })
+    public String update(@PathParam("configKey") final String configKey, final String body) {
+        this.context.authenticatedUser().validateHasPermissionTo("UPDATE_CLEARINGGLCONFIG");
+
+        final Integer exists = jdbcTemplate.queryForObject("SELECT COUNT(*) FROM m_clearing_gl_config WHERE config_key = ?",
+                Integer.class, configKey);
+        if (exists == null || exists == 0) {
+            throw new PlatformDataIntegrityException("error.msg.clearingglconfig.not.found",
+                    "Clearing GL config key '" + configKey + "' was not found.");
+        }
+
+        final var root = this.fromJsonHelper.parse(body);
+        final Long glAccountId = this.fromJsonHelper.extractLongNamed("glAccountId", root);
+
+        if (glAccountId != null) {
+            final Integer accountExists = jdbcTemplate.queryForObject("SELECT COUNT(*) FROM acc_gl_account WHERE id = ?",
+                    Integer.class, glAccountId);
+            if (accountExists == null || accountExists == 0) {
+                throw new PlatformDataIntegrityException("error.msg.clearingglconfig.gl.account.not.found",
+                        "GL account " + glAccountId + " was not found.");
+            }
+        }
+
+        jdbcTemplate.update("UPDATE m_clearing_gl_config SET gl_account_id = ? WHERE config_key = ?", glAccountId,
+                configKey);
+
+        return retrieveAll();
+    }
+
+    private Map<String, Object> toResult(final Map<String, Object> row) {
+        final Map<String, Object> out = new LinkedHashMap<>();
+        out.put("id", row.get("id"));
+        out.put("configKey", row.get("config_key"));
+        out.put("description", row.get("description"));
+        out.put("glAccountId", row.get("gl_account_id"));
+        out.put("glAccountName", row.get("gl_account_name"));
+        out.put("glCode", row.get("gl_code"));
+        return out;
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/portfolio/clearing/service/ClearingJournalService.java

@@ -24,6 +24,7 @@ import java.math.BigDecimal;
 import java.time.LocalDate;
 import java.time.format.DateTimeFormatter;
 import java.util.List;
+import java.util.Map;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.fineract.commands.domain.CommandWrapper;
@@ -32,6 +33,9 @@ import org.apache.fineract.commands.service.PortfolioCommandSourceWritePlatformS
 import org.apache.fineract.commands.service.SynchronousCommandProcessingService;
 import org.apache.fineract.infrastructure.core.data.CommandProcessingResult;
 import org.apache.fineract.infrastructure.core.domain.FineractRequestContextHolder;
+import org.apache.fineract.infrastructure.security.service.PlatformSecurityContext;
+import org.apache.fineract.portfolio.voucher.service.VoucherLine;
+import org.apache.fineract.portfolio.voucher.service.VoucherService;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.stereotype.Service;
 
@@ -49,6 +53,11 @@ public class ClearingJournalService {
     private final PortfolioCommandSourceWritePlatformService commandsSourceWritePlatformService;
     private final FineractRequestContextHolder fineractRequestContextHolder;
     private final JdbcTemplate jdbcTemplate;
+    private final PlatformSecurityContext context;
+    private final VoucherService voucherService;
+
+    /** A clearing posting — a CTS item, a NACH movement, a settlement — keyed by its GL transaction id. */
+    private static final String REF_CLEARING_POSTING = "CLEARING_POSTING";
 
     /**
      * Posts a single-debit / single-credit journal entry and returns the resulting GL transaction id (or null
@@ -57,6 +66,19 @@ public class ClearingJournalService {
      */
     public String postJournalEntry(final Long officeId, final String currencyCode, final LocalDate txnDate, final Long debitGlId,
             final Long creditGlId, final BigDecimal amount, final String comments, final Long linkAccountId) {
+        return postJournalEntry(officeId, currencyCode, txnDate, debitGlId, creditGlId, amount, comments, linkAccountId, null);
+    }
+
+    /**
+     * As above, naming the kind of account {@code linkAccountId} refers to — SAVINGS or CURRENT.
+     *
+     * Savings and current accounts number independently, so the same id exists in both tables and the id
+     * alone cannot say whose account it is. A caller that knows the type passes it and the voucher names
+     * the right customer; one that has no account at all — a settlement summary — passes neither.
+     */
+    public String postJournalEntry(final Long officeId, final String currencyCode, final LocalDate txnDate, final Long debitGlId,
+            final Long creditGlId, final BigDecimal amount, final String comments, final Long linkAccountId,
+            final String linkAccountType) {
         if (amount == null || amount.signum() <= 0 || debitGlId == null || creditGlId == null || officeId == null) {
             log.warn("Skipping clearing journal entry - missing office/GL/amount (office={}, dr={}, cr={}, amt={}).", officeId, debitGlId,
                     creditGlId, amount);
@@ -86,7 +108,10 @@ public class ClearingJournalService {
 
         final CommandWrapper cmd = new CommandWrapperBuilder().createJournalEntry().withJson(payload.toString()).build();
         this.fineractRequestContextHolder.setAttribute(SynchronousCommandProcessingService.COMMAND_SOURCE_ID, null);
-        final CommandProcessingResult result = this.commandsSourceWritePlatformService.logCommandSource(cmd);
+        // Clearing raises its own voucher below, naming the customer account the item belongs to;
+        // the journal command must not raise a second one over the same money.
+        final CommandProcessingResult result = this.voucherService
+                .withOwnVoucher(() -> this.commandsSourceWritePlatformService.logCommandSource(cmd));
         if (result == null) {
             log.warn("Clearing journal entry did not return a result ({}).", comments);
             return null;
@@ -95,9 +120,77 @@ public class ClearingJournalService {
         if (glTxnId != null && linkAccountId != null) {
             linkDebitEntryToAccount(glTxnId, linkAccountId);
         }
+        raiseClearingVoucher(glTxnId, debitGlId, creditGlId, amount, comments, linkAccountId, linkAccountType);
         return glTxnId;
     }
 
+    /**
+     * Records one clearing posting in the voucher register.
+     *
+     * Raised here rather than in each caller because CTS items, NACH movements and settlement
+     * summaries all post through this one path: a voucher per caller would be the same slip written
+     * three times, and one of them would drift.
+     *
+     * The caller's comment carries what the posting is — the item, the movement, the batch — so it
+     * becomes the narration on both sides. Where the caller named a customer account, the debit line
+     * carries that customer and account number; a settlement summary names no account and its lines
+     * stand on the GL names alone, which is what a summary is.
+     *
+     * A failure here does not fail the posting. The entry is already in the ledger, and clearing runs
+     * over batches where one unwritable slip must not take a whole settlement down with it. The
+     * problem is logged and the posting stands.
+     */
+    private void raiseClearingVoucher(final String glTxnId, final Long debitGlId, final Long creditGlId, final BigDecimal amount,
+            final String comments, final Long linkAccountId, final String linkAccountType) {
+        if (glTxnId == null) {
+            return;
+        }
+        try {
+            final Map<String, Object> debitGl = this.voucherService.glAccount(debitGlId);
+            final Map<String, Object> creditGl = this.voucherService.glAccount(creditGlId);
+            final Map<String, Object> holder = accountHolderForVoucher(linkAccountId, linkAccountType);
+
+            // The debit is the side a customer account is named against, matching the row this
+            // posting links to the account for reporting.
+            final String debitParty = holder.get("party") != null ? (String) holder.get("party") : (String) debitGl.get("name");
+            final String debitAccountNo = holder.get("account_no") != null ? (String) holder.get("account_no")
+                    : (String) debitGl.get("gl_code");
+
+            this.voucherService.createVoucherWithLines(VoucherService.TYPE_JOURNAL, REF_CLEARING_POSTING, null, glTxnId,
+                    this.context.authenticatedUser(), VoucherService.PREFIX_JOURNAL,
+                    List.of(VoucherLine.debitGl(debitGlId, debitParty, debitAccountNo, amount).withDescription(comments),
+                            VoucherLine.creditGl(creditGlId, (String) creditGl.get("name"), (String) creditGl.get("gl_code"), amount)
+                                    .withDescription(comments)));
+        } catch (final RuntimeException e) {
+            log.error("Could not raise a voucher for clearing journal transaction {}", glTxnId, e);
+        }
+    }
+
+    /**
+     * The customer and account number a clearing item belongs to, for printing on a voucher.
+     *
+     * The type decides which table to read: savings and current accounts number independently, so
+     * the same id exists in both and looking in the wrong one would put another customer's name on
+     * the slip. Empty when the caller named no account, as a settlement summary does, or named one
+     * without saying which kind — a wrong name is worse on a voucher than no name.
+     */
+    private Map<String, Object> accountHolderForVoucher(final Long accountId, final String accountType) {
+        if (accountId == null || accountType == null) {
+            return Map.of();
+        }
+        final String sql;
+        if ("SAVINGS".equalsIgnoreCase(accountType)) {
+            sql = "SELECT sa.account_no, c.display_name AS party FROM m_savings_account sa "
+                    + "LEFT JOIN m_client c ON c.id = sa.client_id WHERE sa.id = ?";
+        } else if ("CURRENT".equalsIgnoreCase(accountType)) {
+            sql = "SELECT ca.account_no, c.display_name AS party FROM m_current_account ca "
+                    + "LEFT JOIN m_client c ON c.id = ca.client_id WHERE ca.id = ?";
+        } else {
+            return Map.of();
+        }
+        return this.jdbcTemplate.queryForList(sql, accountId).stream().findFirst().orElse(Map.of());
+    }
+
     private void linkDebitEntryToAccount(final String glTxnId, final Long accountId) {
         final List<Long> rowIds = this.jdbcTemplate.queryForList(
                 "SELECT id FROM acc_gl_journal_entry WHERE transaction_id = ? AND type_enum = 2 ORDER BY id ASC LIMIT 1", Long.class,

fineract-provider/src/main/java/org/apache/fineract/portfolio/clerkdisbursement/api/ClerkDisbursementRequestApiResource.java

@@ -46,6 +46,7 @@ import java.time.OffsetDateTime;
 import java.time.format.DateTimeFormatter;
 import java.util.ArrayList;
 import java.util.LinkedHashSet;
+import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -65,6 +66,7 @@ import org.apache.fineract.infrastructure.core.domain.FineractRequestContextHold
 import org.apache.fineract.infrastructure.core.exception.IdempotentCommandProcessSucceedException;
 import org.apache.fineract.infrastructure.core.serialization.FromJsonHelper;
 import org.apache.fineract.infrastructure.security.service.PlatformSecurityContext;
+import org.apache.fineract.portfolio.voucher.service.VoucherLine;
 import org.apache.fineract.portfolio.voucher.service.VoucherService;
 import org.apache.fineract.useradministration.domain.AppUser;
 import org.springframework.jdbc.core.JdbcTemplate;
@@ -109,7 +111,7 @@ public class ClerkDisbursementRequestApiResource {
         final String creditEntriesJson = fromJsonHelper.extractStringNamed("creditEntries", root);
         String requestType = fromJsonHelper.extractStringNamed("requestType", root);
         if (requestType == null || requestType.isBlank()
-                || !java.util.Set.of("DISBURSEMENT", "COLLECTION", "BANK_TRANSFER").contains(requestType)) {
+                || !java.util.Set.of("DISBURSEMENT", "COLLECTION", "BANK_TRANSFER", "FUND_TRANSFER").contains(requestType)) {
             requestType = "DISBURSEMENT";
         }
 
@@ -185,9 +187,13 @@ public class ClerkDisbursementRequestApiResource {
             activityLog, Timestamp.from(Instant.now()), requestType
         );
 
+        // A collection pulls money into the GL, so it reads as a credit; a disbursement and a
+        // bank transfer both move money out of the source side, so they read as a debit.
+        final String voucherPrefix = "COLLECTION".equals(requestType)
+            ? VoucherService.PREFIX_CREDIT : VoucherService.PREFIX_DEBIT;
         final String voucherNo = voucherService.createVoucher(
             VoucherService.TYPE_DISBURSEMENT, VoucherService.REF_CLERK_DISBURSEMENT_REQUEST,
-            newId, txnAmount, currentUser);
+            newId, txnAmount, currentUser, voucherPrefix);
         jdbcTemplate.update(
             "UPDATE m_clerk_disbursement_request SET voucher_no = ? WHERE id = ?", voucherNo, newId);
 
@@ -544,7 +550,7 @@ public class ClerkDisbursementRequestApiResource {
                         return ps;
                     }, btLogKh);
                     final long btLogId = Objects.requireNonNull(btLogKh.getKey()).longValue();
-                    final String btVoucherNo = generateBtVoucherNo(btLogId);
+                    final String btVoucherNo = generateBtVoucherNo(btLogId, currentUser, finalBtTotal);
                     jdbcTemplate.update("UPDATE m_bank_transfer_log SET voucher_no = ? WHERE id = ?", btVoucherNo, btLogId);
                 }
 
@@ -715,6 +721,11 @@ public class ClerkDisbursementRequestApiResource {
             throw apiError(422, "Approval processing failed. All partial transactions have been reversed. Check the request for details.");
         }
 
+        // The sides of the slip, built from the entries as approved. Only reached once every
+        // posting above has succeeded, so the voucher describes a completed movement rather than
+        // one that was attempted.
+        addDisbursementVoucherLines(record, creditEntries, sourceGlId, requestType);
+
         final String txnRefsStr = String.join(",", txnRefs);
         final String updatedLog = buildActivityLog(
             (String) record.get("activity_log"), "APPROVED", currentUser.getUsername(), null);
@@ -981,7 +992,7 @@ public class ClerkDisbursementRequestApiResource {
             return ps;
         }, logKh);
         final long logId = Objects.requireNonNull(logKh.getKey()).longValue();
-        final String voucherNo = generateBtVoucherNo(logId);
+        final String voucherNo = generateBtVoucherNo(logId, currentUser, finalTotalDr);
         jdbcTemplate.update("UPDATE m_bank_transfer_log SET voucher_no = ? WHERE id = ?", voucherNo, logId);
 
         final JsonObject res = new JsonObject();
@@ -997,9 +1008,15 @@ public class ClerkDisbursementRequestApiResource {
      * Uses MAX(id) of the just-inserted row (passed in) to guarantee uniqueness even
      * under concurrent inserts on the same date.
      */
-    private String generateBtVoucherNo(final long logId) {
-        return "BT" + LocalDate.now(DateUtils.getDateTimeZoneOfTenant()).format(DateTimeFormatter.ofPattern("yyMMdd"))
-            + String.format("%05d", logId);
+    /**
+     * Bank-transfer settlement voucher, drawn from the same central register as every other
+     * voucher so the two numbering schemes cannot drift apart. A settlement moves money out of
+     * the debited accounts, so it reads as a debit: DR/2108/0001.
+     */
+    private String generateBtVoucherNo(final long logId, final AppUser currentUser, final BigDecimal amount) {
+        return voucherService.createVoucher(
+            VoucherService.TYPE_DISBURSEMENT, VoucherService.REF_BANK_TRANSFER_LOG,
+            logId, amount, currentUser, VoucherService.PREFIX_DEBIT);
     }
 
     // ── Helpers ───────────────────────────────────────────────────────────────────
@@ -1032,6 +1049,97 @@ public class ClerkDisbursementRequestApiResource {
         );
     }
 
+    /**
+     * Records the sides of an approved disbursement, collection or bank transfer on its voucher.
+     *
+     * The register covers three directions under one request type, and each puts the society's GL
+     * on a different side:
+     *
+     * <ul>
+     * <li>DISBURSEMENT — money out of the source GL into the listed accounts: GL debited, each
+     * account credited.</li>
+     * <li>COLLECTION — money into the target GL out of the listed accounts: each account debited,
+     * GL credited.</li>
+     * <li>BANK_TRANSFER — account to account with no GL involved at all; each entry already carries
+     * its own side, so they are used as given.</li>
+     * </ul>
+     *
+     * The society's side is written as a single line for the total rather than one per counterparty,
+     * because that is how it posts and how the slip reads.
+     *
+     * A failure here does not fail the approval: every transaction is posted by this point, and the
+     * money has moved. The problem is logged, and the voucher keeps its number without sides.
+     */
+    private void addDisbursementVoucherLines(final Map<?, ?> record, final JsonArray creditEntries, final Long sourceGlId,
+            final String requestType) {
+
+        final String voucherNo = (String) record.get("voucher_no");
+        if (voucherNo == null || voucherNo.isBlank()) {
+            return;
+        }
+
+        try {
+            final boolean isBankTransfer = "BANK_TRANSFER".equals(requestType);
+            final boolean isCollection = "COLLECTION".equals(requestType);
+
+            final List<VoucherLine> lines = new ArrayList<>();
+            BigDecimal counterpartyTotal = BigDecimal.ZERO;
+
+            for (final JsonElement el : creditEntries) {
+                final JsonObject entry = el.getAsJsonObject();
+                final BigDecimal entryAmount = new BigDecimal(entry.get("amount").getAsString());
+                final String accountNo = entry.has("accountNo") ? entry.get("accountNo").getAsString() : null;
+                final String accountName = entry.has("accountName") && !entry.get("accountName").isJsonNull()
+                        ? entry.get("accountName").getAsString()
+                        : accountNo;
+                final boolean isGlEntry = "GL".equals(entry.has("accountType") ? entry.get("accountType").getAsString() : "SAVINGS");
+
+                final Long glId = isGlEntry && entry.has("glAccountId") && !entry.get("glAccountId").isJsonNull()
+                        ? entry.get("glAccountId").getAsLong()
+                        : null;
+                final Long savingsId = !isGlEntry && entry.has("savingsAccountId") && !entry.get("savingsAccountId").isJsonNull()
+                        ? entry.get("savingsAccountId").getAsLong()
+                        : null;
+
+                // A bank transfer states each side on the entry itself; the other two directions
+                // put every counterparty on the side opposite the society's GL.
+                final boolean entryIsDebit = isBankTransfer
+                        ? "Dr".equals(entry.has("dbCr") ? entry.get("dbCr").getAsString() : "Cr")
+                        : isCollection;
+
+                final VoucherLine line;
+                if (isGlEntry) {
+                    line = entryIsDebit ? VoucherLine.debitGl(glId, accountName, accountNo, entryAmount)
+                            : VoucherLine.creditGl(glId, accountName, accountNo, entryAmount);
+                } else {
+                    line = entryIsDebit ? VoucherLine.debitSavings(savingsId, accountName, accountNo, entryAmount)
+                            : VoucherLine.creditSavings(savingsId, accountName, accountNo, entryAmount);
+                }
+                lines.add(line);
+
+                if (!isBankTransfer) {
+                    counterpartyTotal = counterpartyTotal.add(entryAmount);
+                }
+            }
+
+            // The society's own side. A bank transfer has none — the money never leaves the members
+            // between them — so its entries already balance on their own.
+            if (!isBankTransfer) {
+                final String glName = (String) record.get("gl_account_name");
+                final String glNo = (String) record.get("gl_account_no");
+                lines.add(isCollection ? VoucherLine.creditGl(sourceGlId, glName, glNo, counterpartyTotal)
+                        : VoucherLine.debitGl(sourceGlId, glName, glNo, counterpartyTotal));
+            }
+
+            // Debits first, so the voucher prints the way a slip is read.
+            lines.sort(Comparator.comparing(VoucherLine::isDebit).reversed());
+
+            voucherService.addLines(voucherNo, lines);
+        } catch (final RuntimeException e) {
+            log.error("Could not record voucher lines for disbursement request voucher {}", voucherNo, e);
+        }
+    }
+
     private Map<?, ?> loadRecord(final Long id) {
         final List<Map<String, Object>> rows = jdbcTemplate.queryForList("""
                 SELECT id, voucher_no, status, request_type, gl_account_id, gl_account_no, gl_account_name, dr_amount,
@@ -1216,7 +1324,8 @@ public class ClerkDisbursementRequestApiResource {
             .withJson(payload.toString())
             .build();
         fineractRequestContextHolder.setAttribute(SynchronousCommandProcessingService.COMMAND_SOURCE_ID, null);
-        commandsSourceWritePlatformService.logCommandSource(cmd);
+        // The disbursement register raises its own voucher; suppress the journal command's own.
+        voucherService.withOwnVoucher(() -> commandsSourceWritePlatformService.logCommandSource(cmd));
     }
 
     // ── Combined GL entry helpers ─────────────────────────────────────────────
@@ -1653,7 +1762,10 @@ public class ClerkDisbursementRequestApiResource {
             .withJson(payload.toString())
             .build();
         fineractRequestContextHolder.setAttribute(SynchronousCommandProcessingService.COMMAND_SOURCE_ID, null);
-        final CommandProcessingResult result = commandsSourceWritePlatformService.logCommandSource(cmd);
+        // The disbursement register raises its own voucher, naming every account involved; the
+        // journal command must not raise a second one over the same money.
+        final CommandProcessingResult result = voucherService
+            .withOwnVoucher(() -> commandsSourceWritePlatformService.logCommandSource(cmd));
         return result != null ? result.getTransactionId() : null;
     }
 

fineract-provider/src/main/java/org/apache/fineract/portfolio/clerkwithdrawal/api/ClerkShareWithdrawalRequestApiResource.java

@@ -41,6 +41,8 @@ import java.sql.Date;
 import java.sql.Timestamp;
 import java.time.Instant;
 import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.ZoneOffset;
 import java.time.format.DateTimeFormatter;
 import java.util.ArrayList;
 import java.util.List;
@@ -55,6 +57,7 @@ import org.apache.fineract.infrastructure.core.serialization.FromJsonHelper;
 import org.apache.fineract.infrastructure.core.service.DateUtils;
 import org.apache.fineract.infrastructure.security.service.PlatformSecurityContext;
 import org.apache.fineract.useradministration.domain.AppUser;
+import org.springframework.dao.IncorrectResultSizeDataAccessException;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
@@ -91,7 +94,25 @@ public class ClerkShareWithdrawalRequestApiResource {
             "(SELECT value FROM m_payment_type WHERE id = settlement_payment_type_id) AS settlement_payment_type_name",
             "settlement_amount", "settlement_savings_transaction_id", "settlement_row_snapshot" };
 
-    private static final String SHARE_REDEMPTION_PAYMENT_TYPE_CODE = "SHARE_REDEMPTION_TRANSFER";
+    // "Share Redemption Transfer" (a dedicated, teller-hidden payment type) was retired in favour of
+    // the plain "Transfer" type every settlement now uses -- this fallback code name follows it, so a
+    // pre-settlement_payment_type_id-column legacy request still resolves to a real payment type
+    // instead of silently posting its settlement with none at all.
+    private static final String SHARE_REDEMPTION_PAYMENT_TYPE_CODE = "TRANSFER";
+
+    // ── Sundry pass-through for the redemption settlement ───────────────────
+    // Fineract convention: 1 = CREDIT, 2 = DEBIT.
+    private static final int CREDIT = 1;
+    private static final int DEBIT = 2;
+
+    // acc_product_mapping.financial_account_type for share products.
+    private static final int FA_SHARES_REFERENCE = 1;
+    private static final int FA_SHARES_SUSPENSE = 2;
+    private static final int PRODUCT_TYPE_SHARES = 4;
+
+    // acc_product_mapping for savings: product_type 2, financial_account_type 2 = Savings Control.
+    private static final int PRODUCT_TYPE_SAVINGS = 2;
+    private static final int FA_SAVINGS_CONTROL = 2;
 
     // ── POST /v1/clerk/share-withdrawal-requests ── Clerk submits new request ───
 
@@ -187,8 +208,9 @@ public class ClerkShareWithdrawalRequestApiResource {
     @Produces(MediaType.APPLICATION_JSON)
     public String list(@QueryParam("status") @DefaultValue("PENDING") final String status,
             @QueryParam("offset") @DefaultValue("0") final int offset, @QueryParam("limit") @DefaultValue("20") final int limit,
-            @QueryParam("fromDate") final String fromDate, @QueryParam("toDate") final String toDate) {
-        return queryList("WHERE status = ?", new ArrayList<>(List.of(status)), fromDate, toDate, offset, limit);
+            @QueryParam("fromDate") final String fromDate, @QueryParam("toDate") final String toDate,
+            @QueryParam("search") final String search) {
+        return queryList("WHERE status = ?", new ArrayList<>(List.of(status)), fromDate, toDate, search, offset, limit);
     }
 
     // ── GET /v1/clerk/share-withdrawal-requests/my ── Clerk's own requests ──────
@@ -206,11 +228,11 @@ public class ClerkShareWithdrawalRequestApiResource {
             where.append(" AND status = ?");
             params.add(status);
         }
-        return queryList(where.toString(), params, fromDate, toDate, offset, limit);
+        return queryList(where.toString(), params, fromDate, toDate, null, offset, limit);
     }
 
     private String queryList(final String baseWhere, final List<Object> baseParams, final String fromDate, final String toDate,
-            final int offset, final int limit) {
+            final String search, final int offset, final int limit) {
         final StringBuilder where = new StringBuilder(baseWhere);
         final List<Object> params = new ArrayList<>(baseParams);
         if (fromDate != null && !fromDate.isBlank()) {
@@ -221,6 +243,13 @@ public class ClerkShareWithdrawalRequestApiResource {
             where.append(" AND DATE(submitted_at) <= ?");
             params.add(Date.valueOf(toDate));
         }
+        if (search != null && !search.isBlank()) {
+            where.append(" AND (account_no ILIKE ? OR client_name ILIKE ? OR resolution_number ILIKE ?)");
+            final String like = "%" + search.trim() + "%";
+            params.add(like);
+            params.add(like);
+            params.add(like);
+        }
 
         final long total = Optional
                 .ofNullable(jdbcTemplate.queryForObject("SELECT COUNT(*) FROM m_clerk_share_withdrawal_request " + where, Long.class,
@@ -320,7 +349,7 @@ public class ClerkShareWithdrawalRequestApiResource {
         final Long requestedShares = ((Number) record.get("requested_shares")).longValue();
 
         final Map<String, Object> shareAccountRow = jdbcTemplate.queryForList("""
-                SELECT total_approved_shares AS totalApprovedShares, status_enum AS statusEnum,
+                SELECT total_approved_shares AS totalApprovedShares, status_enum AS statusEnum, collection_applied AS collectionApplied,
                        savings_account_id AS savingsAccountId, client_id AS clientId, linked_loan_id AS linkedLoanId
                 FROM m_share_account WHERE id = ?
                 """, shareAccountId).stream().findFirst().orElse(null);
@@ -336,6 +365,14 @@ public class ClerkShareWithdrawalRequestApiResource {
                 : -1;
         checks.add(checkResult("Share account is Active", shareAccountStatus == 300, shareStatusLabel(shareAccountStatus)));
 
+        // Active only means approved and activated -- not paid for. Real share capital is only posted
+        // once a Share Advance Collection is applied (see ShareAdvanceCollectionApiResource), and
+        // approve() below hard-blocks on this same flag, so a request failing this check can never
+        // actually be approved regardless of what a checker decides here.
+        final boolean collectionApplied = shareAccountRow != null && Boolean.TRUE.equals(shareAccountRow.get("collectionApplied"));
+        checks.add(checkResult("Shares have been paid for (Share Advance Collection applied)", collectionApplied,
+                collectionApplied ? "Settled" : "Not settled — no collection has been applied to this share account yet"));
+
         final Long savingsAccountId = shareAccountRow != null && shareAccountRow.get("savingsAccountId") != null
                 ? ((Number) shareAccountRow.get("savingsAccountId")).longValue()
                 : null;
@@ -585,6 +622,20 @@ public class ClerkShareWithdrawalRequestApiResource {
         final Object meetingDateObj = record.get("meeting_date");
         final String resolutionNumber = (String) record.get("resolution_number");
 
+        // Account creation, approval and activation post no share-capital GL of their own -- a share
+        // account can be Active with "approved" shares that nobody has actually paid for yet, and only
+        // gets a real Dr Share Sundry / Cr Share Capital entry once a collection is applied (see
+        // ShareAdvanceCollectionApiResource). Redeeming before that would reverse capital that was
+        // never issued, so this is a hard block here, not just an advisory line in validate()'s
+        // checklist -- a checker approving off that checklist alone has no other backstop.
+        final Boolean collectionApplied = jdbcTemplate
+                .queryForList("SELECT collection_applied AS collectionApplied FROM m_share_account WHERE id = ?", shareAccountId).stream()
+                .findFirst().map(row -> (Boolean) row.get("collectionApplied")).orElse(null);
+        if (!Boolean.TRUE.equals(collectionApplied)) {
+            throw apiError(409, "Share account " + shareAccountId + " has not been settled yet -- no Share Advance Collection has been "
+                    + "applied to it, so these shares have not actually been paid for and cannot be redeemed.");
+        }
+
         final JsonObject payload = new JsonObject();
         payload.addProperty("locale", "en");
         payload.addProperty("dateFormat", "dd MMMM yyyy");
@@ -603,11 +654,20 @@ public class ClerkShareWithdrawalRequestApiResource {
         final Long shareTransactionId = shareTxnIdRaw instanceof Number ? ((Number) shareTxnIdRaw).longValue() : null;
         final String shareTxnId = shareTransactionId != null ? shareTransactionId.toString() : null;
 
+        // Redirects the native redeem posting's Cr Shares Reference (Cash at Vault) leg into
+        // Cr Sundry instead — see routeRedeemIntoSundry() for why: every other way money reaches or
+        // leaves share capital in this codebase passes through Sundry, and leaving redeem on its own
+        // "give cash back over the counter" assumption breaks that the moment the settlement below
+        // lands on a different GL than this leg did.
+        if (shareTransactionId != null) {
+            routeRedeemIntoSundry(shareAccountId, shareTransactionId, LocalDate.parse(requestedDateObj.toString().substring(0, 10)),
+                    currentUser.getId());
+        }
+
         // Settlement: within this SAME approval transaction, immediately credit the redemption value
-        // to the member's linked savings account. Two Fineract journal entries get posted — native
-        // redeem's Dr Share Equity / Cr Shares Reference, then this deposit's Dr Shares Reference /
-        // Cr Savings Control — but the Shares Reference leg nets to zero instantly, so the combined
-        // financial result is exactly Dr Share Equity / Cr Savings Control, same as one direct entry.
+        // to the member's linked savings account, routed Dr Sundry / Cr Savings Control -- explicitly,
+        // not by relying on the settlement payment type's own GL Fund Source mapping to coincidentally
+        // land on the same account the leg above credited. See creditLinkedSavingsAccount().
         final Object storedSettlementPaymentTypeId = record.get("settlement_payment_type_id");
         final Long settlementPaymentTypeId = storedSettlementPaymentTypeId instanceof Number
                 ? ((Number) storedSettlementPaymentTypeId).longValue()
@@ -689,14 +749,17 @@ public class ClerkShareWithdrawalRequestApiResource {
      * Reads the amount straight off the just-created redeem transaction row rather than re-deriving
      * the unit price ourselves — the transaction was already priced by Fineract's own
      * {@code ShareProduct#deriveMarketPrice(requestedDate)} (the requested date, not necessarily
-     * today) and already nets out any redemption charge. Uses Fineract's own native savings deposit
-     * command so the transaction is fully audited and posts its own GL entry the normal way — the
-     * debit side lands on whichever GL account is mapped to the settlement payment type the clerk
-     * chose at submit time (validated to be non-cash and persisted on the request row) — matching the
-     * Share Product's own "Shares Reference" mapping (Share Sundry) — so the two entries net to zero
-     * on that bridge account. Falls back to the legacy hardcoded
-     * {@link #SHARE_REDEMPTION_PAYMENT_TYPE_CODE} lookup only for requests submitted before this
-     * column existed.
+     * today) and already nets out any redemption charge.
+     *
+     * <p>
+     * Posted through Fineract's own native savings deposit command first, so the transaction is fully audited and the
+     * member's passbook/statement carry it exactly as an over-the-counter deposit would. That command's own GL entry
+     * (Dr <i>whichever GL the settlement payment type's Fund Source maps to</i> / Cr Savings Control) is then
+     * <b>reversed in full</b> and replaced with an explicit Dr Sundry / Cr Savings Control pair — the debit side used
+     * to be left to the payment type's own mapping in the hope it would land on the same account
+     * {@link #routeRedeemIntoSundry} just credited, netting to zero; when that mapping pointed anywhere else (as it
+     * did the day this was found — Sundry, when it should have matched Cash at Vault) the two legs never actually
+     * met, leaving Sundry debited for money that was never credited to it. Explicit beats coincidental.
      */
     private Settlement creditLinkedSavingsAccount(final Long shareAccountId, final Long shareTransactionId, final String requestedDateStr,
             final String resolutionNumber, final Long settlementPaymentTypeId) {
@@ -735,7 +798,35 @@ public class ClerkShareWithdrawalRequestApiResource {
         final CommandWrapper commandRequest = new CommandWrapperBuilder().savingsAccountDeposit(savingsAccountId)
                 .withJson(payload.toString()).build();
         final CommandProcessingResult result = commandsSourceWritePlatformService.logCommandSource(commandRequest);
-        return new Settlement(settlementAmount, result.getResourceId());
+        final Long savingsTransactionId = result.getResourceId();
+
+        // The deposit's own GL entries (whatever they turned out to be) are reversed wholesale rather
+        // than picked apart leg-by-leg — the correct Dr Sundry / Cr Savings Control pair below stands
+        // on its own regardless of which GL the payment type's Fund Source mapping happened to hit.
+        jdbcTemplate.update("UPDATE acc_gl_journal_entry SET reversed = true WHERE transaction_id = ?", "S" + savingsTransactionId);
+
+        final Map<String, Object> acct = loadShareAccountGlContext(shareAccountId);
+        final Long productId = toLong(acct.get("product_id"));
+        final Long officeId = toLong(acct.get("office_id"));
+        final String currencyCode = (String) acct.get("currency_code");
+        final Long glSundry = requireShareGl(productId, FA_SHARES_SUSPENSE, "Share Sundry (Suspense)");
+        final Long glSavingsControl = savingsControlGlOf(savingsAccountId);
+        if (glSavingsControl == null) {
+            throw apiError(409, "The Savings Control GL is not mapped for this savings account's product.");
+        }
+
+        final LocalDate entryDate = LocalDate.parse(requestedDateStr.substring(0, 10));
+        final long userId = context.authenticatedUser().getId();
+        final LocalDateTime now = LocalDateTime.now(DateUtils.getDateTimeZoneOfTenant());
+        final String txnId = "SHRDMSTL-" + System.nanoTime();
+        final String accountNo = (String) acct.get("account_no");
+
+        insertEntry(officeId, glSundry, DEBIT, settlementAmount, txnId, entryDate, shareAccountId, userId, now, currencyCode,
+                "Share redemption settled to savings | " + accountNo);
+        insertEntry(officeId, glSavingsControl, CREDIT, settlementAmount, txnId, entryDate, shareAccountId, userId, now, currencyCode,
+                "Share redemption settlement credited to savings | " + accountNo);
+
+        return new Settlement(settlementAmount, savingsTransactionId);
     }
 
     // ── POST /v1/clerk/share-withdrawal-requests/{id}/reject ── Manager rejects ─
@@ -806,6 +897,125 @@ public class ClerkShareWithdrawalRequestApiResource {
         }
     }
 
+    // ── Sundry pass-through helpers ──────────────────────────────────────────
+
+    /**
+     * Redirects the native {@code redeemshares} posting's Cr Shares Reference (Cash at Vault) leg into Cr Sundry.
+     *
+     * <p>
+     * Fineract's own accounting bridge assumes a redemption hands cash back over the counter (Dr Share Equity / Cr
+     * Shares Reference) — right for a walk-in cash redemption, wrong here, where the value is heading to the
+     * member's linked savings instead. Left alone, that Cr Shares Reference leg has no partner: the settlement
+     * posted in {@link #creditLinkedSavingsAccount} debits Sundry, not Shares Reference, so Sundry would be debited
+     * for money it was never credited with. Reversing just this one leg (matched by the specific "Shares Reference"
+     * GL account, not merely "the credit leg" — a chargeable redemption also credits Income from Fees, which must be
+     * left standing) and replacing it with Cr Sundry closes that gap: the account genuinely passes through Sundry
+     * the same way every other share-capital movement in this codebase does.
+     */
+    private void routeRedeemIntoSundry(final Long shareAccountId, final Long shareTransactionId, final LocalDate entryDate,
+            final long userId) {
+        final Map<String, Object> acct = loadShareAccountGlContext(shareAccountId);
+        final Long productId = toLong(acct.get("product_id"));
+        final Long officeId = toLong(acct.get("office_id"));
+        final String currencyCode = (String) acct.get("currency_code");
+        final String accountNo = (String) acct.get("account_no");
+
+        final Long glReference = requireShareGl(productId, FA_SHARES_REFERENCE, "Shares Reference");
+        final Long glSundry = requireShareGl(productId, FA_SHARES_SUSPENSE, "Share Sundry (Suspense)");
+
+        final Map<String, Object> reversedLeg = jdbcTemplate
+                .queryForList(
+                        "SELECT amount, transaction_id FROM acc_gl_journal_entry WHERE share_transaction_id = ? AND account_id = ? "
+                                + " AND type_enum = ? AND reversed = false",
+                        shareTransactionId, glReference, CREDIT)
+                .stream().findFirst().orElse(null);
+        if (reversedLeg == null) {
+            // Nothing to redirect -- the native posting didn't credit Shares Reference at all (an
+            // unexpected accounting configuration), so there is no leg here to reroute.
+            return;
+        }
+        final BigDecimal amount = (BigDecimal) reversedLeg.get("amount");
+        // Reuses the native posting's OWN transaction_id rather than minting a new one -- entries are
+        // grouped and checked for balance by transaction_id, so a fresh id here would leave the Dr
+        // Share Equity leg standing alone as "unbalanced" and this new Cr Sundry leg equally alone,
+        // instead of the two reading as the one balanced entry they actually are.
+        final String nativeTxnId = (String) reversedLeg.get("transaction_id");
+
+        jdbcTemplate.update(
+                "UPDATE acc_gl_journal_entry SET reversed = true WHERE share_transaction_id = ? AND account_id = ? "
+                        + " AND type_enum = ? AND reversed = false",
+                shareTransactionId, glReference, CREDIT);
+
+        final LocalDateTime now = LocalDateTime.now(DateUtils.getDateTimeZoneOfTenant());
+        insertEntry(officeId, glSundry, CREDIT, amount, nativeTxnId, entryDate, shareAccountId, userId, now, currencyCode,
+                "Share redemption held in Sundry pending settlement | " + accountNo);
+    }
+
+    private Map<String, Object> loadShareAccountGlContext(final Long shareAccountId) {
+        return jdbcTemplate.queryForMap("""
+                SELECT sa.account_no, sa.product_id, sa.currency_code, c.office_id
+                FROM m_share_account sa JOIN m_client c ON c.id = sa.client_id
+                WHERE sa.id = ?
+                """, shareAccountId);
+    }
+
+    private Long requireShareGl(final Long productId, final int financialAccountType, final String label) {
+        final Long glId = resolveGl(productId, financialAccountType);
+        if (glId == null) {
+            throw apiError(409, label + " GL is not mapped for share product " + productId + ".");
+        }
+        return glId;
+    }
+
+    private Long resolveGl(final Long productId, final int financialAccountType) {
+        try {
+            return jdbcTemplate.queryForObject(
+                    "SELECT gl_account_id FROM acc_product_mapping "
+                            + " WHERE product_id = ? AND product_type = ? AND financial_account_type = ? AND charge_id IS NULL",
+                    Long.class, productId, PRODUCT_TYPE_SHARES, financialAccountType);
+        } catch (final IncorrectResultSizeDataAccessException e) {
+            return null;
+        }
+    }
+
+    private Long savingsControlGlOf(final Long savingsAccountId) {
+        final List<Map<String, Object>> rows = jdbcTemplate.queryForList("""
+                SELECT apm.gl_account_id FROM m_savings_account sa
+                JOIN acc_product_mapping apm ON apm.product_id = sa.product_id
+                WHERE sa.id = ? AND apm.product_type = ? AND apm.financial_account_type = ? LIMIT 1
+                """, savingsAccountId, PRODUCT_TYPE_SAVINGS, FA_SAVINGS_CONTROL);
+        return rows.isEmpty() ? null : toLong(rows.get(0).get("gl_account_id"));
+    }
+
+    private void insertEntry(final Long officeId, final Long glAccountId, final int typeEnum, final BigDecimal amount, final String txnId,
+            final LocalDate entryDate, final Long shareAccountId, final long userId, final LocalDateTime now, final String currencyCode,
+            final String description) {
+        jdbcTemplate.update(
+                "INSERT INTO acc_gl_journal_entry " + "(account_id, office_id, currency_code, transaction_id, reversed, manual_entry, "
+                        + " entry_date, type_enum, amount, description, entity_id, "
+                        + " created_by, last_modified_by, created_date, lastmodified_date, "
+                        + " is_running_balance_calculated, office_running_balance, "
+                        + " organization_running_balance, submitted_on_date, transaction_date, " + " created_on_utc, last_modified_on_utc) "
+                        + "VALUES (?,?,?,?,false,true,?,?,?,?,?,?,?,?,?,false,0,0,?,?,?,?)",
+                glAccountId, officeId, currencyCode, txnId, java.sql.Date.valueOf(entryDate), typeEnum, amount, description, shareAccountId,
+                userId, userId, now, now, java.sql.Date.valueOf(entryDate), java.sql.Date.valueOf(entryDate), toUtc(now), toUtc(now));
+    }
+
+    /**
+     * A tenant-local timestamp converted to the real UTC instant, for the {@code *_on_utc} columns.
+     *
+     * {@code atOffset(ZoneOffset.UTC)} would only relabel it — stamping 18:34 IST as "18:34 UTC", which reads back
+     * as 00:04 the next day. The instant has to be resolved in the tenant's own zone first, which is the zone
+     * {@code now} was taken in.
+     */
+    private java.time.OffsetDateTime toUtc(final LocalDateTime tenantLocalTime) {
+        return tenantLocalTime.atZone(DateUtils.getDateTimeZoneOfTenant()).toOffsetDateTime().withOffsetSameInstant(ZoneOffset.UTC);
+    }
+
+    private Long toLong(final Object o) {
+        return o instanceof Number ? ((Number) o).longValue() : null;
+    }
+
     private String buildActivityLog(final String existingJson, final String action, final String username, final String note) {
         JsonArray log = new JsonArray();
         if (existingJson != null && !existingJson.isBlank()) {

fineract-provider/src/main/java/org/apache/fineract/portfolio/clerkwithdrawal/api/ClerkWithdrawalRequestApiResource.java

@@ -54,7 +54,10 @@ import org.apache.fineract.commands.service.PortfolioCommandSourceWritePlatformS
 import org.apache.fineract.infrastructure.core.data.CommandProcessingResult;
 import org.apache.fineract.infrastructure.core.serialization.FromJsonHelper;
 import org.apache.fineract.infrastructure.security.service.PlatformSecurityContext;
+import org.apache.fineract.portfolio.voucher.service.VoucherLine;
 import org.apache.fineract.portfolio.voucher.service.VoucherService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.apache.fineract.useradministration.domain.AppUser;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.stereotype.Component;
@@ -69,6 +72,10 @@ import com.google.common.base.Splitter;
 @RequiredArgsConstructor
 public class ClerkWithdrawalRequestApiResource {
 
+    // Named LOG rather than declared with @Slf4j: buildActivityLog uses a local "log" for the
+    // activity JsonArray, and a field of the same name reads as that variable at a glance.
+    private static final Logger LOG = LoggerFactory.getLogger(ClerkWithdrawalRequestApiResource.class);
+
     private final JdbcTemplate jdbcTemplate;
     private final FromJsonHelper fromJsonHelper;
     private final PlatformSecurityContext context;
@@ -151,7 +158,8 @@ public class ClerkWithdrawalRequestApiResource {
             @QueryParam("offset") @DefaultValue("0") final int offset,
             @QueryParam("limit") @DefaultValue("20") final int limit,
             @QueryParam("fromDate") final String fromDate,
-            @QueryParam("toDate") final String toDate) {
+            @QueryParam("toDate") final String toDate,
+            @QueryParam("search") final String search) {
 
         final StringBuilder where = new StringBuilder("WHERE status = ?");
         final List<Object> baseParams = new ArrayList<>(List.of(status));
@@ -163,6 +171,14 @@ public class ClerkWithdrawalRequestApiResource {
             where.append(" AND DATE(submitted_at) <= ?");
             baseParams.add(Date.valueOf(toDate));
         }
+        if (search != null && !search.isBlank()) {
+            where.append(" AND (account_no ILIKE ? OR client_name ILIKE ? OR voucher_no ILIKE ? OR tok_no ILIKE ?)");
+            final String like = "%" + search.trim() + "%";
+            baseParams.add(like);
+            baseParams.add(like);
+            baseParams.add(like);
+            baseParams.add(like);
+        }
 
         final long total = Optional.ofNullable(
             jdbcTemplate.queryForObject("SELECT COUNT(*) FROM m_clerk_withdrawal_request " + where, Long.class, baseParams.toArray())
@@ -457,6 +473,10 @@ public class ClerkWithdrawalRequestApiResource {
                 VoucherService.REF_CLERK_WITHDRAWAL_REQUEST, id, Long.valueOf(txnId));
         }
 
+        // The sides of the slip. A withdrawal is money leaving the member, so their account is
+        // debited and the till that pays it out is credited.
+        addWithdrawalVoucherLines(record, savingsAccountId, amount);
+
         final String updatedLog = buildActivityLog(
             (String) record.get("activity_log"), "APPROVED", currentUser.getUsername(), null
         );
@@ -594,6 +614,11 @@ public class ClerkWithdrawalRequestApiResource {
             throw apiError(409, "This withdrawal has already been withdrawn by another cashier. Double disbursement prevented.");
         }
 
+        // The voucher was raised in the clerk's name at submission, before any cashier was involved --
+        // reattribute it to whoever is actually handing over the cash now, so it shows up in their own
+        // voucher register rather than only in the clerk's.
+        voucherService.updateCashier(VoucherService.REF_CLERK_WITHDRAWAL_REQUEST, id, currentUser);
+
         // Record denomination breakdown in m_savings_txn_denomination so cashier vault position updates
         if (denominationData != null && !denominationData.isBlank()) {
             saveDisbursementDenomination(denominationData, record, currentUser);
@@ -663,6 +688,7 @@ public class ClerkWithdrawalRequestApiResource {
         final String accountNo = (String) record.get("account_no");
         final Object clientIdObj = record.get("client_id");
         final Long clientId = clientIdObj != null ? Long.valueOf(clientIdObj.toString()) : null;
+        final String paymentTypeName = (String) record.get("payment_type_name");
 
         for (final Map.Entry<String, com.google.gson.JsonElement> entry : denomMap.entrySet()) {
             final int count;
@@ -686,16 +712,42 @@ public class ClerkWithdrawalRequestApiResource {
             jdbcTemplate.update("""
                 INSERT INTO m_savings_txn_denomination
                 (txn_id, savings_account_id, account_no, client_id, denomination_id,
-                 denomination_value, count, total_amount, txn_date, txn_type, officer_id, officer_username)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, CURRENT_DATE, 'WITHDRAWAL', ?, ?)
+                 denomination_value, count, total_amount, txn_date, txn_type, officer_id, officer_username, payment_type)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, CURRENT_DATE, 'WITHDRAWAL', ?, ?, ?)
                 """,
                 txnId, savingsAccountId, accountNo, clientId, denomId,
                 value, count, BigDecimal.valueOf((long) value * count),
-                cashier.getId(), cashier.getUsername()
+                cashier.getId(), cashier.getUsername(), paymentTypeName
             );
         }
     }
 
+    /**
+     * Records the two sides of an approved withdrawal on its voucher.
+     *
+     * Money leaves the member and is paid out over the counter, so the member's account is debited
+     * and the till is credited. The withdrawal register does not carry a GL id for the till — it
+     * pays out of whichever cashier's drawer serves the request — so that side is named without one.
+     *
+     * A failure here does not fail the approval: the withdrawal is already posted and the member
+     * already paid. The problem is logged, and the voucher keeps its number without sides.
+     */
+    private void addWithdrawalVoucherLines(final Map<?, ?> record, final Long savingsAccountId, final BigDecimal amount) {
+        final String voucherNo = (String) record.get("voucher_no");
+        if (voucherNo == null || voucherNo.isBlank() || savingsAccountId == null) {
+            return;
+        }
+
+        try {
+            voucherService.addLines(voucherNo,
+                    List.of(VoucherLine.debitSavings(savingsAccountId, (String) record.get("client_name"),
+                            (String) record.get("account_no"), amount),
+                            VoucherLine.creditGl(null, "Cash in Hand", null, amount)));
+        } catch (final RuntimeException e) {
+            LOG.error("Could not record voucher lines for withdrawal request voucher {}", voucherNo, e);
+        }
+    }
+
     private Map<?, ?> loadRecord(final Long id) {
         final List<Map<String, Object>> rows = jdbcTemplate.queryForList("""
                 SELECT id, account_no, account_type, savings_account_id, client_id, client_name,
@@ -736,7 +788,13 @@ public class ClerkWithdrawalRequestApiResource {
             .withJson(payload.toString())
             .build();
 
-        final CommandProcessingResult result = commandsSourceWritePlatformService.logCommandSource(commandRequest);
+        // The withdrawal register raised its own voucher at submission and attaches the member and
+        // till sides to it on approval, so the savings command must not raise a second one over the
+        // same money -- one withdrawal was appearing twice on the cashier's payment report, once
+        // under the register's number and once under the savings transaction's, doubling the day's
+        // cash paid out.
+        final CommandProcessingResult result = voucherService
+            .withOwnVoucher(() -> commandsSourceWritePlatformService.logCommandSource(commandRequest));
         return result.getResourceId() != null ? result.getResourceId().toString() : null;
     }
 
@@ -764,7 +822,11 @@ public class ClerkWithdrawalRequestApiResource {
             .withJson(payload.toString())
             .build();
 
-        final CommandProcessingResult result = commandsSourceWritePlatformService.logCommandSource(commandRequest);
+        // Suppressed for the same reason as the savings path above. Current accounts raise no
+        // voucher of their own today, so this changes nothing now; it is here so that the day one
+        // is added, this register does not silently start double-counting again.
+        final CommandProcessingResult result = voucherService
+            .withOwnVoucher(() -> commandsSourceWritePlatformService.logCommandSource(commandRequest));
         return result.getResourceId() != null ? result.getResourceId().toString() : null;
     }
 
@@ -798,9 +860,9 @@ public class ClerkWithdrawalRequestApiResource {
 
     /**
      * Ensures the token number is unique for today's date among non-rejected requests, checking
-     * both this table and {@code m_share_dividend_claim_request} -- a dividend cash claim's token
-     * is redeemed at the very same Transaction Entry field, so the two pools must never collide.
-     * {@code excludeId} is set during resubmit to skip the record being edited.
+     * this table plus {@code m_share_dividend_claim_request} and {@code m_clerk_closure_request} --
+     * all three are redeemed at the very same Transaction Entry token field, so none of the pools
+     * may ever collide. {@code excludeId} is set during resubmit to skip the record being edited.
      */
     private void validateTokenUniqueToday(final String tokNo, final Long excludeId) {
         final StringBuilder sql = new StringBuilder(
@@ -815,13 +877,19 @@ public class ClerkWithdrawalRequestApiResource {
         final long ownCount = Optional.ofNullable(
             jdbcTemplate.queryForObject(sql.toString(), Long.class, params.toArray())
         ).orElse(0L);
-        final long otherCount = Optional.ofNullable(
+        final long dividendCount = Optional.ofNullable(
             jdbcTemplate.queryForObject(
                 "SELECT COUNT(*) FROM m_share_dividend_claim_request "
                 + "WHERE tok_no = ? AND CAST(submitted_at AS DATE) = CURRENT_DATE AND status <> 'REJECTED'",
                 Long.class, tokNo)
         ).orElse(0L);
-        if (ownCount + otherCount > 0) {
+        final long closureCount = Optional.ofNullable(
+            jdbcTemplate.queryForObject(
+                "SELECT COUNT(*) FROM m_clerk_closure_request "
+                + "WHERE tok_no = ? AND CAST(submitted_at AS DATE) = CURRENT_DATE AND status <> 'REJECTED'",
+                Long.class, tokNo)
+        ).orElse(0L);
+        if (ownCount + dividendCount + closureCount > 0) {
             throw apiError(400,
                 "Token number '" + tokNo + "' is already used today. Please enter a different token number.");
         }

fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientAllAccountsApiResource.java

@@ -0,0 +1,330 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.portfolio.client.api;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonObject;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.HeaderParam;
+import jakarta.ws.rs.NotFoundException;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.PathParam;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.core.Context;
+import jakarta.ws.rs.core.MediaType;
+import java.math.BigDecimal;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.time.LocalDate;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.fineract.infrastructure.core.domain.FineractPlatformTenant;
+import org.apache.fineract.infrastructure.core.domain.JdbcSupport;
+import org.apache.fineract.infrastructure.core.service.ThreadLocalContextUtil;
+import org.apache.fineract.infrastructure.security.apiclient.ApiClientCredentialService;
+import org.apache.fineract.infrastructure.security.service.PlatformSecurityContext;
+import org.apache.fineract.portfolio.savings.data.SavingsAccountStatusEnumData;
+import org.apache.fineract.portfolio.savings.service.SavingsEnumerations;
+import org.apache.fineract.portfolio.shareaccounts.data.ShareAccountStatusEnumData;
+import org.apache.fineract.portfolio.shareaccounts.service.SharesEnumerations;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.RowMapper;
+import org.springframework.stereotype.Component;
+
+/**
+ * A single client's full deposit + share picture, looked up by client number OR mobile number (the
+ * path segment is tried as {@code m_client.account_no} first, then {@code m_client.mobile_no}) rather
+ * than the internal client id -- these are what a counter clerk has on the slip, or what a third-party
+ * caller was given, respectively, so no separate client-search step is needed before this call. Built
+ * so the whole thing, including the client lookup itself, resolves in a small handful of index-scan-only
+ * queries, on the theory that this is exactly the kind of check a teller or manager runs right before
+ * approving something (a share purchase, a closure, a large withdrawal) -- the "is there a problem here"
+ * question this endpoint answers has to come back before that decision is made, not after.
+ *
+ * Deliberately its own lightweight resource rather than a reuse of {@code AccountSummaryCollectionData}
+ * (GET /clients/{clientId}/accounts): that endpoint's row mappers each carry six LEFT JOINs to
+ * m_appuser for a full submitted/approved/rejected/activated/closed audit trail per account, which this
+ * caller doesn't need -- account number, product, status and the current balance/share value is the
+ * whole ask. Fewer joins and fewer columns is what actually makes this fast, not a different query
+ * engine.
+ *
+ * Two ways in, deliberately: a normal Fineract user (Basic Auth, unchanged) can call this exactly as
+ * they do every other endpoint; a third-party integration that should never see a Fineract username or
+ * password sends an {@code X-Api-Key} header instead (see {@link ApiClientCredentialService}), minted
+ * via {@code POST /v1/apiclients} by a super user. This path is carved out as {@code permitAll()} in
+ * {@code SecurityConfig} for exactly that second case -- the same posture this fork already uses for the
+ * IMPS and NPCI receivers, where Spring Security's outer gate stays open for one narrow path and the
+ * handler itself is what actually authenticates the caller.
+ */
+@Path("/v1/clientaccounts")
+@Component
+@Tag(name = "Client All Accounts", description = "Fast, single-lookup view of every Savings/Fixed Deposit/Recurring Deposit/Current/Share account a client holds, by client number or mobile number.")
+@RequiredArgsConstructor
+public class ClientAllAccountsApiResource {
+
+    private final JdbcTemplate jdbcTemplate;
+    private final PlatformSecurityContext context;
+    private final ApiClientCredentialService apiClientCredentialService;
+    private final Gson gson = new GsonBuilder().serializeNulls().create();
+
+    // Same header-precedence list CallerIpTrackingFilter uses elsewhere in this fork, kept local
+    // rather than depending on that filter bean: it's only conditionally registered
+    // (fineract.ip-tracking.enabled), and an API-key IP allowlist has to work regardless of whether
+    // that unrelated feature toggle is on.
+    private static final String[] IP_HEADER_CANDIDATES = { "X-Forwarded-For", "Proxy-Client-IP", "WL-Proxy-Client-IP" };
+
+    // One UNION ALL, one round trip: SB/FD/RD (m_savings_account, split by deposit_type_enum),
+    // CD (m_current_account, its own table -- current accounts were never folded into
+    // m_savings_account here, see AccountDetailsReadPlatformServiceJpaRepositoryImpl for the same
+    // split), and Share (m_share_account). Every leg filters on client_id, which is indexed on
+    // all three tables (fksa00000000000001, idx_ca_client_id, m_share_account_ibfk_9) -- an
+    // index-only lookup per leg, not a scan.
+    private static final String ACCOUNTS_SQL = """
+            SELECT sa.deposit_type_enum AS deposit_type, sa.id AS account_id, sa.account_no, sa.external_id,
+                   sa.status_enum AS status_enum, sa.currency_code, sa.product_id,
+                   p.name AS product_name, p.short_name AS short_product_name,
+                   sa.account_balance_derived AS balance, COALESCE(sa.on_hold_funds_derived, 0) AS on_hold,
+                   NULL::bigint AS approved_shares, NULL::bigint AS pending_shares, NULL::numeric(10,2) AS unit_price,
+                   sa.submittedon_date AS submitted_date, sa.activatedon_date AS activated_date
+              FROM m_savings_account sa
+              JOIN m_savings_product p ON p.id = sa.product_id
+             WHERE sa.client_id = ?
+
+            UNION ALL
+
+            SELECT CAST(400 AS smallint) AS deposit_type, ca.id, ca.account_no, ca.external_id,
+                   ca.status_enum, ca.currency_code, ca.product_id, cp.name, cp.short_name,
+                   ca.account_balance_derived, COALESCE(ca.on_hold_funds_derived, 0),
+                   NULL::bigint, NULL::bigint, NULL::numeric(10,2),
+                   ca.submittedon_date, ca.activatedon_date
+              FROM m_current_account ca
+              JOIN m_current_product cp ON cp.id = ca.product_id
+             WHERE ca.client_id = ?
+
+            UNION ALL
+
+            SELECT CAST(NULL AS smallint) AS deposit_type, shr.id, shr.account_no, shr.external_id,
+                   shr.status_enum, shr.currency_code, shr.product_id, sp.name, sp.short_name,
+                   NULL::numeric(19,6), NULL::numeric(19,6),
+                   shr.total_approved_shares, shr.total_pending_shares, sp.unit_price,
+                   shr.submitted_date, shr.activated_date
+              FROM m_share_account shr
+              JOIN m_share_product sp ON sp.id = shr.product_id
+             WHERE shr.client_id = ?
+            """;
+
+    @GET
+    @Path("/{identifier}")
+    @Produces(MediaType.APPLICATION_JSON)
+    public String retrieveByIdentifier(@PathParam("identifier") final String identifier,
+            @HeaderParam("X-Api-Key") final String apiKey, @Context final HttpServletRequest servletRequest) {
+        // Dual-mode: a header present means a third-party caller, checked against m_api_client and
+        // never touching Fineract's own login. No header means an ordinary logged-in user -- exactly
+        // the same authenticatedUser() gate every other resource in this codebase uses. The two are
+        // mutually exclusive on purpose: a request carrying an API key is never also allowed to fall
+        // back to "well, maybe they're logged in too" -- that would let a stolen key ride along on a
+        // legitimate session's cookies/headers.
+        if (StringUtils.isNotBlank(apiKey)) {
+            apiClientCredentialService.authenticate(apiKey, resolveClientIp(servletRequest));
+        } else {
+            context.authenticatedUser();
+        }
+
+        final FineractPlatformTenant tenant = ThreadLocalContextUtil.getTenant();
+        final Map<String, Object> client = resolveClient(identifier, tenant);
+        final Long clientId = ((Number) client.get("id")).longValue();
+
+        final List<Map<String, Object>> rows = jdbcTemplate.query(ACCOUNTS_SQL, new AccountRowMapper(), clientId, clientId, clientId);
+
+        final Map<String, Object> totalsByCurrency = new LinkedHashMap<>();
+        final Map<String, Integer> countByType = new LinkedHashMap<>();
+        for (final Map<String, Object> row : rows) {
+            final String accountType = (String) row.get("accountType");
+            countByType.merge(accountType, 1, Integer::sum);
+
+            final Object valueObj = row.get("currentValue");
+            if (valueObj instanceof BigDecimal value) {
+                final String currency = (String) row.get("currencyCode");
+                final BigDecimal running = (BigDecimal) totalsByCurrency.getOrDefault(currency, BigDecimal.ZERO);
+                totalsByCurrency.put(currency, running.add(value));
+            }
+        }
+
+        final JsonObject res = new JsonObject();
+        // Which bank this response came from -- not decorative. One API key now authenticates
+        // against every tenant (see ApiClientCredentialService), so the ONLY thing that decides
+        // whose data comes back is the Fineract-Platform-TenantId header the caller sent. Echoing it
+        // (plus the bank's display name) back in the body means a caller debugging "why did I get
+        // client X's data instead of client Y's" can tell from the response alone, without having to
+        // go back and re-check what header value they actually sent.
+        res.addProperty("tenantId", tenant.getTenantIdentifier());
+        res.addProperty("tenantName", tenant.getName());
+        res.addProperty("searchedIdentifier", identifier);
+        res.addProperty("clientId", clientId);
+        res.addProperty("matchedBy", (String) client.get("matched_by"));
+        res.addProperty("clientNo", (String) client.get("account_no"));
+        res.addProperty("clientName", (String) client.get("display_name"));
+        res.addProperty("mobileNo", (String) client.get("mobile_no"));
+        res.addProperty("officeId", ((Number) client.get("office_id")).longValue());
+        res.addProperty("clientStatusEnum", ((Number) client.get("status_enum")).intValue());
+        res.addProperty("totalAccounts", rows.size());
+        res.add("accountsByType", gson.toJsonTree(countByType));
+        res.add("totalCurrentValueByCurrency", gson.toJsonTree(totalsByCurrency));
+        res.add("accounts", gson.toJsonTree(rows));
+        return gson.toJson(res);
+    }
+
+    /**
+     * Resolves the path identifier as a client number first, then a mobile number -- two lookups in
+     * the worst case, one in the common case, both on unique indexed columns
+     * ({@code m_client_account_no_key}, {@code m_client_mobile_no_key} / {@code idx_client_mobile_no}),
+     * so neither costs more than the single index-scan lookup this whole endpoint is built around.
+     * Client number is tried first because it's the identifier a teller normally has on the slip in
+     * front of them; falling through to mobile number covers the third-party case where that's the
+     * only thing the caller was given. A value that happens to collide across both columns for two
+     * different clients is not handled specially -- account numbers and mobile numbers use disjoint
+     * formats in this system, so this cannot occur in practice.
+     *
+     * {@code tenant} is only for the not-found message: with one API key now valid across every bank
+     * (see {@link ApiClientCredentialService}), a lookup that finds nothing is as often "right
+     * identifier, wrong bank" (a stale or mistyped {@code Fineract-Platform-TenantId} header) as it is
+     * a genuinely unknown client -- naming the bank actually searched turns that from a guessing game
+     * into something the caller can act on immediately.
+     */
+    private Map<String, Object> resolveClient(final String identifier, final FineractPlatformTenant tenant) {
+        final List<Map<String, Object>> byAccountNo = jdbcTemplate.queryForList("""
+                SELECT id, account_no, display_name, mobile_no, office_id, status_enum
+                  FROM m_client WHERE account_no = ?
+                """, identifier);
+        if (!byAccountNo.isEmpty()) {
+            final Map<String, Object> client = new LinkedHashMap<>(byAccountNo.get(0));
+            client.put("matched_by", "CLIENT_NO");
+            return client;
+        }
+
+        final List<Map<String, Object>> byMobileNo = jdbcTemplate.queryForList("""
+                SELECT id, account_no, display_name, mobile_no, office_id, status_enum
+                  FROM m_client WHERE mobile_no = ?
+                """, identifier);
+        if (!byMobileNo.isEmpty()) {
+            final Map<String, Object> client = new LinkedHashMap<>(byMobileNo.get(0));
+            client.put("matched_by", "MOBILE_NO");
+            return client;
+        }
+
+        throw new NotFoundException("No client found with client number or mobile number '" + identifier + "' in tenant '"
+                + tenant.getTenantIdentifier() + "' (" + tenant.getName() + "). If you expected a match, check the "
+                + "Fineract-Platform-TenantId header -- this identifier may belong to a different bank.");
+    }
+
+    private String resolveClientIp(final HttpServletRequest request) {
+        for (final String header : IP_HEADER_CANDIDATES) {
+            final String value = request.getHeader(header);
+            if (StringUtils.isNotBlank(value)) {
+                // X-Forwarded-For can carry a chain ("client, proxy1, proxy2") -- the first entry is
+                // the original caller, which is what an allowlist entry is written against.
+                return value.split(",")[0].trim();
+            }
+        }
+        return request.getRemoteAddr();
+    }
+
+    /**
+     * Maps one UNION leg row into a flat, display-ready shape -- category label, human status, and a
+     * single {@code currentValue} figure so the caller never has to know that a deposit's value lives
+     * in one column and a share account's lives in another (approved shares × unit price).
+     */
+    private static final class AccountRowMapper implements RowMapper<Map<String, Object>> {
+
+        @Override
+        public Map<String, Object> mapRow(final ResultSet rs, final int rowNum) throws SQLException {
+            final Integer depositType = JdbcSupport.getInteger(rs, "deposit_type");
+            final Integer statusEnum = JdbcSupport.getInteger(rs, "status_enum");
+            final BigDecimal balance = JdbcSupport.getBigDecimalDefaultToNullIfZero(rs, "balance");
+            final BigDecimal onHold = JdbcSupport.getBigDecimalDefaultToNullIfZero(rs, "on_hold");
+            final Long approvedShares = JdbcSupport.getLong(rs, "approved_shares");
+            final Long pendingShares = JdbcSupport.getLong(rs, "pending_shares");
+            final BigDecimal unitPrice = JdbcSupport.getBigDecimalDefaultToNullIfZero(rs, "unit_price");
+
+            final boolean isShare = depositType == null;
+            final String accountType = isShare ? "Share Account" : accountTypeFor(depositType);
+
+            final Map<String, Object> row = new LinkedHashMap<>();
+            row.put("accountType", accountType);
+            row.put("accountId", rs.getLong("account_id"));
+            row.put("accountNo", rs.getString("account_no"));
+            row.put("externalId", rs.getString("external_id"));
+            row.put("productId", rs.getLong("product_id"));
+            row.put("productName", rs.getString("product_name"));
+            row.put("shortProductName", rs.getString("short_product_name"));
+            row.put("currencyCode", rs.getString("currency_code"));
+            // .toString(), not the raw LocalDate: this Gson instance has no java.time adapter
+            // registered, so it falls back to reflecting LocalDate's private fields -- which the JVM
+            // module system blocks outright (java.base does not open java.time to reflection from an
+            // unnamed module), turning every response into a 500. A plain ISO-8601 string needs no
+            // adapter and is what every other date field in this API already returns.
+            row.put("submittedDate", toIsoDateString(JdbcSupport.getLocalDate(rs, "submitted_date")));
+            row.put("activatedDate", toIsoDateString(JdbcSupport.getLocalDate(rs, "activated_date")));
+
+            if (isShare) {
+                final ShareAccountStatusEnumData status = SharesEnumerations.status(statusEnum);
+                row.put("status", status);
+                row.put("approvedShares", approvedShares);
+                row.put("pendingShares", pendingShares);
+                row.put("unitPrice", unitPrice);
+                final BigDecimal shareValue = (approvedShares != null && unitPrice != null)
+                        ? unitPrice.multiply(BigDecimal.valueOf(approvedShares))
+                        : null;
+                row.put("currentValue", shareValue);
+            } else {
+                final SavingsAccountStatusEnumData status = SavingsEnumerations.status(statusEnum);
+                row.put("status", status);
+                row.put("balance", balance);
+                row.put("onHoldFunds", onHold);
+                BigDecimal available = balance;
+                if (available != null && onHold != null) {
+                    available = available.subtract(onHold);
+                }
+                row.put("availableBalance", available);
+                row.put("currentValue", balance);
+            }
+            return row;
+        }
+
+        private String accountTypeFor(final int depositType) {
+            return switch (depositType) {
+                case 100 -> "Savings Account";
+                case 200 -> "Fixed Deposit";
+                case 300 -> "Recurring Deposit";
+                case 400 -> "Current Account";
+                default -> "Other";
+            };
+        }
+
+        private String toIsoDateString(final LocalDate date) {
+            return date == null ? null : date.toString();
+        }
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientKycApiResource.java

@@ -160,10 +160,13 @@ public class ClientKycApiResource {
         template.put("clientTypeName", clientTypeName);
         template.put("legalFormId", legalFormId);
 
-        // Minor detection mirrors the frontend's own rule (age < 18) so the document list
-        // served here stays consistent with what the UI computes from the same date of birth.
+        // Minor detection mirrors the frontend's own rule so the document list served here stays
+        // consistent with what the UI computes from the same date of birth. Both sides read the
+        // threshold from a single named constant -- when they disagree, this endpoint wins and would
+        // silently serve an adult document list (mandatory PAN) to a minor.
         final LocalDate dateOfBirth = client.dateOfBirth();
-        final boolean isMinor = dateOfBirth != null && Period.between(dateOfBirth, LocalDate.now()).getYears() < 18;
+        final boolean isMinor = dateOfBirth != null
+                && Period.between(dateOfBirth, LocalDate.now()).getYears() < ClientApiConstants.MINOR_AGE_THRESHOLD;
         template.put("isMinor", isMinor);
 
         template.put("requiredDocuments", getRequiredDocuments(clientTypeName, legalFormId, isMinor));

fineract-provider/src/main/java/org/apache/fineract/portfolio/client/api/ClientKycExceptionsApiResource.java

@@ -70,4 +70,23 @@ public class ClientKycExceptionsApiResource {
         }
         return this.toApiJsonSerializer.serialize(exceptions);
     }
+
+    /**
+     * Customers whose periodic re-KYC has already fallen due.
+     *
+     * <p>
+     * Sits under the exceptions path because it is the same worklist to the branch — a customer the
+     * bank has to reach — and the outreach is recorded against the same contact log.
+     */
+    @GET
+    @Path("lapsed")
+    @Consumes({ MediaType.APPLICATION_JSON })
+    @Produces({ MediaType.APPLICATION_JSON })
+    @Operation(summary = "Retrieve lapsed KYC records", description = "Returns clients whose periodic re-KYC due date has passed, oldest first.")
+    public String retrieveLapsedKyc() {
+        this.context.authenticatedUser();
+        final List<ClientKycData> lapsed = this.readPlatformService.retrieveLapsedKyc();
+        LOG.info("retrieveLapsedKyc: fetched {} lapsed KYC record(s) from database", lapsed.size());
+        return this.toApiJsonSerializer.serialize(lapsed);
+    }
 }

fineract-provider/src/main/java/org/apache/fineract/portfolio/client/jobs/applykycexpiryrestrictions/ApplyKycExpiryRestrictionsConfig.java

@@ -0,0 +1,52 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.portfolio.client.jobs.applykycexpiryrestrictions;
+
+import org.apache.fineract.infrastructure.jobs.service.JobName;
+import org.springframework.batch.core.Job;
+import org.springframework.batch.core.Step;
+import org.springframework.batch.core.job.builder.JobBuilder;
+import org.springframework.batch.core.launch.support.RunIdIncrementer;
+import org.springframework.batch.core.repository.JobRepository;
+import org.springframework.batch.core.step.builder.StepBuilder;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.transaction.PlatformTransactionManager;
+
+@Configuration
+public class ApplyKycExpiryRestrictionsConfig {
+
+    @Autowired
+    private JobRepository jobRepository;
+    @Autowired
+    private PlatformTransactionManager transactionManager;
+
+    @Bean
+    protected Step applyKycExpiryRestrictionsStep(ApplyKycExpiryRestrictionsTasklet applyKycExpiryRestrictionsTasklet) {
+        return new StepBuilder(JobName.APPLY_KYC_EXPIRY_RESTRICTIONS.name(), jobRepository)
+                .tasklet(applyKycExpiryRestrictionsTasklet, transactionManager).build();
+    }
+
+    @Bean
+    public Job applyKycExpiryRestrictionsJob(ApplyKycExpiryRestrictionsTasklet applyKycExpiryRestrictionsTasklet) {
+        return new JobBuilder(JobName.APPLY_KYC_EXPIRY_RESTRICTIONS.name(), jobRepository)
+                .start(applyKycExpiryRestrictionsStep(applyKycExpiryRestrictionsTasklet)).incrementer(new RunIdIncrementer()).build();
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/portfolio/client/jobs/applykycexpiryrestrictions/ApplyKycExpiryRestrictionsTasklet.java

@@ -0,0 +1,46 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.portfolio.client.jobs.applykycexpiryrestrictions;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.fineract.portfolio.client.service.KycExpiryRestrictionService;
+import org.springframework.batch.core.StepContribution;
+import org.springframework.batch.core.scope.context.ChunkContext;
+import org.springframework.batch.core.step.tasklet.Tasklet;
+import org.springframework.batch.repeat.RepeatStatus;
+import org.springframework.stereotype.Component;
+
+/**
+ * Nightly pass over customers whose periodic re-KYC has lapsed, applying the restriction each one
+ * has reached and releasing those whose KYC has since been renewed.
+ */
+@Slf4j
+@RequiredArgsConstructor
+@Component
+public class ApplyKycExpiryRestrictionsTasklet implements Tasklet {
+
+    private final KycExpiryRestrictionService kycExpiryRestrictionService;
+
+    @Override
+    public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
+        kycExpiryRestrictionService.applyRestrictions();
+        return RepeatStatus.FINISHED;
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/portfolio/client/service/ClientKycReadPlatformService.java

@@ -35,4 +35,14 @@ public interface ClientKycReadPlatformService {
     java.util.List<ClientKycData> retrieveActiveKycExceptions();
 
     java.util.List<ClientKycData> retrieveResolvedKycExceptions();
+
+    /**
+     * KYC records whose periodic re-KYC due date has already passed, oldest first.
+     *
+     * <p>
+     * These are the customers the branch has to chase and, once the grace period runs out, the
+     * accounts the restriction ladder acts on. A record whose renewal is still ahead is not
+     * included: nothing is owed on it yet.
+     */
+    java.util.List<ClientKycData> retrieveLapsedKyc();
 }

fineract-provider/src/main/java/org/apache/fineract/portfolio/client/service/ClientKycReadPlatformServiceImpl.java

@@ -25,6 +25,7 @@ import org.apache.fineract.portfolio.client.data.ClientKycData;
 import org.apache.fineract.portfolio.client.domain.ClientKyc;
 import org.apache.fineract.portfolio.client.domain.ClientKycRepository;
 import org.apache.fineract.portfolio.client.domain.ClientKycRepositoryWrapper;
+import org.apache.fineract.infrastructure.core.service.DateUtils;
 import org.apache.fineract.portfolio.client.domain.ClientKycStatus;
 import org.apache.fineract.portfolio.client.domain.ClientKycType;
 import org.apache.fineract.portfolio.client.domain.KycRiskCategory;
@@ -159,4 +160,12 @@ public class ClientKycReadPlatformServiceImpl implements ClientKycReadPlatformSe
                 .map(this::toData)
                 .collect(java.util.stream.Collectors.toList());
     }
+
+    @Override
+    public java.util.List<ClientKycData> retrieveLapsedKyc() {
+        return this.kycRepository
+                .findLapsedAsOn(DateUtils.getBusinessLocalDate(), ClientKycStatus.REJECTED.getValue()).stream()
+                .map(this::toData)
+                .collect(java.util.stream.Collectors.toList());
+    }
 }

fineract-provider/src/main/java/org/apache/fineract/portfolio/client/service/KycExpiryRestrictionService.java

@@ -0,0 +1,49 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.portfolio.client.service;
+
+/**
+ * Applies and lifts the account restrictions that follow a lapsed periodic re-KYC.
+ */
+public interface KycExpiryRestrictionService {
+
+    /**
+     * Walks every lapsed KYC, applies the stage each one has reached, and releases customers whose
+     * KYC is current again.
+     *
+     * @return what the run did, for the job log
+     */
+    KycExpiryRunSummary applyRestrictions();
+
+    /**
+     * What one run of the ladder did.
+     *
+     * @param lapsed
+     *            KYC records past their due date
+     * @param inGrace
+     *            of those, the ones still inside the grace window with nothing restricted
+     * @param debitBlocked
+     *            customers whose debits are stopped
+     * @param fullyBlocked
+     *            customers whose accounts are inoperative
+     * @param released
+     *            accounts freed because the KYC was renewed
+     */
+    record KycExpiryRunSummary(int lapsed, int inGrace, int debitBlocked, int fullyBlocked, int released) {}
+}

fineract-provider/src/main/java/org/apache/fineract/portfolio/client/service/KycExpiryRestrictionServiceImpl.java

@@ -0,0 +1,134 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.portfolio.client.service;
+
+import java.time.LocalDate;
+import java.time.temporal.ChronoUnit;
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.fineract.infrastructure.core.service.DateUtils;
+import org.apache.fineract.portfolio.client.domain.ClientKyc;
+import org.apache.fineract.portfolio.client.domain.ClientKycRepository;
+import org.apache.fineract.portfolio.client.domain.ClientKycStatus;
+import org.apache.fineract.portfolio.client.domain.KycExpiryStage;
+import org.apache.fineract.portfolio.client.service.KycExpiryRestrictionService.KycExpiryRunSummary;
+import org.apache.fineract.portfolio.savings.domain.SavingsAccount;
+import org.apache.fineract.portfolio.savings.domain.SavingsAccountRepository;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * Applies the restriction ladder that follows a lapsed periodic re-KYC, and lifts it once the KYC
+ * is renewed.
+ *
+ * <p>
+ * The ladder is described on {@link KycExpiryStage}. In short: nothing happens for the grace period,
+ * then debits stop, then the account goes inoperative. Closure is never reached automatically.
+ *
+ * <p>
+ * Restrictions are derived from the expiry date on every run rather than remembered, so a KYC that
+ * is renewed simply stops being lapsed and its accounts are released on the next pass. That also
+ * makes the job safe to re-run: applying a stage that is already applied changes nothing.
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class KycExpiryRestrictionServiceImpl implements KycExpiryRestrictionService {
+
+    private final ClientKycRepository clientKycRepository;
+    private final SavingsAccountRepository savingsAccountRepository;
+
+    @Override
+    @Transactional
+    public KycExpiryRunSummary applyRestrictions() {
+        final LocalDate today = DateUtils.getBusinessLocalDate();
+        final List<ClientKyc> lapsed = clientKycRepository.findLapsedAsOn(today, ClientKycStatus.REJECTED.getValue());
+
+        int debitBlocked = 0;
+        int fullyBlocked = 0;
+        int inGrace = 0;
+
+        for (final ClientKyc kyc : lapsed) {
+            final long daysOverdue = ChronoUnit.DAYS.between(kyc.getExpiryDate(), today);
+            final KycExpiryStage stage = KycExpiryStage.fromDaysOverdue(daysOverdue);
+            if (stage == null || stage.isGrace()) {
+                // Inside the grace window nothing is restricted; the customer is only being chased.
+                inGrace++;
+                continue;
+            }
+
+            final Long clientId = kyc.getClient().getId();
+            final List<SavingsAccount> accounts = savingsAccountRepository.findSavingAccountByClientId(clientId);
+            boolean changedAny = false;
+
+            for (final SavingsAccount account : accounts) {
+                final boolean changed = stage.isInoperative() ? account.applyKycExpiryFullBlock() : account.applyKycExpiryDebitBlock();
+                if (changed) {
+                    savingsAccountRepository.save(account);
+                    changedAny = true;
+                }
+            }
+
+            if (stage.isInoperative()) {
+                fullyBlocked++;
+            } else {
+                debitBlocked++;
+            }
+
+            if (changedAny) {
+                log.info("Client {} re-KYC lapsed {} days ago — {} applied to their savings accounts", clientId, daysOverdue, stage);
+            }
+        }
+
+        final int released = releaseRenewed(today);
+        final KycExpiryRunSummary summary = new KycExpiryRunSummary(lapsed.size(), inGrace, debitBlocked, fullyBlocked, released);
+        log.info("KYC expiry restrictions applied: {}", summary);
+        return summary;
+    }
+
+    /**
+     * Lifts restrictions from customers whose KYC is current again.
+     *
+     * <p>
+     * Renewing a KYC pushes its expiry date into the future, so a renewed customer simply drops out
+     * of the lapsed set. Nothing records that this job was the one that blocked the account, so only
+     * the two states the ladder itself sets are cleared — see
+     * {@link SavingsAccount#releaseKycExpiryBlock()} — and a manual block is left untouched.
+     */
+    private int releaseRenewed(final LocalDate today) {
+        final List<ClientKyc> current = clientKycRepository.findAllByStatus(ClientKycStatus.VERIFIED.getValue());
+        int released = 0;
+
+        for (final ClientKyc kyc : current) {
+            if (kyc.getExpiryDate() == null || !kyc.getExpiryDate().isAfter(today)) {
+                continue;
+            }
+            for (final SavingsAccount account : savingsAccountRepository.findSavingAccountByClientId(kyc.getClient().getId())) {
+                if (account.releaseKycExpiryBlock()) {
+                    savingsAccountRepository.save(account);
+                    released++;
+                    log.info("Client {} re-KYC renewed to {} — restrictions lifted on savings account {}", kyc.getClient().getId(),
+                            kyc.getExpiryDate(), account.getId());
+                }
+            }
+        }
+        return released;
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/portfolio/ctsclearing/service/CtsClearingWritePlatformServiceImpl.java

@@ -225,7 +225,7 @@ public class CtsClearingWritePlatformServiceImpl implements CtsClearingWritePlat
                     controlGlId, suspenseGlId);
         } else {
             this.clearingJournalService.postJournalEntry(debit.officeId, debit.currencyCode, today, controlGlId, suspenseGlId, amount,
-                    "CTS inward clearing pass - item #" + itemId, item.getAccountId());
+                    "CTS inward clearing pass - item #" + itemId, item.getAccountId(), item.getAccountType());
         }
 
         markLeaf(item, true, "CTS cleared", null, userId);
@@ -738,7 +738,7 @@ public class CtsClearingWritePlatformServiceImpl implements CtsClearingWritePlat
             final SavingsAccount account = this.savingsAccountRepositoryWrapper.findOneWithNotFoundDetection(item.getAccountId());
             account.setHelpers(this.savingsAccountTransactionSummaryWrapper, this.savingsHelper);
             if (item.isHoldPlaced() && item.getHoldAmount() != null) {
-                account.releaseOnHoldAmount(item.getHoldAmount());
+                account.releaseOnHoldAmount(item.getHoldAmount(), SavingsAccount.HOLD_CATEGORY_CLEARING);
             }
             final Office office = account.office();
             final Money amountMoney = Money.of(account.getCurrency(), amount);
@@ -770,7 +770,7 @@ public class CtsClearingWritePlatformServiceImpl implements CtsClearingWritePlat
         }
         if (isSavings(item)) {
             final SavingsAccount account = this.savingsAccountRepositoryWrapper.findOneWithNotFoundDetection(item.getAccountId());
-            account.releaseOnHoldAmount(item.getHoldAmount());
+            account.releaseOnHoldAmount(item.getHoldAmount(), SavingsAccount.HOLD_CATEGORY_CLEARING);
             this.savingsAccountRepositoryWrapper.saveAndFlush(account);
         } else {
             final CurrentAccount account = this.currentAccountRepositoryWrapper.findOneWithNotFoundDetection(item.getAccountId());

fineract-provider/src/main/java/org/apache/fineract/portfolio/ctsclearing/service/InwardClearingValidationService.java

@@ -284,7 +284,10 @@ public class InwardClearingValidationService {
             if (account == null) {
                 return;
             }
-            account.holdAmount(amount);
+            // A presented-but-unsettled cheque is exactly what "Clearing Hold" means -- money in the
+            // clearing pipeline, not a staff-placed lien -- so it shares the bucket with a pending
+            // cheque/DD deposit rather than the generic manual Cash Hold.
+            account.holdAmount(amount, SavingsAccount.HOLD_CATEGORY_CLEARING);
             this.savingsAccountRepository.saveAndFlush(account);
         } else {
             final CurrentAccount account = this.currentAccountRepository.findById(item.getAccountId()).orElse(null);

fineract-provider/src/main/java/org/apache/fineract/portfolio/dividenddashboard/api/DividendClaimRequestApiResource.java

@@ -37,7 +37,6 @@ import jakarta.ws.rs.WebApplicationException;
 import jakarta.ws.rs.core.MediaType;
 import jakarta.ws.rs.core.Response;
 import java.math.BigDecimal;
-import java.math.RoundingMode;
 import java.sql.Timestamp;
 import java.time.Instant;
 import java.time.LocalDate;
@@ -45,6 +44,7 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.apache.fineract.commands.domain.CommandWrapper;
 import org.apache.fineract.commands.service.CommandWrapperBuilder;
 import org.apache.fineract.commands.service.PortfolioCommandSourceWritePlatformService;
@@ -52,90 +52,73 @@ import org.apache.fineract.infrastructure.core.data.CommandProcessingResult;
 import org.apache.fineract.infrastructure.core.serialization.FromJsonHelper;
 import org.apache.fineract.infrastructure.core.service.DateUtils;
 import org.apache.fineract.infrastructure.security.service.PlatformSecurityContext;
+import org.apache.fineract.portfolio.voucher.service.VoucherLine;
+import org.apache.fineract.portfolio.voucher.service.VoucherService;
 import org.apache.fineract.useradministration.domain.AppUser;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 
 /**
- * Maker-checker workflow for a member to claim an unclaimed dividend (see
- * {@code m_share_dividend_lock}, status {@code UNCLAIMED} -- a "Dividend Payable" GL liability
- * that was never credited into any savings account). A clerk (maker) records exactly how the
- * member wants it split when they visit the branch: straight into an overdue loan, credited to
- * their linked savings account, or handed over as cash -- any combination, any leftover amount
- * stays {@code UNCLAIMED} for a later visit. A Bank Manager (checker) approves it, which executes
- * the real disbursement, or rejects it, leaving the unclaimed liability untouched.
+ * Maker-checker workflow for a member to claim an unclaimed dividend (see {@code m_share_dividend_lock}, status
+ * {@code UNCLAIMED} -- a "Dividend Payable" GL liability that was never credited into any savings account). A clerk
+ * (maker) records the claim when the member visits the branch; a Bank Manager (checker) approves it, which draws the
+ * draft, or rejects it, leaving the unclaimed liability untouched. Any amount not claimed stays {@code UNCLAIMED} for a
+ * later visit, and is forfeited to profit if three years pass.
  *
  * <p>
- * Disbursement mechanics: a loan-apply or savings-credit leg goes through Fineract's own native
- * repayment/deposit command (so loan schedules and savings ledgers stay fully native and correct),
- * which debits whatever GL account is actually configured as that product's Fund Source -- not
- * necessarily Cash at Main Vault (e.g. a Loan-Against-Warehouse-Receipt product debits its own
- * "Warehouse Receipt" account instead). Since the money never actually came from that account,
- * that same DEBIT leg is rewritten in place to Dividend Payable (see
- * {@code redirectFundSourceDebitToDividendPayable}) rather than reversed with a second manual
- * entry pair, so the transaction ends up with exactly the entries a real accountant would expect
- * -- Dividend Payable debited, Loan Portfolio/Income or Savings credited, nothing else touched --
- * instead of that fund-source account confusingly appearing twice. The cash leg has no account to
- * post through, so approval
- * posts a direct manual entry (Dr Dividend Payable / Cr Cash at Main Vault) immediately -- but the
- * physical hand-over is deferred: the claim's {@code cash_status} becomes
- * {@code AWAITING_DISBURSEMENT} and the clerk-supplied token number ({@code tok_no}) must be
- * redeemed by a cashier at Transaction Entry (see {@code getByToken}/{@code disburse} below) before
- * the money is actually handed over, exactly mirroring {@code ClerkWithdrawalRequestApiResource}'s
- * submit/approve/disburse token flow for ordinary savings withdrawals.
+ * A dividend is collected as a Demand Draft, and only as a Demand Draft. The savings-credit, cash-at-counter and
+ * loan-set-off routes this workflow previously offered are retired: a draft leaves a numbered instrument the member
+ * holds and the branch can trace, where a savings credit disappeared into a running balance and cash left no
+ * counterfoil at all. Claims settled through the old routes remain readable — their columns are still populated on
+ * those historical rows — but new claims only ever write {@code dd_apply_amount}.
+ *
+ * <p>
+ * The draft is raised through the ordinary Sponsor DD flow, consuming a leaflet from inventory and carrying a real DD
+ * number, so it reconciles, stops and reprints like any other. What differs is the funding: a DD bought at the counter
+ * debits the purchaser, whereas this one is funded from the society's own Dividend Payable liability, because the
+ * member is being paid rather than buying anything. That is what {@code payment_method = 'DIVIDEND'} marks on the issue
+ * request, and why no charge or GST attaches to it.
  */
 @Path("/v1/clerk/dividend-claim-requests")
 @Component
-@Tag(name = "Dividend Claim Requests", description = "Maker-checker workflow for a member to claim an unclaimed dividend -- split between an overdue loan, savings credit, or cash.")
+@Tag(name = "Dividend Claim Requests", description = "Maker-checker workflow for a member to claim an unclaimed dividend, collected as a Demand Draft.")
 @RequiredArgsConstructor
+@Slf4j
 public class DividendClaimRequestApiResource {
 
     private final JdbcTemplate jdbcTemplate;
     private final FromJsonHelper fromJsonHelper;
     private final PlatformSecurityContext context;
     private final PortfolioCommandSourceWritePlatformService commandsSourceWritePlatformService;
+    private final VoucherService voucherService;
     private final Gson gson = new GsonBuilder().serializeNulls().setDateFormat("yyyy-MM-dd'T'HH:mm:ss").create();
 
     private static final int FINANCIAL_ACTIVITY_PAYABLE_DIVIDENDS = 201;
-    private static final int FINANCIAL_ACTIVITY_CASH_AT_MAINVAULT = 101;
+
+    /** A dividend payout, keyed by its m_share_dividend_claim_request id. */
+    private static final String REF_DIVIDEND_CLAIM = "DIVIDEND_CLAIM_REQUEST";
+    /** Dividend Paid — seeded by changelog 0481; see there for why it is a liability, not an expense. */
+    private static final int FINANCIAL_ACTIVITY_DIVIDEND_PAID = 202;
     private static final int JOURNAL_ENTRY_TYPE_DEBIT = 2;
+    private static final int JOURNAL_ENTRY_TYPE_CREDIT = 1;
+
+    /**
+     * Named as the purchaser on a dividend draft. The society bought the draft out of its own Dividend Payable, not the
+     * member — so the register shows who actually raised it rather than repeating the beneficiary's name in both
+     * columns, which would read as a counter sale to the member.
+     */
+    private static final String PURCHASER_SOCIETY_DIVIDEND = "THE SOCIETY (Dividend Payout)";
 
     private static final String[] LIST_COLUMNS = { "r.id", "r.lock_id", "r.client_id", "c.display_name AS client_name",
             "r.savings_account_id", "sav.account_no AS savings_account_no", "r.loan_id",
-            "(SELECT account_no FROM m_loan WHERE id = r.loan_id) AS loan_account_no", "r.loan_apply_amount",
-            "r.savings_apply_amount", "r.cash_apply_amount", "r.tok_no", "r.cash_status", "l.amount AS locked_amount",
-            "l.release_due_date", "r.status", "r.clerk_id", "r.clerk_name", "r.manager_id", "r.manager_name", "r.rejection_reason",
-            "r.submitted_at", "r.actioned_at" };
-
-    // ── GET /v1/clerk/dividend-claim-requests/overdue-loans/{clientId} ──────────
-
-    /** Lets the Claim panel show whether this client has an overdue loan to offer paying off. */
-    @GET
-    @Path("/overdue-loans/{clientId}")
-    @Produces(MediaType.APPLICATION_JSON)
-    public String overdueLoans(@PathParam("clientId") final Long clientId) {
-        final List<Map<String, Object>> loans = jdbcTemplate.queryForList("""
-                SELECT ln.id AS loan_id, ln.account_no,
-                       SUM(GREATEST(ri.principal_amount - COALESCE(ri.principal_completed_derived, 0)
-                                    - COALESCE(ri.principal_writtenoff_derived, 0), 0)
-                         + GREATEST(ri.interest_amount - COALESCE(ri.interest_completed_derived, 0)
-                                    - COALESCE(ri.interest_writtenoff_derived, 0) - COALESCE(ri.interest_waived_derived, 0), 0)) AS overdue_amount
-                FROM m_loan ln JOIN m_loan_repayment_schedule ri ON ri.loan_id = ln.id
-                WHERE ln.client_id = ? AND ln.loan_status_id = 300 AND ri.completed_derived = false AND ri.duedate < CURRENT_DATE
-                GROUP BY ln.id, ln.account_no
-                ORDER BY overdue_amount DESC
-                """, clientId);
-        final JsonArray result = new JsonArray();
-        for (final Map<String, Object> loan : loans) {
-            final JsonObject row = new JsonObject();
-            row.addProperty("loanId", ((Number) loan.get("loan_id")).longValue());
-            row.addProperty("accountNo", (String) loan.get("account_no"));
-            row.addProperty("overdueAmount", (BigDecimal) loan.get("overdue_amount"));
-            result.add(row);
-        }
-        return gson.toJson(result);
-    }
+            "(SELECT account_no FROM m_loan WHERE id = r.loan_id) AS loan_account_no", "r.loan_apply_amount", "r.savings_apply_amount",
+            "r.cash_apply_amount", "r.tok_no", "r.cash_status", "l.amount AS locked_amount", "l.release_due_date", "r.status", "r.clerk_id",
+            "r.clerk_name", "r.manager_id", "r.manager_name", "r.rejection_reason", "r.submitted_at", "r.actioned_at",
+            // The Demand Draft this claim is collected as — the only settlement route for new claims.
+            // loan/savings/cash columns above remain for claims settled before those routes were retired.
+            "r.dd_apply_amount", "r.dd_beneficiary_name", "r.dd_payable_at_branch", "r.dd_payable_at_city", "r.dd_issue_request_id",
+            "r.dd_number" };
 
     // ── POST /v1/clerk/dividend-claim-requests ── Clerk records the member's claim ──
 
@@ -147,18 +130,13 @@ public class DividendClaimRequestApiResource {
         final AppUser currentUser = context.authenticatedUser();
         final JsonElement root = fromJsonHelper.parse(body);
         final Long lockId = fromJsonHelper.extractLongNamed("lockId", root);
-        final Long loanId = fromJsonHelper.extractLongNamed("loanId", root);
-        final Long savingsAccountIdOverride = fromJsonHelper.extractLongNamed("savingsAccountId", root);
-        final BigDecimal loanApplyAmount = parseAmount(fromJsonHelper.extractStringNamed("loanApplyAmount", root));
-        final BigDecimal savingsApplyAmount = parseAmount(fromJsonHelper.extractStringNamed("savingsApplyAmount", root));
-        // Cash can only be handed over in whole-rupee notes/coins (no denomination below ₹1),
-        // while a dividend share often works out to paise -- floor to the nearest rupee (never
-        // trusting the frontend to have already done so) so the denomination breakdown the
-        // cashier counts at disburse time can always match exactly; any leftover paise is simply
-        // not claimed here and stays part of the lock's balance for a future claim.
-        final BigDecimal cashApplyAmount = parseAmount(fromJsonHelper.extractStringNamed("cashApplyAmount", root))
-                .setScale(0, RoundingMode.FLOOR);
-        final String tokNo = fromJsonHelper.extractStringNamed("tokNo", root);
+        final BigDecimal ddApplyAmount = parseAmount(fromJsonHelper.extractStringNamed("ddApplyAmount", root));
+        final String ddBeneficiaryName = trimToNull(fromJsonHelper.extractStringNamed("ddBeneficiaryName", root));
+        final String ddPayableAtBranch = trimToNull(fromJsonHelper.extractStringNamed("ddPayableAtBranch", root));
+        final String ddPayableAtCity = trimToNull(fromJsonHelper.extractStringNamed("ddPayableAtCity", root));
+        // Which physical leaflet the clerk took off the shelf. Optional: a caller that has not
+        // chosen one gets the oldest available instead.
+        final Long requestedLeafletId = fromJsonHelper.extractLongNamed("leafletId", root);
         if (lockId == null) {
             throw apiError(400, "lockId is required");
         }
@@ -171,53 +149,19 @@ public class DividendClaimRequestApiResource {
         }
         final Long clientId = ((Number) lock.get("client_id")).longValue();
         final BigDecimal unclaimedAmount = (BigDecimal) lock.get("amount");
-        final Object lockSavingsAccountId = lock.get("savings_account_id");
 
-        // The share account isn't required to have a linked savings account up front any more --
-        // if the member wants a savings credit and none is linked, the clerk supplies which
-        // account to credit right here.
-        Long resolvedSavingsAccountId = lockSavingsAccountId != null ? ((Number) lockSavingsAccountId).longValue()
-                : savingsAccountIdOverride;
-        if (savingsApplyAmount.compareTo(BigDecimal.ZERO) > 0) {
-            if (resolvedSavingsAccountId == null) {
-                throw apiError(400,
-                        "This share account has no linked savings account -- savingsAccountId is required when savingsApplyAmount is greater than zero");
-            }
-            final Long savingsClientId = jdbcTemplate.queryForObject("SELECT client_id FROM m_savings_account WHERE id = ?", Long.class,
-                    resolvedSavingsAccountId);
-            if (savingsClientId == null || !clientId.equals(savingsClientId)) {
-                throw apiError(400, "Savings account " + resolvedSavingsAccountId + " does not belong to this dividend's client");
-            }
+        if (ddApplyAmount.compareTo(BigDecimal.ZERO) <= 0) {
+            throw apiError(400, "ddApplyAmount is required and must be greater than zero");
         }
-
-        final BigDecimal total = loanApplyAmount.add(savingsApplyAmount).add(cashApplyAmount);
-        if (total.compareTo(BigDecimal.ZERO) <= 0) {
-            throw apiError(400, "Enter at least one of loanApplyAmount, savingsApplyAmount or cashApplyAmount, greater than zero");
+        if (ddApplyAmount.compareTo(unclaimedAmount) > 0) {
+            throw apiError(400,
+                    "Amount claimed (" + ddApplyAmount + ") cannot exceed the unclaimed dividend amount of " + unclaimedAmount);
         }
-        if (total.compareTo(unclaimedAmount) > 0) {
-            throw apiError(400, "Total claimed (" + total + ") cannot exceed the unclaimed dividend amount of " + unclaimedAmount);
+        if (ddBeneficiaryName == null) {
+            throw apiError(400, "ddBeneficiaryName is required — a Demand Draft cannot be drawn without a payee");
         }
-
-        if (loanApplyAmount.compareTo(BigDecimal.ZERO) > 0) {
-            if (loanId == null) {
-                throw apiError(400, "loanId is required when loanApplyAmount is greater than zero");
-            }
-            final Map<String, Object> loan = jdbcTemplate
-                    .queryForList("SELECT client_id, loan_status_id FROM m_loan WHERE id = ?", loanId).stream().findFirst()
-                    .orElseThrow(() -> apiError(404, "Loan not found: " + loanId));
-            if (!clientId.equals(((Number) loan.get("client_id")).longValue())) {
-                throw apiError(400, "Loan " + loanId + " does not belong to this dividend's client");
-            }
-            if (((Number) loan.get("loan_status_id")).intValue() != 300) {
-                throw apiError(400, "Loan " + loanId + " is not Active");
-            }
-        }
-
-        if (cashApplyAmount.compareTo(BigDecimal.ZERO) > 0) {
-            if (tokNo == null || tokNo.isBlank()) {
-                throw apiError(400, "Token number (TOK. NO.) is required when cashApplyAmount is greater than zero");
-            }
-            validateTokenUniqueToday(tokNo, null);
+        if (ddPayableAtBranch == null || ddPayableAtCity == null) {
+            throw apiError(400, "ddPayableAtBranch and ddPayableAtCity are both required to draw a Demand Draft");
         }
 
         final Long existingPending = jdbcTemplate.queryForObject(
@@ -226,40 +170,129 @@ public class DividendClaimRequestApiResource {
             throw apiError(409, "A claim request for this dividend is already pending review.");
         }
 
+        validateNotGuarantorOfOverdueLoan(clientId);
+
+        // The leaflet is taken now rather than at approval, so the DD number exists from the moment
+        // the claim is raised and the draft has a place in the queue that nothing else can take.
+        //
+        // The clerk chooses which one on the leaflets screen, and that choice is honoured: the draft
+        // has to be drawn on the physical form in their hand, or the number written on the
+        // counterfoil is not the number in the books. Locked so two concurrent claims cannot take the
+        // same leaflet; if it was taken in the meantime the clerk is told rather than being given a
+        // different draft than the one they are holding.
+        final Map<String, Object> leaflet = requestedLeafletId != null
+                ? jdbcTemplate
+                        .queryForList("SELECT id, dd_number FROM m_sponsor_dd_leaflet WHERE id = ? AND status = 'AVAILABLE' "
+                                + "FOR UPDATE SKIP LOCKED", requestedLeafletId)
+                        .stream().findFirst()
+                        .orElseThrow(() -> apiError(409, "That Demand Draft leaflet is no longer available — someone else has "
+                                + "just taken it. Go back and choose another leaflet."))
+                // No leaflet named (a caller that is not the leaflets screen): fall back to the
+                // oldest available, which is the order a series is meant to be consumed in.
+                : jdbcTemplate.queryForList("""
+                        SELECT id, dd_number FROM m_sponsor_dd_leaflet WHERE status = 'AVAILABLE'
+                        ORDER BY id LIMIT 1 FOR UPDATE SKIP LOCKED
+                        """).stream().findFirst().orElseThrow(() -> apiError(409,
+                        "No Demand Draft leaflets are available in inventory. Add stock before claiming a dividend by DD."));
+        final Long leafletId = ((Number) leaflet.get("id")).longValue();
+        final String ddNumber = (String) leaflet.get("dd_number");
+        final Long branchId = jdbcTemplate.queryForObject("SELECT id FROM m_office ORDER BY hierarchy LIMIT 1", Long.class);
+
+        // loan/savings/cash apply amounts are written as zero: those routes are retired, but the
+        // columns remain for claims settled through them historically.
         final Long newId = jdbcTemplate.queryForObject("""
                 INSERT INTO m_share_dividend_claim_request
-                    (lock_id, client_id, savings_account_id, requested_amount, loan_id, loan_apply_amount, savings_apply_amount,
-                     cash_apply_amount, status, clerk_id, clerk_name, submitted_at, tok_no)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'PENDING', ?, ?, ?, ?)
+                    (lock_id, client_id, requested_amount, loan_apply_amount, savings_apply_amount, cash_apply_amount,
+                     dd_apply_amount, dd_beneficiary_name, dd_payable_at_branch, dd_payable_at_city,
+                     status, clerk_id, clerk_name, submitted_at, dd_number)
+                VALUES (?, ?, ?, 0, 0, 0, ?, ?, ?, ?, 'PENDING', ?, ?, ?, ?)
                 RETURNING id
-                """, Long.class, lockId, clientId, resolvedSavingsAccountId, total, loanId, loanApplyAmount, savingsApplyAmount,
-                cashApplyAmount, currentUser.getId(), currentUser.getDisplayName(), Timestamp.from(Instant.now()),
-                cashApplyAmount.compareTo(BigDecimal.ZERO) > 0 ? tokNo : null);
+                """, Long.class, lockId, clientId, ddApplyAmount, ddApplyAmount, ddBeneficiaryName, ddPayableAtBranch, ddPayableAtCity,
+                currentUser.getId(), currentUser.getDisplayName(), Timestamp.from(Instant.now()), ddNumber);
 
-        return gson.toJson(Map.of("resourceId", newId, "status", "PENDING"));
+        // Raised as an ordinary PENDING issue request so the draft joins the DD Issuance Approvals
+        // queue with every other draft, rather than sitting in a second approvals screen of its own.
+        // payment_method 'DIVIDEND' is what tells that approval there is no purchaser to debit —
+        // the society already owes this money, so the draft is funded from Dividend Payable and the
+        // member pays nothing: no charge, no GST, which is why those columns are zero.
+        final Long issueRequestId = jdbcTemplate.queryForObject("""
+                INSERT INTO m_sponsor_dd_issue_request
+                    (leaflet_id, client_id, walkin_purchaser_name, beneficiary_name, payable_at_branch, payable_at_city,
+                     face_value, charges_amount, gst_amount, gst_percentage_applied, issuing_branch_id, issued_date,
+                     payment_method, status, maker_id, created_date)
+                VALUES (?, ?, ?, ?, ?, ?, ?, 0, 0, 0, ?, ?, 'DIVIDEND', 'PENDING', ?, ?)
+                RETURNING id
+                """, Long.class, leafletId, clientId, PURCHASER_SOCIETY_DIVIDEND, ddBeneficiaryName, ddPayableAtBranch, ddPayableAtCity,
+                ddApplyAmount, branchId, java.sql.Date.valueOf(DateUtils.getBusinessLocalDate()), currentUser.getId(),
+                Timestamp.from(Instant.now()));
+
+        jdbcTemplate.update("UPDATE m_share_dividend_claim_request SET dd_issue_request_id = ? WHERE id = ?", issueRequestId, newId);
+
+        return gson.toJson(Map.of("resourceId", newId, "status", "PENDING", "ddNumber", ddNumber, "ddIssueRequestId", issueRequestId));
     }
 
     /**
-     * Ensures the token number is unique for today's date across both this table and
-     * {@code m_clerk_withdrawal_request} -- cashiers type either kind of token into the same
-     * Transaction Entry field, so the two pools must never collide.
+     * Blocks a dividend claim while the member stands as guarantor on someone else's overdue loan.
+     *
+     * A guarantee is a promise to pay if the borrower does not, and the guarantor's share capital is the security
+     * behind it — the same capital this dividend was earned on. Paying the dividend out by draft while the guaranteed
+     * loan is in arrears hands over money the society may be about to demand back from the very same member, and once
+     * a draft is drawn there is nothing left to recover it from.
+     *
+     * Only OVERDUE guarantees block. A guarantee on a loan being repaid on time is a contingent obligation that has
+     * not crystallised, and withholding a dividend against it would penalise a member for a loan nobody has defaulted
+     * on. The block lifts on its own the moment the borrower clears the arrears.
+     *
+     * Deliberately not a silent hold: the clerk is told which loan, whose, and how much is overdue, so they can tell
+     * the member standing at the counter why — and so the member can go to the borrower about it.
      */
-    private void validateTokenUniqueToday(final String tokNo, final Long excludeId) {
-        final StringBuilder sql = new StringBuilder("SELECT COUNT(*) FROM m_share_dividend_claim_request "
-                + "WHERE tok_no = ? AND CAST(submitted_at AS DATE) = CURRENT_DATE AND status <> 'REJECTED'");
-        final List<Object> params = new ArrayList<>();
-        params.add(tokNo);
-        if (excludeId != null) {
-            sql.append(" AND id <> ?");
-            params.add(excludeId);
+    private void validateNotGuarantorOfOverdueLoan(final Long clientId) {
+        final List<Map<String, Object>> overdueGuarantees = jdbcTemplate.queryForList("""
+                SELECT l.account_no,
+                       COALESCE(b.display_name, '(unnamed borrower)') AS borrower_name,
+                       COALESCE(SUM(ri.principal_amount + ri.interest_amount
+                                    - COALESCE(ri.principal_completed_derived, 0)
+                                    - COALESCE(ri.interest_completed_derived, 0)), 0) AS overdue_amount
+                FROM m_guarantor g
+                JOIN m_loan l ON l.id = g.loan_id
+                LEFT JOIN m_client b ON b.id = l.client_id
+                JOIN m_loan_repayment_schedule ri ON ri.loan_id = l.id
+                WHERE g.entity_id = ?
+                  AND g.type_enum = 1
+                  AND g.is_active = true
+                  AND l.loan_status_id IN (300, 303, 304, 700)
+                  AND ri.completed_derived = false
+                  AND ri.duedate < CURRENT_DATE
+                GROUP BY l.account_no, b.display_name
+                HAVING COALESCE(SUM(ri.principal_amount + ri.interest_amount
+                                    - COALESCE(ri.principal_completed_derived, 0)
+                                    - COALESCE(ri.interest_completed_derived, 0)), 0) > 0
+                ORDER BY overdue_amount DESC
+                """, clientId);
+
+        if (overdueGuarantees.isEmpty()) {
+            return;
         }
-        final Long ownCount = jdbcTemplate.queryForObject(sql.toString(), Long.class, params.toArray());
-        final Long otherCount = jdbcTemplate.queryForObject("SELECT COUNT(*) FROM m_clerk_withdrawal_request "
-                + "WHERE tok_no = ? AND CAST(submitted_at AS DATE) = CURRENT_DATE AND status <> 'REJECTED'", Long.class, tokNo);
-        final long total = (ownCount == null ? 0 : ownCount) + (otherCount == null ? 0 : otherCount);
-        if (total > 0) {
-            throw apiError(400, "Token number '" + tokNo + "' is already used today. Please enter a different token number.");
+
+        final StringBuilder detail = new StringBuilder();
+        for (final Map<String, Object> guarantee : overdueGuarantees) {
+            if (detail.length() > 0) {
+                detail.append("; ");
+            }
+            detail.append("loan ").append(guarantee.get("account_no")).append(" (").append(guarantee.get("borrower_name"))
+                    .append(") overdue ").append(guarantee.get("overdue_amount"));
         }
+
+        throw apiError(409, "This member is an active guarantor on an overdue loan, so their dividend cannot be paid out yet: "
+                + detail + ". The dividend stays unclaimed until the arrears are cleared or the guarantee ends.");
+    }
+
+    private String trimToNull(final String value) {
+        if (value == null) {
+            return null;
+        }
+        final String trimmed = value.trim();
+        return trimmed.isEmpty() ? null : trimmed;
     }
 
     private BigDecimal parseAmount(final String value) {
@@ -317,373 +350,243 @@ public class DividendClaimRequestApiResource {
         if (!"PENDING".equals(record.get("status"))) {
             throw apiError(409, "Only PENDING claim requests can be approved. Current status: " + record.get("status"));
         }
+        // 409 rather than 403: the user has every right to approve dividend claims — just not this
+        // one, because they raised it. A 403 reads as "you lack permission", which sends the checker
+        // to an administrator to fix access that was never the problem.
         final Long makerId = ((Number) record.get("clerk_id")).longValue();
         if (makerId.equals(currentUser.getId())) {
-            throw apiError(403, "Maker-checker: you cannot approve a dividend claim you submitted yourself. Ask another manager.");
+            throw apiError(409, "You raised this dividend claim, so you cannot also approve it. Two different people must handle a "
+                    + "payout: one to raise it, another to check it. Ask a different manager to approve this claim.");
         }
 
         final Long lockId = ((Number) record.get("lock_id")).longValue();
         final Map<String, Object> lock = jdbcTemplate
-                .queryForList("SELECT currency_code, amount, status FROM m_share_dividend_lock WHERE id = ?", lockId).stream()
-                .findFirst().orElseThrow(() -> apiError(404, "Dividend lock not found: " + lockId));
+                .queryForList("SELECT currency_code, amount, status FROM m_share_dividend_lock WHERE id = ?", lockId).stream().findFirst()
+                .orElseThrow(() -> apiError(404, "Dividend lock not found: " + lockId));
         if (!"UNCLAIMED".equals(lock.get("status"))) {
             throw apiError(409, "This dividend is no longer UNCLAIMED (status: " + lock.get("status") + ")");
         }
 
+        // Re-checked at approval, not just at submission: a claim can sit pending for days, and a
+        // guaranteed loan can fall into arrears in that window. Approval is the point the draft is
+        // actually drawn, so it is the last moment the society can still hold the money back.
+        validateNotGuarantorOfOverdueLoan(((Number) record.get("client_id")).longValue());
+
         final String currencyCode = (String) lock.get("currency_code");
         final BigDecimal unclaimedAmount = (BigDecimal) lock.get("amount");
-        final BigDecimal loanApplyAmount = (BigDecimal) record.get("loan_apply_amount");
-        final BigDecimal savingsApplyAmount = (BigDecimal) record.get("savings_apply_amount");
-        final BigDecimal cashApplyAmount = (BigDecimal) record.get("cash_apply_amount");
-        final BigDecimal total = loanApplyAmount.add(savingsApplyAmount).add(cashApplyAmount);
-        if (total.compareTo(unclaimedAmount) > 0) {
+        final BigDecimal ddApplyAmount = (BigDecimal) record.get("dd_apply_amount");
+        if (ddApplyAmount == null || ddApplyAmount.compareTo(BigDecimal.ZERO) <= 0) {
+            throw apiError(409, "This claim has no Demand Draft amount recorded.");
+        }
+        if (ddApplyAmount.compareTo(unclaimedAmount) > 0) {
             throw apiError(409,
                     "The unclaimed amount has since reduced below what this claim requested -- reject this claim and resubmit.");
         }
-        final Object claimSavingsAccountId = record.get("savings_account_id");
-        if (savingsApplyAmount.compareTo(BigDecimal.ZERO) > 0 && claimSavingsAccountId == null) {
-            throw apiError(409, "No savings account was recorded on this claim for the savings-credit portion.");
-        }
 
         final LocalDate today = DateUtils.getBusinessLocalDate();
-        final String note = "Dividend claim #" + id + " (lock #" + lockId + ")";
+        final Map<String, Object> issuedDraft = issueDemandDraftFromDividendPayable(id, lockId, record, ddApplyAmount, currencyCode, today,
+                currentUser);
 
-        if (loanApplyAmount.compareTo(BigDecimal.ZERO) > 0) {
-            final Long loanId = ((Number) record.get("loan_id")).longValue();
-            final JsonObject payload = new JsonObject();
-            payload.addProperty("locale", "en");
-            payload.addProperty("dateFormat", "yyyy-MM-dd");
-            payload.addProperty("transactionDate", today.toString());
-            payload.addProperty("transactionAmount", loanApplyAmount);
-            payload.addProperty("note", note);
-            final CommandWrapper repaymentCommand = new CommandWrapperBuilder().loanRepaymentTransaction(loanId)
-                    .withJson(payload.toString()).build();
-            final CommandProcessingResult repaymentResult = commandsSourceWritePlatformService.logCommandSource(repaymentCommand);
-            redirectFundSourceDebitToDividendPayable(repaymentResult.getResourceId(), null);
-        }
-
-        if (savingsApplyAmount.compareTo(BigDecimal.ZERO) > 0) {
-            final JsonObject payload = new JsonObject();
-            payload.addProperty("locale", "en");
-            payload.addProperty("dateFormat", "yyyy-MM-dd");
-            payload.addProperty("transactionDate", today.toString());
-            payload.addProperty("transactionAmount", savingsApplyAmount);
-            payload.addProperty("note", note);
-            payload.addProperty("paymentTypeId", resolveDividendClaimPaymentTypeId());
-            final Long savingsAccountId = ((Number) claimSavingsAccountId).longValue();
-            final CommandWrapper depositCommand = new CommandWrapperBuilder().savingsAccountDeposit(savingsAccountId)
-                    .withJson(payload.toString()).build();
-            final CommandProcessingResult depositResult = commandsSourceWritePlatformService.logCommandSource(depositCommand);
-            redirectFundSourceDebitToDividendPayable(null, depositResult.getResourceId());
-        }
-
-        if (cashApplyAmount.compareTo(BigDecimal.ZERO) > 0) {
-            payCashFromDividendPayable(id, currencyCode, cashApplyAmount, today);
-        }
-
-        final BigDecimal remainder = unclaimedAmount.subtract(total);
+        final BigDecimal remainder = unclaimedAmount.subtract(ddApplyAmount);
         if (remainder.compareTo(BigDecimal.ZERO) > 0) {
-            jdbcTemplate.update("UPDATE m_share_dividend_lock SET amount = ?, last_modified_date = now() WHERE id = ?", remainder,
-                    lockId);
+            jdbcTemplate.update("UPDATE m_share_dividend_lock SET amount = ?, last_modified_date = now() WHERE id = ?", remainder, lockId);
         } else {
             jdbcTemplate.update("UPDATE m_share_dividend_lock SET status = 'CLAIMED', last_modified_date = now() WHERE id = ?", lockId);
         }
 
-        final String cashStatus = cashApplyAmount.compareTo(BigDecimal.ZERO) > 0 ? "AWAITING_DISBURSEMENT" : null;
         jdbcTemplate.update("""
                 UPDATE m_share_dividend_claim_request SET status = 'APPROVED', manager_id = ?, manager_name = ?, actioned_at = ?,
-                       cash_status = ?
+                       dd_issue_request_id = ?, dd_number = ?
                 WHERE id = ? AND status = 'PENDING'
-                """, currentUser.getId(), currentUser.getDisplayName(), Timestamp.from(Instant.now()), cashStatus, id);
+                """, currentUser.getId(), currentUser.getDisplayName(), Timestamp.from(Instant.now()),
+                issuedDraft.get("issueRequestId"), issuedDraft.get("ddNumber"), id);
 
         final JsonObject response = new JsonObject();
         response.addProperty("resourceId", id);
         response.addProperty("status", "APPROVED");
-        response.addProperty("totalDisbursed", total);
+        response.addProperty("totalDisbursed", ddApplyAmount);
         response.addProperty("remainingUnclaimed", remainder.max(BigDecimal.ZERO));
+        response.addProperty("ddNumber", (String) issuedDraft.get("ddNumber"));
+        response.addProperty("ddIssueRequestId", (Long) issuedDraft.get("issueRequestId"));
         return gson.toJson(response);
     }
 
-    // ── GET /v1/clerk/dividend-claim-requests/by-token/{token} ── Cashier token lookup ──
-
     /**
-     * Mirrors {@code ClerkWithdrawalRequestApiResource.getByToken} -- a cashier at Transaction
-     * Entry types the clerk-supplied token number here to resolve the approved cash amount before
-     * disbursing it, instead of the manager handing over cash directly at approval time.
+     * Draws the Demand Draft the member is collecting their dividend as, funded by the society's Dividend Payable
+     * liability rather than by anything the member pays in.
+     *
+     * A DD raised at the counter debits the purchaser — their savings account, or cash they hand over — because they
+     * are buying the instrument. Here the society already owes the money, so the draft is funded from Dividend Payable
+     * and the member pays nothing: no charge, no GST. That is what payment_method 'DIVIDEND' marks, and why those
+     * columns are written as zero.
+     *
+     * The leaflet is taken from inventory and marked ISSUED exactly as the normal flow does, so the draft carries a
+     * real DD number, appears in DD reconciliation, and can be stopped or reprinted like any other.
      */
-    @GET
-    @Path("/by-token/{token}")
-    @Produces(MediaType.APPLICATION_JSON)
-    public String getByToken(@PathParam("token") final String token) {
-        final List<Map<String, Object>> rows = jdbcTemplate.queryForList("""
-                SELECT r.id, r.client_id, c.display_name AS client_name, r.cash_apply_amount AS amount,
-                       r.tok_no, r.status, r.cash_status, r.submitted_at, r.actioned_at
-                FROM m_share_dividend_claim_request r
-                JOIN m_client c ON c.id = r.client_id
-                WHERE r.tok_no = ? AND CAST(r.submitted_at AS DATE) = CURRENT_DATE
-                ORDER BY r.submitted_at DESC LIMIT 1
-                """, token);
+    private Map<String, Object> issueDemandDraftFromDividendPayable(final Long claimId, final Long lockId,
+            final Map<String, Object> record, final BigDecimal amount, final String currencyCode, final LocalDate today,
+            final AppUser currentUser) {
 
-        if (rows.isEmpty()) {
-            throw apiError(404, "Token '" + token + "' not found for today. Please check the token number.");
-        }
+        // Oldest series first, and locked so two concurrent approvals cannot take the same leaflet.
+        final Map<String, Object> leaflet = jdbcTemplate.queryForList("""
+                SELECT id, dd_number FROM m_sponsor_dd_leaflet WHERE status = 'AVAILABLE'
+                ORDER BY id LIMIT 1 FOR UPDATE SKIP LOCKED
+                """).stream().findFirst()
+                .orElseThrow(() -> apiError(409, "No Demand Draft leaflets are available in inventory."));
+        final Long leafletId = ((Number) leaflet.get("id")).longValue();
+        final String ddNumber = (String) leaflet.get("dd_number");
 
-        final Map<String, Object> row = rows.get(0);
-        final String status = String.valueOf(row.get("status"));
-        final String cashStatus = row.get("cash_status") == null ? null : String.valueOf(row.get("cash_status"));
+        final Long clientId = ((Number) record.get("client_id")).longValue();
+        final Long branchId = jdbcTemplate.queryForObject("SELECT id FROM m_office ORDER BY hierarchy LIMIT 1", Long.class);
 
-        if ("PENDING".equals(status)) {
-            throw apiError(422, "Token '" + token + "' is still PENDING — manager has not approved this claim yet.");
-        }
-        if ("REJECTED".equals(status)) {
-            throw apiError(422, "Token '" + token + "' was REJECTED by the manager. This claim cannot be processed.");
-        }
-        if (!"APPROVED".equals(status)) {
-            throw apiError(422, "Token '" + token + "' has unexpected status: " + status);
-        }
-        if ("DISBURSED".equals(cashStatus)) {
-            throw apiError(422, "Token '" + token + "' has already been withdrawn. Cash was handed over by another cashier.");
-        }
-        if (!"AWAITING_DISBURSEMENT".equals(cashStatus)) {
-            throw apiError(422, "Token '" + token + "' has no cash portion awaiting disbursement.");
-        }
-        return gson.toJson(row);
-    }
+        // APPROVED outright: the manager approving this claim IS the check on it, and a second
+        // maker-checker round on the draft would leave a member's paid dividend in limbo.
+        // client_id still records WHOSE dividend this is — the entitlement belongs to them and the
+        // draft has to be traceable back to the member. walkin_purchaser_name names who actually
+        // raised it, which is the society, so the two roles stay distinguishable.
+        final Long issueRequestId = jdbcTemplate.queryForObject("""
+                INSERT INTO m_sponsor_dd_issue_request
+                    (leaflet_id, client_id, walkin_purchaser_name, beneficiary_name, payable_at_branch, payable_at_city,
+                     face_value, charges_amount, gst_amount, gst_percentage_applied, issuing_branch_id, issued_date,
+                     payment_method, status, maker_id, created_date, checker_id, checker_date)
+                VALUES (?, ?, ?, ?, ?, ?, ?, 0, 0, 0, ?, ?, 'DIVIDEND', 'APPROVED', ?, ?, ?, ?)
+                RETURNING id
+                """, Long.class, leafletId, clientId, PURCHASER_SOCIETY_DIVIDEND, record.get("dd_beneficiary_name"),
+                record.get("dd_payable_at_branch"), record.get("dd_payable_at_city"), amount, branchId, java.sql.Date.valueOf(today),
+                ((Number) record.get("clerk_id")).longValue(), Timestamp.from(Instant.now()), currentUser.getId(),
+                Timestamp.from(Instant.now()));
 
-    // ── POST /v1/clerk/dividend-claim-requests/{id}/disburse ── Cashier confirms cash hand-over ──
+        // The leaflet carries its own copy of the draft's details, and the DD register reads from
+        // there rather than from the issue request — so setting the status alone leaves the draft
+        // listed with every column blank. Mirrors what the ordinary issue flow writes.
+        //
+        // issued_to_client_id is deliberately left NULL and the purchaser named as the society
+        // instead. On an ordinary draft the client IS the purchaser — they walked in and bought it.
+        // Here the society is paying the member their own dividend, so recording the member as
+        // purchaser would read as though they had bought the draft, and the register would show the
+        // same name as both purchaser and beneficiary with nothing to distinguish a
+        // society-initiated draft from a counter sale.
+        jdbcTemplate.update("""
+                UPDATE m_sponsor_dd_leaflet
+                SET status = 'ISSUED', face_value = ?, issued_to_client_id = NULL,
+                    walkin_purchaser_name = ?, beneficiary_name = ?,
+                    payable_at_branch = ?, payable_at_city = ?, issuing_branch_id = ?, issued_date = ?,
+                    advice_status = 'NOT_SENT'
+                WHERE id = ?
+                """, amount, PURCHASER_SOCIETY_DIVIDEND, record.get("dd_beneficiary_name"), record.get("dd_payable_at_branch"),
+                record.get("dd_payable_at_city"), branchId, java.sql.Date.valueOf(today), leafletId);
 
-    /**
-     * Mirrors {@code ClerkWithdrawalRequestApiResource.disburse} -- the GL entry already posted at
-     * approve time, so this step is purely a physical-cash-handover record with double-disbursement
-     * protection ({@code WHERE cash_status = 'AWAITING_DISBURSEMENT'}), never a new transaction.
-     */
-    @POST
-    @Path("/{id}/disburse")
-    @Consumes(MediaType.APPLICATION_JSON)
-    @Produces(MediaType.APPLICATION_JSON)
-    @Transactional
-    public String disburse(@PathParam("id") final Long id, final String body) {
-        final AppUser currentUser = context.authenticatedUser();
-        final Map<String, Object> record = jdbcTemplate
-                .queryForList("SELECT id, lock_id, client_id, cash_apply_amount, cash_status FROM m_share_dividend_claim_request WHERE id = ?",
-                        id)
-                .stream().findFirst().orElseThrow(() -> new NotFoundException("Dividend claim request not found: " + id));
+        postDividendPayableToDdPayable(claimId, lockId, ddNumber, currencyCode, amount, today, currentUser);
 
-        final String cashStatus = record.get("cash_status") == null ? null : String.valueOf(record.get("cash_status"));
-        if (!"AWAITING_DISBURSEMENT".equals(cashStatus)) {
-            throw apiError(409, "Only claims AWAITING_DISBURSEMENT can be disbursed. Current cash status: " + cashStatus);
-        }
-
-        String denominationData = null;
-        BigDecimal transactionAmount = null;
-        if (body != null && !body.isBlank()) {
-            final JsonElement root = fromJsonHelper.parse(body);
-            denominationData = fromJsonHelper.extractStringNamed("denominationData", root);
-            transactionAmount = parseAmount(fromJsonHelper.extractStringNamed("transactionAmount", root));
-        }
-        if (transactionAmount == null || transactionAmount.compareTo(BigDecimal.ZERO) <= 0) {
-            throw apiError(400, "transactionAmount is required and must be greater than zero for disbursement.");
-        }
-
-        // cash_apply_amount is floored to whole rupees at submit time now (see submit() above),
-        // but a claim created before that fix may still carry paise -- floor here too so an older
-        // claim can still be disbursed in whole-rupee cash rather than being stuck forever.
-        final BigDecimal cashApplyAmount = (BigDecimal) record.get("cash_apply_amount");
-        final BigDecimal disbursableAmount = cashApplyAmount.setScale(0, RoundingMode.FLOOR);
-        if (disbursableAmount.compareTo(transactionAmount) != 0) {
-            throw apiError(400, "Transaction amount " + transactionAmount + " does not match the claim's disbursable cash amount of "
-                    + disbursableAmount + " (cash can only be handed over in whole rupees).");
-        }
-
-        final long denomTotal = denominationTotal(denominationData);
-        if (denomTotal > 0 && BigDecimal.valueOf(denomTotal).compareTo(transactionAmount) != 0) {
-            throw apiError(400,
-                    "Cash denomination total " + denomTotal + " does not match disbursement amount " + transactionAmount);
-        }
-
-        final int updated = jdbcTemplate.update("""
-                UPDATE m_share_dividend_claim_request SET
-                    cash_status = 'DISBURSED', cashier_id = ?, disbursed_by = ?, disbursement_denomination_data = ?, disbursed_at = ?
-                WHERE id = ? AND cash_status = 'AWAITING_DISBURSEMENT'
-                """, currentUser.getId(), currentUser.getDisplayName(), denominationData, Timestamp.from(Instant.now()), id);
-
-        if (updated == 0) {
-            throw apiError(409, "This dividend cash claim has already been withdrawn by another cashier. Double disbursement prevented.");
-        }
-
-        if (denominationData != null && !denominationData.isBlank()) {
-            final Long clientId = ((Number) record.get("client_id")).longValue();
-            final Long lockId = ((Number) record.get("lock_id")).longValue();
-            saveDisbursementDenomination(id, clientId, lockId, denominationData, currentUser);
-        }
-
-        return gson.toJson(Map.of("resourceId", id, "status", "DISBURSED"));
-    }
-
-    /** Sums a {"note:500": 2, "coin:1": 10} breakdown; 0 when absent or empty. */
-    private long denominationTotal(final String denominationData) {
-        if (denominationData == null || denominationData.isBlank()) {
-            return 0;
-        }
-        final JsonObject denomMap;
-        try {
-            denomMap = gson.fromJson(denominationData, JsonObject.class);
-        } catch (final Exception e) {
-            throw apiError(400, "denominationData is not valid JSON");
-        }
-        if (denomMap == null) {
-            return 0;
-        }
-        long total = 0;
-        for (final Map.Entry<String, JsonElement> entry : denomMap.entrySet()) {
-            final String[] parts = entry.getKey().split(":", 2);
-            if (parts.length != 2) {
-                continue;
-            }
-            final int value;
-            final int count;
-            try {
-                value = Integer.parseInt(parts[1]);
-                count = entry.getValue().getAsInt();
-            } catch (final Exception e) {
-                continue;
-            }
-            if (count > 0) {
-                total += (long) value * count;
-            }
-        }
-        return total;
+        final Map<String, Object> result = new java.util.LinkedHashMap<>();
+        result.put("issueRequestId", issueRequestId);
+        result.put("ddNumber", ddNumber);
+        return result;
     }
 
     /**
-     * Records the cashier's note/coin breakdown for a dividend cash disbursement into
-     * {@code m_savings_txn_denomination} for vault-position reporting. There is no native savings
-     * transaction backing this (the cash leg is a pure GL entry posted at approve time), so this
-     * claim request's own id is used as the stable txn identifier for grouping.
+     * Moves the member's entitlement from Dividend Payable to the DD liability: the society still owes the money, but
+     * now against a numbered instrument rather than an unclaimed dividend. Cleared when the draft is presented and
+     * paid, through the normal DD settlement.
+     *
+     * Skipped if the DD liability GL is not configured, rather than blocking the claim — same posture the declaration
+     * and forfeiture entries take, so a missing GL mapping never traps a member's dividend.
      */
-    private void saveDisbursementDenomination(final Long claimRequestId, final Long clientId, final Long lockId,
-            final String denominationData, final AppUser cashier) {
-        final JsonObject denomMap;
-        try {
-            denomMap = gson.fromJson(denominationData, JsonObject.class);
-        } catch (final Exception e) {
-            return;
-        }
-        if (denomMap == null || denomMap.size() == 0) {
-            return;
-        }
+    private void postDividendPayableToDdPayable(final Long claimId, final Long lockId, final String ddNumber, final String currencyCode,
+            final BigDecimal amount, final LocalDate today, final AppUser currentUser) {
 
-        for (final Map.Entry<String, JsonElement> entry : denomMap.entrySet()) {
-            final int count;
-            try {
-                count = entry.getValue().getAsInt();
-            } catch (final Exception e) {
-                continue;
-            }
-            if (count <= 0) {
-                continue;
-            }
-
-            final String[] parts = entry.getKey().split(":", 2);
-            if (parts.length != 2) {
-                continue;
-            }
-            final String kind = parts[0];
-            final int value;
-            try {
-                value = Integer.parseInt(parts[1]);
-            } catch (final Exception e) {
-                continue;
-            }
-
-            final List<Long> ids = jdbcTemplate.queryForList(
-                    "SELECT id FROM m_denomination_master WHERE denomination = ? AND kind = ? AND (deleted IS NULL OR deleted = false) LIMIT 1",
-                    Long.class, value, kind);
-            if (ids.isEmpty()) {
-                continue;
-            }
-            final Long denomId = ids.get(0);
-
-            jdbcTemplate.update("""
-                    INSERT INTO m_savings_txn_denomination
-                    (txn_id, savings_account_id, account_no, client_id, denomination_id,
-                     denomination_value, count, total_amount, txn_date, txn_type, officer_id, officer_username)
-                    VALUES (?, NULL, ?, ?, ?, ?, ?, ?, CURRENT_DATE, 'WITHDRAWAL', ?, ?)
-                    """, claimRequestId, "DIVIDEND-" + lockId, clientId, denomId, value, count,
-                    BigDecimal.valueOf((long) value * count), cashier.getId(), cashier.getUsername());
-        }
-    }
-
-    /**
-     * Fineract's savings deposit command mandates paymentTypeId even for an internal posting with
-     * no real customer payment instrument -- resolves the system-seeded "Dividend Claim
-     * Settlement" payment type (see migration 0464) rather than hardcoding a numeric id, which
-     * would break on any tenant seeded differently.
-     */
-    private Long resolveDividendClaimPaymentTypeId() {
-        final Long paymentTypeId = jdbcTemplate
-                .queryForList("SELECT id FROM m_payment_type WHERE code_name = 'DIVIDEND_CLAIM_SETTLEMENT'", Long.class).stream()
+        final Long payableDividendsAccountId = jdbcTemplate
+                .queryForList("SELECT gl_account_id FROM acc_gl_financial_activity_account WHERE financial_activity_type = ?", Long.class,
+                        FINANCIAL_ACTIVITY_PAYABLE_DIVIDENDS)
+                .stream().findFirst().orElse(null);
+        final Long dividendPaidAccountId = jdbcTemplate
+                .queryForList("SELECT gl_account_id FROM acc_gl_financial_activity_account WHERE financial_activity_type = ?", Long.class,
+                        FINANCIAL_ACTIVITY_DIVIDEND_PAID)
+                .stream().findFirst().orElse(null);
+        final Long ddPayableAccountId = jdbcTemplate
+                .queryForList("SELECT dd_payable_gl_account_id FROM m_sponsor_dd_gl_mapping ORDER BY id LIMIT 1", Long.class).stream()
                 .findFirst().orElse(null);
-        if (paymentTypeId == null) {
-            throw apiError(500, "Payment type 'DIVIDEND_CLAIM_SETTLEMENT' is not seeded -- run the latest database migrations.");
-        }
-        return paymentTypeId;
-    }
-
-    /**
-     * The loan repayment / savings deposit command just posted its own native GL entries assuming
-     * the money came out of whichever account is that product's actual Fund Source (not always
-     * literally "Cash at Main Vault" -- e.g. a Loan-Against-Warehouse-Receipt product debits its
-     * own "Warehouse Receipt" account instead) -- it didn't really. Rather than reverse that with
-     * a second manual entry pair (which would leave that fund-source account appearing twice, once
-     * debited then immediately credited back -- a confusing "wash" no real accountant would post),
-     * this rewrites that same DEBIT leg's account in place to Dividend Payable, so the transaction
-     * ends up with exactly the entries a real accountant would expect: Dividend Payable debited,
-     * Loan Portfolio/Income or Savings credited, nothing else touched. Skipped (loan/savings still
-     * updated) if the bank hasn't mapped the Dividend Payable financial activity. Exactly one of
-     * the two ids is non-null per call.
-     */
-    private void redirectFundSourceDebitToDividendPayable(final Long loanTransactionId, final Long savingsTransactionId) {
-        final Long payableDividendsAccountId = jdbcTemplate
-                .queryForList("SELECT gl_account_id FROM acc_gl_financial_activity_account WHERE financial_activity_type = ?", Long.class,
-                        FINANCIAL_ACTIVITY_PAYABLE_DIVIDENDS)
-                .stream().findFirst().orElse(null);
-        if (payableDividendsAccountId == null) {
-            return;
-        }
-        if (loanTransactionId != null) {
-            jdbcTemplate.update("UPDATE acc_gl_journal_entry SET account_id = ? WHERE loan_transaction_id = ? AND type_enum = ?",
-                    payableDividendsAccountId, loanTransactionId, JOURNAL_ENTRY_TYPE_DEBIT);
-        }
-        if (savingsTransactionId != null) {
-            jdbcTemplate.update("UPDATE acc_gl_journal_entry SET account_id = ? WHERE savings_transaction_id = ? AND type_enum = ?",
-                    payableDividendsAccountId, savingsTransactionId, JOURNAL_ENTRY_TYPE_DEBIT);
-        }
-    }
-
-    /**
-     * A straight cash handover has no account to post through, so Cash at Main Vault genuinely is
-     * correct here (unlike the loan/savings legs above) -- real cash leaves the vault into the
-     * member's hand.
-     */
-    private void payCashFromDividendPayable(final Long claimRequestId, final String currencyCode, final BigDecimal amount,
-            final LocalDate entryDate) {
-        final Long payableDividendsAccountId = jdbcTemplate
-                .queryForList("SELECT gl_account_id FROM acc_gl_financial_activity_account WHERE financial_activity_type = ?", Long.class,
-                        FINANCIAL_ACTIVITY_PAYABLE_DIVIDENDS)
-                .stream().findFirst().orElse(null);
-        final Long cashAtVaultAccountId = jdbcTemplate
-                .queryForList("SELECT gl_account_id FROM acc_gl_financial_activity_account WHERE financial_activity_type = ?", Long.class,
-                        FINANCIAL_ACTIVITY_CASH_AT_MAINVAULT)
-                .stream().findFirst().orElse(null);
-        if (payableDividendsAccountId == null || cashAtVaultAccountId == null) {
+        if (payableDividendsAccountId == null || ddPayableAccountId == null) {
             return;
         }
 
-        final AppUser currentUser = context.authenticatedUser();
-        final java.sql.Date sqlEntryDate = java.sql.Date.valueOf(entryDate);
-        final String transactionId = "DIVCLAIM" + claimRequestId + "-" + System.nanoTime();
-        final String description = "Dividend claim #" + claimRequestId + " disbursed";
+        final java.sql.Date entryDate = java.sql.Date.valueOf(today);
+        final String transactionId = "DIVDD" + claimId;
+        // Stamped with the financial year the dividend was DECLARED for, not the year it is being
+        // claimed in — a member can collect a 2026-27 dividend in 2028. Without it the ledger cannot
+        // say how much of each year's declaration has actually been claimed.
+        final String description = "FY " + financialYearOfLock(lockId) + " dividend paid by Demand Draft " + ddNumber + " — claim #"
+                + claimId + " (lock #" + lockId + ")";
+        if (dividendPaidAccountId == null) {
+            // Dividend Paid not mapped: post straight across, exactly as before this account existed.
+            // A society that has not configured it still gets a correct payout, just without the
+            // separate "how much has been claimed" measure.
+            postJournalEntryPair(payableDividendsAccountId, ddPayableAccountId, amount, currencyCode, transactionId, entryDate, description,
+                    currentUser);
+            raiseDividendVoucher(claimId, payableDividendsAccountId, ddPayableAccountId, amount, description, currentUser);
+            return;
+        }
+
+        // Routed through Dividend Paid rather than posted straight across, so the society can read
+        // off what has been claimed and what is still unclaimed as two separate balances instead of
+        // only the net of Dividend Payable.
+        //
+        // Two pairs, in the order the money moves, each with its own description — reading Dividend
+        // Paid's ledger has to show which line settled the member's entitlement and which raised the
+        // draft, and one shared description makes the two indistinguishable.
+        postJournalEntryPair(payableDividendsAccountId, dividendPaidAccountId, amount, currencyCode, transactionId, entryDate,
+                description + " (member's entitlement settled)", currentUser);
+        // The obligation does not end here: the society still owes the money until the draft is
+        // presented and paid, which is why this moves to Sponsor DD Payable rather than to cash.
+        // Dividend Paid nets to nil, leaving its credit total as the cumulative dividend claimed.
+        postJournalEntryPair(dividendPaidAccountId, ddPayableAccountId, amount, currencyCode, transactionId, entryDate,
+                description + " (draft raised)", currentUser);
+
+        // The voucher names the two accounts the payout actually moves between, not the three the
+        // ledger touches. Dividend Paid nets to nil across the pair above: it is there to measure
+        // how much has been claimed, and putting it on the slip would show the member a middle
+        // account that holds none of their money.
+        raiseDividendVoucher(claimId, payableDividendsAccountId, ddPayableAccountId, amount, description, currentUser);
+    }
+
+    /**
+     * Records the payout in the voucher register: Dividend Payable debited, the DD liability credited.
+     *
+     * A failure here does not fail the claim. The dividend is already posted and the draft already
+     * raised, and refusing an approved payout because its slip could not be written would hold back
+     * a member's money over paperwork. The claim stands, and the register shows a gap.
+     */
+    private void raiseDividendVoucher(final Long claimId, final Long debitGlId, final Long creditGlId, final BigDecimal amount,
+            final String description, final AppUser currentUser) {
+        try {
+            final Map<String, Object> debitGl = glAccountForVoucher(debitGlId);
+            final Map<String, Object> creditGl = glAccountForVoucher(creditGlId);
+
+            voucherService.createVoucherWithLines(VoucherService.TYPE_JOURNAL, REF_DIVIDEND_CLAIM, claimId, currentUser,
+                    VoucherService.PREFIX_DEBIT,
+                    List.of(VoucherLine.debitGl(debitGlId, (String) debitGl.get("name"), (String) debitGl.get("gl_code"), amount)
+                            .withDescription(description),
+                            VoucherLine.creditGl(creditGlId, (String) creditGl.get("name"), (String) creditGl.get("gl_code"), amount)
+                                    .withDescription(description)));
+        } catch (final RuntimeException e) {
+            log.error("Could not raise a voucher for dividend claim {}", claimId, e);
+        }
+    }
+
+    /** Name and code of a GL account, for printing on a voucher. Empty rather than absent if unmapped. */
+    private Map<String, Object> glAccountForVoucher(final Long glAccountId) {
+        return jdbcTemplate.queryForList("SELECT name, gl_code FROM acc_gl_account WHERE id = ?", glAccountId).stream().findFirst()
+                .orElse(Map.of());
+    }
+
+    /**
+     * Posts one balanced journal-entry pair — debit account first, then credit — so the entry ids follow the direction
+     * the money travelled and the ledger reads in order.
+     */
+    private void postJournalEntryPair(final Long debitAccountId, final Long creditAccountId, final BigDecimal amount,
+            final String currencyCode, final String transactionId, final java.sql.Date entryDate, final String description,
+            final AppUser currentUser) {
+
         final String insertSql = """
                 INSERT INTO acc_gl_journal_entry
                     (account_id, office_id, currency_code, transaction_id, reversed, manual_entry, entry_date, type_enum, amount,
@@ -691,13 +594,12 @@ public class DividendClaimRequestApiResource {
                      submitted_on_date, transaction_date)
                 VALUES (?, 1, ?, ?, false, true, ?, ?, ?, ?, ?, ?, now(), now(), now(), now(), ?, ?)
                 """;
-        this.jdbcTemplate.update(insertSql, payableDividendsAccountId, currencyCode, transactionId, sqlEntryDate, 2, amount, description,
-                currentUser.getId(), currentUser.getId(), sqlEntryDate, sqlEntryDate);
-        this.jdbcTemplate.update(insertSql, cashAtVaultAccountId, currencyCode, transactionId, sqlEntryDate, 1, amount, description,
-                currentUser.getId(), currentUser.getId(), sqlEntryDate, sqlEntryDate);
+        jdbcTemplate.update(insertSql, debitAccountId, currencyCode, transactionId, entryDate, JOURNAL_ENTRY_TYPE_DEBIT, amount,
+                description, currentUser.getId(), currentUser.getId(), entryDate, entryDate);
+        jdbcTemplate.update(insertSql, creditAccountId, currencyCode, transactionId, entryDate, JOURNAL_ENTRY_TYPE_CREDIT, amount,
+                description, currentUser.getId(), currentUser.getId(), entryDate, entryDate);
     }
 
-    // ── POST /v1/clerk/dividend-claim-requests/{id}/reject ── Manager rejects ───
 
     @POST
     @Path("/{id}/reject")
@@ -742,6 +644,7 @@ public class DividendClaimRequestApiResource {
     private Map<String, Object> loadRecord(final Long id) {
         final List<Map<String, Object>> rows = jdbcTemplate.queryForList("""
                 SELECT id, lock_id, client_id, savings_account_id, loan_id, loan_apply_amount, savings_apply_amount, cash_apply_amount,
+                       dd_apply_amount, dd_beneficiary_name, dd_payable_at_branch, dd_payable_at_city,
                        status, clerk_id, clerk_name
                 FROM m_share_dividend_claim_request WHERE id = ?
                 """, id);
@@ -751,6 +654,28 @@ public class DividendClaimRequestApiResource {
         return rows.get(0);
     }
 
+    /**
+     * The financial year of the declaration a lock came from — walking lock to per-member detail to declaration.
+     *
+     * Returns "unknown" rather than throwing if that chain is broken: a missing label must never stop a member being
+     * paid their dividend.
+     */
+    private String financialYearOfLock(final Long lockId) {
+        final List<Map<String, Object>> rows = jdbcTemplate.queryForList("""
+                SELECT d.dividend_period_end_date
+                FROM m_share_dividend_lock l
+                JOIN m_share_account_dividend_details sad ON sad.id = l.dividend_detail_id
+                JOIN m_share_product_dividend_pay_out d ON d.id = sad.dividend_pay_out_id
+                WHERE l.id = ?
+                """, lockId);
+        if (rows.isEmpty() || rows.get(0).get("dividend_period_end_date") == null) {
+            return "unknown";
+        }
+        final LocalDate periodEnd = LocalDate.parse(String.valueOf(rows.get(0).get("dividend_period_end_date")));
+        final int startYear = periodEnd.getMonthValue() >= 4 ? periodEnd.getYear() : periodEnd.getYear() - 1;
+        return startYear + "-" + String.format("%02d", (startYear + 1) % 100);
+    }
+
     private WebApplicationException apiError(final int httpStatus, final String message) {
         final JsonObject errorBody = new JsonObject();
         errorBody.addProperty("message", message);

fineract-provider/src/main/java/org/apache/fineract/portfolio/dividenddashboard/api/DividendDashboardApiResource.java

@@ -26,6 +26,7 @@ import com.google.gson.JsonObject;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.ws.rs.Consumes;
 import jakarta.ws.rs.GET;
+import jakarta.ws.rs.NotFoundException;
 import jakarta.ws.rs.POST;
 import jakarta.ws.rs.Path;
 import jakarta.ws.rs.PathParam;
@@ -51,11 +52,10 @@ import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 
 /**
- * Bank Manager's Dividend Dashboard: summary stats, every dividend ever declared and its payout
- * progress, full 3-year lock history, and members whose unclaimed dividend (see
- * {@code m_share_dividend_lock}) sits alongside an overdue loan installment so the manager can
- * proactively apply it towards that EMI instead of waiting for the member to claim it or for it
- * to be forfeited to profit after 3 years.
+ * Bank Manager's Dividend Dashboard: summary stats, every dividend ever declared and its payout progress, full 3-year
+ * lock history, and members whose unclaimed dividend (see {@code m_share_dividend_lock}) sits alongside an overdue loan
+ * installment so the manager can proactively apply it towards that EMI instead of waiting for the member to claim it or
+ * for it to be forfeited to profit after 3 years.
  */
 @Path("/v1/clerk/dividend-dashboard")
 @Component
@@ -112,8 +112,7 @@ public class DividendDashboardApiResource {
 
         final JsonObject result = new JsonObject();
         result.addProperty("totalDeclarations", ((Number) declarationStats.get("total_declarations")).longValue());
-        result.addProperty("pendingApprovalDeclarations",
-                ((Number) declarationStats.get("pending_approval_declarations")).longValue());
+        result.addProperty("pendingApprovalDeclarations", ((Number) declarationStats.get("pending_approval_declarations")).longValue());
         result.addProperty("approvedDeclarations", ((Number) declarationStats.get("approved_declarations")).longValue());
         result.addProperty("membersAffected", ((Number) detailStats.get("members_affected")).longValue());
         result.addProperty("totalMemberDividends", ((Number) detailStats.get("total_member_dividends")).longValue());
@@ -129,12 +128,70 @@ public class DividendDashboardApiResource {
         return gson.toJson(result);
     }
 
+    // ── GET /v1/clerk/dividend-dashboard/declaration/{id}/report-header ──────────
+
+    /**
+     * The heading of a Share Dividend Distribution Report: what rate the board resolved, what it came to, and when it
+     * was paid.
+     *
+     * The per-member breakdown screen already lists who gets what, but a distribution report is not just the list — it
+     * has to state the rate and the payment date, because that is what an AGM resolution and an auditor both ask for.
+     * Those two facts live on the declaration rather than on any member row, so they are fetched once here rather than
+     * repeated on every row of the member query.
+     *
+     * The rate is read as declared, never re-derived from amount over capital: a share movement back-dated into a
+     * closed period would silently change a rate the board actually resolved.
+     */
+    @GET
+    @Path("/declaration/{dividendId}/report-header")
+    @Produces(MediaType.APPLICATION_JSON)
+    public String declarationReportHeader(@PathParam("dividendId") final Long dividendId) {
+        final List<Map<String, Object>> rows = jdbcTemplate.queryForList("""
+                SELECT d.id, p.name AS product_name, d.amount, d.rate_percentage, d.status,
+                       d.dividend_period_start_date, d.dividend_period_end_date,
+                       d.created_date, d.lastmodified_date,
+                       COUNT(sad.id) FILTER (WHERE sad.amount > 0) AS paid_members,
+                       COUNT(sad.id) FILTER (WHERE sad.amount = 0) AS unpaid_members,
+                       COALESCE(SUM(sad.amount), 0) AS allocated_amount
+                FROM m_share_product_dividend_pay_out d
+                JOIN m_share_product p ON p.id = d.product_id
+                LEFT JOIN m_share_account_dividend_details sad ON sad.dividend_pay_out_id = d.id
+                WHERE d.id = ?
+                GROUP BY d.id, p.name
+                """, dividendId);
+        if (rows.isEmpty()) {
+            throw new NotFoundException("Dividend declaration not found: " + dividendId);
+        }
+        final Map<String, Object> row = rows.get(0);
+        final boolean approved = ((Number) row.get("status")).intValue() == DIVIDEND_PAYOUT_STATUS_APPROVED;
+
+        final JsonObject out = new JsonObject();
+        out.addProperty("dividendId", ((Number) row.get("id")).longValue());
+        out.addProperty("productName", (String) row.get("product_name"));
+        final Object periodEnd = row.get("dividend_period_end_date");
+        out.addProperty("periodStartDate", String.valueOf(row.get("dividend_period_start_date")));
+        out.addProperty("periodEndDate", String.valueOf(periodEnd));
+        out.addProperty("financialYear", financialYearOf(String.valueOf(periodEnd)));
+        out.addProperty("ratePercentage", (BigDecimal) row.get("rate_percentage"));
+        out.addProperty("declaredAmount", (BigDecimal) row.get("amount"));
+        out.addProperty("allocatedAmount", (BigDecimal) row.get("allocated_amount"));
+        out.addProperty("paidMembers", ((Number) row.get("paid_members")).longValue());
+        out.addProperty("unpaidMembers", ((Number) row.get("unpaid_members")).longValue());
+        out.addProperty("status", approved ? "APPROVED" : "PENDING_APPROVAL");
+        out.addProperty("declaredOn", row.get("created_date") == null ? null : String.valueOf(row.get("created_date")));
+        // The payment date IS the approval date: approval is what makes a member's entitlement
+        // claimable, so nothing is payable before it and it is the date the report must quote.
+        out.addProperty("paymentDate",
+                approved && row.get("lastmodified_date") != null ? String.valueOf(row.get("lastmodified_date")) : null);
+        return gson.toJson(out);
+    }
+
     // ── GET /v1/clerk/dividend-dashboard/declarations ────────────────────────────
 
     /**
-     * Every dividend ever declared (across every share product), so a manager tracking multiple
-     * dividends at once can see -- per declaration -- how many members it covers and how far its
-     * payout has actually progressed, not just whether it was approved.
+     * Every dividend ever declared (across every share product), so a manager tracking multiple dividends at once can
+     * see -- per declaration -- how many members it covers and how far its payout has actually progressed, not just
+     * whether it was approved.
      */
     @GET
     @Path("/declarations")
@@ -179,25 +236,116 @@ public class DividendDashboardApiResource {
     // ── GET /v1/clerk/dividend-dashboard/locks ───────────────────────────────────
 
     /**
-     * Full history of every 3-year dividend lock, regardless of status -- UNCLAIMED (still
-     * counting down), CLAIMED (a member claimed it, or a manager applied it to an overdue loan --
-     * see {@code applied_loan_id}) or FORFEITED (3 years passed unclaimed, swept to the bank's
-     * profit). Optional {@code status} query param filters to one.
+     * One member's dividend record across every financial year — what they were entitled to, what they collected, what
+     * they let lapse, and on which draft.
+     *
+     * The lock history answers "what is outstanding right now"; this answers "what has this member ever been paid",
+     * which is the question at the counter when someone asks about a dividend from years ago. Forfeited years are
+     * included deliberately: a member asking why they never received a dividend needs to be told it lapsed, not to be
+     * shown nothing.
+     *
+     * Searched by name or share account number, because a member at the counter has a passbook rather than a client id.
+     */
+    @GET
+    @Path("/member-history")
+    @Produces(MediaType.APPLICATION_JSON)
+    public String memberHistory(@QueryParam("search") final String search) {
+        final String term = search == null ? "" : search.trim();
+        if (term.length() < 2) {
+            return gson.toJson(new JsonArray());
+        }
+        final String like = "%" + term.toLowerCase() + "%";
+
+        final List<Map<String, Object>> rows = jdbcTemplate.queryForList("""
+                SELECT c.id AS client_id, c.display_name AS client_name, sha.account_no AS share_account_no,
+                       p.name AS product_name, d.dividend_period_start_date, d.dividend_period_end_date,
+                       sad.amount AS entitled_amount,
+                       l.id AS lock_id, l.status AS lock_status, l.amount AS lock_amount,
+                       l.locked_date, l.release_due_date, ln.account_no AS applied_loan_account_no,
+                       cr.status AS claim_status, cr.dd_number, cr.actioned_at
+                FROM m_share_account_dividend_details sad
+                JOIN m_share_account sha ON sha.id = sad.account_id
+                JOIN m_client c ON c.id = sha.client_id
+                JOIN m_share_product_dividend_pay_out d ON d.id = sad.dividend_pay_out_id
+                JOIN m_share_product p ON p.id = d.product_id
+                LEFT JOIN m_share_dividend_lock l ON l.dividend_detail_id = sad.id
+                LEFT JOIN m_loan ln ON ln.id = l.applied_loan_id
+                LEFT JOIN m_share_dividend_claim_request cr ON cr.lock_id = l.id AND cr.status IN ('PENDING', 'APPROVED')
+                WHERE sad.amount > 0
+                  AND (LOWER(c.display_name) LIKE ? OR LOWER(COALESCE(sha.account_no, '')) LIKE ?)
+                ORDER BY c.display_name, d.dividend_period_end_date DESC
+                """, like, like);
+
+        final JsonArray result = new JsonArray();
+        for (final Map<String, Object> row : rows) {
+            final JsonObject entry = new JsonObject();
+            entry.addProperty("clientId", ((Number) row.get("client_id")).longValue());
+            entry.addProperty("clientName", (String) row.get("client_name"));
+            entry.addProperty("shareAccountNo", (String) row.get("share_account_no"));
+            entry.addProperty("productName", (String) row.get("product_name"));
+            final Object periodEnd = row.get("dividend_period_end_date");
+            entry.addProperty("periodStartDate", String.valueOf(row.get("dividend_period_start_date")));
+            entry.addProperty("periodEndDate", String.valueOf(periodEnd));
+            entry.addProperty("financialYear", financialYearOf(String.valueOf(periodEnd)));
+            entry.addProperty("entitledAmount", (BigDecimal) row.get("entitled_amount"));
+            final Object lockId = row.get("lock_id");
+            entry.addProperty("lockId", lockId == null ? null : ((Number) lockId).longValue());
+            // No lock row at all means the entitlement was below the payable minimum and was swept
+            // with the rounding residue — never anybody's money to collect.
+            entry.addProperty("status", lockId == null ? "BELOW_MINIMUM" : (String) row.get("lock_status"));
+            entry.addProperty("amount", (BigDecimal) row.get("lock_amount"));
+            entry.addProperty("lockedDate", row.get("locked_date") == null ? null : String.valueOf(row.get("locked_date")));
+            entry.addProperty("releaseDueDate", row.get("release_due_date") == null ? null : String.valueOf(row.get("release_due_date")));
+            entry.addProperty("appliedLoanAccountNo", (String) row.get("applied_loan_account_no"));
+            entry.addProperty("claimStatus", (String) row.get("claim_status"));
+            entry.addProperty("ddNumber", (String) row.get("dd_number"));
+            entry.addProperty("claimedOn", row.get("actioned_at") == null ? null : String.valueOf(row.get("actioned_at")));
+            result.add(entry);
+        }
+        return gson.toJson(result);
+    }
+
+    /**
+     * Full history of every 3-year dividend lock, regardless of status -- UNCLAIMED (still counting down), CLAIMED (a
+     * member claimed it, or a manager applied it to an overdue loan -- see {@code applied_loan_id}) or FORFEITED (3
+     * years passed unclaimed, swept to the bank's profit). Optional {@code status} query param filters to one.
      */
     @GET
     @Path("/locks")
     @Produces(MediaType.APPLICATION_JSON)
     public String locks(@QueryParam("status") final String status) {
         final boolean filterByStatus = status != null && !status.isBlank() && !"ALL".equalsIgnoreCase(status);
+        // Which declaration each lock came from. Once a member has more than one unclaimed dividend —
+        // this year's plus a prior year they never collected — amount and locked date alone cannot
+        // tell them apart, so the clerk has no way to say which year is being paid out. The join
+        // walks lock -> per-member detail -> declaration -> product to name the period and product.
         final String sql = "SELECT l.id AS lock_id, l.client_id, c.display_name AS client_name, l.savings_account_id, "
                 + "sav.account_no AS savings_account_no, l.amount, l.locked_date, l.release_due_date, l.status, "
-                + "l.applied_loan_id, ln.account_no AS applied_loan_account_no " //
+                + "l.applied_loan_id, ln.account_no AS applied_loan_account_no, "
+                + "d.id AS declaration_id, d.dividend_period_start_date, d.dividend_period_end_date, p.name AS product_name, " //
+                // The share account the dividend was earned on. A clerk searching for a member at the
+                // counter has the passbook in front of them, which carries the account number and not
+                // the display name as the system spells it — so the number has to be searchable too.
+                + "sha.account_no AS share_account_no, " //
+                // The draft this dividend is being paid out as, and how far along it is. Once a claim
+                // exists the clerk needs the DD number rather than another Claim button — it is what
+                // goes on the counterfoil and what the member asks about when they come back.
+                + "cr.status AS claim_status, cr.dd_number AS claim_dd_number " //
                 + "FROM m_share_dividend_lock l " //
                 + "JOIN m_client c ON c.id = l.client_id " //
                 + "LEFT JOIN m_savings_account sav ON sav.id = l.savings_account_id " //
                 + "LEFT JOIN m_loan ln ON ln.id = l.applied_loan_id " //
+                + "LEFT JOIN m_share_account_dividend_details sad ON sad.id = l.dividend_detail_id " //
+                + "LEFT JOIN m_share_account sha ON sha.id = sad.account_id " //
+                + "LEFT JOIN m_share_product_dividend_pay_out d ON d.id = sad.dividend_pay_out_id " //
+                + "LEFT JOIN m_share_product p ON p.id = d.product_id " //
+                // The live claim only: a rejected one leaves the dividend claimable again, so it must
+                // not keep showing a DD number the member will never receive.
+                + "LEFT JOIN m_share_dividend_claim_request cr ON cr.lock_id = l.id AND cr.status IN ('PENDING', 'APPROVED') " //
                 + (filterByStatus ? "WHERE l.status = ? " : "") //
-                + "ORDER BY l.locked_date DESC";
+                // Oldest unclaimed first: a lock nearing its three-year forfeiture is the one that
+                // needs attention, and it is the one a member should be paid out of first.
+                + "ORDER BY d.dividend_period_end_date DESC NULLS LAST, l.locked_date DESC";
         final List<Map<String, Object>> rows = filterByStatus ? jdbcTemplate.queryForList(sql, status.toUpperCase())
                 : jdbcTemplate.queryForList(sql);
 
@@ -207,6 +355,9 @@ public class DividendDashboardApiResource {
             entry.addProperty("lockId", ((Number) row.get("lock_id")).longValue());
             entry.addProperty("clientId", ((Number) row.get("client_id")).longValue());
             entry.addProperty("clientName", (String) row.get("client_name"));
+            entry.addProperty("shareAccountNo", (String) row.get("share_account_no"));
+            entry.addProperty("claimStatus", (String) row.get("claim_status"));
+            entry.addProperty("claimDdNumber", (String) row.get("claim_dd_number"));
             final Object savingsAccountId = row.get("savings_account_id");
             entry.addProperty("savingsAccountId", savingsAccountId == null ? null : ((Number) savingsAccountId).longValue());
             entry.addProperty("savingsAccountNo", (String) row.get("savings_account_no"));
@@ -217,6 +368,17 @@ public class DividendDashboardApiResource {
             final Object appliedLoanId = row.get("applied_loan_id");
             entry.addProperty("appliedLoanId", appliedLoanId == null ? null : ((Number) appliedLoanId).longValue());
             entry.addProperty("appliedLoanAccountNo", (String) row.get("applied_loan_account_no"));
+            final Object declarationId = row.get("declaration_id");
+            entry.addProperty("declarationId", declarationId == null ? null : ((Number) declarationId).longValue());
+            entry.addProperty("productName", (String) row.get("product_name"));
+            final Object periodStart = row.get("dividend_period_start_date");
+            final Object periodEnd = row.get("dividend_period_end_date");
+            entry.addProperty("periodStartDate", periodStart == null ? null : periodStart.toString());
+            entry.addProperty("periodEndDate", periodEnd == null ? null : periodEnd.toString());
+            // The financial year the dividend was earned in, taken from the period end so a
+            // declaration is labelled by the year it closes — "FY 2026-27", the way a member and an
+            // auditor both refer to it.
+            entry.addProperty("financialYear", periodEnd == null ? null : financialYearOf(periodEnd.toString()));
             result.add(entry);
         }
         return gson.toJson(result);
@@ -229,9 +391,14 @@ public class DividendDashboardApiResource {
     public String list() {
         final List<Map<String, Object>> locks = jdbcTemplate.queryForList("""
                 SELECT l.id AS lock_id, l.client_id, c.display_name AS client_name, l.savings_account_id, l.amount AS locked_amount,
-                       l.locked_date, l.release_due_date
+                       l.locked_date, l.release_due_date,
+                       -- The share account the dividend was earned on, so a clerk holding the
+                       -- member's passbook can find the row by its number rather than by name.
+                       sha.account_no AS share_account_no
                 FROM m_share_dividend_lock l
                 JOIN m_client c ON c.id = l.client_id
+                LEFT JOIN m_share_account_dividend_details sad ON sad.id = l.dividend_detail_id
+                LEFT JOIN m_share_account sha ON sha.id = sad.account_id
                 WHERE l.status = 'UNCLAIMED'
                   AND EXISTS (
                       SELECT 1 FROM m_loan ln JOIN m_loan_repayment_schedule ri ON ri.loan_id = ln.id
@@ -248,6 +415,7 @@ public class DividendDashboardApiResource {
             row.addProperty("lockId", ((Number) lock.get("lock_id")).longValue());
             row.addProperty("clientId", clientId);
             row.addProperty("clientName", (String) lock.get("client_name"));
+            row.addProperty("shareAccountNo", (String) lock.get("share_account_no"));
             final Object savingsAccountId = lock.get("savings_account_id");
             row.addProperty("savingsAccountId", savingsAccountId == null ? null : ((Number) savingsAccountId).longValue());
             row.addProperty("lockedAmount", (BigDecimal) lock.get("locked_amount"));
@@ -260,17 +428,19 @@ public class DividendDashboardApiResource {
     }
 
     private JsonArray overdueLoansFor(final Long clientId) {
-        final List<Map<String, Object>> loans = jdbcTemplate.queryForList("""
-                SELECT ln.id AS loan_id, ln.account_no,
-                       SUM(GREATEST(ri.principal_amount - COALESCE(ri.principal_completed_derived, 0)
-                                    - COALESCE(ri.principal_writtenoff_derived, 0), 0)
-                         + GREATEST(ri.interest_amount - COALESCE(ri.interest_completed_derived, 0)
-                                    - COALESCE(ri.interest_writtenoff_derived, 0) - COALESCE(ri.interest_waived_derived, 0), 0)) AS overdue_amount
-                FROM m_loan ln JOIN m_loan_repayment_schedule ri ON ri.loan_id = ln.id
-                WHERE ln.client_id = ? AND ln.loan_status_id = 300 AND ri.completed_derived = false AND ri.duedate < CURRENT_DATE
-                GROUP BY ln.id, ln.account_no
-                ORDER BY overdue_amount DESC
-                """, clientId);
+        final List<Map<String, Object>> loans = jdbcTemplate.queryForList(
+                """
+                        SELECT ln.id AS loan_id, ln.account_no,
+                               SUM(GREATEST(ri.principal_amount - COALESCE(ri.principal_completed_derived, 0)
+                                            - COALESCE(ri.principal_writtenoff_derived, 0), 0)
+                                 + GREATEST(ri.interest_amount - COALESCE(ri.interest_completed_derived, 0)
+                                            - COALESCE(ri.interest_writtenoff_derived, 0) - COALESCE(ri.interest_waived_derived, 0), 0)) AS overdue_amount
+                        FROM m_loan ln JOIN m_loan_repayment_schedule ri ON ri.loan_id = ln.id
+                        WHERE ln.client_id = ? AND ln.loan_status_id = 300 AND ri.completed_derived = false AND ri.duedate < CURRENT_DATE
+                        GROUP BY ln.id, ln.account_no
+                        ORDER BY overdue_amount DESC
+                        """,
+                clientId);
         final JsonArray result = new JsonArray();
         for (final Map<String, Object> loan : loans) {
             final JsonObject row = new JsonObject();
@@ -285,14 +455,13 @@ public class DividendDashboardApiResource {
     // ── POST /v1/clerk/dividend-dashboard/{lockId}/apply-to-loan ────────────────
 
     /**
-     * Proactive recovery: a manager notices a member with an unclaimed dividend AND an overdue
-     * loan EMI (see {@code list()} above) and applies it without waiting for the member to visit
-     * and file a claim. Since the dividend was never credited into any savings account (it's a
-     * pure "Dividend Payable" GL liability until claimed -- see
-     * {@code DividendClaimRequestApiResource}), there's no hold to release or account-transfer to
-     * make: this posts a native loan repayment (so the loan's own schedule/state stays fully
-     * native and correct) and then redirects the debit leg it assumed the cash came from to the
-     * Dividend Payable liability instead -- identical mechanic to a claim's loan leg.
+     * Proactive recovery: a manager notices a member with an unclaimed dividend AND an overdue loan EMI (see
+     * {@code list()} above) and applies it without waiting for the member to visit and file a claim. Since the dividend
+     * was never credited into any savings account (it's a pure "Dividend Payable" GL liability until claimed -- see
+     * {@code DividendClaimRequestApiResource}), there's no hold to release or account-transfer to make: this posts a
+     * native loan repayment (so the loan's own schedule/state stays fully native and correct) and then redirects the
+     * debit leg it assumed the cash came from to the Dividend Payable liability instead -- identical mechanic to a
+     * claim's loan leg.
      */
     @POST
     @Path("/{lockId}/apply-to-loan")
@@ -341,15 +510,14 @@ public class DividendDashboardApiResource {
         payload.addProperty("transactionDate", today.toString());
         payload.addProperty("transactionAmount", applyAmount);
         payload.addProperty("note", "Unclaimed share dividend applied to overdue loan EMI (lock #" + lockId + ")");
-        final CommandWrapper repaymentCommand = new CommandWrapperBuilder().loanRepaymentTransaction(loanId)
-                .withJson(payload.toString()).build();
+        final CommandWrapper repaymentCommand = new CommandWrapperBuilder().loanRepaymentTransaction(loanId).withJson(payload.toString())
+                .build();
         final CommandProcessingResult repaymentResult = commandsSourceWritePlatformService.logCommandSource(repaymentCommand);
         redirectFundSourceDebitToDividendPayable(repaymentResult.getResourceId());
 
         final BigDecimal remainder = unclaimedAmount.subtract(applyAmount);
         if (remainder.compareTo(BigDecimal.ZERO) > 0) {
-            jdbcTemplate.update("UPDATE m_share_dividend_lock SET amount = ?, last_modified_date = now() WHERE id = ?", remainder,
-                    lockId);
+            jdbcTemplate.update("UPDATE m_share_dividend_lock SET amount = ?, last_modified_date = now() WHERE id = ?", remainder, lockId);
         } else {
             jdbcTemplate.update("""
                     UPDATE m_share_dividend_lock
@@ -366,16 +534,14 @@ public class DividendDashboardApiResource {
     }
 
     /**
-     * The loan repayment just posted above assumed the money came out of whichever account is
-     * this loan product's actual Fund Source (not always literally "Cash at Main Vault" -- e.g. a
-     * Loan-Against-Warehouse-Receipt product debits its own "Warehouse Receipt" account instead)
-     * -- it didn't really. Rather than reverse that with a second manual entry pair (which would
-     * leave that fund-source account appearing twice, once debited then immediately credited back
-     * -- a confusing "wash" no real accountant would post), this rewrites that same DEBIT leg's
-     * account in place to Dividend Payable, so the transaction ends up with exactly the entries a
-     * real accountant would expect: Dividend Payable debited, Loan Portfolio/Income credited,
-     * nothing else touched. Skipped (loan still updated) if the bank hasn't mapped the Dividend
-     * Payable financial activity.
+     * The loan repayment just posted above assumed the money came out of whichever account is this loan product's
+     * actual Fund Source (not always literally "Cash at Main Vault" -- e.g. a Loan-Against-Warehouse-Receipt product
+     * debits its own "Warehouse Receipt" account instead) -- it didn't really. Rather than reverse that with a second
+     * manual entry pair (which would leave that fund-source account appearing twice, once debited then immediately
+     * credited back -- a confusing "wash" no real accountant would post), this rewrites that same DEBIT leg's account
+     * in place to Dividend Payable, so the transaction ends up with exactly the entries a real accountant would expect:
+     * Dividend Payable debited, Loan Portfolio/Income credited, nothing else touched. Skipped (loan still updated) if
+     * the bank hasn't mapped the Dividend Payable financial activity.
      */
     private void redirectFundSourceDebitToDividendPayable(final Long loanTransactionId) {
         final Long payableDividendsAccountId = jdbcTemplate
@@ -389,6 +555,16 @@ public class DividendDashboardApiResource {
                 payableDividendsAccountId, loanTransactionId, JOURNAL_ENTRY_TYPE_DEBIT);
     }
 
+    /**
+     * The Indian financial year an ISO date falls in, as "2026-27". April starts the year, so a declaration ending
+     * 31 March 2027 is FY 2026-27 — the label a member and an auditor would both use for it.
+     */
+    private String financialYearOf(final String isoDate) {
+        final LocalDate date = LocalDate.parse(isoDate);
+        final int startYear = date.getMonthValue() >= 4 ? date.getYear() : date.getYear() - 1;
+        return startYear + "-" + String.format("%02d", (startYear + 1) % 100);
+    }
+
     private WebApplicationException apiError(final int httpStatus, final String message) {
         final JsonObject errorBody = new JsonObject();
         errorBody.addProperty("message", message);

fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/service/LoanWritePlatformServiceJpaRepositoryImpl.java

@@ -217,6 +217,8 @@ import org.apache.fineract.portfolio.note.domain.Note;
 import org.apache.fineract.portfolio.note.domain.NoteRepository;
 import org.apache.fineract.portfolio.paymentdetail.domain.PaymentDetail;
 import org.apache.fineract.portfolio.paymentdetail.service.PaymentDetailWritePlatformService;
+import org.apache.fineract.portfolio.voucher.service.VoucherLine;
+import org.apache.fineract.portfolio.voucher.service.VoucherService;
 import org.apache.fineract.portfolio.repaymentwithpostdatedchecks.domain.PostDatedChecks;
 import org.apache.fineract.portfolio.repaymentwithpostdatedchecks.domain.PostDatedChecksRepository;
 import org.apache.fineract.portfolio.repaymentwithpostdatedchecks.service.RepaymentWithPostDatedChecksAssembler;
@@ -232,6 +234,7 @@ import org.springframework.transaction.annotation.Transactional;
 public class LoanWritePlatformServiceJpaRepositoryImpl implements LoanWritePlatformService {
 
     private final PlatformSecurityContext context;
+    private final VoucherService voucherService;
     private final LoanTransactionValidator loanTransactionValidator;
     private final LoanUpdateCommandFromApiJsonDeserializer loanUpdateCommandFromApiJsonDeserializer;
     private final LoanRepositoryWrapper loanRepositoryWrapper;
@@ -521,6 +524,17 @@ public class LoanWritePlatformServiceJpaRepositoryImpl implements LoanWritePlatf
 
         businessEventNotifierService.notifyPostBusinessEvent(new LoanBalanceChangedBusinessEvent(loan));
 
+        // Money leaving the society to the borrower: the Loan Portfolio account is debited, because
+        // the loan is now an asset owed back, and the fund the money came out of is credited.
+        // Skipped for an account transfer, where the disbursement lands in another account rather
+        // than being paid out and that account's own posting carries the voucher.
+        if (!isAccountTransfer && disbursalTransactionId != null) {
+            final String voucherNo = raiseLoanVoucher(loan, disbursalTransactionId, loan.getDisbursedAmount(), true);
+            if (voucherNo != null) {
+                changes.put("voucherNo", voucherNo);
+            }
+        }
+
         return new CommandProcessingResultBuilder() //
                 .withCommandId(command.commandId()) //
                 .withEntityId(loan.getId()) //
@@ -1073,6 +1087,56 @@ public class LoanWritePlatformServiceJpaRepositoryImpl implements LoanWritePlatf
                 .build();
     }
 
+    /**
+     * Records a loan disbursement or repayment in the voucher register, and returns its number.
+     *
+     * The borrower's side is the product's Loan Portfolio account, because that is what the balance
+     * posts against; the line still names the borrower and their loan account number, so the slip
+     * reads as theirs. The other side is the till.
+     *
+     * A disbursement debits the portfolio — the society now holds a receivable — and credits the
+     * cash paid out. A repayment reverses that.
+     *
+     * A failure here does not fail the transaction. The disbursement or repayment is already posted
+     * and the borrower's balance already moved; taking that back over a slip would undo a correct
+     * transaction for a paperwork reason. The problem is logged and the transaction stands.
+     */
+    private String raiseLoanVoucher(final Loan loan, final Long transactionId, final BigDecimal amount, final boolean isDisbursement) {
+        // A register further out may have already raised a voucher naming the instrument this
+        // movement belongs to; its voucher describes it better than a bare loan posting would.
+        if (!this.voucherService.shouldRaiseVoucher()) {
+            return null;
+        }
+
+        try {
+            final AppUser currentUser = this.context.authenticatedUser();
+            final Map<String, Object> portfolio = this.voucherService.loanPortfolioAccount(loan.getId());
+            final Long portfolioGlId = portfolio.get("id") == null ? null : ((Number) portfolio.get("id")).longValue();
+
+            final String party = loan.getClient() != null ? loan.getClient().getDisplayName() : null;
+            final String accountNo = loan.getAccountNumber();
+            final String partyName = party != null ? party : (String) portfolio.get("name");
+
+            final VoucherLine borrowerSide = isDisbursement ? VoucherLine.debitGl(portfolioGlId, partyName, accountNo, amount)
+                    : VoucherLine.creditGl(portfolioGlId, partyName, accountNo, amount);
+
+            // The till. The loan module does not resolve a GL for the cashier's drawer, so the line
+            // names it without an id rather than guessing at one.
+            final VoucherLine cashSide = isDisbursement ? VoucherLine.creditGl(null, "Cash in Hand", null, amount)
+                    : VoucherLine.debitGl(null, "Cash in Hand", null, amount);
+
+            final List<VoucherLine> lines = isDisbursement ? List.of(borrowerSide, cashSide) : List.of(cashSide, borrowerSide);
+
+            return this.voucherService.createVoucherWithLines(
+                    isDisbursement ? VoucherService.TYPE_DISBURSEMENT : VoucherService.TYPE_REPAYMENT,
+                    VoucherService.REF_LOAN_TRANSACTION, transactionId, currentUser,
+                    isDisbursement ? VoucherService.PREFIX_DEBIT : VoucherService.PREFIX_CREDIT, lines);
+        } catch (final RuntimeException e) {
+            log.error("Could not raise a voucher for loan transaction {}", transactionId, e);
+            return null;
+        }
+    }
+
     private void saveNote(String noteText, Loan loan, LoanTransaction loanTransaction) {
         if (StringUtils.isNotBlank(noteText)) {
             final Note note = Note.loanTransactionNote(loan, loanTransaction, noteText);
@@ -1118,6 +1182,13 @@ public class LoanWritePlatformServiceJpaRepositoryImpl implements LoanWritePlatf
         loan = loanTransaction.getLoan();
         this.loanAccountDomainService.updateAndSaveLoanCollateralTransactionsForIndividualAccounts(loan, loanTransaction);
 
+        // Money coming back from the borrower: cash is debited and the Loan Portfolio account is
+        // credited, reducing what the loan still carries as owed.
+        final String repaymentVoucherNo = raiseLoanVoucher(loan, loanTransaction.getId(), transactionAmount, false);
+        if (repaymentVoucherNo != null) {
+            changes.put("voucherNo", repaymentVoucherNo);
+        }
+
         return new CommandProcessingResultBuilder().withCommandId(command.commandId()) //
                 .withLoanId(loan.getId()) //
                 .withEntityId(loanTransaction.getId()) //

fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/starter/LoanAccountConfiguration.java

@@ -176,6 +176,7 @@ import org.apache.fineract.portfolio.loanproduct.service.LoanDropdownReadPlatfor
 import org.apache.fineract.portfolio.loanproduct.service.LoanProductReadPlatformService;
 import org.apache.fineract.portfolio.note.domain.NoteRepository;
 import org.apache.fineract.portfolio.paymentdetail.service.PaymentDetailWritePlatformService;
+import org.apache.fineract.portfolio.voucher.service.VoucherService;
 import org.apache.fineract.portfolio.paymenttype.service.PaymentTypeReadService;
 import org.apache.fineract.portfolio.rate.service.RateAssembler;
 import org.apache.fineract.portfolio.repaymentwithpostdatedchecks.domain.PostDatedChecksRepository;
@@ -413,7 +414,7 @@ public class LoanAccountConfiguration {
 
     @Bean
     @ConditionalOnMissingBean(LoanWritePlatformService.class)
-    public LoanWritePlatformService loanWritePlatformService(PlatformSecurityContext context,
+    public LoanWritePlatformService loanWritePlatformService(PlatformSecurityContext context, VoucherService voucherService,
             LoanTransactionValidator loanTransactionValidator,
             LoanUpdateCommandFromApiJsonDeserializer loanUpdateCommandFromApiJsonDeserializer, LoanRepositoryWrapper loanRepositoryWrapper,
             LoanAccountDomainService loanAccountDomainService, NoteRepository noteRepository,
@@ -446,7 +447,8 @@ public class LoanAccountConfiguration {
             LoanJournalEntryPoster journalEntryPoster, LoanAdjustmentService loanAdjustmentService, LoanMapper loanMapper,
             LoanTransactionProcessingService loanTransactionProcessingService, final LoanBalanceService loanBalanceService,
             LoanTransactionService loanTransactionService) {
-        return new LoanWritePlatformServiceJpaRepositoryImpl(context, loanTransactionValidator, loanUpdateCommandFromApiJsonDeserializer,
+        return new LoanWritePlatformServiceJpaRepositoryImpl(context, voucherService, loanTransactionValidator,
+                loanUpdateCommandFromApiJsonDeserializer,
                 loanRepositoryWrapper, loanAccountDomainService, noteRepository, loanTransactionRepository,
                 loanTransactionRelationRepository, loanAssembler, calendarInstanceRepository, paymentDetailWritePlatformService,
                 holidayRepository, configurationDomainService, workingDaysRepository, accountTransfersWritePlatformService,

fineract-provider/src/main/java/org/apache/fineract/portfolio/nachclearing/service/NachWritePlatformServiceImpl.java

@@ -338,10 +338,10 @@ public class NachWritePlatformServiceImpl implements NachWritePlatformService {
         }
         if (txn.isCredit()) {
             this.clearingJournalService.postJournalEntry(movement.officeId, movement.currencyCode, txnDate, suspenseGlId, controlGlId,
-                    amount, "NACH credit pass - transaction #" + txn.getId(), txn.getAccountId());
+                    amount, "NACH credit pass - transaction #" + txn.getId(), txn.getAccountId(), txn.getAccountType());
         } else {
             this.clearingJournalService.postJournalEntry(movement.officeId, movement.currencyCode, txnDate, controlGlId, suspenseGlId,
-                    amount, "NACH debit pass - transaction #" + txn.getId(), txn.getAccountId());
+                    amount, "NACH debit pass - transaction #" + txn.getId(), txn.getAccountId(), txn.getAccountType());
         }
     }
 

fineract-provider/src/main/java/org/apache/fineract/portfolio/orgsetup/api/BranchProfileApiResource.java

@@ -0,0 +1,186 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.portfolio.orgsetup.api;
+
+import com.google.gson.Gson;
+import jakarta.ws.rs.Consumes;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.PUT;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.PathParam;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.QueryParam;
+import jakarta.ws.rs.core.MediaType;
+import java.time.Instant;
+import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import lombok.RequiredArgsConstructor;
+import org.apache.fineract.infrastructure.core.exception.PlatformDataIntegrityException;
+import org.apache.fineract.infrastructure.core.serialization.FromJsonHelper;
+import org.apache.fineract.infrastructure.security.service.PlatformSecurityContext;
+import org.apache.fineract.useradministration.domain.AppUser;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Component;
+
+/**
+ * The operational profile behind a branch — code, address, contact, type and working hours — kept as
+ * a side table on m_office (see migration 0511) rather than added to the core office entity, so this
+ * stays independent of the stock office create/edit flow. Every office already exists via the
+ * standard Offices screen; this only adds the real-world fields on top for the offices that have them
+ * set. An office with no profile row yet is a valid, ordinary state — not an error.
+ */
+@Path("/v1/branchprofile")
+@Component
+@RequiredArgsConstructor
+@Produces({ MediaType.APPLICATION_JSON })
+public class BranchProfileApiResource {
+
+    private final JdbcTemplate jdbcTemplate;
+    private final PlatformSecurityContext context;
+    private final FromJsonHelper fromJsonHelper;
+    private final Gson gson = new Gson();
+
+    @GET
+    public String list(@QueryParam("officeId") final Long officeId) {
+        this.context.authenticatedUser().validateHasReadPermission("BRANCHPROFILE");
+        final String where = officeId != null ? "WHERE o.id = ?" : "";
+        final List<Map<String, Object>> rows = officeId != null
+                ? jdbcTemplate.queryForList(baseSql() + where + " ORDER BY o.hierarchy", officeId)
+                : jdbcTemplate.queryForList(baseSql() + " ORDER BY o.hierarchy");
+
+        final List<Map<String, Object>> out = new ArrayList<>();
+        for (final Map<String, Object> row : rows) {
+            out.add(toResult(row));
+        }
+        if (officeId != null) {
+            if (out.isEmpty()) {
+                throw new PlatformDataIntegrityException("error.msg.branchprofile.office.not.found",
+                        "Office " + officeId + " was not found.");
+            }
+            return gson.toJson(out.get(0));
+        }
+        return gson.toJson(out);
+    }
+
+    @PUT
+    @Path("{officeId}")
+    @Consumes({ MediaType.APPLICATION_JSON })
+    public String update(@PathParam("officeId") final Long officeId, final String body) {
+        this.context.authenticatedUser().validateHasPermissionTo("UPDATE_BRANCHPROFILE");
+
+        final Integer officeExists = jdbcTemplate.queryForObject("SELECT COUNT(*) FROM m_office WHERE id = ?",
+                Integer.class, officeId);
+        if (officeExists == null || officeExists == 0) {
+            throw new PlatformDataIntegrityException("error.msg.branchprofile.office.not.found",
+                    "Office " + officeId + " was not found.");
+        }
+
+        final var root = this.fromJsonHelper.parse(body);
+        final String branchCode = this.fromJsonHelper.extractStringNamed("branchCode", root);
+        final String branchType = this.fromJsonHelper.extractStringNamed("branchType", root);
+        final String address = this.fromJsonHelper.extractStringNamed("address", root);
+        final String contactPhone = this.fromJsonHelper.extractStringNamed("contactPhone", root);
+        final String contactEmail = this.fromJsonHelper.extractStringNamed("contactEmail", root);
+        final String workingHoursStart = this.fromJsonHelper.extractStringNamed("workingHoursStart", root);
+        final String workingHoursEnd = this.fromJsonHelper.extractStringNamed("workingHoursEnd", root);
+        final String workingDays = this.fromJsonHelper.extractStringNamed("workingDays", root);
+        final String ifscCode = this.fromJsonHelper.extractStringNamed("ifscCode", root);
+        final String micrCode = this.fromJsonHelper.extractStringNamed("micrCode", root);
+        final java.math.BigDecimal latitude = this.fromJsonHelper.extractBigDecimalWithLocaleNamed("latitude", root);
+        final java.math.BigDecimal longitude = this.fromJsonHelper.extractBigDecimalWithLocaleNamed("longitude", root);
+
+        if (branchCode != null && !branchCode.isBlank()) {
+            final Integer dupe = jdbcTemplate.queryForObject(
+                    "SELECT COUNT(*) FROM m_office_profile WHERE branch_code = ? AND office_id <> ?", Integer.class,
+                    branchCode, officeId);
+            if (dupe != null && dupe > 0) {
+                throw new PlatformDataIntegrityException("error.msg.branchprofile.code.duplicate",
+                        "Branch code '" + branchCode + "' is already used by another branch.");
+            }
+        }
+
+        final AppUser currentUser = this.context.authenticatedUser();
+        final Integer existing = jdbcTemplate.queryForObject("SELECT COUNT(*) FROM m_office_profile WHERE office_id = ?",
+                Integer.class, officeId);
+        if (existing != null && existing > 0) {
+            jdbcTemplate.update("""
+                    UPDATE m_office_profile
+                       SET branch_code = ?, branch_type = ?, address = ?, contact_phone = ?, contact_email = ?,
+                           working_hours_start = ?, working_hours_end = ?, working_days = ?,
+                           ifsc_code = ?, micr_code = ?, latitude = ?, longitude = ?,
+                           updated_by_username = ?, updated_at = ?
+                     WHERE office_id = ?
+                    """, branchCode, branchType, address, contactPhone, contactEmail, workingHoursStart,
+                workingHoursEnd, workingDays, ifscCode, micrCode, latitude, longitude, currentUser.getUsername(),
+                Timestamp.from(Instant.now()), officeId);
+        } else {
+            jdbcTemplate.update("""
+                    INSERT INTO m_office_profile
+                    (office_id, branch_code, branch_type, address, contact_phone, contact_email,
+                     working_hours_start, working_hours_end, working_days, ifsc_code, micr_code,
+                     latitude, longitude, updated_by_username, updated_at)
+                    VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+                    """, officeId, branchCode, branchType, address, contactPhone, contactEmail, workingHoursStart,
+                workingHoursEnd, workingDays, ifscCode, micrCode, latitude, longitude, currentUser.getUsername(),
+                Timestamp.from(Instant.now()));
+        }
+
+        return list(officeId);
+    }
+
+    private String baseSql() {
+        return """
+                SELECT o.id AS office_id, o.name AS office_name, o.hierarchy, o.parent_id, o.opening_date,
+                       p.branch_code, p.branch_type, p.address, p.contact_phone, p.contact_email,
+                       p.working_hours_start, p.working_hours_end, p.working_days,
+                       p.ifsc_code, p.micr_code, p.latitude, p.longitude,
+                       p.updated_by_username, p.updated_at
+                  FROM m_office o LEFT JOIN m_office_profile p ON p.office_id = o.id
+                """;
+    }
+
+    private Map<String, Object> toResult(final Map<String, Object> row) {
+        final Map<String, Object> out = new LinkedHashMap<>();
+        out.put("officeId", row.get("office_id"));
+        out.put("officeName", row.get("office_name"));
+        out.put("hierarchy", row.get("hierarchy"));
+        out.put("parentId", row.get("parent_id"));
+        final Object opening = row.get("opening_date");
+        out.put("openingDate", opening == null ? null : opening.toString());
+        out.put("branchCode", row.get("branch_code"));
+        out.put("branchType", row.get("branch_type"));
+        out.put("address", row.get("address"));
+        out.put("contactPhone", row.get("contact_phone"));
+        out.put("contactEmail", row.get("contact_email"));
+        out.put("workingHoursStart", row.get("working_hours_start"));
+        out.put("workingHoursEnd", row.get("working_hours_end"));
+        out.put("workingDays", row.get("working_days"));
+        out.put("ifscCode", row.get("ifsc_code"));
+        out.put("micrCode", row.get("micr_code"));
+        out.put("latitude", row.get("latitude"));
+        out.put("longitude", row.get("longitude"));
+        out.put("updatedByUsername", row.get("updated_by_username"));
+        final Object updatedAt = row.get("updated_at");
+        out.put("updatedAt", updatedAt == null ? null : updatedAt.toString());
+        return out;
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/portfolio/orgsetup/api/InstitutionProfileApiResource.java

@@ -0,0 +1,274 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.portfolio.orgsetup.api;
+
+import com.google.gson.Gson;
+import jakarta.ws.rs.Consumes;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.PUT;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.core.MediaType;
+import java.sql.Date;
+import java.sql.Timestamp;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import lombok.RequiredArgsConstructor;
+import org.apache.fineract.infrastructure.core.serialization.FromJsonHelper;
+import org.apache.fineract.infrastructure.security.service.PlatformSecurityContext;
+import org.apache.fineract.useradministration.domain.AppUser;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Component;
+
+/**
+ * The institution's own "Bank Master" — identity and classification, regulatory details, address
+ * (registered, with optional head-office/communication overrides), contact, the institution-level
+ * banking identifier (SWIFT/BIC — IFSC/MICR are per-branch and live on {@link BranchProfileApiResource}
+ * instead), document header names and terms text, the authorised representative, and audit fields. A
+ * singleton (always id=1): unlike offices there is only ever one bank running this tenant.
+ *
+ * Deliberately does NOT store Business Date, Financial Year, Time Zone, Working Days or Holiday
+ * Calendar — those already exist as their own configuration elsewhere in the system, and copying
+ * them here would just create a second, driftable value for the same fact. The currency shown is
+ * likewise derived live from {@code m_organisation_currency} rather than stored.
+ */
+@Path("/v1/institutionprofile")
+@Component
+@RequiredArgsConstructor
+@Produces({ MediaType.APPLICATION_JSON })
+public class InstitutionProfileApiResource {
+
+    private final JdbcTemplate jdbcTemplate;
+    private final PlatformSecurityContext context;
+    private final FromJsonHelper fromJsonHelper;
+    private final Gson gson = new Gson();
+
+    @GET
+    public String get() {
+        this.context.authenticatedUser().validateHasReadPermission("INSTITUTIONPROFILE");
+        ensureRowExists();
+        final Map<String, Object> row = jdbcTemplate.queryForMap("""
+                SELECT bank_name, legal_name, short_name, bank_code, institution_code, bank_type,
+                       ownership_type, parent_institution_name,
+                       registration_number, license_number, established_date, status, country,
+                       regulatory_authority, registration_date, license_status, license_expiry_date,
+                       swift_bic,
+                       address_line1, address_line2, city, district, state, pincode,
+                       head_office_same_as_registered, head_office_address,
+                       communication_same_as_registered, communication_address,
+                       contact_phone, contact_email, customer_care_number, grievance_email, website,
+                       pan, tan, gstin,
+                       statement_header_name, passbook_header_name, receipt_header_name, terms_and_conditions,
+                       authorized_person_name, authorized_person_designation, authorized_person_contact,
+                       authorized_person_email,
+                       created_by_username, created_at, activation_date, deactivation_date,
+                       updated_by_username, updated_at
+                  FROM m_institution_profile WHERE id = 1
+                """);
+        return gson.toJson(toResult(row));
+    }
+
+    @PUT
+    @Consumes({ MediaType.APPLICATION_JSON })
+    public String update(final String body) {
+        this.context.authenticatedUser().validateHasPermissionTo("UPDATE_INSTITUTIONPROFILE");
+        ensureRowExists();
+
+        final var root = this.fromJsonHelper.parse(body);
+        final String bankName = this.fromJsonHelper.extractStringNamed("bankName", root);
+        final String legalName = this.fromJsonHelper.extractStringNamed("legalName", root);
+        final String shortName = this.fromJsonHelper.extractStringNamed("shortName", root);
+        final String bankCode = this.fromJsonHelper.extractStringNamed("bankCode", root);
+        final String institutionCode = this.fromJsonHelper.extractStringNamed("institutionCode", root);
+        final String bankType = this.fromJsonHelper.extractStringNamed("bankType", root);
+        final String ownershipType = this.fromJsonHelper.extractStringNamed("ownershipType", root);
+        final String parentInstitutionName = this.fromJsonHelper.extractStringNamed("parentInstitutionName", root);
+        final String registrationNumber = this.fromJsonHelper.extractStringNamed("registrationNumber", root);
+        final String licenseNumber = this.fromJsonHelper.extractStringNamed("licenseNumber", root);
+        final LocalDate establishedDate = parseDate(this.fromJsonHelper.extractStringNamed("establishedDate", root));
+        final String status = this.fromJsonHelper.extractStringNamed("status", root);
+        final String country = this.fromJsonHelper.extractStringNamed("country", root);
+        final String regulatoryAuthority = this.fromJsonHelper.extractStringNamed("regulatoryAuthority", root);
+        final LocalDate registrationDate = parseDate(this.fromJsonHelper.extractStringNamed("registrationDate", root));
+        final String licenseStatus = this.fromJsonHelper.extractStringNamed("licenseStatus", root);
+        final LocalDate licenseExpiryDate = parseDate(this.fromJsonHelper.extractStringNamed("licenseExpiryDate", root));
+        final String swiftBic = this.fromJsonHelper.extractStringNamed("swiftBic", root);
+        final String addressLine1 = this.fromJsonHelper.extractStringNamed("addressLine1", root);
+        final String addressLine2 = this.fromJsonHelper.extractStringNamed("addressLine2", root);
+        final String city = this.fromJsonHelper.extractStringNamed("city", root);
+        final String district = this.fromJsonHelper.extractStringNamed("district", root);
+        final String state = this.fromJsonHelper.extractStringNamed("state", root);
+        final String pincode = this.fromJsonHelper.extractStringNamed("pincode", root);
+        final Boolean headOfficeSame = this.fromJsonHelper.parameterExists("headOfficeSameAsRegistered", root)
+                ? this.fromJsonHelper.extractBooleanNamed("headOfficeSameAsRegistered", root) : Boolean.TRUE;
+        final String headOfficeAddress = this.fromJsonHelper.extractStringNamed("headOfficeAddress", root);
+        final Boolean communicationSame = this.fromJsonHelper.parameterExists("communicationSameAsRegistered", root)
+                ? this.fromJsonHelper.extractBooleanNamed("communicationSameAsRegistered", root) : Boolean.TRUE;
+        final String communicationAddress = this.fromJsonHelper.extractStringNamed("communicationAddress", root);
+        final String contactPhone = this.fromJsonHelper.extractStringNamed("contactPhone", root);
+        final String contactEmail = this.fromJsonHelper.extractStringNamed("contactEmail", root);
+        final String customerCareNumber = this.fromJsonHelper.extractStringNamed("customerCareNumber", root);
+        final String grievanceEmail = this.fromJsonHelper.extractStringNamed("grievanceEmail", root);
+        final String website = this.fromJsonHelper.extractStringNamed("website", root);
+        final String pan = this.fromJsonHelper.extractStringNamed("pan", root);
+        final String tan = this.fromJsonHelper.extractStringNamed("tan", root);
+        final String gstin = this.fromJsonHelper.extractStringNamed("gstin", root);
+        final String statementHeaderName = this.fromJsonHelper.extractStringNamed("statementHeaderName", root);
+        final String passbookHeaderName = this.fromJsonHelper.extractStringNamed("passbookHeaderName", root);
+        final String receiptHeaderName = this.fromJsonHelper.extractStringNamed("receiptHeaderName", root);
+        final String termsAndConditions = this.fromJsonHelper.extractStringNamed("termsAndConditions", root);
+        final String authorizedPersonName = this.fromJsonHelper.extractStringNamed("authorizedPersonName", root);
+        final String authorizedPersonDesignation = this.fromJsonHelper.extractStringNamed("authorizedPersonDesignation",
+                root);
+        final String authorizedPersonContact = this.fromJsonHelper.extractStringNamed("authorizedPersonContact", root);
+        final String authorizedPersonEmail = this.fromJsonHelper.extractStringNamed("authorizedPersonEmail", root);
+
+        // A status flip is stamped automatically the first time it happens, rather than asking the
+        // user to also remember to set a date — the previous row's own status is what "the first
+        // time" is judged against.
+        final String previousStatus = jdbcTemplate.queryForObject("SELECT status FROM m_institution_profile WHERE id = 1",
+                String.class);
+        final boolean turningActive = "ACTIVE".equalsIgnoreCase(status) && !"ACTIVE".equalsIgnoreCase(previousStatus);
+        final boolean turningInactive = "INACTIVE".equalsIgnoreCase(status) && !"INACTIVE".equalsIgnoreCase(previousStatus);
+        final LocalDate today = LocalDate.now();
+
+        final AppUser currentUser = this.context.authenticatedUser();
+        jdbcTemplate.update("""
+                UPDATE m_institution_profile
+                   SET bank_name = ?, legal_name = ?, short_name = ?, bank_code = ?, institution_code = ?,
+                       bank_type = ?, ownership_type = ?, parent_institution_name = ?,
+                       registration_number = ?, license_number = ?, established_date = ?, status = ?, country = ?,
+                       regulatory_authority = ?, registration_date = ?, license_status = ?, license_expiry_date = ?,
+                       swift_bic = ?,
+                       address_line1 = ?, address_line2 = ?, city = ?, district = ?, state = ?, pincode = ?,
+                       head_office_same_as_registered = ?, head_office_address = ?,
+                       communication_same_as_registered = ?, communication_address = ?,
+                       contact_phone = ?, contact_email = ?, customer_care_number = ?, grievance_email = ?,
+                       website = ?, pan = ?, tan = ?, gstin = ?,
+                       statement_header_name = ?, passbook_header_name = ?, receipt_header_name = ?,
+                       terms_and_conditions = ?,
+                       authorized_person_name = ?, authorized_person_designation = ?, authorized_person_contact = ?,
+                       authorized_person_email = ?,
+                       activation_date = CASE WHEN ? THEN ? ELSE activation_date END,
+                       deactivation_date = CASE WHEN ? THEN ? ELSE deactivation_date END,
+                       updated_by_username = ?, updated_at = ?
+                 WHERE id = 1
+                """, bankName, legalName, shortName, bankCode, institutionCode, bankType, ownershipType,
+            parentInstitutionName, registrationNumber, licenseNumber, toSqlDate(establishedDate), status, country,
+            regulatoryAuthority, toSqlDate(registrationDate), licenseStatus, toSqlDate(licenseExpiryDate), swiftBic,
+            addressLine1, addressLine2, city, district, state, pincode, headOfficeSame, headOfficeAddress,
+            communicationSame, communicationAddress, contactPhone, contactEmail, customerCareNumber, grievanceEmail,
+            website, pan, tan, gstin, statementHeaderName, passbookHeaderName, receiptHeaderName, termsAndConditions,
+            authorizedPersonName, authorizedPersonDesignation, authorizedPersonContact, authorizedPersonEmail,
+            turningActive, toSqlDate(today), turningInactive, toSqlDate(today), currentUser.getUsername(),
+            Timestamp.from(Instant.now()));
+
+        return get();
+    }
+
+    private void ensureRowExists() {
+        final Integer count = jdbcTemplate.queryForObject("SELECT COUNT(*) FROM m_institution_profile WHERE id = 1",
+                Integer.class);
+        if (count == null || count == 0) {
+            final AppUser currentUser = this.context.authenticatedUser();
+            jdbcTemplate.update("""
+                    INSERT INTO m_institution_profile (id, status, created_by_username, created_at)
+                    VALUES (1, 'ACTIVE', ?, ?)
+                    """, currentUser.getUsername(), Timestamp.from(Instant.now()));
+        }
+    }
+
+    /** The tenant's one enabled currency (see the INR-only enforcement migration) — read-only here. */
+    private String resolveCurrencyCode() {
+        final List<String> codes = jdbcTemplate.queryForList(
+                "SELECT code FROM m_organisation_currency ORDER BY code LIMIT 1", String.class);
+        return codes.isEmpty() ? null : codes.get(0);
+    }
+
+    private LocalDate parseDate(final String raw) {
+        return (raw != null && !raw.isBlank()) ? LocalDate.parse(raw) : null;
+    }
+
+    private Date toSqlDate(final LocalDate d) {
+        return d == null ? null : Date.valueOf(d);
+    }
+
+    private Map<String, Object> toResult(final Map<String, Object> row) {
+        final Map<String, Object> out = new LinkedHashMap<>();
+        out.put("bankName", row.get("bank_name"));
+        out.put("legalName", row.get("legal_name"));
+        out.put("shortName", row.get("short_name"));
+        out.put("bankCode", row.get("bank_code"));
+        out.put("institutionCode", row.get("institution_code"));
+        out.put("bankType", row.get("bank_type"));
+        out.put("ownershipType", row.get("ownership_type"));
+        out.put("parentInstitutionName", row.get("parent_institution_name"));
+        out.put("registrationNumber", row.get("registration_number"));
+        out.put("licenseNumber", row.get("license_number"));
+        out.put("establishedDate", str(row.get("established_date")));
+        out.put("status", row.get("status"));
+        out.put("country", row.get("country"));
+        out.put("currencyCode", resolveCurrencyCode());
+        out.put("regulatoryAuthority", row.get("regulatory_authority"));
+        out.put("registrationDate", str(row.get("registration_date")));
+        out.put("licenseStatus", row.get("license_status"));
+        out.put("licenseExpiryDate", str(row.get("license_expiry_date")));
+        out.put("swiftBic", row.get("swift_bic"));
+        out.put("addressLine1", row.get("address_line1"));
+        out.put("addressLine2", row.get("address_line2"));
+        out.put("city", row.get("city"));
+        out.put("district", row.get("district"));
+        out.put("state", row.get("state"));
+        out.put("pincode", row.get("pincode"));
+        out.put("headOfficeSameAsRegistered", row.get("head_office_same_as_registered"));
+        out.put("headOfficeAddress", row.get("head_office_address"));
+        out.put("communicationSameAsRegistered", row.get("communication_same_as_registered"));
+        out.put("communicationAddress", row.get("communication_address"));
+        out.put("contactPhone", row.get("contact_phone"));
+        out.put("contactEmail", row.get("contact_email"));
+        out.put("customerCareNumber", row.get("customer_care_number"));
+        out.put("grievanceEmail", row.get("grievance_email"));
+        out.put("website", row.get("website"));
+        out.put("pan", row.get("pan"));
+        out.put("tan", row.get("tan"));
+        out.put("gstin", row.get("gstin"));
+        out.put("statementHeaderName", row.get("statement_header_name"));
+        out.put("passbookHeaderName", row.get("passbook_header_name"));
+        out.put("receiptHeaderName", row.get("receipt_header_name"));
+        out.put("termsAndConditions", row.get("terms_and_conditions"));
+        out.put("authorizedPersonName", row.get("authorized_person_name"));
+        out.put("authorizedPersonDesignation", row.get("authorized_person_designation"));
+        out.put("authorizedPersonContact", row.get("authorized_person_contact"));
+        out.put("authorizedPersonEmail", row.get("authorized_person_email"));
+        out.put("createdByUsername", row.get("created_by_username"));
+        out.put("createdAt", str(row.get("created_at")));
+        out.put("activationDate", str(row.get("activation_date")));
+        out.put("deactivationDate", str(row.get("deactivation_date")));
+        out.put("updatedByUsername", row.get("updated_by_username"));
+        out.put("updatedAt", str(row.get("updated_at")));
+        return out;
+    }
+
+    private static String str(final Object o) {
+        return o == null ? null : o.toString();
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/DeafRemittanceApiResource.java

@@ -0,0 +1,80 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.portfolio.savings.api;
+
+import com.google.gson.JsonElement;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.ws.rs.Consumes;
+import jakarta.ws.rs.POST;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.PathParam;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.core.MediaType;
+import lombok.RequiredArgsConstructor;
+import org.apache.fineract.infrastructure.core.api.JsonCommand;
+import org.apache.fineract.infrastructure.core.data.CommandProcessingResult;
+import org.apache.fineract.infrastructure.core.serialization.DefaultToApiJsonSerializer;
+import org.apache.fineract.infrastructure.core.serialization.FromJsonHelper;
+import org.apache.fineract.portfolio.savings.service.DeafRemittanceWritePlatformService;
+import org.springframework.stereotype.Component;
+
+/**
+ * Records remittances of escheated balances to RBI's Depositor Education and Awareness Fund.
+ *
+ * <p>
+ * The transfer to RBI happens outside this system; these endpoints only write down that it was
+ * made, so the escheat report can distinguish money that reached the fund from money that has left
+ * the customer's account and gone nowhere.
+ */
+@Path("/v1/savingsaccounts/deaf-remittance")
+@Component
+@Tag(name = "DEAF Remittance", description = "Record remittance of escheated balances to RBI's DEAF.")
+@RequiredArgsConstructor
+public class DeafRemittanceApiResource {
+
+    private final DeafRemittanceWritePlatformService writePlatformService;
+    private final DefaultToApiJsonSerializer<CommandProcessingResult> toApiJsonSerializer;
+    private final FromJsonHelper fromJsonHelper;
+
+    @POST
+    @Consumes({ MediaType.APPLICATION_JSON })
+    @Produces({ MediaType.APPLICATION_JSON })
+    @Operation(summary = "Record a DEAF remittance", description = "Marks the escheated balances of the given savings accounts "
+            + "as remitted to RBI. Accounts that are not escheated, or already recorded, are skipped.")
+    public String recordRemittance(final String apiRequestBodyAsJson) {
+        final JsonElement parsed = this.fromJsonHelper.parse(apiRequestBodyAsJson);
+        final JsonCommand command = JsonCommand.fromJsonElement(null, parsed, this.fromJsonHelper);
+        final CommandProcessingResult result = this.writePlatformService.recordRemittance(command);
+        return this.toApiJsonSerializer.serialize(result);
+    }
+
+    @POST
+    @Path("{savingsAccountId}/refund")
+    @Consumes({ MediaType.APPLICATION_JSON })
+    @Produces({ MediaType.APPLICATION_JSON })
+    @Operation(summary = "Record a claim against a remitted balance", description = "Marks that the customer claimed the balance "
+            + "back after it had gone to the fund, and the bank recovered it from RBI.")
+    public String markRefunded(@PathParam("savingsAccountId") final Long savingsAccountId, final String apiRequestBodyAsJson) {
+        final JsonElement parsed = this.fromJsonHelper.parse(apiRequestBodyAsJson);
+        final JsonCommand command = JsonCommand.fromJsonElement(savingsAccountId, parsed, this.fromJsonHelper);
+        final CommandProcessingResult result = this.writePlatformService.markRefunded(savingsAccountId, command);
+        return this.toApiJsonSerializer.serialize(result);
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/DormantAccountsApiResource.java

@@ -0,0 +1,59 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.portfolio.savings.api;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.ws.rs.Consumes;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.QueryParam;
+import jakarta.ws.rs.core.MediaType;
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import org.apache.fineract.infrastructure.core.serialization.DefaultToApiJsonSerializer;
+import org.apache.fineract.portfolio.savings.data.DormantAccountData;
+import org.apache.fineract.portfolio.savings.service.DormantAccountReadPlatformService;
+import org.springframework.stereotype.Component;
+
+/**
+ * The read side of the dormancy ladder: which accounts the nightly job has marked, and how long
+ * each has been idle.
+ */
+@Path("/v1/savingsaccounts/dormant")
+@Component
+@Tag(name = "Dormant Savings Accounts", description = "Accounts marked inactive, dormant or escheated by the dormancy job.")
+@RequiredArgsConstructor
+public class DormantAccountsApiResource {
+
+    private final DormantAccountReadPlatformService readPlatformService;
+    private final DefaultToApiJsonSerializer<DormantAccountData> toApiJsonSerializer;
+
+    @GET
+    @Consumes({ MediaType.APPLICATION_JSON })
+    @Produces({ MediaType.APPLICATION_JSON })
+    @Operation(summary = "Retrieve dormant accounts", description = "Accounts at any of the three dormancy marks, longest idle first. "
+            + "Pass subStatus to narrow to one: 100 inactive, 200 dormant, 300 escheat.")
+    public String retrieveDormantAccounts(@QueryParam("subStatus") final Integer subStatus,
+            @QueryParam("officeName") final String officeName) {
+        final List<DormantAccountData> accounts = this.readPlatformService.retrieveDormantAccounts(subStatus, officeName);
+        return this.toApiJsonSerializer.serialize(accounts);
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/FacilityChargeMappingsApiResource.java

@@ -0,0 +1,94 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.portfolio.savings.api;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.ws.rs.Consumes;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.PUT;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.PathParam;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.core.MediaType;
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import org.apache.fineract.commands.domain.CommandWrapper;
+import org.apache.fineract.commands.service.CommandWrapperBuilder;
+import org.apache.fineract.commands.service.PortfolioCommandSourceWritePlatformService;
+import org.apache.fineract.infrastructure.core.data.CommandProcessingResult;
+import org.apache.fineract.infrastructure.security.service.PlatformSecurityContext;
+import org.apache.fineract.portfolio.savings.data.FacilityChargeMappingData;
+import org.apache.fineract.portfolio.savings.service.FacilityChargeMappingReadPlatformService;
+import org.springframework.stereotype.Component;
+
+/**
+ * Admin screen backing API for {@code m_facility_charge_mapping}: which {@link org.apache.fineract.portfolio.charge.domain.Charge}
+ * is applied when a named account facility (ATM_FACILITY, UPI_FACILITY, ...) is enabled on a savings/current
+ * account. The 16 facility rows themselves are fixed and auto-seeded by FacilityChargeSeederService at startup,
+ * so this resource only ever reads them and updates which charge one maps to -- there is no create/delete.
+ */
+@Path("/v1/facilitychargemappings")
+@Component
+@Tag(name = "Facility Charge Mappings", description = """
+        Which charge is applied when a named account facility (ATM Facility, UPI Facility, Cheque Book, ...) \
+        is enabled on a savings or current account. Enabling a facility whose mapping has no charge configured \
+        is rejected -- configure the mapping here first.""")
+@RequiredArgsConstructor
+public class FacilityChargeMappingsApiResource {
+
+    private static final String RESOURCE_NAME_FOR_PERMISSION = "FACILITYCHARGEMAPPING";
+
+    private final PlatformSecurityContext context;
+    private final FacilityChargeMappingReadPlatformService readPlatformService;
+    private final PortfolioCommandSourceWritePlatformService commandsSourceWritePlatformService;
+
+    @GET
+    @Consumes({ MediaType.APPLICATION_JSON })
+    @Produces({ MediaType.APPLICATION_JSON })
+    @Operation(summary = "List Facility Charge Mappings", description = "Example Requests: facilitychargemappings")
+    public List<FacilityChargeMappingData> retrieveAll() {
+        context.authenticatedUser().validateHasReadPermission(RESOURCE_NAME_FOR_PERMISSION);
+        return readPlatformService.retrieveAll();
+    }
+
+    @GET
+    @Path("template")
+    @Consumes({ MediaType.APPLICATION_JSON })
+    @Produces({ MediaType.APPLICATION_JSON })
+    @Operation(summary = "Retrieve Facility Charge Mapping Template", description = "Charge options available for mapping to a facility")
+    public FacilityChargeMappingData retrieveTemplate() {
+        context.authenticatedUser().validateHasReadPermission(RESOURCE_NAME_FOR_PERMISSION);
+        return readPlatformService.retrieveTemplate();
+    }
+
+    @PUT
+    @Path("{mappingId}")
+    @Consumes({ MediaType.APPLICATION_JSON })
+    @Produces({ MediaType.APPLICATION_JSON })
+    @Operation(summary = "Update a Facility Charge Mapping", description = "Changes which charge is applied when the facility is enabled")
+    public CommandProcessingResult update(@PathParam("mappingId") @Parameter(description = "mappingId") final Long mappingId,
+            @Parameter(hidden = true) final String apiRequestBodyAsJson) {
+        final CommandWrapper commandRequest = new CommandWrapperBuilder().updateFacilityChargeMapping(mappingId)
+                .withJson(apiRequestBodyAsJson).build();
+
+        return commandsSourceWritePlatformService.logCommandSource(commandRequest);
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/api/FixedDepositAccountsApiResource.java

@@ -81,6 +81,7 @@ import org.apache.fineract.portfolio.savings.data.SavingsAccountChargeData;
 import org.apache.fineract.portfolio.savings.data.SavingsAccountTransactionData;
 import org.apache.fineract.portfolio.savings.service.DepositAccountPreMatureCalculationPlatformService;
 import org.apache.fineract.portfolio.savings.service.DepositAccountReadPlatformService;
+import org.apache.fineract.portfolio.savings.service.DepositAccountWritePlatformService;
 import org.apache.fineract.portfolio.savings.service.FixedDepositAccountInterestCalculationService;
 import org.apache.fineract.portfolio.savings.service.SavingsAccountChargeReadPlatformService;
 import org.glassfish.jersey.media.multipart.FormDataContentDisposition;
@@ -107,6 +108,7 @@ public class FixedDepositAccountsApiResource {
     private final BulkImportWorkbookPopulatorService bulkImportWorkbookPopulatorService;
     private final FixedDepositAccountInterestCalculationService fixedDepositAccountInterestCalculationService;
     private final SqlValidator sqlValidator;
+    private final DepositAccountWritePlatformService depositAccountWritePlatformService;
 
     @GET
     @Path("template")
@@ -245,6 +247,28 @@ public class FixedDepositAccountsApiResource {
         final FixedDepositAccountData accountTemplate = populateTemplateAndAssociations(accountId, account, staffInSelectedOfficeOnly,
                 chargeStatus, uriInfo, mandatoryResponseParameters);
         accountTemplate.setActivationCharge(getActivationCharge(accountId));
+        // FD Special customers/staff need to see exactly how much interest is projected each month across
+        // the whole term, not just a flat rate/12 approximation -- computed on demand from the real
+        // interest engine (FixedDepositAccount#projectInterestSchedule), side-effect-free, so this GET can
+        // safely recompute it on every request. SINGLE/DOUBLE FDs never get this field.
+        if ("SPECIAL".equalsIgnoreCase(account.getFdType())) {
+            final java.util.List<java.util.Map<String, Object>> schedule = this.depositAccountWritePlatformService
+                    .retrieveProjectedInterestSchedule(accountId, DepositAccountType.FIXED_DEPOSIT);
+            accountTemplate.setProjectedInterestSchedule(schedule);
+            // Computed once here -- the single source of truth for "what does the customer end up with
+            // overall" -- rather than the frontend re-summing the schedule array itself, the same way
+            // maturityAmount itself is always a backend-computed field, never a client-side derivation.
+            BigDecimal totalInterest = BigDecimal.ZERO;
+            for (final java.util.Map<String, Object> period : schedule) {
+                final Object amount = period.get("interestAmount");
+                if (amount instanceof BigDecimal) {
+                    totalInterest = totalInterest.add((BigDecimal) amount);
+                }
+            }
+            final BigDecimal principal = accountTemplate.getDepositAmount();
+            final BigDecimal totalValue = principal != null ? principal.add(totalInterest) : totalInterest;
+            accountTemplate.setProjectedInterestTotals(totalInterest, totalValue);
+        }
         final ApiRequestJsonSerializationSettings settings = this.apiRequestParameterHelper.process(uriInfo.getQueryParameters(),
                 mandatoryResponseParameters);
         return this.toApiJsonSerializer.serialize(settings, accountTemplate,
@@ -440,6 +464,9 @@ public class FixedDepositAccountsApiResource {
         } else if (is(commandParam, "prematureClose")) {
             final CommandWrapper commandRequest = builder.prematureCloseFixedDepositAccount(accountId).build();
             result = this.commandsSourceWritePlatformService.logCommandSource(commandRequest);
+        } else if (is(commandParam, "payment")) {
+            final CommandWrapper commandRequest = builder.paymentFixedDepositAccount(accountId).build();
+            result = this.commandsSourceWritePlatformService.logCommandSource(commandRequest);
         } else if (is(commandParam, "calculatePrematureAmount")) {
             final JsonElement parsedQuery = this.fromJsonHelper.parse(apiRequestBodyAsJson);
             final JsonQuery query = JsonQuery.from(apiRequestBodyAsJson, parsedQuery, this.fromJsonHelper);
@@ -453,7 +480,7 @@ public class FixedDepositAccountsApiResource {
         if (result == null) {
             throw new UnrecognizedQueryParamException("command", commandParam,
                     new Object[] { "reject", "withdrawnByApplicant", "approve", "undoapproval", "activate", "calculateInterest",
-                            "postInterest", "close", "prematureClose", "calculatePrematureAmount" });
+                            "postInterest", "close", "prematureClose", "payment", "calculatePrematureAmount" });
         }
 
         return this.toApiJsonSerializer.serialize(result);
@@ -489,6 +516,8 @@ public class FixedDepositAccountsApiResource {
         DepositAccountData account = null;
         if (is(commandParam, "close")) {
             account = this.depositAccountReadPlatformService.retrieveOneWithClosureTemplate(DepositAccountType.FIXED_DEPOSIT, accountId);
+        } else if (is(commandParam, "payment")) {
+            account = this.depositAccountReadPlatformService.retrieveOneWithPaymentTemplate(DepositAccountType.FIXED_DEPOSIT, accountId);
         }
 
         final ApiRequestJsonSerializationSettings settings = this.apiRequestParameterHelper.process(uriInfo.getQueryParameters());

fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/dailyinterest/SavingsDailyInterestOrchestrator.java

@@ -0,0 +1,197 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.portfolio.savings.dailyinterest;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.List;
+import java.util.Map;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * Runs the day: accrue for every account, then pay out any product whose cycle ended today.
+ *
+ * Accrual and posting are separated on purpose. Accrual touches no money and can be repeated
+ * freely; posting moves money and must not be. Keeping them apart means a posting that fails can
+ * be retried without recomputing the accrual, and an accrual can be rebuilt after a backdated
+ * transaction without disturbing what has already been paid.
+ *
+ * Each product posts in its own transaction, so one product failing does not roll back another
+ * that already settled. The failure is recorded against that product's run and the day continues.
+ */
+@Service
+@Slf4j
+@RequiredArgsConstructor
+public class SavingsDailyInterestOrchestrator {
+
+    private final JdbcTemplate jdbcTemplate;
+    private final SavingsDailyInterestService accrualService;
+    private final SavingsPooledInterestPostingService postingService;
+
+    /** Accrue for the day, then post for any product whose cycle ends today. */
+    public void runForDate(final LocalDate businessDate) {
+        accrualService.accrueForDate(businessDate);
+        enrolNewProducts();
+
+        final List<Map<String, Object>> schedules = jdbcTemplate.queryForList("""
+                SELECT s.savings_product_id, s.posting_period_enum
+                  FROM m_savings_interest_posting_schedule s
+                  JOIN m_savings_product p ON p.id = s.savings_product_id
+                 WHERE s.is_active = true AND p.deposit_type_enum = 100
+                 ORDER BY s.savings_product_id
+                """);
+
+        for (final Map<String, Object> schedule : schedules) {
+            final long productId = ((Number) schedule.get("savings_product_id")).longValue();
+            final Long dueCount = jdbcTemplate.queryForObject("""
+                    SELECT COUNT(*) FROM m_savings_daily_interest
+                     WHERE savings_product_id = ? AND balance_date = ? AND is_posting_day = true
+                       AND savings_transaction_id IS NULL AND cycle_cumulative_interest > 0
+                    """, Long.class, productId, businessDate);
+            if (dueCount == null || dueCount == 0) {
+                updateSchedule(productId, businessDate, null);
+                continue;
+            }
+
+            try {
+                final BigDecimal paid = postingService.postForProduct(productId, businessDate);
+                updateSchedule(productId, businessDate, "COMPLETED");
+                log.info("Savings interest: product {} posted {} on {}", productId, paid, businessDate);
+            } catch (final RuntimeException e) {
+                // The product rolled back on its own; record why and let the others run.
+                log.error("Savings interest: product {} failed to post on {}", productId, businessDate, e);
+                jdbcTemplate.update("""
+                        UPDATE m_savings_interest_posting_run
+                           SET status = 'FAILED', failure_reason = ?
+                         WHERE savings_product_id = ? AND posting_date = ?
+                        """, truncate(e.getMessage()), productId, businessDate);
+                updateSchedule(productId, businessDate, "FAILED");
+            }
+        }
+    }
+
+    /**
+     * Enrols the product behind one account, if it is not already on the timetable.
+     *
+     * <p>
+     * Called when an account is activated, so the first account opened on a brand-new product brings
+     * that product onto the timetable rather than the product waiting for the nightly sweep. The
+     * insert is guarded the same way as {@link #enrolNewProducts()}, so calling it for a product
+     * already enrolled does nothing.
+     */
+    @Transactional
+    public void enrolProductOf(final Long savingsAccountId) {
+        try {
+            final int enrolled = jdbcTemplate.update("""
+                    INSERT INTO m_savings_interest_posting_schedule
+                           (savings_product_id, posting_period_enum, run_at_time, is_active)
+                    SELECT sp.id, sp.interest_posting_period_enum, TIME '00:30:00', true
+                      FROM m_savings_account sa
+                      JOIN m_savings_product sp ON sp.id = sa.product_id
+                     WHERE sa.id = ?
+                       AND sp.deposit_type_enum = 100
+                       AND sp.interest_posting_period_enum IS NOT NULL
+                       AND NOT EXISTS (SELECT 1 FROM m_savings_interest_posting_schedule s
+                                        WHERE s.savings_product_id = sp.id)
+                    """, savingsAccountId);
+            if (enrolled > 0) {
+                log.info("Savings interest: enrolled the product behind account {} into the daily-interest schedule", savingsAccountId);
+            }
+        } catch (final RuntimeException e) {
+            // Called from activation, which must not be rolled back because the timetable could not
+            // be written. The nightly sweep enrols the product anyway.
+            log.error("Savings interest: could not enrol the product behind account {}; the nightly run will do it",
+                    savingsAccountId, e);
+        }
+    }
+
+    /**
+     * The nightly sweep: gives any savings product without a timetable one, on its own posting period.
+     *
+     * <p>
+     * Activation enrols a product as soon as its first account opens, so this is the safety net —
+     * it catches a product whose accounts were activated while this was not yet wired, or where the
+     * enrolment on activation failed. The period comes from the product's own
+     * {@code interest_posting_period_enum}, so a product set to post monthly posts monthly.
+     */
+    private void enrolNewProducts() {
+        final int enrolled = jdbcTemplate.update("""
+                INSERT INTO m_savings_interest_posting_schedule
+                       (savings_product_id, posting_period_enum, run_at_time, is_active)
+                SELECT sp.id, sp.interest_posting_period_enum, TIME '00:30:00', true
+                  FROM m_savings_product sp
+                 WHERE sp.deposit_type_enum = 100
+                   AND sp.interest_posting_period_enum IS NOT NULL
+                   AND NOT EXISTS (SELECT 1 FROM m_savings_interest_posting_schedule s
+                                    WHERE s.savings_product_id = sp.id)
+                """);
+        if (enrolled > 0) {
+            log.info("Savings interest: enrolled {} new savings product(s) into the daily-interest schedule", enrolled);
+        }
+    }
+
+    /**
+     * Moves a product's timetable on. next_posting_date is worked out from the cycle the ledger
+     * itself recorded, so the schedule and the rows can never drift apart.
+     */
+    private void updateSchedule(final long productId, final LocalDate businessDate, final String status) {
+        final List<Map<String, Object>> cycle = jdbcTemplate.queryForList("""
+                SELECT MIN(cycle_end_date) AS next_end FROM m_savings_daily_interest
+                 WHERE savings_product_id = ? AND balance_date = ? AND cycle_end_date >= ?
+                """, productId, businessDate, businessDate);
+
+        LocalDate nextPosting = null;
+        if (!cycle.isEmpty() && cycle.get(0).get("next_end") != null) {
+            nextPosting = ((java.sql.Date) cycle.get(0).get("next_end")).toLocalDate();
+            if (nextPosting.isEqual(businessDate) && "COMPLETED".equals(status)) {
+                final int period = jdbcTemplate.queryForObject(
+                        "SELECT posting_period_enum FROM m_savings_interest_posting_schedule WHERE savings_product_id = ?",
+                        Integer.class, productId);
+                nextPosting = SavingsInterestCycleCalculator.nextCycleEndDate(businessDate, period,
+                        financialYearBeginningMonth());
+            }
+        }
+
+        jdbcTemplate.update("""
+                UPDATE m_savings_interest_posting_schedule
+                   SET next_posting_date = ?,
+                       last_posting_date = CASE WHEN ? = 'COMPLETED' THEN ? ELSE last_posting_date END,
+                       last_run_status = COALESCE(?, last_run_status),
+                       last_run_at = CURRENT_TIMESTAMP, updated_on = CURRENT_TIMESTAMP
+                 WHERE savings_product_id = ?
+                """, nextPosting, status, businessDate, status, productId);
+    }
+
+    private int financialYearBeginningMonth() {
+        final Integer month = jdbcTemplate.queryForObject(
+                "SELECT value FROM c_configuration WHERE name = 'financial-year-beginning-month'", Integer.class);
+        return month == null || month < 1 || month > 12 ? 1 : month;
+    }
+
+    private static String truncate(final String message) {
+        if (message == null) {
+            return "unknown failure";
+        }
+        return message.length() > 1000 ? message.substring(0, 1000) : message;
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/dailyinterest/SavingsDailyInterestService.java

@@ -0,0 +1,529 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.portfolio.savings.dailyinterest;
+
+import java.math.BigDecimal;
+import java.math.MathContext;
+import java.math.RoundingMode;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * Writes the day-by-day working behind each savings account's interest.
+ *
+ * The engine already computes interest correctly; what it does not do is leave a record. It keeps
+ * one derived total per account and recomputes it from the whole transaction history whenever
+ * anybody looks, so there is no way to ask what an account earned on a particular day, or why a
+ * day earned nothing. This service produces that record: one row per account per day, carrying the
+ * balance it was worked out on and the running total for the cycle.
+ *
+ * The interest terms - rate, posting period, compounding, calculation type, days in year - are read
+ * from the PRODUCT, deliberately. Fineract copies them onto each account at creation and the engine
+ * afterwards reads the account's copy, so the two can drift: in this tenant seventeen accounts on a
+ * quarterly 10% product still carry a daily 7% from whenever they were opened. Interest here is a
+ * property of the product a member bought, not of a stale copy, so this ledger states the product's
+ * terms and the whole product posts on one rhythm. The consequence is that these figures can differ
+ * from total_interest_earned_derived on any account whose copy has drifted; that difference is the
+ * point, and the reconciliation reports it rather than hiding it.
+ *
+ * The minimum balance is the exception: it is held only on the account, never on the product.
+ *
+ * Two rules the engine enforces and this has to match, or the ledger and the account will disagree:
+ *
+ *   - Interest is taken on the day's CLOSING balance. EndOfDayBalance holds an opening balance too
+ *     but never uses it in the arithmetic; opening is kept here only because it chains.
+ *   - A day whose closing balance is under the account's minimum earns nothing at all, not a
+ *     reduced amount. That is a cliff, and the row records it so a zero does not read as a fault.
+ *
+ * Scope is savings only - deposit_type_enum 100. Fixed and recurring deposits share
+ * m_savings_account and the same interest engine, but they carry maturity and lock-in rules this
+ * ledger does not model, so they are left alone.
+ */
+@Service
+@Slf4j
+@RequiredArgsConstructor
+public class SavingsDailyInterestService {
+
+    private static final MathContext MC = new MathContext(19, RoundingMode.HALF_EVEN);
+    private static final int SAVINGS_DEPOSIT_TYPE = 100;
+    private static final int ACTIVE_STATUS = 300;
+
+    /** m_savings_account.interest_calculation_type_enum: 1 daily balance, 2 average daily balance. */
+    private static final class SavingsInterestCalculationType {
+
+        private SavingsInterestCalculationType() {}
+
+        static final int AVERAGE_DAILY_BALANCE = 2;
+    }
+
+    private final JdbcTemplate jdbcTemplate;
+
+    /**
+     * Writes one day's rows for every active savings account, for both savings products.
+     *
+     * Safe to run more than once for the same day: rows are keyed on (account, date) and a repeat
+     * updates in place rather than accruing twice. That matters because a day rewritten after a
+     * backdated transaction has to be able to replace what is already there.
+     *
+     * @return how many rows were written
+     */
+    @Transactional
+    public int accrueForDate(final LocalDate businessDate) {
+        final int financialYearBeginningMonth = financialYearBeginningMonth();
+        final List<Map<String, Object>> accounts = jdbcTemplate.queryForList("""
+                SELECT sa.id, sa.product_id, sa.activatedon_date,
+                       sp.nominal_annual_interest_rate            AS rate,
+                       sp.interest_posting_period_enum            AS posting_period,
+                       sp.interest_compounding_period_enum        AS compounding_period,
+                       sp.interest_calculation_type_enum          AS calculation_type,
+                       sp.interest_calculation_days_in_year_type_enum AS days_in_year,
+                       sa.min_balance_for_interest_calculation    AS min_balance
+                  FROM m_savings_account sa
+                  JOIN m_savings_product sp ON sp.id = sa.product_id
+                 WHERE sp.deposit_type_enum = ?
+                   AND sa.status_enum = ?
+                   AND sa.activatedon_date IS NOT NULL
+                   AND sa.activatedon_date <= ?
+                 ORDER BY sa.product_id, sa.id
+                """, SAVINGS_DEPOSIT_TYPE, ACTIVE_STATUS, businessDate);
+
+        int written = 0;
+        for (final Map<String, Object> account : accounts) {
+            written += accrueOneAccount(account, businessDate, financialYearBeginningMonth) ? 1 : 0;
+        }
+        log.info("Savings daily interest: wrote {} rows for {}", written, businessDate);
+        return written;
+    }
+
+    /**
+     * Opens the ledger for one newly activated account.
+     *
+     * <p>
+     * The nightly run would pick the account up on its own, but not until tomorrow, and until then
+     * the account is simply absent from the ledger — which reads as though it is not being accrued at
+     * all. Called from activation, it writes the account's first row there and then, so an account is
+     * on the ledger from the day it opens.
+     *
+     * <p>
+     * Only savings accounts are accrued. Anything else — a term or recurring deposit — is left alone,
+     * and a failure is logged rather than raised: the activation itself has succeeded and must not be
+     * rolled back because the ledger could not be opened. The nightly run will pick it up.
+     *
+     * <p>
+     * Runs in the caller's transaction, deliberately. Activation sets the account active in that
+     * transaction and has not committed yet, so a REQUIRES_NEW transaction here would read the row as
+     * it was before — still approved, not yet active — find nothing to accrue, and return quietly
+     * having done nothing. Joining the caller sees the activation, and the status is not re-checked
+     * for the same reason: the value in the database is the pre-activation one until commit.
+     *
+     * @return true if a row was written
+     */
+    @Transactional
+    public boolean accrueOnActivation(final Long savingsAccountId, final LocalDate businessDate) {
+        try {
+            final List<Map<String, Object>> accounts = jdbcTemplate.queryForList("""
+                    SELECT sa.id, sa.product_id, sa.activatedon_date,
+                           sp.nominal_annual_interest_rate            AS rate,
+                           sp.interest_posting_period_enum            AS posting_period,
+                           sp.interest_compounding_period_enum        AS compounding_period,
+                           sp.interest_calculation_type_enum          AS calculation_type,
+                           sp.interest_calculation_days_in_year_type_enum AS days_in_year,
+                           sa.min_balance_for_interest_calculation    AS min_balance
+                      FROM m_savings_account sa
+                      JOIN m_savings_product sp ON sp.id = sa.product_id
+                     WHERE sa.id = ? AND sp.deposit_type_enum = ?
+                       AND sa.activatedon_date IS NOT NULL AND sa.activatedon_date <= ?
+                    """, savingsAccountId, SAVINGS_DEPOSIT_TYPE, businessDate);
+
+            if (accounts.isEmpty()) {
+                return false;
+            }
+
+            final boolean written = accrueOneAccount(accounts.get(0), businessDate, financialYearBeginningMonth());
+            if (written) {
+                log.info("Savings daily interest: opened the ledger for newly activated account {}", savingsAccountId);
+            }
+            return written;
+        } catch (final RuntimeException e) {
+            log.error("Savings daily interest: could not open the ledger for account {} on activation; the nightly run will "
+                    + "pick it up", savingsAccountId, e);
+            return false;
+        }
+    }
+
+    private boolean accrueOneAccount(final Map<String, Object> account, final LocalDate businessDate,
+            final int financialYearBeginningMonth) {
+        final Long accountId = ((Number) account.get("id")).longValue();
+        final Long productId = ((Number) account.get("product_id")).longValue();
+        final LocalDate activatedOn = ((java.sql.Date) account.get("activatedon_date")).toLocalDate();
+        final BigDecimal rate = (BigDecimal) account.get("rate");
+        final int postingPeriod = ((Number) account.get("posting_period")).intValue();
+        final Number compounding = (Number) account.get("compounding_period");
+        final Number calcType = (Number) account.get("calculation_type");
+        final int daysInYear = daysInYear(account.get("days_in_year"), businessDate);
+        final BigDecimal minBalance = (BigDecimal) account.get("min_balance");
+
+        // The account's row is the only thing that carries the chain forward: it holds the balance
+        // the last accrued day closed on and the cycle's running total. Its absence means this is
+        // the account's first day.
+        //
+        // The ledger keeps one row per account, so the row is read and then rewritten in place with
+        // today's figures. Only a row for a day before today can be carried forward — one already
+        // stamped with today or later means the day has been accrued and re-reading it as "previous"
+        // would compound the same day's interest onto itself.
+        final List<Map<String, Object>> previous = jdbcTemplate.queryForList("""
+                SELECT balance_date, closing_balance, cycle_cumulative_interest, cycle_number,
+                       cycle_start_date, cycle_end_date, is_posting_day
+                  FROM m_savings_daily_interest
+                 WHERE savings_account_id = ? AND balance_date < ?
+                """, accountId, businessDate);
+
+        final BigDecimal openingBalance;
+        final BigDecimal carriedInterest;
+        final int cycleNumber;
+        final LocalDate cycleStart;
+        final LocalDate cycleEnd;
+
+        if (previous.isEmpty()) {
+            openingBalance = BigDecimal.ZERO;
+            carriedInterest = BigDecimal.ZERO;
+            cycleNumber = 1;
+            // The first row belongs to the cycle the day it records falls in, and starts at
+            // activation only when that day is still inside the account's opening cycle. Anchoring
+            // on activation alone dates the row into a cycle that closed months ago: an account
+            // opened in June, first accrued in September, would be stamped with June's cycle end
+            // and sit there permanently past its own posting date.
+            cycleEnd = SavingsInterestCycleCalculator.cycleEndDate(businessDate, postingPeriod,
+                    financialYearBeginningMonth);
+            final LocalDate gridStart = SavingsInterestCycleCalculator.cycleStartDate(businessDate, postingPeriod,
+                    financialYearBeginningMonth);
+            cycleStart = activatedOn.isAfter(gridStart) ? activatedOn : gridStart;
+        } else {
+            final Map<String, Object> prev = previous.get(0);
+            openingBalance = (BigDecimal) prev.get("closing_balance");
+            final boolean prevWasPosting = Boolean.TRUE.equals(prev.get("is_posting_day"));
+            final LocalDate prevCycleEnd = ((java.sql.Date) prev.get("cycle_end_date")).toLocalDate();
+            // A cycle is finished either because it was paid out or because its end date has gone
+            // by. The second case happens whenever the ledger has a gap over a posting date - the
+            // run was missed, or the account was accrued again after a break - and treating it as
+            // unfinished would leave the row in a cycle that ended before the day it records.
+            if (prevWasPosting || businessDate.isAfter(prevCycleEnd)) {
+                carriedInterest = BigDecimal.ZERO;
+                cycleNumber = ((Number) prev.get("cycle_number")).intValue() + 1;
+                cycleStart = prevCycleEnd.plusDays(1);
+                cycleEnd = SavingsInterestCycleCalculator.cycleEndDate(businessDate, postingPeriod,
+                        financialYearBeginningMonth);
+            } else {
+                carriedInterest = (BigDecimal) prev.get("cycle_cumulative_interest");
+                cycleNumber = ((Number) prev.get("cycle_number")).intValue();
+                cycleStart = ((java.sql.Date) prev.get("cycle_start_date")).toLocalDate();
+                cycleEnd = prevCycleEnd;
+            }
+        }
+
+        final BigDecimal movement = dayMovement(accountId, businessDate);
+        final BigDecimal closingBalance = openingBalance.add(movement);
+
+        // The minimum is a cliff, not a taper: below it nothing is earned. It is tested against
+        // whichever balance the account actually earns on, which is not always today's closing.
+        final boolean averageDailyBalance = calcType != null
+                && calcType.intValue() == SavingsInterestCalculationType.AVERAGE_DAILY_BALANCE;
+
+        final BigDecimal dailyInterest;
+        final BigDecimal cumulative;
+        final boolean belowMinimumForInterest;
+
+        if (averageDailyBalance) {
+            // Average daily balance is a statement about the whole period, not about one day:
+            // the engine averages every closing balance in the cycle and applies the rate once
+            // across all of the days at once. So what this works out is the cycle's running
+            // total, and the day's own interest is whatever that total moved by since yesterday.
+            // Early in a cycle the figure is provisional - a later deposit shifts the average and
+            // restates it - which is inherent to the method, not an artefact of writing it down.
+            final int daysSoFar = (int) (businessDate.toEpochDay() - cycleStart.toEpochDay()) + 1;
+            final BigDecimal averageBalance = averageBalanceForCycle(accountId, cycleStart, businessDate,
+                    closingBalance);
+            belowMinimumForInterest = minBalance != null && minBalance.compareTo(BigDecimal.ZERO) > 0
+                    && averageBalance.compareTo(minBalance) < 0;
+            if (belowMinimumForInterest || averageBalance.compareTo(BigDecimal.ZERO) <= 0 || rate == null
+                    || rate.compareTo(BigDecimal.ZERO) <= 0) {
+                cumulative = carriedInterest;
+                dailyInterest = BigDecimal.ZERO;
+            } else {
+                cumulative = averageBalance.multiply(rate, MC)
+                        .divide(BigDecimal.valueOf(100L), MC)
+                        .divide(BigDecimal.valueOf(daysInYear), MC)
+                        .multiply(BigDecimal.valueOf(daysSoFar), MC);
+                dailyInterest = cumulative.subtract(carriedInterest);
+            }
+        } else {
+            belowMinimumForInterest = minBalance != null && minBalance.compareTo(BigDecimal.ZERO) > 0
+                    && closingBalance.compareTo(minBalance) < 0;
+            if (belowMinimumForInterest || closingBalance.compareTo(BigDecimal.ZERO) <= 0 || rate == null
+                    || rate.compareTo(BigDecimal.ZERO) <= 0) {
+                dailyInterest = BigDecimal.ZERO;
+            } else {
+                dailyInterest = closingBalance.multiply(rate, MC)
+                        .divide(BigDecimal.valueOf(100L), MC)
+                        .divide(BigDecimal.valueOf(daysInYear), MC);
+            }
+            cumulative = carriedInterest.add(dailyInterest);
+        }
+        final boolean isPostingDay = !businessDate.isBefore(cycleEnd);
+
+        jdbcTemplate.update("""
+                INSERT INTO m_savings_daily_interest
+                    (savings_product_id, savings_account_id, balance_date, opening_balance, closing_balance,
+                     daily_interest, cycle_cumulative_interest, cycle_number, cycle_start_date, cycle_end_date,
+                     posting_date, is_posting_day, interest_rate, days_in_year, compounding_period_enum,
+                     posting_period_enum, calculation_type_enum, min_balance_for_interest, below_min_balance)
+                VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+                ON CONFLICT (savings_account_id) DO UPDATE SET
+                     balance_date = EXCLUDED.balance_date,
+                     opening_balance = EXCLUDED.opening_balance,
+                     -- Taken as computed. The interest this ledger posts is counted as movement on
+                     -- the day it was paid (see dayMovement), so the recomputed closing already
+                     -- carries it and needs no adjustment here.
+                     closing_balance = EXCLUDED.closing_balance,
+                     daily_interest = EXCLUDED.daily_interest,
+                     -- Likewise the total that was actually paid: once money has moved on the
+                     -- strength of this figure, recomputing the same day would leave the ledger
+                     -- disagreeing with the member's passbook. A posted day is settled — but only
+                     -- that day. The next day starts the new cycle's total from zero, which is what
+                     -- the accrual has computed, so it is taken as given.
+                     cycle_cumulative_interest = CASE
+                         WHEN m_savings_daily_interest.posted_amount IS NOT NULL
+                              AND m_savings_daily_interest.balance_date = EXCLUDED.balance_date
+                             THEN m_savings_daily_interest.cycle_cumulative_interest
+                         ELSE EXCLUDED.cycle_cumulative_interest END,
+                     -- Cleared when the row moves to a new day: posted_amount and the transaction
+                     -- behind it belong to the day they were paid on, and carrying them onto the
+                     -- next day would make an unposted cycle look settled.
+                     posted_amount = CASE
+                         WHEN m_savings_daily_interest.balance_date = EXCLUDED.balance_date
+                             THEN m_savings_daily_interest.posted_amount ELSE NULL END,
+                     savings_transaction_id = CASE
+                         WHEN m_savings_daily_interest.balance_date = EXCLUDED.balance_date
+                             THEN m_savings_daily_interest.savings_transaction_id ELSE NULL END,
+                     posting_run_id = CASE
+                         WHEN m_savings_daily_interest.balance_date = EXCLUDED.balance_date
+                             THEN m_savings_daily_interest.posting_run_id ELSE NULL END,
+                     cycle_number = EXCLUDED.cycle_number,
+                     cycle_start_date = EXCLUDED.cycle_start_date,
+                     cycle_end_date = EXCLUDED.cycle_end_date,
+                     posting_date = EXCLUDED.posting_date,
+                     is_posting_day = EXCLUDED.is_posting_day,
+                     below_min_balance = EXCLUDED.below_min_balance,
+                     -- The terms are re-stamped too. A row rewritten under different product terms
+                     -- must not keep the old rate beside a figure the new one produced, or the row
+                     -- stops explaining itself. Days already posted keep their money above; this
+                     -- only restates what the money was worked out from.
+                     interest_rate = EXCLUDED.interest_rate,
+                     days_in_year = EXCLUDED.days_in_year,
+                     compounding_period_enum = EXCLUDED.compounding_period_enum,
+                     posting_period_enum = EXCLUDED.posting_period_enum,
+                     calculation_type_enum = EXCLUDED.calculation_type_enum,
+                     min_balance_for_interest = EXCLUDED.min_balance_for_interest,
+                     last_recomputed_on = CURRENT_TIMESTAMP
+                """, productId, accountId, businessDate, openingBalance, closingBalance, dailyInterest, cumulative,
+                cycleNumber, cycleStart, cycleEnd, cycleEnd, isPostingDay, rate, daysInYear,
+                compounding == null ? null : compounding.intValue(), postingPeriod,
+                calcType == null ? null : calcType.intValue(), minBalance, belowMinimumForInterest);
+        return true;
+    }
+
+    /**
+     * The mean of the cycle's daily closing balances, today included.
+     *
+     * Rows already written for this cycle carry the earlier days; today's closing is not among
+     * them yet, so it is added by the caller. A day the ledger never wrote would pull the mean
+     * off, which is the other reason the chain check matters.
+     */
+    private BigDecimal averageBalanceForCycle(final Long accountId, final LocalDate cycleStart,
+            final LocalDate businessDate, final BigDecimal todaysClosing) {
+        final BigDecimal earlierSum = jdbcTemplate.queryForObject("""
+                SELECT COALESCE(SUM(closing_balance), 0) FROM m_savings_daily_interest
+                 WHERE savings_account_id = ? AND balance_date >= ? AND balance_date < ?
+                """, BigDecimal.class, accountId, cycleStart, businessDate);
+        final Long earlierDays = jdbcTemplate.queryForObject("""
+                SELECT COUNT(*) FROM m_savings_daily_interest
+                 WHERE savings_account_id = ? AND balance_date >= ? AND balance_date < ?
+                """, Long.class, accountId, cycleStart, businessDate);
+        final long days = (earlierDays == null ? 0L : earlierDays) + 1L;
+        final BigDecimal total = (earlierSum == null ? BigDecimal.ZERO : earlierSum).add(todaysClosing);
+        return total.divide(BigDecimal.valueOf(days), MC);
+    }
+
+    /**
+     * The day's net movement, interest postings included.
+     *
+     * Interest credited by this ledger counts as movement like any other credit. It has to: the
+     * ledger holds one row per account, so a balance is only ever built from the row before it, and
+     * a posting left out of the movement is a posting missing from every balance that follows. The
+     * member is paid, their passbook shows it, and the ledger would go on earning on the balance
+     * they had before - the interest silently stops compounding.
+     *
+     * It cannot double-count, because a posting only ever falls on one day and the row for that day
+     * keeps the balance the posting left it with (see the closing_balance guard in the upsert).
+     */
+    private BigDecimal dayMovement(final Long accountId, final LocalDate businessDate) {
+        final BigDecimal movement = jdbcTemplate.queryForObject("""
+                SELECT COALESCE(SUM(CASE
+                         WHEN t.transaction_type_enum IN (1, 3, 8) THEN t.amount
+                         WHEN t.transaction_type_enum IN (2, 4, 5, 7) THEN -t.amount
+                         ELSE 0 END), 0)
+                  FROM m_savings_account_transaction t
+                 WHERE t.savings_account_id = ?
+                   AND t.transaction_date = ?
+                   AND t.is_reversed = false
+                """, BigDecimal.class, accountId, businessDate);
+        return movement == null ? BigDecimal.ZERO : movement;
+    }
+
+    /**
+     * 365, 360, or the actual length of the year. The column holds the enum value, which for the
+     * two fixed options is the number itself; ACTUAL is 1 and means the calendar year.
+     */
+    private int daysInYear(final Object raw, final LocalDate businessDate) {
+        if (raw == null) {
+            return 365;
+        }
+        final int value = ((Number) raw).intValue();
+        if (value == 360 || value == 365) {
+            return value;
+        }
+        return businessDate.lengthOfYear();
+    }
+
+    private int financialYearBeginningMonth() {
+        final Integer month = jdbcTemplate.queryForObject(
+                "SELECT value FROM c_configuration WHERE name = 'financial-year-beginning-month'", Integer.class);
+        return month == null || month < 1 || month > 12 ? 1 : month;
+    }
+
+    /**
+     * Rebuilds the ledger for one account from a date forward, for when a backdated transaction
+     * changes what earlier days should have earned.
+     *
+     * Recomputing in place rather than writing correction rows: the ledger's job is to say what an
+     * account earned, and after a backdated deposit the honest answer is the new figure. The
+     * last_recomputed_on stamp is what records that the row was revisited.
+     */
+    @Transactional
+    public int recomputeAccountFrom(final long accountId, final LocalDate fromDate, final LocalDate toDate) {
+        final int financialYearBeginningMonth = financialYearBeginningMonth();
+        final List<Map<String, Object>> rows = jdbcTemplate.queryForList("""
+                SELECT sa.id, sa.product_id, sa.activatedon_date,
+                       sp.nominal_annual_interest_rate            AS rate,
+                       sp.interest_posting_period_enum            AS posting_period,
+                       sp.interest_compounding_period_enum        AS compounding_period,
+                       sp.interest_calculation_type_enum          AS calculation_type,
+                       sp.interest_calculation_days_in_year_type_enum AS days_in_year,
+                       sa.min_balance_for_interest_calculation    AS min_balance
+                  FROM m_savings_account sa
+                  JOIN m_savings_product sp ON sp.id = sa.product_id
+                 WHERE sa.id = ?
+                """, accountId);
+        if (rows.isEmpty()) {
+            return 0;
+        }
+        final Map<String, Object> account = rows.get(0);
+        int rewritten = 0;
+        for (LocalDate day = fromDate; !day.isAfter(toDate); day = day.plusDays(1)) {
+            accrueOneAccount(account, day, financialYearBeginningMonth);
+            rewritten++;
+        }
+        log.info("Savings daily interest: recomputed {} days for account {} from {}", rewritten, accountId, fromDate);
+        return rewritten;
+    }
+
+    /**
+     * Backfills every active savings account from activation up to the given date.
+     *
+     * Existing accounts have months of history the ledger knows nothing about; without this the
+     * table starts blank and the first cycle it sees is a partial one that will not reconcile
+     * against the account's own totals.
+     */
+    @Transactional
+    public int backfillAll(final LocalDate upToDate) {
+        final List<Long> accountIds = jdbcTemplate.queryForList("""
+                SELECT sa.id FROM m_savings_account sa
+                  JOIN m_savings_product sp ON sp.id = sa.product_id
+                 WHERE sp.deposit_type_enum = ? AND sa.status_enum = ?
+                   AND sa.activatedon_date IS NOT NULL
+                 ORDER BY sa.id
+                """, Long.class, SAVINGS_DEPOSIT_TYPE, ACTIVE_STATUS);
+
+        int total = 0;
+        for (final Long accountId : accountIds) {
+            final java.sql.Date activated = jdbcTemplate.queryForObject(
+                    "SELECT activatedon_date FROM m_savings_account WHERE id = ?", java.sql.Date.class, accountId);
+            if (activated == null) {
+                continue;
+            }
+            total += recomputeAccountFrom(accountId, activated.toLocalDate(), upToDate);
+        }
+        log.info("Savings daily interest: backfilled {} rows across {} accounts", total, accountIds.size());
+        return total;
+    }
+
+    /**
+     * The two checks worth running: that no day's opening lost touch with the day before it, and
+     * that the open cycle still agrees with what the account itself reports as unposted.
+     */
+    public List<String> reconcile() {
+        final List<String> problems = new ArrayList<>();
+
+        jdbcTemplate.queryForList("""
+                SELECT curr.savings_account_id, curr.balance_date, curr.opening_balance, prev.closing_balance
+                  FROM m_savings_daily_interest curr
+                  JOIN m_savings_daily_interest prev
+                    ON prev.savings_account_id = curr.savings_account_id
+                   AND prev.balance_date = curr.balance_date - INTERVAL '1 day'
+                 WHERE curr.opening_balance <> prev.closing_balance
+                 ORDER BY curr.savings_account_id, curr.balance_date
+                """).forEach(row -> problems.add(String.format(
+                        "chain break: account %s on %s opens at %s but previous day closed at %s",
+                        row.get("savings_account_id"), row.get("balance_date"), row.get("opening_balance"),
+                        row.get("closing_balance"))));
+
+        jdbcTemplate.queryForList("""
+                SELECT d.savings_account_id, d.cycle_cumulative_interest AS ledger,
+                       COALESCE(sa.total_interest_earned_derived, 0) - COALESCE(sa.total_interest_posted_derived, 0) AS account
+                  FROM m_savings_daily_interest d
+                  JOIN m_savings_account sa ON sa.id = d.savings_account_id
+                 WHERE d.balance_date = (SELECT MAX(balance_date) FROM m_savings_daily_interest
+                                          WHERE savings_account_id = d.savings_account_id)
+                   AND ABS(d.cycle_cumulative_interest
+                           - (COALESCE(sa.total_interest_earned_derived, 0)
+                              - COALESCE(sa.total_interest_posted_derived, 0))) > 0.01
+                """).forEach(row -> problems.add(String.format(
+                        "unposted mismatch: account %s ledger says %s, account says %s", row.get("savings_account_id"),
+                        row.get("ledger"), row.get("account"))));
+
+        return problems;
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/dailyinterest/SavingsInterestCycleCalculator.java

@@ -0,0 +1,146 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.portfolio.savings.dailyinterest;
+
+import java.time.LocalDate;
+import java.time.temporal.TemporalAdjusters;
+
+/**
+ * Where a posting cycle ends, for a given posting period.
+ *
+ * This mirrors SavingsHelper.determineInterestPostingPeriodEndDateFrom, which is private to the
+ * engine and works on the engine's own period objects. The daily ledger needs the same boundaries
+ * to label its rows, so the rule is restated here rather than reached into.
+ *
+ * The boundaries are calendar dates anchored on the financial year start, not anniversaries of the
+ * account: an account opened on 24 August under a quarterly product does not post on 24 November,
+ * it posts at the next quarter end on the grid. The consequence is that the first cycle of any
+ * account is a stub - activation to the first boundary - and every cycle after it is a full period.
+ *
+ * One deliberate difference from the engine. Fineract adds a day to the period end and posts on the
+ * morning after ("interest posting always occurs on next day after the period end date"), unless
+ * the savings-interest-posting-current-period-end configuration is on, in which case it posts on
+ * the period end itself. This ledger always uses the period end date, matching that configuration
+ * being enabled, which is the behaviour this feature was asked for. If the configuration is left
+ * off, the engine's own posting transaction will be dated one day later than the ledger's
+ * posting_date, and the reconciliation will show it - the amounts still agree, only the date moves.
+ */
+public final class SavingsInterestCycleCalculator {
+
+    private SavingsInterestCycleCalculator() {}
+
+    // m_savings_product.interest_posting_period_enum / SavingsPostingInterestPeriodType
+    public static final int DAILY = 1;
+    public static final int MONTHLY = 4;
+    public static final int QUARTERLY = 5;
+    public static final int BIANNUAL = 6;
+    public static final int ANNUAL = 7;
+
+    /**
+     * The last day of the cycle that {@code within} falls in - the day interest is posted.
+     *
+     * @param within
+     *            any day inside the cycle
+     * @param postingPeriodEnum
+     *            the account's posting period
+     * @param financialYearBeginningMonth
+     *            1-12, from the financial-year-beginning-month configuration
+     */
+    public static LocalDate cycleEndDate(final LocalDate within, final int postingPeriodEnum,
+            final int financialYearBeginningMonth) {
+        switch (postingPeriodEnum) {
+            case DAILY:
+                return within;
+            case MONTHLY:
+                return within.with(TemporalAdjusters.lastDayOfMonth());
+            case QUARTERLY:
+                return periodEndOnGrid(within, financialYearBeginningMonth, 3);
+            case BIANNUAL:
+                return periodEndOnGrid(within, financialYearBeginningMonth, 6);
+            case ANNUAL:
+                return periodEndOnGrid(within, financialYearBeginningMonth, 12);
+            default:
+                throw new IllegalArgumentException("Unsupported savings interest posting period: " + postingPeriodEnum);
+        }
+    }
+
+    /**
+     * The first day of the cycle that {@code within} falls in, ignoring activation. Callers hold
+     * the account's start date and take the later of the two, which is what makes cycle 1 a stub.
+     */
+    public static LocalDate cycleStartDate(final LocalDate within, final int postingPeriodEnum,
+            final int financialYearBeginningMonth) {
+        if (postingPeriodEnum == DAILY) {
+            return within;
+        }
+        final LocalDate previousEnd = cycleEndDate(within, postingPeriodEnum, financialYearBeginningMonth);
+        // The cycle containing `within` starts the day after the previous cycle ended.
+        return cycleEndDate(previousEnd.minusMonths(monthsIn(postingPeriodEnum)), postingPeriodEnum,
+                financialYearBeginningMonth).plusDays(1);
+    }
+
+    /** The cycle after the one ending on {@code cycleEnd}. */
+    public static LocalDate nextCycleEndDate(final LocalDate cycleEnd, final int postingPeriodEnum,
+            final int financialYearBeginningMonth) {
+        return cycleEndDate(cycleEnd.plusDays(1), postingPeriodEnum, financialYearBeginningMonth);
+    }
+
+    private static int monthsIn(final int postingPeriodEnum) {
+        switch (postingPeriodEnum) {
+            case MONTHLY:
+                return 1;
+            case QUARTERLY:
+                return 3;
+            case BIANNUAL:
+                return 6;
+            case ANNUAL:
+                return 12;
+            default:
+                return 0;
+        }
+    }
+
+    /**
+     * Walks the fixed grid of period ends starting at the financial year month and returns the
+     * first one on or after {@code within}.
+     *
+     * The grid is built from the financial year start rather than from January, so a year
+     * beginning in April gives quarter ends of 30 Jun, 30 Sep, 31 Dec, 31 Mar - the same dates
+     * the engine produces for the same configuration.
+     */
+    private static LocalDate periodEndOnGrid(final LocalDate within, final int financialYearBeginningMonth,
+            final int monthsPerPeriod) {
+        // Last day of the month before the financial year starts, in the year `within` falls in.
+        LocalDate gridAnchor = within.withDayOfMonth(1).withMonth(financialYearBeginningMonth).minusDays(1);
+        if (gridAnchor.isAfter(within)) {
+            gridAnchor = gridAnchor.minusYears(1);
+        }
+        LocalDate candidate = gridAnchor;
+        // At most 12/monthsPerPeriod steps land on or past `within`; the extra step guards the
+        // case where the anchor itself is the answer.
+        for (int i = 0; i <= 12 / monthsPerPeriod; i++) {
+            if (!candidate.isBefore(within)) {
+                return candidate;
+            }
+            candidate = candidate.plusDays(1).plusMonths(monthsPerPeriod).minusDays(1)
+                    .with(TemporalAdjusters.lastDayOfMonth());
+        }
+        return candidate;
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/dailyinterest/SavingsPooledInterestPostingService.java

@@ -0,0 +1,383 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.portfolio.savings.dailyinterest;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.time.LocalDate;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * Pays a savings product's accrued interest to its members, pooled through two control accounts.
+ *
+ * Stock Fineract posts interest one member at a time - debit Interest on Savings, credit Savings
+ * Control, per account - and its posting job spreads that work across a thread pool, each batch in
+ * its own transaction. That is sound double entry, but it has no seam a failure can be caught on:
+ * a run that dies at the halfway mark leaves some members paid and some not, and nothing anywhere
+ * holds the figure that would say so.
+ *
+ * This posts the product's total first, into the liability the product names as its Savings Interest
+ * Payable, and only then pays it out to members:
+ *
+ * <pre>
+ *   Dr  Savings Interest Paid / Interest On Savings   (expense, from the product)
+ *   Cr  Savings Interest Payable                      (liability, from the product)
+ *
+ *   Dr  Savings Interest Payable                      (per member)
+ *   Cr  Savings Control                               (per member, from the product)
+ * </pre>
+ *
+ * Every account named above is read from the product's own GL configuration; none is written into
+ * this class. A product that configures no payable falls back to the two seeded control accounts,
+ * which keeps products predating that mapping posting exactly as before.
+ *
+ * The whole product settles inside one transaction, and the payable has to read zero before it is
+ * allowed to commit. A failure rolls the product back entirely - nobody is half paid - and a run
+ * that never reached commit leaves a PENDING row naming the product and date for the next run.
+ *
+ * The paise problem is the one worth stating plainly. Each member's interest is rounded to two
+ * decimals, and rounded amounts do not generally add up to the rounded total. Left alone the pool
+ * ends a few paise adrift and that money is simply gone. Here the residual is worked out and given
+ * to the largest holding - the account least distorted by it - so the pool closes exactly and the
+ * amount that moved is written down in the run record.
+ */
+@Service
+@Slf4j
+@RequiredArgsConstructor
+public class SavingsPooledInterestPostingService {
+
+    /** Two decimals: what the member is actually credited. */
+    private static final int MONEY_SCALE = 2;
+    private static final RoundingMode MONEY_ROUNDING = RoundingMode.HALF_EVEN;
+
+    /**
+     * Reserved names in the product's own GL mappings, which is where the two legs of the interest
+     * bill are configured. The names are the contract between this service and the product screen —
+     * the GL codes behind them are the bank's choice, not ours, so nothing here names an account.
+     */
+    private static final String MAPPING_INTEREST_PAYABLE = "Savings Interest Payable";
+    private static final String MAPPING_INTEREST_PAID = "Savings Interest Paid";
+
+    /** Fallback control accounts, used only where the product leaves the mappings unset. */
+    private static final String GL_POSTING_CONTROL = "200304";
+    private static final String GL_POSTED_CONTROL = "200305";
+
+    /** m_savings_account_transaction.transaction_type_enum */
+    private static final int INTEREST_POSTING = 3;
+    /** acc_gl_journal_entry.entity_type_enum for a savings entry. */
+    private static final int ENTITY_TYPE_SAVINGS = 2;
+    private static final int GL_ACCOUNTS_FOR_SAVINGS_INTEREST_ON_SAVINGS = 3;
+
+    private final JdbcTemplate jdbcTemplate;
+
+    /**
+     * Posts one product's interest for one posting date.
+     *
+     * REQUIRES_NEW so that a product that fails is rolled back on its own without taking the other
+     * product's completed run down with it.
+     *
+     * @return the amount distributed, or zero if there was nothing to do
+     */
+    @Transactional(propagation = Propagation.REQUIRES_NEW)
+    public BigDecimal postForProduct(final long productId, final LocalDate postingDate) {
+        final Long completed = jdbcTemplate.queryForObject("""
+                SELECT COUNT(*) FROM m_savings_interest_posting_run
+                 WHERE savings_product_id = ? AND posting_date = ? AND status = 'COMPLETED'
+                """, Long.class, productId, postingDate);
+        if (completed != null && completed > 0) {
+            log.info("Savings interest posting: product {} already completed for {}", productId, postingDate);
+            return BigDecimal.ZERO;
+        }
+
+        // The accounts due today, with what they accrued. Anything already carrying a posting
+        // transaction is skipped, so a resumed run cannot pay somebody a second time.
+        // A savings account has no office of its own: it belongs to a client, or to a group when
+        // there is no client, and the office is theirs. The journal entries have to be raised
+        // against that office or they land in the wrong branch's books.
+        final List<Map<String, Object>> due = jdbcTemplate.queryForList("""
+                SELECT d.id AS ledger_id, d.savings_account_id, d.closing_balance,
+                       d.cycle_cumulative_interest AS gross_interest,
+                       COALESCE(c.office_id, g.office_id) AS office_id, sa.currency_code,
+                       sa.currency_digits
+                  FROM m_savings_daily_interest d
+                  JOIN m_savings_account sa ON sa.id = d.savings_account_id
+                  LEFT JOIN m_client c ON c.id = sa.client_id
+                  LEFT JOIN m_group g ON g.id = sa.group_id
+                 WHERE d.savings_product_id = ? AND d.balance_date = ? AND d.is_posting_day = true
+                   AND d.savings_transaction_id IS NULL
+                   AND d.cycle_cumulative_interest > 0
+                   AND COALESCE(c.office_id, g.office_id) IS NOT NULL
+                 ORDER BY d.savings_account_id
+                """, productId, postingDate);
+
+        if (due.isEmpty()) {
+            log.info("Savings interest posting: nothing due for product {} on {}", productId, postingDate);
+            return BigDecimal.ZERO;
+        }
+
+        final long runId = openRun(productId, postingDate, due.size());
+
+        // Round each member's share, then make the rounded shares add up. The residual is the
+        // difference between what the pool holds and what the members would otherwise receive.
+        BigDecimal grossTotal = BigDecimal.ZERO;
+        BigDecimal roundedTotal = BigDecimal.ZERO;
+        for (final Map<String, Object> row : due) {
+            final BigDecimal gross = (BigDecimal) row.get("gross_interest");
+            final BigDecimal rounded = gross.setScale(MONEY_SCALE, MONEY_ROUNDING);
+            row.put("rounded_interest", rounded);
+            grossTotal = grossTotal.add(gross);
+            roundedTotal = roundedTotal.add(rounded);
+        }
+        final BigDecimal pooled = grossTotal.setScale(MONEY_SCALE, MONEY_ROUNDING);
+        final BigDecimal residual = pooled.subtract(roundedTotal);
+
+        if (residual.compareTo(BigDecimal.ZERO) != 0) {
+            // To the largest balance: the account where a paisa is proportionally smallest.
+            final Map<String, Object> largest = due.stream()
+                    .max(Comparator.comparing(r -> (BigDecimal) r.get("closing_balance"))).orElseThrow();
+            largest.put("rounded_interest", ((BigDecimal) largest.get("rounded_interest")).add(residual));
+            log.info("Savings interest posting: residual {} assigned to account {}", residual,
+                    largest.get("savings_account_id"));
+        }
+
+        // The expense the bill is recognised against, and the liability it sits in until it reaches
+        // the members. Both come from the product: "Savings Interest Paid" if the product names one,
+        // otherwise the standard Interest On Savings mapping; "Savings Interest Payable" for the
+        // liability, falling back to the control accounts only where a product configures neither.
+        final Long interestExpenseGl = firstNonNull(namedGlAccount(productId, MAPPING_INTEREST_PAID),
+                mappedGlAccount(productId, GL_ACCOUNTS_FOR_SAVINGS_INTEREST_ON_SAVINGS));
+        final Long payableGl = namedGlAccount(productId, MAPPING_INTEREST_PAYABLE);
+        final Long postingControlGl = firstNonNull(payableGl, glAccountId(GL_POSTING_CONTROL));
+        final Long postedControlGl = payableGl != null ? payableGl : glAccountId(GL_POSTED_CONTROL);
+
+        final Long officeId = ((Number) due.get(0).get("office_id")).longValue();
+        final String currency = (String) due.get(0).get("currency_code");
+        final String poolReference = "SIP-" + productId + "-" + postingDate;
+
+        // Stage 1: the product's whole interest bill, recognised and parked in the payable.
+        journalEntry(officeId, currency, interestExpenseGl, postingDate, pooled, true, poolReference, null);
+        journalEntry(officeId, currency, postingControlGl, postingDate, pooled, false, poolReference, null);
+
+        // Stage 2: the pool moves to the account it is paid out of.
+        //
+        // Where the product names a single payable, both control legs resolve to it and this stage
+        // would debit and credit the same account for the same amount — a pair of entries that say
+        // nothing and clutter the ledger. Only a product still on the two distinct control accounts
+        // needs the transfer written.
+        if (!postingControlGl.equals(postedControlGl)) {
+            journalEntry(officeId, currency, postingControlGl, postingDate, pooled, true, poolReference, null);
+            journalEntry(officeId, currency, postedControlGl, postingDate, pooled, false, poolReference, null);
+        }
+
+        // Stage 3: out to the members, one at a time.
+        BigDecimal distributed = BigDecimal.ZERO;
+        for (final Map<String, Object> row : due) {
+            final BigDecimal amount = (BigDecimal) row.get("rounded_interest");
+            if (amount.compareTo(BigDecimal.ZERO) <= 0) {
+                continue;
+            }
+            final long accountId = ((Number) row.get("savings_account_id")).longValue();
+            final BigDecimal newBalance = ((BigDecimal) row.get("closing_balance")).add(amount);
+            // The member's own branch, which need not be the branch the pool was raised in.
+            final long accountOfficeId = ((Number) row.get("office_id")).longValue();
+
+            final long transactionId = createInterestPostingTransaction(accountId, accountOfficeId, postingDate, amount,
+                    newBalance);
+
+            journalEntry(accountOfficeId, currency, postedControlGl, postingDate, amount, true, poolReference,
+                    accountId);
+            creditMemberSavingsControl(accountOfficeId, currency, productId, postingDate, amount, poolReference,
+                    accountId, transactionId);
+
+            // closing_balance is raised here because the interest transaction has just been written
+            // and the accrual for this day has already run: nothing else will fold it in before the
+            // next day reads this row as its opening.
+            jdbcTemplate.update("""
+                    UPDATE m_savings_daily_interest
+                       SET posted_amount = ?, savings_transaction_id = ?, posting_run_id = ?,
+                           closing_balance = closing_balance + ?
+                     WHERE id = ?
+                    """, amount, transactionId, runId, amount, ((Number) row.get("ledger_id")).longValue());
+
+            jdbcTemplate.update("""
+                    UPDATE m_savings_account
+                       SET account_balance_derived = COALESCE(account_balance_derived, 0) + ?,
+                           total_interest_posted_derived = COALESCE(total_interest_posted_derived, 0) + ?
+                     WHERE id = ?
+                    """, amount, amount, accountId);
+
+            distributed = distributed.add(amount);
+        }
+
+        // The whole point of the two control accounts: if this does not hold, nothing commits.
+        if (pooled.compareTo(distributed) != 0) {
+            throw new IllegalStateException(String.format(
+                    "Savings interest posting for product %d on %s did not balance: pooled %s, distributed %s",
+                    productId, postingDate, pooled, distributed));
+        }
+
+        jdbcTemplate.update("""
+                UPDATE m_savings_interest_posting_run
+                   SET pooled_amount = ?, distributed_amount = ?, rounding_residual = ?,
+                       status = 'COMPLETED', completed_at = CURRENT_TIMESTAMP
+                 WHERE id = ?
+                """, pooled, distributed, residual, runId);
+
+        log.info("Savings interest posting: product {} on {} paid {} across {} accounts (residual {})", productId,
+                postingDate, distributed, due.size(), residual);
+        return distributed;
+    }
+
+    private long openRun(final long productId, final LocalDate postingDate, final int accountCount) {
+        jdbcTemplate.update("""
+                INSERT INTO m_savings_interest_posting_run
+                    (savings_product_id, posting_date, account_count, status)
+                VALUES (?, ?, ?, 'PENDING')
+                ON CONFLICT (savings_product_id, posting_date) DO UPDATE SET
+                    account_count = EXCLUDED.account_count, status = 'PENDING',
+                    started_at = CURRENT_TIMESTAMP, failure_reason = NULL
+                """, productId, postingDate, accountCount);
+        return jdbcTemplate.queryForObject("""
+                SELECT id FROM m_savings_interest_posting_run
+                 WHERE savings_product_id = ? AND posting_date = ?
+                """, Long.class, productId, postingDate);
+    }
+
+    private long createInterestPostingTransaction(final long accountId, final long officeId, final LocalDate date,
+            final BigDecimal amount, final BigDecimal runningBalance) {
+        jdbcTemplate.update("""
+                INSERT INTO m_savings_account_transaction
+                    (savings_account_id, office_id, is_reversed, is_reversal, is_lien_transaction,
+                     transaction_type_enum, transaction_date, amount, running_balance_derived,
+                     submitted_on_date, created_by, last_modified_by, created_on_utc, last_modified_on_utc)
+                VALUES (?, ?, false, false, false, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+                """, accountId, officeId, INTEREST_POSTING, date, amount, runningBalance, date, systemUserId(),
+                systemUserId());
+        return jdbcTemplate.queryForObject("""
+                SELECT id FROM m_savings_account_transaction
+                 WHERE savings_account_id = ? AND transaction_date = ? AND transaction_type_enum = ?
+                 ORDER BY id DESC LIMIT 1
+                """, Long.class, accountId, date, INTEREST_POSTING);
+    }
+
+    /** The member's own leg: the product's Savings Control account, credited per account. */
+    private void creditMemberSavingsControl(final long officeId, final String currency, final long productId,
+            final LocalDate date, final BigDecimal amount, final String reference, final long accountId,
+            final long transactionId) {
+        final Long savingsControlGl = mappedGlAccount(productId, 2); // SAVINGS_CONTROL
+        journalEntry(officeId, currency, savingsControlGl, date, amount, false, reference, accountId, transactionId);
+    }
+
+    private void journalEntry(final long officeId, final String currency, final Long glAccountId, final LocalDate date,
+            final BigDecimal amount, final boolean debit, final String reference, final Long savingsAccountId) {
+        journalEntry(officeId, currency, glAccountId, date, amount, debit, reference, savingsAccountId, null);
+    }
+
+    private void journalEntry(final long officeId, final String currency, final Long glAccountId, final LocalDate date,
+            final BigDecimal amount, final boolean debit, final String reference, final Long savingsAccountId,
+            final Long transactionId) {
+        jdbcTemplate.update("""
+                INSERT INTO acc_gl_journal_entry
+                    (office_id, account_id, currency_code, transaction_id, entry_date, transaction_date, type_enum,
+                     amount, description, entity_type_enum, entity_id, is_running_balance_calculated,
+                     savings_transaction_id, reversed, manual_entry, office_running_balance,
+                     organization_running_balance, created_by, last_modified_by, created_date, lastmodified_date,
+                     created_on_utc, last_modified_on_utc, submitted_on_date)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, false, ?, false, false, 0, 0, ?, ?,
+                        CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, ?)
+                """, officeId, glAccountId, currency, reference, date, date, debit ? 1 : 2, amount,
+                debit ? "Savings interest posting" : "Savings interest posted",
+                savingsAccountId == null ? null : ENTITY_TYPE_SAVINGS, savingsAccountId, transactionId,
+                systemUserId(), systemUserId(), date);
+    }
+
+    /**
+     * The user these rows are attributed to. The job runs without anybody logged in, and the audit
+     * columns are NOT NULL, so entries are stamped to the system account the scheduler uses.
+     */
+    private Long systemUserId() {
+        final List<Long> ids = jdbcTemplate.queryForList(
+                "SELECT id FROM m_appuser WHERE username = 'system' ORDER BY id LIMIT 1", Long.class);
+        return ids.isEmpty() ? 1L : ids.get(0);
+    }
+
+    private Long glAccountId(final String glCode) {
+        return jdbcTemplate.queryForObject("SELECT id FROM acc_gl_account WHERE gl_code = ?", Long.class, glCode);
+    }
+
+    private Long mappedGlAccount(final long productId, final int financialAccountType) {
+        return jdbcTemplate.queryForObject("""
+                SELECT gl_account_id FROM acc_product_mapping
+                 WHERE product_id = ? AND product_type = 2 AND financial_account_type = ?
+                 LIMIT 1
+                """, Long.class, productId, financialAccountType);
+    }
+
+    /**
+     * The GL account a product has mapped under one of the reserved names in its own GL mappings.
+     *
+     * <p>
+     * These live in {@code m_savings_product.other_gl_mappings} as a JSON document of
+     * {@code {assets|liabilities|expenses|income: [{accountName, glCode}]}} rather than in
+     * {@code acc_product_mapping}, because they are named extensions rather than one of Fineract's
+     * fixed financial account types. The name is matched across all four groups: which group a bank
+     * files it under is a presentation choice, and a payable configured under the wrong heading
+     * should still be honoured rather than silently ignored.
+     *
+     * @return the account id, or null where the product does not configure this name
+     */
+    private Long namedGlAccount(final long productId, final String accountName) {
+        // The column holds an empty string on a product saved with no named mappings, and casting
+        // that to jsonb is an error rather than an empty document — so the cast is done inside a
+        // subquery that has already filtered those rows out. Postgres is free to evaluate a WHERE
+        // clause in any order, so guarding in the same query level as the cast would only work by
+        // luck.
+        final List<Long> found = jdbcTemplate.queryForList("""
+                SELECT gl.id
+                  FROM (SELECT other_gl_mappings::jsonb AS doc
+                          FROM m_savings_product
+                         WHERE id = ?
+                           AND other_gl_mappings IS NOT NULL
+                           AND other_gl_mappings <> ''
+                           AND other_gl_mappings LIKE '{%') sp
+                  CROSS JOIN LATERAL jsonb_array_elements(
+                         COALESCE(sp.doc -> 'assets',      '[]'::jsonb)
+                      || COALESCE(sp.doc -> 'liabilities', '[]'::jsonb)
+                      || COALESCE(sp.doc -> 'expenses',    '[]'::jsonb)
+                      || COALESCE(sp.doc -> 'income',      '[]'::jsonb)
+                  ) AS m(entry)
+                  JOIN acc_gl_account gl ON gl.gl_code = m.entry ->> 'glCode'
+                 WHERE m.entry ->> 'accountName' = ?
+                 LIMIT 1
+                """, Long.class, productId, accountName);
+        return found.isEmpty() ? null : found.get(0);
+    }
+
+    private static Long firstNonNull(final Long preferred, final Long fallback) {
+        return preferred != null ? preferred : fallback;
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/dailyinterest/SavingsProductTermsCascadeService.java

@@ -0,0 +1,194 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.portfolio.savings.dailyinterest;
+
+import java.util.List;
+import java.util.Map;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * Pushes a savings product's interest terms down onto the accounts opened under it.
+ *
+ * Fineract copies rate, posting period, compounding period, calculation type and days-in-year onto
+ * each account when it is created, and the interest engine reads that copy from then on. Editing the
+ * product changes nothing for accounts that already exist: a product moved from 7% to 10% goes on
+ * paying 7% on every account opened before the edit, indefinitely and silently. Because the copies
+ * are what the engine reads, they are also what the member is actually paid.
+ *
+ * This bank's rule is that interest follows the product, so an edit has to reach the accounts. The
+ * cascade runs on the same transaction as the product update, which means an edit either lands
+ * everywhere or nowhere - no state where the product says one thing and its accounts another.
+ *
+ * Scope is deliberately narrow:
+ *
+ *   - savings only (deposit_type_enum 100). Fixed and recurring deposits keep the rate they were
+ *     contracted at; that is the nature of a term deposit and changing it retroactively would
+ *     rewrite an agreement.
+ *   - active and pending accounts only. A closed account's terms are history.
+ *   - min_balance_for_interest_calculation is never touched: it exists only on the account, so
+ *     there is nothing on the product to cascade from.
+ *
+ * Interest already posted is not disturbed. Only future accrual moves, which is what an interest
+ * rate change ordinarily means.
+ */
+@Service
+@Slf4j
+@RequiredArgsConstructor
+public class SavingsProductTermsCascadeService {
+
+    private static final int SAVINGS_DEPOSIT_TYPE = 100;
+
+    /** m_savings_account.status_enum: 100 submitted/pending approval, 200 approved, 300 active. */
+    private static final String CASCADEABLE_STATUSES = "(100, 200, 300)";
+
+    private final JdbcTemplate jdbcTemplate;
+
+    /**
+     * Copies the product's interest terms onto its savings accounts.
+     *
+     * @param productId
+     *            the product that was edited
+     * @param changes
+     *            what the update actually changed, from the command result; the cascade is skipped
+     *            when none of the interest fields are among them
+     * @return how many accounts were updated
+     */
+    @Transactional
+    public int cascadeInterestTerms(final Long productId, final Map<String, Object> changes) {
+        if (productId == null || changes == null || changes.isEmpty()) {
+            return 0;
+        }
+        if (!touchesInterestTerms(changes)) {
+            return 0;
+        }
+
+        final List<Map<String, Object>> product = jdbcTemplate.queryForList("""
+                SELECT nominal_annual_interest_rate, interest_compounding_period_enum,
+                       interest_posting_period_enum, interest_calculation_type_enum,
+                       interest_calculation_days_in_year_type_enum
+                  FROM m_savings_product
+                 WHERE id = ? AND deposit_type_enum = ?
+                """, productId, SAVINGS_DEPOSIT_TYPE);
+        if (product.isEmpty()) {
+            // Not a savings product - a fixed or recurring deposit, which is left alone.
+            return 0;
+        }
+
+        // Only rows that actually differ are written, so the count reported is the number of
+        // accounts whose terms really moved rather than the size of the product's book.
+        final int updated = jdbcTemplate.update("""
+                UPDATE m_savings_account sa
+                   SET nominal_annual_interest_rate = sp.nominal_annual_interest_rate,
+                       interest_compounding_period_enum = sp.interest_compounding_period_enum,
+                       interest_posting_period_enum = sp.interest_posting_period_enum,
+                       interest_calculation_type_enum = sp.interest_calculation_type_enum,
+                       interest_calculation_days_in_year_type_enum = sp.interest_calculation_days_in_year_type_enum
+                  FROM m_savings_product sp
+                 WHERE sp.id = sa.product_id
+                   AND sa.product_id = ?
+                   AND sp.deposit_type_enum = ?
+                   AND sa.status_enum IN """ + CASCADEABLE_STATUSES + """
+                   AND (sa.nominal_annual_interest_rate <> sp.nominal_annual_interest_rate
+                        OR sa.interest_compounding_period_enum <> sp.interest_compounding_period_enum
+                        OR sa.interest_posting_period_enum <> sp.interest_posting_period_enum
+                        OR sa.interest_calculation_type_enum <> sp.interest_calculation_type_enum
+                        OR sa.interest_calculation_days_in_year_type_enum
+                           <> sp.interest_calculation_days_in_year_type_enum)
+                """, productId, SAVINGS_DEPOSIT_TYPE);
+
+        if (updated > 0) {
+            log.info("Savings product {}: interest terms cascaded to {} account(s) — {}", productId, updated,
+                    changes.keySet());
+        }
+        return updated;
+    }
+
+    /**
+     * Whether the edit touched anything the accounts hold a copy of.
+     *
+     * The names are the API's own parameter names, which is what the update result reports.
+     */
+    private boolean touchesInterestTerms(final Map<String, Object> changes) {
+        return changes.containsKey("nominalAnnualInterestRate")
+                || changes.containsKey("interestCompoundingPeriodType")
+                || changes.containsKey("interestPostingPeriodType")
+                || changes.containsKey("interestCalculationType")
+                || changes.containsKey("interestCalculationDaysInYearType");
+    }
+
+    /**
+     * Brings every savings account in line with its product, regardless of what changed.
+     *
+     * For the accounts that drifted before the cascade existed - in this tenant, accounts opened on
+     * a 7% daily copy of a product that now reads 10% quarterly.
+     *
+     * @return how many accounts were updated
+     */
+    @Transactional
+    public int realignAllAccounts() {
+        final int updated = jdbcTemplate.update("""
+                UPDATE m_savings_account sa
+                   SET nominal_annual_interest_rate = sp.nominal_annual_interest_rate,
+                       interest_compounding_period_enum = sp.interest_compounding_period_enum,
+                       interest_posting_period_enum = sp.interest_posting_period_enum,
+                       interest_calculation_type_enum = sp.interest_calculation_type_enum,
+                       interest_calculation_days_in_year_type_enum = sp.interest_calculation_days_in_year_type_enum
+                  FROM m_savings_product sp
+                 WHERE sp.id = sa.product_id
+                   AND sp.deposit_type_enum = ?
+                   AND sa.status_enum IN """ + CASCADEABLE_STATUSES + """
+                   AND (sa.nominal_annual_interest_rate <> sp.nominal_annual_interest_rate
+                        OR sa.interest_compounding_period_enum <> sp.interest_compounding_period_enum
+                        OR sa.interest_posting_period_enum <> sp.interest_posting_period_enum
+                        OR sa.interest_calculation_type_enum <> sp.interest_calculation_type_enum
+                        OR sa.interest_calculation_days_in_year_type_enum
+                           <> sp.interest_calculation_days_in_year_type_enum)
+                """, SAVINGS_DEPOSIT_TYPE);
+        log.info("Savings interest terms realigned to product on {} account(s)", updated);
+        return updated;
+    }
+
+    /** The accounts whose terms differ from their product, for a report or a pre-flight check. */
+    public List<Map<String, Object>> findDrifted() {
+        return jdbcTemplate.queryForList("""
+                SELECT sa.id AS account_id, sa.account_no, sp.id AS product_id, sp.name AS product_name,
+                       sa.nominal_annual_interest_rate AS account_rate,
+                       sp.nominal_annual_interest_rate AS product_rate,
+                       sa.interest_posting_period_enum AS account_posting,
+                       sp.interest_posting_period_enum AS product_posting,
+                       sa.interest_calculation_type_enum AS account_calculation,
+                       sp.interest_calculation_type_enum AS product_calculation
+                  FROM m_savings_account sa
+                  JOIN m_savings_product sp ON sp.id = sa.product_id
+                 WHERE sp.deposit_type_enum = ?
+                   AND sa.status_enum IN """ + CASCADEABLE_STATUSES + """
+                   AND (sa.nominal_annual_interest_rate <> sp.nominal_annual_interest_rate
+                        OR sa.interest_compounding_period_enum <> sp.interest_compounding_period_enum
+                        OR sa.interest_posting_period_enum <> sp.interest_posting_period_enum
+                        OR sa.interest_calculation_type_enum <> sp.interest_calculation_type_enum
+                        OR sa.interest_calculation_days_in_year_type_enum
+                           <> sp.interest_calculation_days_in_year_type_enum)
+                 ORDER BY sp.id, sa.id
+                """, SAVINGS_DEPOSIT_TYPE);
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/dailyinterest/api/SavingsDailyInterestApiResource.java

@@ -0,0 +1,319 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.portfolio.savings.dailyinterest.api;
+
+import com.google.gson.Gson;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.POST;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.PathParam;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.QueryParam;
+import jakarta.ws.rs.core.MediaType;
+import java.time.LocalDate;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import lombok.RequiredArgsConstructor;
+import org.apache.fineract.infrastructure.core.service.DateUtils;
+import org.apache.fineract.portfolio.savings.dailyinterest.SavingsDailyInterestOrchestrator;
+import org.apache.fineract.portfolio.savings.dailyinterest.SavingsDailyInterestService;
+import org.apache.fineract.portfolio.savings.dailyinterest.SavingsProductTermsCascadeService;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Component;
+
+/**
+ * Reads the savings daily interest ledger, per product and per account.
+ *
+ * The per-product listing is the view this was built for: pick a product, see its accounts and
+ * where each one is in its cycle. The per-account listing is the working itself - a day per row,
+ * the balance it was taken on, and the running total resetting to zero the day interest is paid.
+ */
+@Path("/v1/savingsdailyinterest")
+@Component
+@RequiredArgsConstructor
+@Produces({ MediaType.APPLICATION_JSON })
+public class SavingsDailyInterestApiResource {
+
+    private final JdbcTemplate jdbcTemplate;
+    private final SavingsDailyInterestService accrualService;
+    private final SavingsDailyInterestOrchestrator orchestrator;
+    private final SavingsProductTermsCascadeService termsCascadeService;
+    private final Gson gson = new Gson();
+
+    /**
+     * The accounts whose interest terms differ from the product they were opened under.
+     *
+     * A product edit cascades to its accounts now, but accounts opened before that was so can still
+     * be sitting on the terms they were created with — and those copies are what the engine pays on.
+     */
+    @GET
+    @Path("/drifted")
+    public String drifted() {
+        final List<Map<String, Object>> rows = termsCascadeService.findDrifted();
+        final Map<String, Object> result = new LinkedHashMap<>();
+        result.put("count", rows.size());
+        result.put("accounts", rows);
+        return gson.toJson(result);
+    }
+
+    /** Brings every savings account's interest terms back in line with its product. */
+    @POST
+    @Path("/realign")
+    public String realign() {
+        final int updated = termsCascadeService.realignAllAccounts();
+        final Map<String, Object> result = new LinkedHashMap<>();
+        result.put("accountsRealigned", updated);
+        return gson.toJson(result);
+    }
+
+    /** The savings products carrying a ledger, with where each one is in its timetable. */
+    @GET
+    @Path("/products")
+    public String products() {
+        final List<Map<String, Object>> rows = jdbcTemplate.queryForList("""
+                SELECT p.id, p.name, p.short_name, p.nominal_annual_interest_rate AS rate,
+                       s.posting_period_enum, s.run_at_time, s.last_posting_date, s.next_posting_date,
+                       s.last_run_status, s.is_active,
+                       (SELECT COUNT(*) FROM m_savings_account sa
+                         WHERE sa.product_id = p.id AND sa.status_enum = 300) AS active_accounts,
+                       (SELECT COALESCE(SUM(d.cycle_cumulative_interest), 0)
+                          FROM m_savings_daily_interest d
+                         WHERE d.savings_product_id = p.id
+                           AND d.balance_date = (SELECT MAX(balance_date) FROM m_savings_daily_interest
+                                                  WHERE savings_product_id = p.id)) AS accrued_this_cycle
+                  FROM m_savings_product p
+                  LEFT JOIN m_savings_interest_posting_schedule s ON s.savings_product_id = p.id
+                 WHERE p.deposit_type_enum = 100
+                 ORDER BY p.id
+                """);
+        return gson.toJson(rows);
+    }
+
+    /** One product's accounts as at the latest day the ledger holds. */
+    @GET
+    @Path("/products/{productId}/accounts")
+    public String accountsForProduct(@PathParam("productId") final Long productId) {
+        final List<Map<String, Object>> rows = jdbcTemplate.queryForList("""
+                SELECT d.savings_account_id, sa.account_no, c.display_name AS client_name,
+                       d.balance_date, d.opening_balance, d.closing_balance, d.daily_interest,
+                       d.cycle_cumulative_interest, d.cycle_number, d.cycle_start_date, d.cycle_end_date,
+                       d.below_min_balance
+                  FROM m_savings_daily_interest d
+                  JOIN m_savings_account sa ON sa.id = d.savings_account_id
+                  LEFT JOIN m_client c ON c.id = sa.client_id
+                 WHERE d.savings_product_id = ?
+                   AND d.balance_date = (SELECT MAX(balance_date) FROM m_savings_daily_interest
+                                          WHERE savings_product_id = ?)
+                 ORDER BY sa.account_no
+                """, productId, productId);
+        return gson.toJson(rows);
+    }
+
+    /** One account's day-by-day working, newest first. */
+    @GET
+    @Path("/accounts/{accountId}")
+    public String accountLedger(@PathParam("accountId") final Long accountId,
+            @QueryParam("limit") final Integer limit) {
+        final int rowLimit = limit == null || limit <= 0 ? 200 : Math.min(limit, 2000);
+        final List<Map<String, Object>> rows = jdbcTemplate.queryForList("""
+                SELECT balance_date, opening_balance, closing_balance, daily_interest,
+                       cycle_cumulative_interest, cycle_number, cycle_start_date, cycle_end_date,
+                       is_posting_day, posted_amount, savings_transaction_id, below_min_balance,
+                       interest_rate, days_in_year, min_balance_for_interest, last_recomputed_on
+                  FROM m_savings_daily_interest
+                 WHERE savings_account_id = ?
+                 ORDER BY balance_date DESC
+                 LIMIT ?
+                """, accountId, rowLimit);
+        return gson.toJson(rows);
+    }
+
+    /**
+     * One row per account: where each one stands right now.
+     *
+     * <p>
+     * The ledger behind this is day-by-day and has to stay that way — interest is worked out on the
+     * balance each day carried, and a reversed backdated entry means every day after it is
+     * recomputed. What a reader wants, though, is the current position without reading thirty rows
+     * to find it, which is what {@code v_savings_interest_summary} gives: the latest day's figures
+     * per account, with the cycle total and the lifetime posted total beside them.
+     *
+     * <p>
+     * Optionally narrowed to one product, one office, or one account.
+     */
+    @GET
+    @Path("/summary")
+    public String summary(@QueryParam("productId") final Long productId, @QueryParam("officeName") final String officeName,
+            @QueryParam("accountNo") final String accountNo) {
+        final List<Object> args = new java.util.ArrayList<>();
+        final StringBuilder sql = new StringBuilder("SELECT * FROM v_savings_interest_summary WHERE 1 = 1");
+
+        if (productId != null) {
+            sql.append(" AND savings_product_id = ?");
+            args.add(productId);
+        }
+        if (officeName != null && !officeName.isBlank()) {
+            sql.append(" AND office_name = ?");
+            args.add(officeName);
+        }
+        if (accountNo != null && !accountNo.isBlank()) {
+            sql.append(" AND account_no = ?");
+            args.add(accountNo);
+        }
+        sql.append(" ORDER BY account_no");
+
+        return gson.toJson(jdbcTemplate.queryForList(sql.toString(), args.toArray()));
+    }
+
+    /**
+     * Interest actually paid to members, one row per posting.
+     *
+     * <p>
+     * Read from the savings transactions rather than the daily ledger. The ledger holds one row per
+     * account carrying the current cycle, and clears the posted amount when the next cycle opens, so
+     * it cannot answer what was paid last quarter. The transaction is the payment itself and stays.
+     *
+     * <p>
+     * {@code period} narrows to one posting rhythm, matching the product's own
+     * {@code interest_posting_period_enum}: 1 daily, 4 monthly, 5 quarterly, 6 half-yearly,
+     * 7 annual. A report screen shows each rhythm on its own, because a monthly product's
+     * month-end posting and a quarterly product's quarter-end posting are different events and
+     * mixing them reads as one uneven series.
+     */
+    @GET
+    @Path("/postings")
+    public String postings(@QueryParam("period") final Integer period, @QueryParam("productId") final Long productId,
+            @QueryParam("fromDate") final String fromDate, @QueryParam("toDate") final String toDate,
+            @QueryParam("officeName") final String officeName) {
+        final List<Object> args = new java.util.ArrayList<>();
+        final StringBuilder sql = new StringBuilder("""
+                SELECT t.id                              AS transaction_id,
+                       t.savings_account_id              AS savings_account_id,
+                       sa.account_no                     AS account_no,
+                       sa.client_id                      AS client_id,
+                       c.display_name                    AS client_name,
+                       o.name                            AS office_name,
+                       sa.product_id                     AS savings_product_id,
+                       sp.name                           AS product_name,
+                       sp.interest_posting_period_enum   AS posting_period_enum,
+                       sp.nominal_annual_interest_rate   AS interest_rate,
+                       sa.currency_code                  AS currency_code,
+                       -- Formatted here rather than left as a date: this resource serialises with a
+                       -- plain Gson, which renders a java.sql.Date as an object the browser cannot
+                       -- read back, and every posting showed as "Invalid Date".
+                       TO_CHAR(t.transaction_date, 'YYYY-MM-DD') AS posting_date,
+                       t.amount                          AS interest_amount,
+                       t.running_balance_derived         AS balance_after,
+                       (t.running_balance_derived - t.amount) AS balance_before,
+                       t.created_on_utc                  AS recorded_on
+                  FROM m_savings_account_transaction t
+                  JOIN m_savings_account sa ON sa.id = t.savings_account_id
+                  JOIN m_savings_product sp ON sp.id = sa.product_id
+                  LEFT JOIN m_client c ON c.id = sa.client_id
+                  LEFT JOIN m_office o ON o.id = c.office_id
+                 WHERE t.transaction_type_enum = 3
+                   AND t.is_reversed = false
+                   AND sp.deposit_type_enum = 100
+                """);
+
+        if (period != null) {
+            sql.append(" AND sp.interest_posting_period_enum = ? ");
+            args.add(period);
+        }
+        if (productId != null) {
+            sql.append(" AND sa.product_id = ? ");
+            args.add(productId);
+        }
+        if (fromDate != null && !fromDate.isBlank()) {
+            sql.append(" AND t.transaction_date >= ? ");
+            args.add(LocalDate.parse(fromDate));
+        }
+        if (toDate != null && !toDate.isBlank()) {
+            sql.append(" AND t.transaction_date <= ? ");
+            args.add(LocalDate.parse(toDate));
+        }
+        if (officeName != null && !officeName.isBlank()) {
+            sql.append(" AND o.name = ? ");
+            args.add(officeName);
+        }
+        sql.append(" ORDER BY t.transaction_date DESC, sa.account_no");
+
+        return gson.toJson(jdbcTemplate.queryForList(sql.toString(), args.toArray()));
+    }
+
+    /** What each posting run pooled and paid, and whether it finished. */
+    @GET
+    @Path("/runs")
+    public String runs(@QueryParam("productId") final Long productId) {
+        final String sql = """
+                SELECT r.id, r.savings_product_id, p.name AS product_name, r.posting_date, r.account_count,
+                       r.pooled_amount, r.distributed_amount, r.rounding_residual, r.status,
+                       r.failure_reason, r.started_at, r.completed_at
+                  FROM m_savings_interest_posting_run r
+                  JOIN m_savings_product p ON p.id = r.savings_product_id
+                """ + (productId == null ? "" : " WHERE r.savings_product_id = ? ")
+                + " ORDER BY r.posting_date DESC, r.savings_product_id";
+        final List<Map<String, Object>> rows = productId == null ? jdbcTemplate.queryForList(sql)
+                : jdbcTemplate.queryForList(sql, productId);
+        return gson.toJson(rows);
+    }
+
+    /**
+     * The chain check and the unposted-total check. An empty list is the answer you want: every
+     * day picks up where the last one left off, and the ledger still agrees with the accounts.
+     */
+    @GET
+    @Path("/reconcile")
+    public String reconcile() {
+        final List<String> problems = accrualService.reconcile();
+        final Map<String, Object> result = new LinkedHashMap<>();
+        result.put("clean", problems.isEmpty());
+        result.put("problemCount", problems.size());
+        result.put("problems", problems);
+        return gson.toJson(result);
+    }
+
+    /** Runs a day by hand, for a first backfill or after fixing a failed night. */
+    @POST
+    @Path("/run")
+    public String run(@QueryParam("date") final String dateParam) {
+        final LocalDate businessDate = dateParam == null || dateParam.isBlank()
+                ? LocalDate.now(DateUtils.getDateTimeZoneOfTenant())
+                : LocalDate.parse(dateParam);
+        orchestrator.runForDate(businessDate);
+        final Map<String, Object> result = new LinkedHashMap<>();
+        result.put("ranFor", businessDate.toString());
+        return gson.toJson(result);
+    }
+
+    /** Rebuilds the ledger for every account from activation to the given date. */
+    @POST
+    @Path("/backfill")
+    public String backfill(@QueryParam("upTo") final String upToParam) {
+        final LocalDate upTo = upToParam == null || upToParam.isBlank()
+                ? LocalDate.now(DateUtils.getDateTimeZoneOfTenant())
+                : LocalDate.parse(upToParam);
+        final int rows = accrualService.backfillAll(upTo);
+        final Map<String, Object> result = new LinkedHashMap<>();
+        result.put("rowsWritten", rows);
+        result.put("upTo", upTo.toString());
+        return gson.toJson(result);
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/dailyinterest/jobs/SavingsDailyInterestConfig.java

@@ -0,0 +1,52 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.portfolio.savings.dailyinterest.jobs;
+
+import org.apache.fineract.infrastructure.jobs.service.JobName;
+import org.springframework.batch.core.Job;
+import org.springframework.batch.core.Step;
+import org.springframework.batch.core.job.builder.JobBuilder;
+import org.springframework.batch.core.launch.support.RunIdIncrementer;
+import org.springframework.batch.core.repository.JobRepository;
+import org.springframework.batch.core.step.builder.StepBuilder;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.transaction.PlatformTransactionManager;
+
+@Configuration
+public class SavingsDailyInterestConfig {
+
+    @Autowired
+    private JobRepository jobRepository;
+    @Autowired
+    private PlatformTransactionManager transactionManager;
+
+    @Bean
+    protected Step savingsDailyInterestStep(SavingsDailyInterestTasklet savingsDailyInterestTasklet) {
+        return new StepBuilder(JobName.SAVINGS_DAILY_INTEREST.name(), jobRepository)
+                .tasklet(savingsDailyInterestTasklet, transactionManager).build();
+    }
+
+    @Bean
+    public Job savingsDailyInterestJob(SavingsDailyInterestTasklet savingsDailyInterestTasklet) {
+        return new JobBuilder(JobName.SAVINGS_DAILY_INTEREST.name(), jobRepository)
+                .start(savingsDailyInterestStep(savingsDailyInterestTasklet)).incrementer(new RunIdIncrementer()).build();
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/dailyinterest/jobs/SavingsDailyInterestTasklet.java

@@ -0,0 +1,52 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.portfolio.savings.dailyinterest.jobs;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.fineract.infrastructure.core.service.DateUtils;
+import org.apache.fineract.portfolio.savings.dailyinterest.SavingsDailyInterestOrchestrator;
+import org.springframework.batch.core.StepContribution;
+import org.springframework.batch.core.scope.context.ChunkContext;
+import org.springframework.batch.core.step.tasklet.Tasklet;
+import org.springframework.batch.repeat.RepeatStatus;
+import org.springframework.stereotype.Component;
+
+/**
+ * Runs the day's savings interest: accrue every account's interest for the business date, then post
+ * for the products whose cycle ends on it.
+ *
+ * <p>
+ * Until this existed the orchestrator was only reachable through its API, so the ledger accrued for
+ * as long as somebody kept calling it and posted only when somebody remembered to. Interest a bank
+ * owes its depositors is not something to run by hand.
+ */
+@Slf4j
+@RequiredArgsConstructor
+@Component
+public class SavingsDailyInterestTasklet implements Tasklet {
+
+    private final SavingsDailyInterestOrchestrator orchestrator;
+
+    @Override
+    public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
+        orchestrator.runForDate(DateUtils.getBusinessLocalDate());
+        return RepeatStatus.FINISHED;
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/data/DepositAccountDataValidator.java

@@ -97,6 +97,7 @@ import org.apache.fineract.portfolio.savings.SavingsInterestCalculationType;
 import org.apache.fineract.portfolio.savings.SavingsPeriodFrequencyType;
 import org.apache.fineract.portfolio.savings.SavingsPostingInterestPeriodType;
 import org.apache.fineract.portfolio.savings.domain.SavingsAccount;
+import org.apache.fineract.portfolio.savings.domain.SavingsAccountRepositoryWrapper;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -105,11 +106,14 @@ public class DepositAccountDataValidator {
 
     private final FromJsonHelper fromApiJsonHelper;
     private final DepositProductDataValidator productDataValidator;
+    private final SavingsAccountRepositoryWrapper savingsAccountRepositoryWrapper;
 
     @Autowired
-    public DepositAccountDataValidator(final FromJsonHelper fromApiJsonHelper, final DepositProductDataValidator productDataValidator) {
+    public DepositAccountDataValidator(final FromJsonHelper fromApiJsonHelper, final DepositProductDataValidator productDataValidator,
+            final SavingsAccountRepositoryWrapper savingsAccountRepositoryWrapper) {
         this.fromApiJsonHelper = fromApiJsonHelper;
         this.productDataValidator = productDataValidator;
+        this.savingsAccountRepositoryWrapper = savingsAccountRepositoryWrapper;
     }
 
     public void validateFixedDepositForSubmit(final String json) {
@@ -351,10 +355,40 @@ public class DepositAccountDataValidator {
             baseDataValidator.reset().parameter(maturityInstructionIdParamName).value(depositRolloverId).notNull()
                     .isOneOfTheseValues(DepositAccountOnClosureType.integerValues());
 
+            // Withdraw Deposit books the maturity proceeds straight out of the bank's cash/vault GL the
+            // moment the account matures -- before the customer has actually come in to collect it. For
+            // maturities processed automatically by the scheduled job (not a live counter transaction),
+            // that books cash as disbursed while it is still physically in the vault, so this option is
+            // disabled: every account must resolve to Transfer to Savings or a Reinvest option instead.
+            if (depositRolloverId.equals(DepositAccountOnClosureType.WITHDRAW_DEPOSIT.getValue())) {
+                baseDataValidator.reset().parameter(maturityInstructionIdParamName).value(depositRolloverId).failWithCodeAndMessage(
+                        "maturity.instruction.withdraw.deposit.not.allowed",
+                        "Withdraw Deposit is not a valid maturity instruction -- choose Transfer to Savings or a Reinvest option.");
+            }
+
+            // Partial Reinvest needs a specific kept-amount decided at the moment of closure -- there is
+            // nothing sensible to pre-commit to years in advance as a standing instruction, so it is only
+            // ever chosen manually via the Payment action, never set here.
+            if (depositRolloverId.equals(DepositAccountOnClosureType.PARTIAL_REINVEST.getValue())) {
+                baseDataValidator.reset().parameter(maturityInstructionIdParamName).value(depositRolloverId).failWithCodeAndMessage(
+                        "maturity.instruction.partial.reinvest.not.allowed",
+                        "Partial Re-Invest is not a valid standing maturity instruction -- it can only be chosen manually at closure time.");
+            }
+
             if (depositRolloverId.equals(DepositAccountOnClosureType.TRANSFER_TO_SAVINGS.getValue())) {
                 final Long transferToSavingsId = this.fromApiJsonHelper.extractLongNamed(transferToSavingsIdParamName, element);
                 baseDataValidator.reset().parameter(transferToSavingsIdParamName).value(transferToSavingsId).notNull()
                         .longGreaterThanZero();
+
+                // Transfer to Savings can only ever post into a genuine Savings account -- Current accounts
+                // live in a separate ledger/module that this maturity-closure transfer cannot write into.
+                if (transferToSavingsId != null && transferToSavingsId > 0
+                        && !this.savingsAccountRepositoryWrapper.existsWithDepositAccountType(transferToSavingsId,
+                                DepositAccountType.SAVINGS_DEPOSIT)) {
+                    baseDataValidator.reset().parameter(transferToSavingsIdParamName).value(transferToSavingsId)
+                            .failWithCodeAndMessage("transfer.to.savings.id.is.not.a.savings.account",
+                                    "The selected account is not a Savings account -- Transfer to Savings can only target a Savings account.");
+                }
             }
         }
     }
@@ -493,10 +527,40 @@ public class DepositAccountDataValidator {
             baseDataValidator.reset().parameter(maturityInstructionIdParamName).value(depositRolloverId).notNull()
                     .isOneOfTheseValues(DepositAccountOnClosureType.integerValues());
 
+            // Withdraw Deposit books the maturity proceeds straight out of the bank's cash/vault GL the
+            // moment the account matures -- before the customer has actually come in to collect it. For
+            // maturities processed automatically by the scheduled job (not a live counter transaction),
+            // that books cash as disbursed while it is still physically in the vault, so this option is
+            // disabled: every account must resolve to Transfer to Savings or a Reinvest option instead.
+            if (depositRolloverId.equals(DepositAccountOnClosureType.WITHDRAW_DEPOSIT.getValue())) {
+                baseDataValidator.reset().parameter(maturityInstructionIdParamName).value(depositRolloverId).failWithCodeAndMessage(
+                        "maturity.instruction.withdraw.deposit.not.allowed",
+                        "Withdraw Deposit is not a valid maturity instruction -- choose Transfer to Savings or a Reinvest option.");
+            }
+
+            // Partial Reinvest needs a specific kept-amount decided at the moment of closure -- there is
+            // nothing sensible to pre-commit to years in advance as a standing instruction, so it is only
+            // ever chosen manually via the Payment action, never set here.
+            if (depositRolloverId.equals(DepositAccountOnClosureType.PARTIAL_REINVEST.getValue())) {
+                baseDataValidator.reset().parameter(maturityInstructionIdParamName).value(depositRolloverId).failWithCodeAndMessage(
+                        "maturity.instruction.partial.reinvest.not.allowed",
+                        "Partial Re-Invest is not a valid standing maturity instruction -- it can only be chosen manually at closure time.");
+            }
+
             if (depositRolloverId.equals(DepositAccountOnClosureType.TRANSFER_TO_SAVINGS.getValue())) {
                 final Long transferToSavingsId = this.fromApiJsonHelper.extractLongNamed(transferToSavingsIdParamName, element);
                 baseDataValidator.reset().parameter(transferToSavingsIdParamName).value(transferToSavingsId).notNull()
                         .longGreaterThanZero();
+
+                // Transfer to Savings can only ever post into a genuine Savings account -- Current accounts
+                // live in a separate ledger/module that this maturity-closure transfer cannot write into.
+                if (transferToSavingsId != null && transferToSavingsId > 0
+                        && !this.savingsAccountRepositoryWrapper.existsWithDepositAccountType(transferToSavingsId,
+                                DepositAccountType.SAVINGS_DEPOSIT)) {
+                    baseDataValidator.reset().parameter(transferToSavingsIdParamName).value(transferToSavingsId)
+                            .failWithCodeAndMessage("transfer.to.savings.id.is.not.a.savings.account",
+                                    "The selected account is not a Savings account -- Transfer to Savings can only target a Savings account.");
+                }
             }
         }
 

fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/data/DepositAccountTransactionDataValidator.java

@@ -82,6 +82,13 @@ public class DepositAccountTransactionDataValidator {
     private static final Set<String> DEPOSIT_ACCOUNT_PRE_MATURE_CALCULATION_REQUEST_DATA_PARAMETERS = new HashSet<>(
             Arrays.asList(DepositsApiConstants.localeParamName, DepositsApiConstants.dateFormatParamName, closedOnDateParamName));
 
+    private static final Set<String> DEPOSIT_ACCOUNT_PAYMENT_REQUEST_DATA_PARAMETERS = new HashSet<>(
+            Arrays.asList(DepositsApiConstants.localeParamName, DepositsApiConstants.dateFormatParamName, closedOnDateParamName,
+                    DepositsApiConstants.noteParamName, onAccountClosureIdParamName, paymentTypeIdParamName,
+                    transactionAccountNumberParamName, checkNumberParamName, routingCodeParamName, receiptNumberParamName,
+                    bankNumberParamName, DepositsApiConstants.transferDescriptionParamName, toSavingsAccountIdParamName,
+                    DepositsApiConstants.reinvestAmountParamName));
+
     @Autowired
     public DepositAccountTransactionDataValidator(final FromJsonHelper fromApiJsonHelper) {
         this.fromApiJsonHelper = fromApiJsonHelper;
@@ -222,7 +229,15 @@ public class DepositAccountTransactionDataValidator {
 
         if (onAccountClosureId != null) {
             final DepositAccountOnClosureType accountOnClosureType = DepositAccountOnClosureType.fromInt(onAccountClosureId);
-            if (accountOnClosureType.isTransferToSavings()) {
+            if (accountOnClosureType.isPartialReinvest()) {
+                // Partial Re-Invest needs a kept-amount and a destination account that only the Payment
+                // command collects, and only its handler implements. Neither the FD nor the RD closure
+                // handler has a branch for it, so without this it would fall through to their terminal
+                // "withdraw the whole balance" case and silently pay the deposit out in cash.
+                baseDataValidator.reset().parameter(onAccountClosureIdParamName).value(onAccountClosureId).failWithCode(
+                        "partial.reinvest.not.allowed",
+                        "Partial Re-Invest is only supported through the Payment action, not account closure");
+            } else if (accountOnClosureType.isTransferToSavings()) {
                 final Long toSavingsAccountId = this.fromApiJsonHelper.extractLongNamed(toSavingsAccountIdParamName, element);
                 baseDataValidator.reset().parameter(toSavingsAccountIdParamName).value(toSavingsAccountId)
                         .cantBeBlankWhenParameterProvidedIs(onAccountClosureIdParamName,
@@ -247,6 +262,73 @@ public class DepositAccountTransactionDataValidator {
         throwExceptionIfValidationWarningsExist(dataValidationErrors);
     }
 
+    /**
+     * Validates the FD "Payment" command -- kept independent of {@link #validateClosing}, which stays exactly as-is
+     * for Close/Premature Close, so this never changes either of their existing behavior. Unlike
+     * {@code validateClosing}, reinvest is always allowed here (there is no {@code isPreMatureClose} restriction --
+     * Payment is meant to work on an Active account too), and a new Partial Reinvest closure type needs its own
+     * amount and destination-account rules.
+     */
+    public void validatePayment(final JsonCommand command) {
+        final String json = command.json();
+
+        if (StringUtils.isBlank(json)) {
+            throw new InvalidJsonException();
+        }
+
+        final Type typeOfMap = new TypeToken<Map<String, Object>>() {}.getType();
+        this.fromApiJsonHelper.checkForUnsupportedParameters(typeOfMap, json, DEPOSIT_ACCOUNT_PAYMENT_REQUEST_DATA_PARAMETERS);
+
+        final List<ApiParameterError> dataValidationErrors = new ArrayList<>();
+        final DataValidatorBuilder baseDataValidator = new DataValidatorBuilder(dataValidationErrors)
+                .resource(DepositAccountType.FIXED_DEPOSIT.resourceName());
+
+        final JsonElement element = command.parsedJson();
+
+        final LocalDate closedOnDate = this.fromApiJsonHelper.extractLocalDateNamed(closedOnDateParamName, element);
+        baseDataValidator.reset().parameter(closedOnDateParamName).value(closedOnDate).notNull();
+
+        final Integer onAccountClosureId = this.fromApiJsonHelper.extractIntegerSansLocaleNamed(onAccountClosureIdParamName, element);
+        baseDataValidator.reset().parameter(onAccountClosureIdParamName).value(onAccountClosureId).notBlank()
+                .isOneOfTheseValues(DepositAccountOnClosureType.integerValues());
+
+        if (onAccountClosureId != null) {
+            final DepositAccountOnClosureType accountOnClosureType = DepositAccountOnClosureType.fromInt(onAccountClosureId);
+            if (accountOnClosureType.isWithdarwDeposit()) {
+                baseDataValidator.reset().parameter(onAccountClosureIdParamName).value(onAccountClosureId).failWithCodeAndMessage(
+                        "withdraw.deposit.not.allowed.for.payment",
+                        "Withdraw Deposit is not supported via Payment -- choose Transfer to Savings or a Reinvest option.");
+            }
+            // Interest earned under Reinvest Principal Only has to leave the deposit somewhere -- the same
+            // destination-account rule Transfer to Savings and Partial Reinvest already need.
+            if (accountOnClosureType.isTransferToSavings() || accountOnClosureType.isPartialReinvest()
+                    || accountOnClosureType.isReinvestPrincipal()) {
+                final Long toSavingsAccountId = this.fromApiJsonHelper.extractLongNamed(toSavingsAccountIdParamName, element);
+                baseDataValidator.reset().parameter(toSavingsAccountIdParamName).value(toSavingsAccountId)
+                        .cantBeBlankWhenParameterProvidedIs(onAccountClosureIdParamName, accountOnClosureType.getCode());
+            }
+            if (accountOnClosureType.isPartialReinvest()) {
+                final BigDecimal reinvestAmount = this.fromApiJsonHelper
+                        .extractBigDecimalWithLocaleNamed(DepositsApiConstants.reinvestAmountParamName, element);
+                baseDataValidator.reset().parameter(DepositsApiConstants.reinvestAmountParamName).value(reinvestAmount).notNull()
+                        .positiveAmount();
+            }
+        }
+
+        // Validate all string payment detail fields for max length
+        final Integer paymentTypeId = this.fromApiJsonHelper.extractIntegerWithLocaleNamed(paymentTypeIdParamName, element);
+        baseDataValidator.reset().parameter(paymentTypeIdParamName).value(paymentTypeId).ignoreIfNull().integerGreaterThanZero();
+        final Set<String> paymentDetailParameters = new HashSet<>(Arrays.asList(transactionAccountNumberParamName, checkNumberParamName,
+                routingCodeParamName, receiptNumberParamName, bankNumberParamName));
+        for (final String paymentDetailParameterName : paymentDetailParameters) {
+            final String paymentDetailParameterValue = this.fromApiJsonHelper.extractStringNamed(paymentDetailParameterName, element);
+            baseDataValidator.reset().parameter(paymentDetailParameterName).value(paymentDetailParameterValue).ignoreIfNull()
+                    .notExceedingLengthOf(50);
+        }
+
+        throwExceptionIfValidationWarningsExist(dataValidationErrors);
+    }
+
     private void throwExceptionIfValidationWarningsExist(final List<ApiParameterError> dataValidationErrors) {
         if (!dataValidationErrors.isEmpty()) {
             //

fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/data/DormantAccountData.java

@@ -0,0 +1,75 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.portfolio.savings.data;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import lombok.Builder;
+import lombok.Getter;
+
+/**
+ * One account that has gone quiet, as the dormancy reports read it.
+ *
+ * <p>
+ * {@code lastCustomerTransactionDate} is the heart of it: RBI measures the silence from the last
+ * transaction the <em>customer</em> made, so interest the bank posts and charges it recovers are
+ * excluded when this is worked out. Where an account has never been transacted on, the activation
+ * date stands in — the clock has to start somewhere, and that is the day the account began.
+ */
+@Getter
+@Builder
+public class DormantAccountData {
+
+    private final Long accountId;
+    private final String accountNo;
+    private final Long clientId;
+    private final String clientName;
+    private final String officeName;
+    private final String productName;
+    private final BigDecimal balance;
+    private final String mobileNo;
+
+    /** 100 inactive, 200 dormant, 300 escheat. */
+    private final Integer subStatus;
+    private final String subStatusCode;
+
+    private final LocalDate lastCustomerTransactionDate;
+    private final Long daysIdle;
+
+    /** The product's own periods, so the report can say when the next mark falls. */
+    private final Long daysToInactive;
+    private final Long daysToDormancy;
+    private final Long daysToEscheat;
+
+    /** Escheat only — the day the account was closed and the balance taken out. */
+    private final LocalDate closedOnDate;
+
+    /**
+     * Escheat only — the day the balance was actually remitted to RBI's DEAF, or null if that has
+     * not been recorded. A null here on an escheated account means the money is out of the
+     * customer's account but not yet accounted for as having reached the fund.
+     */
+    private final LocalDate deafRemittedOn;
+
+    /** RBI's acknowledgement reference for the remittance. */
+    private final String deafReference;
+
+    /** Set if the customer later claimed the balance and it was recovered from the fund. */
+    private final LocalDate deafRefundedOn;
+}

fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/data/SavingsAccountTransactionDataValidator.java

@@ -69,7 +69,8 @@ public class SavingsAccountTransactionDataValidator {
     private final FromJsonHelper fromApiJsonHelper;
     private static final Set<String> SAVINGS_ACCOUNT_HOLD_AMOUNT_REQUEST_DATA_PARAMETERS = new HashSet<>(
             Arrays.asList(transactionDateParamName, SavingsApiConstants.dateFormatParamName, SavingsApiConstants.localeParamName,
-                    transactionAmountParamName, lienAllowedParamName, SavingsApiConstants.reasonForBlockParamName));
+                    transactionAmountParamName, lienAllowedParamName, SavingsApiConstants.reasonForBlockParamName,
+                    SavingsApiConstants.holdCategoryParamName));
     private final ConfigurationDomainService configurationDomainService;
 
     public void validateTransactionWithPivotDate(final LocalDate transactionDate, final SavingsAccount savingsAccount) {

fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/domain/DepositAccountAssembler.java

@@ -32,6 +32,7 @@ import static org.apache.fineract.portfolio.savings.DepositsApiConstants.expecte
 import static org.apache.fineract.portfolio.savings.DepositsApiConstants.isCalendarInheritedParamName;
 import static org.apache.fineract.portfolio.savings.DepositsApiConstants.isMandatoryDepositParamName;
 import static org.apache.fineract.portfolio.savings.DepositsApiConstants.isSeniorCitizenParamName;
+import static org.apache.fineract.portfolio.savings.DepositsApiConstants.linkedAccountParamName;
 import static org.apache.fineract.portfolio.savings.DepositsApiConstants.seniorCitizenInterestRateParamName;
 import static org.apache.fineract.portfolio.savings.DepositsApiConstants.mandatoryRecommendedDepositAmountParamName;
 import static org.apache.fineract.portfolio.savings.DepositsApiConstants.maturityInstructionIdParamName;
@@ -68,6 +69,7 @@ import java.util.Locale;
 import java.util.Set;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.fineract.infrastructure.core.api.JsonCommand;
+import org.apache.fineract.infrastructure.core.exception.GeneralPlatformDomainRuleException;
 import org.apache.fineract.infrastructure.core.exception.InvalidJsonException;
 import org.apache.fineract.infrastructure.core.exception.UnsupportedParameterException;
 import org.apache.fineract.infrastructure.core.serialization.FromJsonHelper;
@@ -87,6 +89,7 @@ import org.apache.fineract.portfolio.group.exception.CenterNotActiveException;
 import org.apache.fineract.portfolio.group.exception.ClientNotInGroupException;
 import org.apache.fineract.portfolio.group.exception.GroupNotActiveException;
 import org.apache.fineract.portfolio.interestratechart.domain.InterestRateChart;
+import org.apache.fineract.portfolio.interestratechart.domain.InterestRateChartFields;
 import org.apache.fineract.portfolio.paymentdetail.domain.PaymentDetail;
 import org.apache.fineract.portfolio.paymentdetail.domain.PaymentDetailAssembler;
 import org.apache.fineract.portfolio.savings.DepositAccountOnClosureType;
@@ -97,9 +100,11 @@ import org.apache.fineract.portfolio.savings.SavingsInterestCalculationType;
 import org.apache.fineract.portfolio.savings.SavingsPeriodFrequencyType;
 import org.apache.fineract.portfolio.savings.SavingsPostingInterestPeriodType;
 import org.apache.fineract.portfolio.savings.data.SavingsAccountTransactionDTO;
+import org.apache.fineract.portfolio.savings.data.FdInterestRateEffectiveData;
 import org.apache.fineract.portfolio.savings.exception.FixedDepositProductNotFoundException;
 import org.apache.fineract.portfolio.savings.exception.RecurringDepositProductNotFoundException;
 import org.apache.fineract.portfolio.savings.exception.SavingsProductNotFoundException;
+import org.apache.fineract.portfolio.savings.service.FdBaseInterestRateReadPlatformService;
 import org.apache.fineract.useradministration.domain.AppUser;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
@@ -123,6 +128,7 @@ public class DepositAccountAssembler {
 
     private final ExternalIdFactory externalIdFactory;
     private final SavingsAccountAssembler savingsAccountAssembler;
+    private final FdBaseInterestRateReadPlatformService fdBaseInterestRateReadPlatformService;
 
     @Autowired
     public DepositAccountAssembler(final SavingsAccountTransactionSummaryWrapper savingsAccountTransactionSummaryWrapper,
@@ -134,7 +140,8 @@ public class DepositAccountAssembler {
             final RecurringDepositProductRepository recurringDepositProductRepository,
             final AccountTransfersReadPlatformService accountTransfersReadPlatformService, final PlatformSecurityContext context,
             final PaymentDetailAssembler paymentDetailAssembler, ExternalIdFactory externalIdFactory,
-            final SavingsAccountAssembler savingsAccountAssembler) {
+            final SavingsAccountAssembler savingsAccountAssembler,
+            final FdBaseInterestRateReadPlatformService fdBaseInterestRateReadPlatformService) {
 
         this.savingsAccountTransactionSummaryWrapper = savingsAccountTransactionSummaryWrapper;
         this.clientRepository = clientRepository;
@@ -151,6 +158,7 @@ public class DepositAccountAssembler {
         this.paymentDetailAssembler = paymentDetailAssembler;
         this.externalIdFactory = externalIdFactory;
         this.savingsAccountAssembler = savingsAccountAssembler;
+        this.fdBaseInterestRateReadPlatformService = fdBaseInterestRateReadPlatformService;
     }
 
     /**
@@ -242,6 +250,14 @@ public class DepositAccountAssembler {
             }
         }
 
+        // FD Special (fdType=SPECIAL) is a non-cumulative, monthly-interest-payout product: interest must
+        // post every month and leave the account for its linked savings account (see
+        // assembleAccountTermAndPreClosure below and the maturity-instruction override there), regardless
+        // of whatever compounding/posting period the product or the request otherwise specifies. SINGLE and
+        // DOUBLE FD types are untouched by this flag.
+        final boolean isSpecialFixedDeposit = depositAccountType.isFixedDeposit() && product instanceof FixedDepositProduct
+                && "SPECIAL".equalsIgnoreCase(((FixedDepositProduct) product).getFdType());
+
         SavingsCompoundingInterestPeriodType interestCompoundingPeriodType = null;
         final Integer interestPeriodTypeValue = command.integerValueOfParameterNamed(interestCompoundingPeriodTypeParamName);
         if (interestPeriodTypeValue != null) {
@@ -249,6 +265,13 @@ public class DepositAccountAssembler {
         } else {
             interestCompoundingPeriodType = product.interestCompoundingPeriodType();
         }
+        if (isSpecialFixedDeposit) {
+            // Keep compounding no coarser than the forced Monthly posting below -- compounded interest gets
+            // reset to zero every period anyway once transferInterestToLinkedAccount is true (see
+            // CompoundInterestHelper), so this is only about keeping the interest engine's own
+            // posting/compounding-period expectations internally consistent, not a behaviour choice.
+            interestCompoundingPeriodType = SavingsCompoundingInterestPeriodType.MONTHLY;
+        }
 
         SavingsPostingInterestPeriodType interestPostingPeriodType = null;
         final Integer interestPostingPeriodTypeValue = command.integerValueOfParameterNamed(interestPostingPeriodTypeParamName);
@@ -257,6 +280,9 @@ public class DepositAccountAssembler {
         } else {
             interestPostingPeriodType = product.interestPostingPeriodType();
         }
+        if (isSpecialFixedDeposit) {
+            interestPostingPeriodType = SavingsPostingInterestPeriodType.MONTHLY;
+        }
 
         SavingsInterestCalculationType interestCalculationType = null;
         final Integer interestCalculationTypeValue = command.integerValueOfParameterNamed(interestCalculationTypeParamName);
@@ -322,6 +348,28 @@ public class DepositAccountAssembler {
             accountChart = DepositAccountInterestRateChart.from(productChart);
         }
 
+        // A new FD priced from its product's own chart never carries a senior-citizen premium -- that
+        // concept exists only on the CBS Base Interest Rate master. So whenever staff hasn't picked a
+        // specific chart, price the account from that master's currently active version instead (the same
+        // one the Base Interest Rates screen shows and renewals already use), so a senior-citizen FD shows
+        // its premium from day one rather than only after its first renewal. RD is unaffected: this only
+        // runs when depositAccountType.isFixedDeposit(), and it's a no-op wherever no active base-rate
+        // version exists for the product's FD type, in which case the product's own chart above stands.
+        if (depositAccountType.isFixedDeposit() && accountChart != null && !command.parameterExists(chartIdParamName)
+                && product instanceof FixedDepositProduct) {
+            final String fdType = ((FixedDepositProduct) product).getFdType();
+            if (fdType != null) {
+                final FdInterestRateEffectiveData activeBaseRates = this.fdBaseInterestRateReadPlatformService
+                        .retrieveActiveInterestRatesByType(fdType).stream().findFirst().orElse(null);
+                if (activeBaseRates != null && activeBaseRates.getSlabs() != null && !activeBaseRates.getSlabs().isEmpty()) {
+                    final InterestRateChartFields baseChartFields = DepositAccountDomainServiceJpa.baseChartFieldsOf(activeBaseRates);
+                    final Collection<DepositAccountInterestRateChart.SlabSnapshot> baseChartSlabs = DepositAccountDomainServiceJpa
+                            .baseChartSlabsOf(activeBaseRates, product.currency().getCode());
+                    accountChart.refreshFromSlabSnapshots(baseChartFields, baseChartSlabs);
+                }
+            }
+        }
+
         boolean withHoldTax = product.withHoldTax();
         if (command.parameterExists(withHoldTaxParamName)) {
             withHoldTax = command.booleanPrimitiveValueOfParameterNamed(withHoldTaxParamName);
@@ -338,7 +386,7 @@ public class DepositAccountAssembler {
         if (depositAccountType.isFixedDeposit()) {
             final DepositProductTermAndPreClosure prodTermAndPreClosure = ((FixedDepositProduct) product).depositProductTermAndPreClosure();
             final DepositAccountTermAndPreClosure accountTermAndPreClosure = this.assembleAccountTermAndPreClosure(command,
-                    prodTermAndPreClosure);
+                    prodTermAndPreClosure, isSpecialFixedDeposit);
 
             FixedDepositAccount fdAccount = FixedDepositAccount.createNewApplicationForSubmittal(client, group, product, fieldOfficer,
                     accountNo, externalIdFactory.create(externalId), accountType, submittedOnDate, submittedBy, interestRate,
@@ -352,7 +400,7 @@ public class DepositAccountAssembler {
             final DepositProductTermAndPreClosure prodTermAndPreClosure = ((RecurringDepositProduct) product)
                     .depositProductTermAndPreClosure();
             final DepositAccountTermAndPreClosure accountTermAndPreClosure = this.assembleAccountTermAndPreClosure(command,
-                    prodTermAndPreClosure);
+                    prodTermAndPreClosure, false);
 
             final DepositProductRecurringDetail prodRecurringDetail = ((RecurringDepositProduct) product).depositRecurringDetail();
             final DepositAccountRecurringDetail accountRecurringDetail = this.assembleAccountRecurringDetail(command,
@@ -392,7 +440,7 @@ public class DepositAccountAssembler {
     }
 
     public DepositAccountTermAndPreClosure assembleAccountTermAndPreClosure(final JsonCommand command,
-            final DepositProductTermAndPreClosure productTermAndPreclosure) {
+            final DepositProductTermAndPreClosure productTermAndPreclosure, final boolean forceMonthlyPayoutToLinkedSavings) {
         final DepositPreClosureDetail productPreClosure = (productTermAndPreclosure == null) ? null
                 : productTermAndPreclosure.depositPreClosureDetail();
         final DepositTermDetail productTerm = (productTermAndPreclosure == null) ? null : productTermAndPreclosure.depositTermDetail();
@@ -407,17 +455,34 @@ public class DepositAccountAssembler {
         final SavingsPeriodFrequencyType depositPeriodFrequency = SavingsPeriodFrequencyType.fromInt(depositPeriodFrequencyId);
         final SavingsAccount account = null;
         final LocalDate expectedFirstDepositOnDate = command.localDateValueOfParameterNamed(expectedFirstDepositOnDateParamName);
-        final Boolean trasferInterest = command.booleanPrimitiveValueOfParameterNamed(transferInterestToSavingsParamName);
+        Boolean trasferInterest = command.booleanPrimitiveValueOfParameterNamed(transferInterestToSavingsParamName);
 
         // calculate maturity amount
         final BigDecimal maturityAmount = null;// calculated and updated in
                                                // account
         final LocalDate maturityDate = null;// calculated and updated in account
         final Integer accountOnClosureTypeId = command.integerValueOfParameterNamed(maturityInstructionIdParamName);
-        final DepositAccountOnClosureType accountOnClosureType = accountOnClosureTypeId != null
+        DepositAccountOnClosureType accountOnClosureType = accountOnClosureTypeId != null
                 ? DepositAccountOnClosureType.fromInt(accountOnClosureTypeId)
                 : null;
-        final Long transferToSavingsId = command.longValueOfParameterNamed(transferToSavingsIdParamName);
+        Long transferToSavingsId = command.longValueOfParameterNamed(transferToSavingsIdParamName);
+
+        if (forceMonthlyPayoutToLinkedSavings) {
+            final Long linkedSavingsAccountId = command.longValueOfParameterNamed(linkedAccountParamName);
+            if (linkedSavingsAccountId == null) {
+                throw new GeneralPlatformDomainRuleException("error.msg.fixeddepositaccount.special.requires.linked.savings.account",
+                        "FD Special (Monthly Interest Payout) requires a linked savings account to be selected.");
+            }
+            // Non-cumulative payout FD: every month's interest leaves for the linked savings account
+            // (TransferInterestToSavingsTasklet) instead of compounding, and maturity re-uses the existing
+            // "Transfer to Savings" maturity-instruction path (see
+            // DepositAccountWritePlatformServiceJpaRepositoryImpl#updateMaturityDetails) to move the
+            // principal out and close the account automatically, with no staff action needed.
+            trasferInterest = true;
+            transferToSavingsId = linkedSavingsAccountId;
+            accountOnClosureType = DepositAccountOnClosureType.TRANSFER_TO_SAVINGS;
+        }
+
         return DepositAccountTermAndPreClosure.createNew(updatedProductPreClosure, updatedProductTerm, account, depositAmount,
                 maturityAmount, maturityDate, depositPeriod, depositPeriodFrequency, expectedFirstDepositOnDate, accountOnClosureType,
                 trasferInterest, transferToSavingsId);

fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/domain/DepositAccountDomainService.java

@@ -35,6 +35,14 @@ public interface DepositAccountDomainService {
     SavingsAccountTransaction handleFDDeposit(FixedDepositAccount account, DateTimeFormatter fmt, LocalDate transactionDate,
             BigDecimal transactionAmount, PaymentDetail paymentDetail);
 
+    /**
+     * As above, but lets the caller declare the deposit as an internal account-to-account movement rather
+     * than cash taken over the counter. Used by reinvestment on maturity, where the funds come straight
+     * from the matured deposit and must post against the transfer-suspense GL instead of cash/vault.
+     */
+    SavingsAccountTransaction handleFDDeposit(FixedDepositAccount account, DateTimeFormatter fmt, LocalDate transactionDate,
+            BigDecimal transactionAmount, PaymentDetail paymentDetail, boolean isAccountTransfer);
+
     SavingsAccountTransaction handleRDDeposit(RecurringDepositAccount account, DateTimeFormatter fmt, LocalDate transactionDate,
             BigDecimal transactionAmount, PaymentDetail paymentDetail, boolean isRegularTransaction);
 
@@ -56,4 +64,7 @@ public interface DepositAccountDomainService {
 
     Long handleRDAccountPreMatureClosure(RecurringDepositAccount account, PaymentDetail paymentDetail, AppUser user, JsonCommand command,
             Map<String, Object> changes);
+
+    Long handleFDAccountPayment(FixedDepositAccount account, PaymentDetail paymentDetail, AppUser user, JsonCommand command,
+            Map<String, Object> changes);
 }

fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/domain/DepositAccountDomainServiceJpa.java

@@ -19,6 +19,7 @@
 package org.apache.fineract.portfolio.savings.domain;
 
 import static org.apache.fineract.portfolio.savings.DepositsApiConstants.onAccountClosureIdParamName;
+import static org.apache.fineract.portfolio.savings.DepositsApiConstants.reinvestAmountParamName;
 import static org.apache.fineract.portfolio.savings.DepositsApiConstants.toSavingsAccountIdParamName;
 import static org.apache.fineract.portfolio.savings.DepositsApiConstants.transferDescriptionParamName;
 
@@ -26,6 +27,9 @@ import java.math.BigDecimal;
 import java.math.MathContext;
 import java.time.LocalDate;
 import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;
@@ -55,12 +59,18 @@ import org.apache.fineract.portfolio.calendar.domain.CalendarInstanceRepository;
 import org.apache.fineract.portfolio.calendar.domain.CalendarType;
 import org.apache.fineract.portfolio.calendar.service.CalendarUtils;
 import org.apache.fineract.portfolio.common.domain.PeriodFrequencyType;
+import org.apache.fineract.portfolio.interestratechart.domain.InterestRateChartFields;
+import org.apache.fineract.portfolio.interestratechart.domain.InterestRateChartSlabFields;
 import org.apache.fineract.portfolio.paymentdetail.domain.PaymentDetail;
 import org.apache.fineract.portfolio.savings.DepositAccountOnClosureType;
 import org.apache.fineract.portfolio.savings.DepositAccountType;
 import org.apache.fineract.portfolio.savings.DepositsApiConstants;
 import org.apache.fineract.portfolio.savings.SavingsApiConstants;
+import org.apache.fineract.portfolio.savings.SavingsPeriodFrequencyType;
 import org.apache.fineract.portfolio.savings.SavingsTransactionBooleanValues;
+import org.apache.fineract.portfolio.savings.data.FdInterestRateEffectiveData;
+import org.apache.fineract.portfolio.savings.data.FdInterestRateSlabData;
+import org.apache.fineract.portfolio.savings.service.FdBaseInterestRateReadPlatformService;
 import org.apache.fineract.portfolio.savings.service.SavingsAccountDomainService;
 import org.apache.fineract.useradministration.domain.AppUser;
 import org.springframework.stereotype.Service;
@@ -80,13 +90,28 @@ public class DepositAccountDomainServiceJpa implements DepositAccountDomainServi
     private final AccountNumberFormatRepositoryWrapper accountNumberFormatRepository;
     private final CalendarInstanceRepository calendarInstanceRepository;
     private final ExternalIdFactory externalIdFactory;
+    private final FixedDepositRenewalHistoryRepository fixedDepositRenewalHistoryRepository;
+    private final FixedDepositRenewalChartSlabHistoryRepository fixedDepositRenewalChartSlabHistoryRepository;
+    private final FdBaseInterestRateReadPlatformService fdBaseInterestRateReadPlatformService;
 
     @Transactional
     @Override
     public SavingsAccountTransaction handleWithdrawal(final SavingsAccount account, final DateTimeFormatter fmt,
             final LocalDate transactionDate, final BigDecimal transactionAmount, final PaymentDetail paymentDetail,
             final boolean applyWithdrawFee, final boolean isRegularTransaction) {
-        boolean isAccountTransfer = false;
+        final boolean isAccountTransfer = false;
+        return handleWithdrawal(account, fmt, transactionDate, transactionAmount, paymentDetail, applyWithdrawFee, isRegularTransaction,
+                isAccountTransfer);
+    }
+
+    /**
+     * As above, but lets the caller declare the withdrawal as an internal account-to-account movement
+     * rather than cash paid out over the counter. Used by reinvestment on maturity, where the balance
+     * moves straight into the new deposit and must post against the transfer-suspense GL, not cash/vault.
+     */
+    private SavingsAccountTransaction handleWithdrawal(final SavingsAccount account, final DateTimeFormatter fmt,
+            final LocalDate transactionDate, final BigDecimal transactionAmount, final PaymentDetail paymentDetail,
+            final boolean applyWithdrawFee, final boolean isRegularTransaction, final boolean isAccountTransfer) {
         boolean isInterestTransfer = false;
         boolean isWithdrawBalance = false;
         final boolean backdatedTxnsAllowedTill = false;
@@ -100,7 +125,15 @@ public class DepositAccountDomainServiceJpa implements DepositAccountDomainServi
     @Override
     public SavingsAccountTransaction handleFDDeposit(final FixedDepositAccount account, final DateTimeFormatter fmt,
             final LocalDate transactionDate, final BigDecimal transactionAmount, final PaymentDetail paymentDetail) {
-        boolean isAccountTransfer = false;
+        final boolean isAccountTransfer = false;
+        return handleFDDeposit(account, fmt, transactionDate, transactionAmount, paymentDetail, isAccountTransfer);
+    }
+
+    @Transactional
+    @Override
+    public SavingsAccountTransaction handleFDDeposit(final FixedDepositAccount account, final DateTimeFormatter fmt,
+            final LocalDate transactionDate, final BigDecimal transactionAmount, final PaymentDetail paymentDetail,
+            final boolean isAccountTransfer) {
         boolean isRegularTransaction = false;
         final boolean backdatedTxnsAllowedTill = false;
         return this.savingsAccountDomainService.handleDeposit(account, fmt, transactionDate, transactionAmount, paymentDetail,
@@ -200,16 +233,26 @@ public class DepositAccountDomainServiceJpa implements DepositAccountDomainServi
         final Integer onAccountClosureId = command.integerValueOfParameterNamed(onAccountClosureIdParamName);
         final DepositAccountOnClosureType onClosureType = DepositAccountOnClosureType.fromInt(onAccountClosureId);
         if (onClosureType.isReinvest()) {
+            // Captured before the withdrawal below empties the account, so the renewal history can
+            // record what this term actually matured at.
+            final BigDecimal maturedBalance = account.getAccountBalance();
             ExternalId externalId = this.externalIdFactory.create();
-            FixedDepositAccount reinvestedDeposit = account.reInvest(account.getAccountBalance(), externalId);
+            FixedDepositAccount reinvestedDeposit = account.reInvest(maturedBalance, externalId);
             this.depositAccountAssembler.assignSavingAccountHelpers(reinvestedDeposit);
             reinvestedDeposit.updateMaturityDateAndAmountBeforeAccountActivation(mc, isPreMatureClosure,
                     isSavingsInterestPostingAtCurrentPeriodEnd, financialYearBeginningMonth);
             this.savingsAccountRepository.saveAndFlush(reinvestedDeposit);
             autoGenerateAccountNumber(reinvestedDeposit);
-            final SavingsAccountTransaction withdrawal = this.handleWithdrawal(account, fmt, closedDate, account.getAccountBalance(),
-                    paymentDetail, false, isRegularTransaction);
+            // Renewal is an internal movement into the new deposit, not cash paid out -- post it
+            // against the transfer-suspense GL rather than crediting cash/vault.
+            final boolean isInternalTransferLeg = true;
+            final SavingsAccountTransaction withdrawal = this.handleWithdrawal(account, fmt, closedDate, maturedBalance, paymentDetail,
+                    false, isRegularTransaction, isInternalTransferLeg);
             savingsTransactionId = withdrawal.getId();
+            // Reached when a user closes the account with a re-invest instruction, rather than the
+            // maturity job acting on a standing instruction.
+            recordRenewal(account, reinvestedDeposit, maturedBalance, maturedBalance, closedDate,
+                    FixedDepositRenewalHistory.RENEWAL_TYPE_MANUAL, user);
         } else if (onClosureType.isTransferToSavings()) {
             final Long toSavingsId = command.longValueOfParameterNamed(toSavingsAccountIdParamName);
             final String transferDescription = command.stringValueOfParameterNamed(transferDescriptionParamName);
@@ -260,13 +303,58 @@ public class DepositAccountDomainServiceJpa implements DepositAccountDomainServi
         account.postMaturityInterest(isSavingsInterestPostingAtCurrentPeriodEnd, financialYearBeginningMonth);
         account.setClosedOnDate(closedDate);
         final DepositAccountOnClosureType onClosureType = DepositAccountOnClosureType.fromInt(onAccountClosureId);
-        if (onClosureType.isReinvest()) {
-            BigDecimal reInvestAmount;
-            if (onClosureType.isReinvestPrincipal()) {
-                reInvestAmount = account.getDepositAmount();
-            } else {
-                reInvestAmount = account.getAccountBalance();
-            }
+        if (onClosureType.isReinvestPrincipalAndInterest()) {
+            // Renews on the SAME account, so the customer keeps one account number however many times
+            // the deposit rolls over. Nothing moves: the whole matured balance simply becomes the new
+            // term's principal, so there is no withdrawal, no deposit and no journal entry for the
+            // rollover itself -- which also removes the transfer-suspense round trip the old
+            // close-and-reopen flow needed.
+            final BigDecimal closingPrincipal = account.getDepositAmount();
+            final BigDecimal maturedBalance = account.getAccountBalance();
+            final BigDecimal interestEarned = maturedBalance == null || closingPrincipal == null ? null
+                    : maturedBalance.subtract(closingPrincipal);
+
+            // The active CBS base interest-rate version for this FD type: the same rate card the Base
+            // Interest Rates screen shows and the account-opening wizard prices from. Used for both the
+            // new term's slabs and its senior-citizen premium, so screen and account agree.
+            final FdInterestRateEffectiveData activeBaseRates = account.fdType() == null ? null
+                    : this.fdBaseInterestRateReadPlatformService.retrieveActiveInterestRatesByType(account.fdType()).stream().findFirst()
+                            .orElse(null);
+
+            final BigDecimal currentSeniorCitizenRate = account.isSeniorCitizen()
+                    ? seniorCitizenRateFor(activeBaseRates, account.depositPeriod(), account.depositPeriodFrequency())
+                    : null;
+
+            // Captured before renewInPlace overwrites the account's chart, so the closing term's full
+            // rate-by-tenure chart (including its senior-citizen premiums) can be archived rather than lost
+            // -- renewInPlace mutates the same chart row every time, it does not create a new one.
+            final String closingChartName = account.currentChartName();
+            final List<DepositAccountInterestRateChart.SlabSnapshot> closingChartSlabs = account.currentChartSlabFields();
+            // Likewise captured before renewInPlace overwrites the account's own rate/tenure with the new
+            // term's -- needed only if this is the closing term's first-ever history row (see
+            // recordInPlaceRenewal), so that row records what this term actually ran at instead of blank.
+            final BigDecimal closingInterestRate = account.getNominalAnnualInterestRate();
+            final Integer closingTenure = account.depositPeriod();
+            final Integer closingTenureFrequencyEnum = account.depositPeriodFrequency();
+
+            account.renewInPlace(maturedBalance, closedDate, currentSeniorCitizenRate, baseChartFieldsOf(activeBaseRates),
+                    baseChartSlabsOf(activeBaseRates, account.getCurrency().getCode()));
+            account.updateMaturityDateAndAmount(mc, isPreMatureClosure, isSavingsInterestPostingAtCurrentPeriodEnd,
+                    financialYearBeginningMonth);
+            this.savingsAccountRepository.save(account);
+
+            recordInPlaceRenewal(account, closingPrincipal, interestEarned, maturedBalance, maturedBalance, closedDate,
+                    FixedDepositRenewalHistory.RENEWAL_TYPE_AUTO, user, closingChartName, closingChartSlabs, closingInterestRate,
+                    closingTenure, closingTenureFrequencyEnum);
+            changes.put("renewedInPlace", Boolean.TRUE);
+            changes.put("renewalCycleNo", account.renewalCycleNo());
+
+        } else if (onClosureType.isReinvest()) {
+            // "Re-invest principal only" still closes and reopens, because only the principal carries
+            // forward and the interest has to leave the deposit -- which needs a payout destination that
+            // an in-place renewal has nowhere to send. Left on the original flow rather than guessing.
+            final BigDecimal maturedBalance = account.getAccountBalance();
+            final BigDecimal reInvestAmount = account.getDepositAmount();
             ExternalId externalId = this.externalIdFactory.create();
 
             FixedDepositAccount reinvestedDeposit = account.reInvest(reInvestAmount, externalId);
@@ -276,18 +364,26 @@ public class DepositAccountDomainServiceJpa implements DepositAccountDomainServi
 
             this.savingsAccountRepository.saveAndFlush(reinvestedDeposit);
             autoGenerateAccountNumber(reinvestedDeposit);
+            // Renewal moves the balance internally into the new deposit -- no cash leaves the branch --
+            // so this leg is posted as an account transfer (against the transfer-suspense GL) rather
+            // than as a counter withdrawal, which would wrongly credit the cash/vault account.
+            final boolean isInternalTransferLeg = true;
             final SavingsAccountTransaction withdrawal = this.handleWithdrawal(account, fmt, closedDate, reInvestAmount, paymentDetail,
-                    false, isRegularTransaction);
+                    false, isRegularTransaction, isInternalTransferLeg);
             savingsTransactionId = withdrawal.getId();
+            // handleWithdrawal() posts this withdrawal's own journal entries, so it has to be marked as
+            // already accounted for -- exactly as the transfer-to-savings branch below does -- or the
+            // postJournalEntries() call at the end of this method posts it a second time.
+            updateAlreadyPostedTransactions(existingTransactionIds, account);
 
-            if (onClosureType.isReinvestPrincipalAndInterest()) {
-                account.updateClosedStatus();
-                account.updateOnAccountClosureStatus(onClosureType);
-            }
             changes.put("reinvestedDepositId", reinvestedDeposit.getId());
             reinvestedDeposit.approveAndActivateApplication(closedDate, user);
             this.savingsAccountRepository.save(reinvestedDeposit);
 
+            // Reached from the maturity job processing the account's standing maturity instruction.
+            recordRenewal(account, reinvestedDeposit, maturedBalance, reInvestAmount, closedDate,
+                    FixedDepositRenewalHistory.RENEWAL_TYPE_AUTO, user);
+
         } else if (onClosureType.isTransferToSavings()) {
             final SavingsAccount toSavingsAccount = this.depositAccountAssembler.assembleFrom(toSavingsId,
                     DepositAccountType.SAVINGS_DEPOSIT);
@@ -304,6 +400,7 @@ public class DepositAccountDomainServiceJpa implements DepositAccountDomainServi
             final SavingsAccountTransaction withdrawal = this.handleWithdrawal(account, fmt, closedDate, account.getAccountBalance(),
                     paymentDetail, false, isRegularTransaction);
             savingsTransactionId = withdrawal.getId();
+            updateAlreadyPostedTransactions(existingTransactionIds, account);
         }
 
         // if(!processMaturityInstructionOnly)
@@ -429,6 +526,274 @@ public class DepositAccountDomainServiceJpa implements DepositAccountDomainServi
         }
     }
 
+    /**
+     * Persists the closing term's full rate-by-tenure chart -- each slab together with its senior-citizen premium --
+     * against its {@link FixedDepositRenewalHistory} row.
+     * <p>
+     * Slabs missing a rate or a from-period are skipped -- they cannot describe a tenure band. Writes nothing when the
+     * closing term had no chart (e.g. a plain flat-rate deposit), rather than persisting an empty, meaningless archive.
+     */
+    private void archiveChartSlabs(final Long fdRenewalHistoryId, final String chartName,
+            final List<DepositAccountInterestRateChart.SlabSnapshot> snapshots, final String currencyCode) {
+        if (snapshots == null || snapshots.isEmpty()) {
+            return;
+        }
+        for (final DepositAccountInterestRateChart.SlabSnapshot snapshot : snapshots) {
+            final InterestRateChartSlabFields fields = snapshot.getFields();
+            if (fields.annualInterestRate() == null || fields.fromPeriod() == null) {
+                continue;
+            }
+            this.fixedDepositRenewalChartSlabHistoryRepository
+                    .save(FixedDepositRenewalChartSlabHistory.create(fdRenewalHistoryId, chartName, fields.description(),
+                            fields.periodType(), fields.fromPeriod(), fields.toPeriod(), fields.getAmountRangeFrom(),
+                            fields.getAmountRangeTo(), fields.annualInterestRate(), currencyCode, snapshot.getSeniorCitizenRate()));
+        }
+    }
+
+    /**
+     * Chart identity for the account snapshot, so it names the base rate version it was priced from. Package-private
+     * and static (no instance state used) so {@link DepositAccountAssembler} can reuse the exact same mapping when a
+     * new FD account is first priced from this master, instead of duplicating the logic.
+     */
+    static InterestRateChartFields baseChartFieldsOf(final FdInterestRateEffectiveData baseRates) {
+        // name and from_date are NOT NULL on the embeddable. A base version missing either would abort the
+        // whole renewal (or account creation) with a constraint violation, so treat it as "no identity to
+        // apply" instead: refreshFromSlabSnapshots keeps the chart's existing fields when handed null, and
+        // the slabs -- the part that actually prices the deposit -- still get applied.
+        if (baseRates == null || baseRates.getVersionLabel() == null || baseRates.getEffectiveFromDate() == null) {
+            return null;
+        }
+        final boolean isPrimaryGroupingByAmount = false; // the base rate card bands by tenure, never by amount
+        return InterestRateChartFields.createNew(baseRates.getVersionLabel(), baseRates.getRemarks(), baseRates.getEffectiveFromDate(),
+                baseRates.getEffectiveToDate(), isPrimaryGroupingByAmount);
+    }
+
+    /**
+     * Translates the base rate card's slabs into the shape an account chart stores, each paired with its senior-citizen
+     * premium so that figure is persisted on the account (and later archived) rather than only ever being looked up live.
+     * <p>
+     * The base master bands purely by tenure, so amount ranges are left unset -- which
+     * {@code InterestRateChartSlabFields.isAmountBetween} then treats as "any amount", exactly the intent. Slabs with no
+     * from-period are dropped, since a slab that does not say where it starts cannot be matched against a tenure.
+     */
+    static Collection<DepositAccountInterestRateChart.SlabSnapshot> baseChartSlabsOf(final FdInterestRateEffectiveData baseRates,
+            final String currencyCode) {
+        if (baseRates == null || baseRates.getSlabs() == null) {
+            return Collections.emptyList();
+        }
+        final List<DepositAccountInterestRateChart.SlabSnapshot> snapshots = new ArrayList<>();
+        for (final FdInterestRateSlabData slab : baseRates.getSlabs()) {
+            if (slab.getFromPeriod() == null || slab.getAnnualInterestRate() == null) {
+                continue;
+            }
+            final InterestRateChartSlabFields fields = InterestRateChartSlabFields.createNew(slab.getDescription(),
+                    SavingsPeriodFrequencyType.fromInt(slab.getPeriodTypeEnum()), slab.getFromPeriod(), slab.getToPeriod(), null, null,
+                    slab.getAnnualInterestRate(), currencyCode);
+            snapshots.add(new DepositAccountInterestRateChart.SlabSnapshot(fields, slab.getSeniorCitizenRate()));
+        }
+        return snapshots;
+    }
+
+    /**
+     * The senior-citizen premium from the active base rate card for a given tenure.
+     * <p>
+     * The tenure and the slab bounds are converted to a common unit before comparing, so a rate card published in years
+     * still matches a deposit taken for a number of months. Conversion stays inside a unit family -- days/weeks, or
+     * months/years -- because only those are exact; a days-based card is therefore still never matched against a
+     * months-based tenure, since "1 month" is not a fixed number of days and guessing would land the deposit in the
+     * wrong band. Null when no slab covers the tenure or the matching slab carries no premium, which leaves the
+     * account's existing rate untouched rather than silently dropping the depositor's premium.
+     */
+    private BigDecimal seniorCitizenRateFor(final FdInterestRateEffectiveData baseRates, final Integer tenure,
+            final Integer tenurePeriodTypeEnum) {
+        if (baseRates == null || baseRates.getSlabs() == null || tenure == null) {
+            return null;
+        }
+        final Integer tenureInBaseUnit = inFamilyBaseUnit(tenure, tenurePeriodTypeEnum);
+        if (tenureInBaseUnit == null) {
+            return null;
+        }
+        for (final FdInterestRateSlabData slab : baseRates.getSlabs()) {
+            if (!sameUnitFamily(tenurePeriodTypeEnum, slab.getPeriodTypeEnum())) {
+                continue;
+            }
+            final Integer slabFrom = inFamilyBaseUnit(slab.getFromPeriod(), slab.getPeriodTypeEnum());
+            if (slabFrom == null || tenureInBaseUnit < slabFrom) {
+                continue;
+            }
+            if (slab.getToPeriod() != null) {
+                final Integer slabTo = inFamilyBaseUnit(slab.getToPeriod(), slab.getPeriodTypeEnum());
+                if (slabTo == null || tenureInBaseUnit > slabTo) {
+                    continue;
+                }
+            }
+            final BigDecimal rate = slab.getSeniorCitizenRate();
+            if (rate != null && rate.compareTo(BigDecimal.ZERO) > 0) {
+                return rate;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * {@code value} restated in the finest unit of its own family -- days for DAYS/WEEKS, months for MONTHS/YEARS -- so
+     * two periods written in different but related units can be compared without losing precision. Null for an unknown
+     * unit. Enum codes are {@link SavingsPeriodFrequencyType}: DAYS(0), WEEKS(1), MONTHS(2), YEARS(3).
+     */
+    private Integer inFamilyBaseUnit(final Integer value, final Integer periodTypeEnum) {
+        if (value == null || periodTypeEnum == null) {
+            return null;
+        }
+        return switch (SavingsPeriodFrequencyType.fromInt(periodTypeEnum)) {
+            case DAYS, MONTHS -> value;
+            case WEEKS -> value * 7;
+            case YEARS -> value * 12;
+            default -> null;
+        };
+    }
+
+    /**
+     * Whether two period types convert exactly into one another. Days and weeks do; months and years do. Across those
+     * two families they do not, because a month is not a fixed number of days -- so a days-based rate card is never
+     * matched against a months-based tenure rather than guessing and landing the deposit in the wrong band.
+     */
+    private boolean sameUnitFamily(final Integer firstPeriodTypeEnum, final Integer secondPeriodTypeEnum) {
+        if (firstPeriodTypeEnum == null || secondPeriodTypeEnum == null) {
+            return false;
+        }
+        return isDayFamily(firstPeriodTypeEnum) == isDayFamily(secondPeriodTypeEnum);
+    }
+
+    private boolean isDayFamily(final Integer periodTypeEnum) {
+        final SavingsPeriodFrequencyType type = SavingsPeriodFrequencyType.fromInt(periodTypeEnum);
+        return type == SavingsPeriodFrequencyType.DAYS || type == SavingsPeriodFrequencyType.WEEKS;
+    }
+
+    /**
+     * Records a renewal that happened on the SAME account, where there is no second account row to describe the new term.
+     * <p>
+     * Called after {@link FixedDepositAccount#renewInPlace}, which has already advanced the account's cycle number,
+     * principal and maturity date -- so the closing term's figures have to be passed in rather than read back off the
+     * account, where they no longer exist. Every row for one FD shares that FD's single account id and account number;
+     * they are told apart by renewal_no, which is what makes this a one-to-many history of one account.
+     *
+     * @param closingChartName
+     *            the name of the chart the closing term was priced on, captured before renewInPlace overwrote it; null if
+     *            unavailable
+     * @param closingChartSlabs
+     *            the closing term's full rate-by-tenure chart, likewise captured before it was overwritten. Archived
+     *            against the closing term's row so its whole rate card remains queryable, not only the single effective
+     *            rate {@link FixedDepositRenewalHistory} records.
+     * @param closingInterestRate
+     *            the closing term's own {@code nominalAnnualInterestRate}, captured before renewInPlace overwrote it --
+     *            needed only when this term has no existing row yet (see below), since the account itself no longer
+     *            carries it once renewInPlace has run.
+     * @param closingTenure
+     *            the closing term's own deposit period, captured the same way and needed for the same reason.
+     * @param closingTenureFrequencyEnum
+     *            the closing term's own deposit period frequency, captured the same way and needed for the same reason.
+     */
+    private void recordInPlaceRenewal(final FixedDepositAccount account, final BigDecimal closingPrincipal,
+            final BigDecimal closingInterestEarned, final BigDecimal maturedBalance, final BigDecimal renewedAmount,
+            final LocalDate renewedOn, final String renewalType, final AppUser user, final String closingChartName,
+            final List<DepositAccountInterestRateChart.SlabSnapshot> closingChartSlabs, final BigDecimal closingInterestRate,
+            final Integer closingTenure, final Integer closingTenureFrequencyEnum) {
+
+        // The CHAIN's number, not this account's own. They differ for an FD that was renewed under the old
+        // close-and-reopen model before renewing in place: its rows are keyed on the original account's
+        // number, so keying new rows on this account's number would split the history in two and re-create
+        // a duplicate row for the term that already has one. fdAccountNumber() falls back to this account's
+        // own number when there is no chain, which is what the read side resolves to as well.
+        final String fdAccountNumber = account.fdAccountNumber();
+        final int newCycleNo = account.renewalCycleNo();
+        final Long createdById = user == null ? null : user.getId();
+
+        final List<FixedDepositRenewalHistory> existingRows = this.fixedDepositRenewalHistoryRepository
+                .findByFdAccountNumberOrderByRenewalNoAsc(fdAccountNumber);
+        FixedDepositRenewalHistory closingRow = existingRows.stream()
+                .filter(row -> Integer.valueOf(newCycleNo - 1).equals(row.getRenewalNo())).findFirst().orElse(null);
+
+        // The term that just closed has no row when this FD renews for the first time since the history
+        // table existed. Written now, from the figures captured before the rollover, so the history
+        // always begins with the term the customer originally opened -- rate and tenure included, rather
+        // than left blank, since the caller captured them before renewInPlace overwrote the account with
+        // the new term's own values.
+        if (closingRow == null) {
+            closingRow = this.fixedDepositRenewalHistoryRepository.saveAndFlush(FixedDepositRenewalHistory.create(fdAccountNumber,
+                    account.getId(), account.getId(), null, null, newCycleNo - 1, closingPrincipal, null, maturedBalance,
+                    closingPrincipal, closingInterestRate, account.getActivationDate(), renewedOn, closingTenure,
+                    closingTenureFrequencyEnum, renewalType, account.getActivationDate(), createdById));
+        }
+        closingRow.recordOutcome(closingInterestEarned, maturedBalance);
+        closingRow.markMatured();
+        this.fixedDepositRenewalHistoryRepository.save(closingRow);
+
+        archiveChartSlabs(closingRow.getId(), closingChartName, closingChartSlabs, account.getCurrency().getCode());
+
+        // The new term's own interest/maturity stay unset until it closes in turn.
+        this.fixedDepositRenewalHistoryRepository.save(FixedDepositRenewalHistory.create(fdAccountNumber, account.getId(),
+                account.getId(), null, closingRow.getId(), newCycleNo, renewedAmount, null, null, renewedAmount,
+                account.getNominalAnnualInterestRate(), renewedOn, account.maturityDate(), account.depositPeriod(),
+                account.depositPeriodFrequency(), renewalType, renewedOn, createdById));
+    }
+
+    /**
+     * Records the renewal that started {@code newTerm}, and closes off the previous term's history row.
+     * <p>
+     * Each term of an FD runs as its own deposit instance so it keeps an immutable ledger, which means the rollover event
+     * itself -- what the previous term earned, what carried forward, at what rate, automatically or by whom -- is not
+     * recoverable from the account rows alone. This writes it down explicitly.
+     * <p>
+     * The chain's first term is backfilled here too when it has no row yet: an FD opened before this table existed only
+     * gets discovered at its first renewal, and without its opening row the history would start at "Renewal 1" with no
+     * original.
+     */
+    private void recordRenewal(final FixedDepositAccount previousTerm, final FixedDepositAccount newTerm,
+            final BigDecimal maturityAmount, final BigDecimal renewedAmount, final LocalDate renewedOn, final String renewalType,
+            final AppUser user) {
+
+        final String fdAccountNumber = previousTerm.fdAccountNumber();
+        final Long originalAccountId = this.fixedDepositRenewalHistoryRepository
+                .findByFdAccountNumberOrderByRenewalNoAsc(fdAccountNumber).stream().findFirst()
+                .map(FixedDepositRenewalHistory::getOriginalSavingsAccountId)
+                .orElseGet(() -> previousTerm.reinvestedFromSavingsId() == null ? previousTerm.getId() : null);
+
+        FixedDepositRenewalHistory previousRow = this.fixedDepositRenewalHistoryRepository
+                .findBySavingsAccountIdOrderByRenewalNoDesc(previousTerm.getId()).stream().findFirst().orElse(null);
+
+        // Backfill the opening term when the chain started before this table existed, so the history
+        // always begins with the account the customer actually opened.
+        if (previousRow == null && originalAccountId != null && originalAccountId.equals(previousTerm.getId())) {
+            previousRow = this.fixedDepositRenewalHistoryRepository.saveAndFlush(FixedDepositRenewalHistory.create(fdAccountNumber,
+                    originalAccountId, previousTerm.getId(), null, null, previousTerm.renewalCycleNo(),
+                    previousTerm.getDepositAmount(), null, previousTerm.maturityAmount(), previousTerm.getDepositAmount(),
+                    previousTerm.getNominalAnnualInterestRate(), previousTerm.getActivationDate(), previousTerm.maturityDate(),
+                    previousTerm.depositPeriod(), previousTerm.depositPeriodFrequency(), renewalType, previousTerm.getActivationDate(),
+                    user == null ? null : user.getId()));
+        }
+
+        // What the closing term actually earned. maturityAmount is passed in rather than read off the
+        // account because the caller has already withdrawn the balance out of it by this point, which
+        // would make it read as zero. Recorded on the CLOSING term's own row -- every row states its own
+        // term's outcome, so a reader never has to look at the next row to find out how one term did.
+        final BigDecimal previousPrincipal = previousTerm.getDepositAmount();
+        final BigDecimal interestEarned = maturityAmount == null || previousPrincipal == null ? null
+                : maturityAmount.subtract(previousPrincipal);
+
+        if (previousRow != null) {
+            previousRow.recordOutcome(interestEarned, maturityAmount);
+            previousRow.markMatured();
+            this.fixedDepositRenewalHistoryRepository.save(previousRow);
+        }
+
+        // The new term's own interest/maturity stay unset until it closes in turn.
+        this.fixedDepositRenewalHistoryRepository.save(FixedDepositRenewalHistory.create(fdAccountNumber,
+                originalAccountId == null ? previousTerm.getId() : originalAccountId, newTerm.getId(), previousTerm.getId(),
+                previousRow == null ? null : previousRow.getId(), newTerm.renewalCycleNo(), renewedAmount, null, null, renewedAmount,
+                newTerm.getNominalAnnualInterestRate(), renewedOn, newTerm.maturityDate(), newTerm.depositPeriod(),
+                newTerm.depositPeriodFrequency(), renewalType, renewedOn, user == null ? null : user.getId()));
+    }
+
     @Transactional
     @Override
     public Long handleFDAccountPreMatureClosure(final FixedDepositAccount account, final PaymentDetail paymentDetail, final AppUser user,
@@ -474,6 +839,9 @@ public class DepositAccountDomainServiceJpa implements DepositAccountDomainServi
             final SavingsAccountTransaction withdrawal = this.handleWithdrawal(account, fmt, closedDate, account.getAccountBalance(),
                     paymentDetail, false, isRegularTransaction);
             savingsTransactionId = withdrawal.getId();
+            // handleWithdrawal() posts this withdrawal's journal entries itself, so mark it as already
+            // accounted for or the postJournalEntries() call below posts it a second time.
+            updateAlreadyPostedTransactions(existingTransactionIds, account);
         }
 
         account.prematureClosure(user, command, changes);
@@ -484,6 +852,238 @@ public class DepositAccountDomainServiceJpa implements DepositAccountDomainServi
         return savingsTransactionId;
     }
 
+    /**
+     * A staff-triggered, always-available alternative to Premature Close (Active-only, no reinvest) and Close
+     * (Matured-only): works on an FD in either state, and adds a Partial Reinvest option neither of those two support
+     * -- part of the matured amount renews on this same account via {@link FixedDepositAccount#renewInPlace}, the rest
+     * transfers out to a savings account picked at the moment of the request. Full reinvest here also goes through
+     * {@code renewInPlace} rather than the legacy close-and-reopen {@link FixedDepositAccount#reInvest}, which is what
+     * the existing manual Close command still uses today.
+     * <p>
+     * Deliberately independent of {@link #handleFDAccountClosure} and {@link #handleFDAccountPreMatureClosure} --
+     * neither of those two methods is touched, so the existing Close/Premature Close buttons keep behaving exactly as
+     * before.
+     */
+    @Transactional
+    @Override
+    public Long handleFDAccountPayment(final FixedDepositAccount account, final PaymentDetail paymentDetail, final AppUser user,
+            final JsonCommand command, final Map<String, Object> changes) {
+
+        final boolean isSavingsInterestPostingAtCurrentPeriodEnd = this.configurationDomainService
+                .isSavingsInterestPostingAtCurrentPeriodEnd();
+        final Integer financialYearBeginningMonth = this.configurationDomainService.retrieveFinancialYearBeginningMonth();
+
+        boolean isRegularTransaction = false;
+        boolean isAccountTransfer = false;
+        final boolean isPreMatureClosure = false;
+        final Set<Long> existingTransactionIds = new HashSet<>();
+        final Set<Long> existingReversedTransactionIds = new HashSet<>();
+        updateExistingTransactionsDetails(account, existingTransactionIds, existingReversedTransactionIds);
+
+        final MathContext mc = MathContext.DECIMAL64;
+        final Locale locale = command.extractLocale();
+        final DateTimeFormatter fmt = DateTimeFormatter.ofPattern(command.dateFormat()).withLocale(locale);
+        final LocalDate closedDate = command.localDateValueOfParameterNamed(SavingsApiConstants.closedOnDateParamName);
+        Long savingsTransactionId = null;
+
+        // account.isMatured() only reflects whether the overnight scheduler has already flipped this
+        // account's status -- not whether the customer actually showed up before or after the maturity
+        // date. A customer walking in ON the maturity date (or any day after) is not premature just
+        // because that job hasn't run yet today, so the real test is the date, not the status flag.
+        if (!account.isMatured()) {
+            if (!DateUtils.isBefore(closedDate, account.maturityDate())) {
+                // Genuinely due, the scheduler just hasn't caught up yet -- do exactly what it would:
+                // flip to Matured and post final interest at the full contracted rate, no penalty.
+                account.updateMaturityStatus(isSavingsInterestPostingAtCurrentPeriodEnd, financialYearBeginningMonth);
+            } else {
+                // The three closing closure types re-check this themselves inside prematureClosure()
+                // below, but the two reinvest branches never call it (they keep the account open on the
+                // same term), so it is enforced once, up front, for every genuinely-premature Payment --
+                // a locked-in FD (e.g. a Tax Saver with its statutory lock-in) cannot be touched early via
+                // this action either.
+                if (account.isLockedOnDate(closedDate)) {
+                    throw new GeneralPlatformDomainRuleException("error.msg.fixeddeposit.payment.lockin.period.not.elapsed",
+                            "This account is still within its lock-in period and cannot be processed before it elapses.", closedDate);
+                }
+                // Same penalty-aware interest calculation prematureClosure() already relies on, so a
+                // genuinely early Payment settles interest exactly as a Premature Close would.
+                account.postPreMaturityInterest(closedDate, true, isSavingsInterestPostingAtCurrentPeriodEnd, financialYearBeginningMonth);
+            }
+        } else {
+            account.postMaturityInterest(isSavingsInterestPostingAtCurrentPeriodEnd, financialYearBeginningMonth);
+        }
+
+        // Same as the closure and maturity paths do: the legacy reinvest branch's reInvest() reads
+        // getClosedOnDate() to pick the new account's chart and submitted date, so it has to be set
+        // before branching. renewInPlace() clears it again for the branches that keep the account open.
+        account.setClosedOnDate(closedDate);
+
+        // Re-read after the block above: updateMaturityStatus() may just have flipped it, so this now
+        // correctly decides close() (needs Matured) vs prematureClosure() (needs Active) either way.
+        final boolean alreadyMatured = account.isMatured();
+
+        final Integer onAccountClosureId = command.integerValueOfParameterNamed(onAccountClosureIdParamName);
+        final DepositAccountOnClosureType onClosureType = DepositAccountOnClosureType.fromInt(onAccountClosureId);
+
+        if (onClosureType.isReinvestPrincipalAndInterest() || onClosureType.isPartialReinvest()) {
+            // These two branches keep the account open, so they never reach close()/prematureClosure() and
+            // would otherwise accept any date at all -- including one behind already-posted interest, which
+            // the renewal would then turn into a pivot that reverses and re-posts it.
+            account.validateRenewalDate(closedDate);
+
+            final BigDecimal closingPrincipal = account.getDepositAmount();
+            final BigDecimal maturedBalance = account.getAccountBalance();
+            final BigDecimal interestEarned = maturedBalance == null || closingPrincipal == null ? null
+                    : maturedBalance.subtract(closingPrincipal);
+
+            final BigDecimal renewedAmount;
+            if (onClosureType.isPartialReinvest()) {
+                renewedAmount = command.bigDecimalValueOfParameterNamed(reinvestAmountParamName);
+                if (renewedAmount == null || renewedAmount.compareTo(BigDecimal.ZERO) <= 0
+                        || renewedAmount.compareTo(maturedBalance) >= 0) {
+                    throw new GeneralPlatformDomainRuleException("error.msg.fixeddeposit.partial.reinvest.amount.invalid",
+                            "The reinvest amount must be greater than zero and less than the matured balance.", renewedAmount);
+                }
+            } else {
+                renewedAmount = maturedBalance;
+            }
+
+            final FdInterestRateEffectiveData activeBaseRates = account.fdType() == null ? null
+                    : this.fdBaseInterestRateReadPlatformService.retrieveActiveInterestRatesByType(account.fdType()).stream().findFirst()
+                            .orElse(null);
+            final BigDecimal currentSeniorCitizenRate = account.isSeniorCitizen()
+                    ? seniorCitizenRateFor(activeBaseRates, account.depositPeriod(), account.depositPeriodFrequency())
+                    : null;
+
+            final String closingChartName = account.currentChartName();
+            final List<DepositAccountInterestRateChart.SlabSnapshot> closingChartSlabs = account.currentChartSlabFields();
+            // Likewise captured before renewInPlace overwrites the account's own rate/tenure with the new
+            // term's -- needed only if this is the closing term's first-ever history row (see
+            // recordInPlaceRenewal), so that row records what this term actually ran at instead of blank.
+            final BigDecimal closingInterestRate = account.getNominalAnnualInterestRate();
+            final Integer closingTenure = account.depositPeriod();
+            final Integer closingTenureFrequencyEnum = account.depositPeriodFrequency();
+
+            account.renewInPlace(renewedAmount, closedDate, currentSeniorCitizenRate, baseChartFieldsOf(activeBaseRates),
+                    baseChartSlabsOf(activeBaseRates, account.getCurrency().getCode()));
+            account.updateMaturityDateAndAmount(mc, isPreMatureClosure, isSavingsInterestPostingAtCurrentPeriodEnd,
+                    financialYearBeginningMonth);
+            this.savingsAccountRepository.save(account);
+
+            recordInPlaceRenewal(account, closingPrincipal, interestEarned, maturedBalance, renewedAmount, closedDate,
+                    FixedDepositRenewalHistory.RENEWAL_TYPE_MANUAL, user, closingChartName, closingChartSlabs, closingInterestRate,
+                    closingTenure, closingTenureFrequencyEnum);
+            changes.put("renewedInPlace", Boolean.TRUE);
+            changes.put("renewalCycleNo", account.renewalCycleNo());
+
+            if (onClosureType.isPartialReinvest()) {
+                // The kept portion never left the account -- renewInPlace() just relabels it as the new
+                // term's principal -- so only the remainder is an actual money movement, posted the same
+                // way the Transfer to Savings branch below posts its full-balance transfer.
+                final BigDecimal remainder = maturedBalance.subtract(renewedAmount);
+                final Long toSavingsId = command.longValueOfParameterNamed(toSavingsAccountIdParamName);
+                final String transferDescription = command.stringValueOfParameterNamed(transferDescriptionParamName);
+                final SavingsAccount toSavingsAccount = this.depositAccountAssembler.assembleFrom(toSavingsId,
+                        DepositAccountType.SAVINGS_DEPOSIT);
+                final boolean isExceptionForBalanceCheck = false;
+                final AccountTransferDTO accountTransferDTO = new AccountTransferDTO(closedDate, remainder, PortfolioAccountType.SAVINGS,
+                        PortfolioAccountType.SAVINGS, null, null, transferDescription, locale, fmt, null, null, null, null, null,
+                        AccountTransferType.ACCOUNT_TRANSFER.getValue(), null, null, ExternalId.empty(), null, toSavingsAccount, account,
+                        isAccountTransfer, isExceptionForBalanceCheck);
+                this.accountTransfersWritePlatformService.transferFunds(accountTransferDTO);
+                updateAlreadyPostedTransactions(existingTransactionIds, account);
+            }
+
+        } else if (onClosureType.isReinvestPrincipal()) {
+            // Legacy close-and-reopen, same shape as handleFDAccountClosure()'s isReinvest() branch --
+            // the interest has to leave the deposit, which needs a payout destination an in-place renewal
+            // has nowhere to send.
+            final BigDecimal maturedBalance = account.getAccountBalance();
+            final BigDecimal reInvestAmount = account.getDepositAmount();
+            final ExternalId externalId = this.externalIdFactory.create();
+
+            final FixedDepositAccount reinvestedDeposit = account.reInvest(reInvestAmount, externalId);
+            this.depositAccountAssembler.assignSavingAccountHelpers(reinvestedDeposit);
+            reinvestedDeposit.updateMaturityDateAndAmountBeforeAccountActivation(mc, isPreMatureClosure,
+                    isSavingsInterestPostingAtCurrentPeriodEnd, financialYearBeginningMonth);
+
+            this.savingsAccountRepository.saveAndFlush(reinvestedDeposit);
+            autoGenerateAccountNumber(reinvestedDeposit);
+            final boolean isInternalTransferLeg = true;
+            final SavingsAccountTransaction withdrawal = this.handleWithdrawal(account, fmt, closedDate, reInvestAmount, paymentDetail,
+                    false, isRegularTransaction, isInternalTransferLeg);
+            savingsTransactionId = withdrawal.getId();
+            updateAlreadyPostedTransactions(existingTransactionIds, account);
+
+            changes.put("reinvestedDepositId", reinvestedDeposit.getId());
+            reinvestedDeposit.approveAndActivateApplication(closedDate, user);
+            this.savingsAccountRepository.save(reinvestedDeposit);
+
+            recordRenewal(account, reinvestedDeposit, maturedBalance, reInvestAmount, closedDate,
+                    FixedDepositRenewalHistory.RENEWAL_TYPE_MANUAL, user);
+
+            // Only the principal moved into the new deposit -- the interest earned on this term is still
+            // sitting in this account's balance. Pay it out to the chosen savings account now, before
+            // closing, rather than stranding it here with nowhere left to go.
+            final BigDecimal interestRemainder = maturedBalance.subtract(reInvestAmount);
+            if (interestRemainder.compareTo(BigDecimal.ZERO) > 0) {
+                final Long toSavingsId = command.longValueOfParameterNamed(toSavingsAccountIdParamName);
+                final String transferDescription = command.stringValueOfParameterNamed(transferDescriptionParamName);
+                final SavingsAccount toSavingsAccount = this.depositAccountAssembler.assembleFrom(toSavingsId,
+                        DepositAccountType.SAVINGS_DEPOSIT);
+                final boolean isExceptionForBalanceCheck = false;
+                final AccountTransferDTO accountTransferDTO = new AccountTransferDTO(closedDate, interestRemainder,
+                        PortfolioAccountType.SAVINGS, PortfolioAccountType.SAVINGS, null, null, transferDescription, locale, fmt, null,
+                        null, null, null, null, AccountTransferType.ACCOUNT_TRANSFER.getValue(), null, null, ExternalId.empty(), null,
+                        toSavingsAccount, account, isAccountTransfer, isExceptionForBalanceCheck);
+                this.accountTransfersWritePlatformService.transferFunds(accountTransferDTO);
+                updateAlreadyPostedTransactions(existingTransactionIds, account);
+            }
+
+            if (alreadyMatured) {
+                account.close(user, command, changes);
+            } else {
+                account.prematureClosure(user, command, changes);
+            }
+
+        } else if (onClosureType.isTransferToSavings()) {
+            final Long toSavingsId = command.longValueOfParameterNamed(toSavingsAccountIdParamName);
+            final String transferDescription = command.stringValueOfParameterNamed(transferDescriptionParamName);
+            final SavingsAccount toSavingsAccount = this.depositAccountAssembler.assembleFrom(toSavingsId,
+                    DepositAccountType.SAVINGS_DEPOSIT);
+            final boolean isExceptionForBalanceCheck = false;
+            final AccountTransferDTO accountTransferDTO = new AccountTransferDTO(closedDate, account.getAccountBalance(),
+                    PortfolioAccountType.SAVINGS, PortfolioAccountType.SAVINGS, null, null, transferDescription, locale, fmt, null, null,
+                    null, null, null, AccountTransferType.ACCOUNT_TRANSFER.getValue(), null, null, ExternalId.empty(), null,
+                    toSavingsAccount, account, isAccountTransfer, isExceptionForBalanceCheck);
+            this.accountTransfersWritePlatformService.transferFunds(accountTransferDTO);
+            updateAlreadyPostedTransactions(existingTransactionIds, account);
+
+            if (alreadyMatured) {
+                account.close(user, command, changes);
+            } else {
+                account.prematureClosure(user, command, changes);
+            }
+
+        } else {
+            final SavingsAccountTransaction withdrawal = this.handleWithdrawal(account, fmt, closedDate, account.getAccountBalance(),
+                    paymentDetail, false, isRegularTransaction);
+            savingsTransactionId = withdrawal.getId();
+            updateAlreadyPostedTransactions(existingTransactionIds, account);
+
+            if (alreadyMatured) {
+                account.close(user, command, changes);
+            } else {
+                account.prematureClosure(user, command, changes);
+            }
+        }
+
+        this.savingsAccountRepository.save(account);
+        postJournalEntries(account, existingTransactionIds, existingReversedTransactionIds, isAccountTransfer);
+
+        return savingsTransactionId;
+    }
+
     @Transactional
     @Override
     public Long handleRDAccountPreMatureClosure(final RecurringDepositAccount account, final PaymentDetail paymentDetail,
@@ -555,14 +1155,19 @@ public class DepositAccountDomainServiceJpa implements DepositAccountDomainServi
     }
 
     private void updateAlreadyPostedTransactions(final Set<Long> existingTransactionIds, final SavingsAccount savingsAccount) {
-        List<SavingsAccountTransaction> transactions = savingsAccount.getTransactions();
-        int size = transactions.size();
-        for (int i = size - 1;; i--) {
-            SavingsAccountTransaction transaction = transactions.get(i);
-            if (transaction.isWithdrawal() || transaction.isWithdrawalFee()) {
+        // accountTransfersWritePlatformService.transferFunds() already posts accounting for the
+        // withdrawal it creates on this account (via SavingsAccountDomainServiceJpa#handleWithdrawal),
+        // so that withdrawal must be added to existingTransactionIds here or the caller's own
+        // postJournalEntries() re-derives and re-posts it a second time. The previous implementation
+        // found it by walking the transaction list backwards from the end while the type stayed
+        // withdrawal/withdrawal-fee -- but @OneToMany collections only guarantee @OrderBy ordering on
+        // a fresh fetch, not after an in-memory append, so a same-day interest posting or any other
+        // ordering quirk could put the new withdrawal anywhere in the list and break the walk
+        // silently. Scanning every transaction and checking against the original snapshot is correct
+        // regardless of collection order.
+        for (final SavingsAccountTransaction transaction : savingsAccount.getTransactions()) {
+            if ((transaction.isWithdrawal() || transaction.isWithdrawalFee()) && !existingTransactionIds.contains(transaction.getId())) {
                 existingTransactionIds.add(transaction.getId());
-            } else {
-                break;
             }
         }
     }

fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/domain/FixedDepositAccount.java

@@ -53,6 +53,7 @@ import org.apache.fineract.portfolio.accountdetails.domain.AccountType;
 import org.apache.fineract.portfolio.client.domain.Client;
 import org.apache.fineract.portfolio.group.domain.Group;
 import org.apache.fineract.portfolio.interestratechart.domain.InterestRateChart;
+import org.apache.fineract.portfolio.interestratechart.domain.InterestRateChartFields;
 import org.apache.fineract.portfolio.interestratechart.service.InterestRateChartAssembler;
 import org.apache.fineract.portfolio.savings.DepositAccountOnClosureType;
 import org.apache.fineract.portfolio.savings.DepositAccountType;
@@ -149,6 +150,18 @@ public class FixedDepositAccount extends SavingsAccount {
         }
     }
 
+    /**
+     * Re-forces the standing instructions that make FD Special work -- see
+     * {@link DepositAccountTermAndPreClosure#forceMonthlyPayoutToLinkedSavings}. Called from the modify-application
+     * write path after this same request's own linked-account resolution has settled, since
+     * {@link #modifyApplication} (via {@code accountTermAndPreClosure.update}) has no fdType awareness and would
+     * otherwise let a SPECIAL account's transferInterestToLinkedAccount/onAccountClosureType/transferToSavingsId
+     * be silently unset by that same request.
+     */
+    public void forceSpecialFdMonthlyPayoutSettings(final Long transferToSavingsId) {
+        this.accountTermAndPreClosure.forceMonthlyPayoutToLinkedSavings(transferToSavingsId);
+    }
+
     @Override
     protected BigDecimal getEffectiveInterestRateAsFraction(final MathContext mc, final LocalDate interestPostingUpToDate) {
         boolean isPreMatureClosure = false;
@@ -249,7 +262,13 @@ public class FixedDepositAccount extends SavingsAccount {
             totalInterestPayable = totalInterestPayable.plus(postingPeriod.getInterestEarned());
         }
         final Money depositAmount = Money.of(getCurrency(), this.accountTermAndPreClosure.depositAmount());
-        final Money maturityAmount = depositAmount.plus(totalInterestPayable);
+        // FD Special pays each period's interest out to the linked savings account every month instead of
+        // compounding it into this account's own balance (see DepositAccountAssembler and
+        // TransferInterestToSavingsTasklet) -- so unlike a cumulative FD, this account's own balance never
+        // actually grows to depositAmount + totalInterestPayable by maturity; it stays at depositAmount
+        // throughout the term. Showing the compounded projection here would be a customer-facing figure
+        // that never happens. SINGLE/DOUBLE FDs are unaffected -- they still get the real compounded value.
+        final Money maturityAmount = "SPECIAL".equalsIgnoreCase(fdType()) ? depositAmount : depositAmount.plus(totalInterestPayable);
 
         this.accountTermAndPreClosure.updateMaturityDetails(maturityAmount.getAmount(), maturityDate);
     }
@@ -276,7 +295,9 @@ public class FixedDepositAccount extends SavingsAccount {
 
     public LocalDate calculateMaturityDate() {
 
-        final LocalDate startDate = accountSubmittedOrActivationDate();
+        // The CURRENT term's start, not the account's activation date -- on a renewed FD these differ,
+        // and measuring the term from activation would put maturity in the past.
+        final LocalDate startDate = depositStartDate();
         LocalDate maturityDate = null;
         final Integer depositPeriod = this.accountTermAndPreClosure.depositPeriod();
         switch (this.accountTermAndPreClosure.depositPeriodFrequencyType()) {
@@ -312,13 +333,19 @@ public class FixedDepositAccount extends SavingsAccount {
                 .fromInt(this.interestCalculationDaysInYearType);
         List<LocalDate> postedAsOnTransactionDates = getManualPostingDates();
 
+        // Scoped to the current term, so a renewed FD's projection covers only the term now running --
+        // matching what postInterest() will actually post -- rather than replaying the whole account.
         final List<LocalDateInterval> postingPeriodIntervals = this.savingsHelper.determineInterestPostingPeriods(
-                accountSubmittedOrActivationDate(), maturityDate, postingPeriodType, financialYearBeginningMonth,
-                postedAsOnTransactionDates);
+                depositStartDate(), maturityDate, postingPeriodType, financialYearBeginningMonth, postedAsOnTransactionDates);
 
         final List<PostingPeriod> allPostingPeriods = new ArrayList<>();
 
-        Money periodStartingBalance = Money.zero(currency);
+        // On a first term the opening deposit falls inside the first posting period, so the period can
+        // start from zero and pick the balance up from that transaction. On a renewed term that deposit
+        // is BEFORE the period range and would be missed, leaving the term to earn interest on nothing,
+        // so the term's own principal seeds the opening balance instead.
+        Money periodStartingBalance = isRenewedTerm() ? Money.of(currency, this.accountTermAndPreClosure.depositAmount())
+                : Money.zero(currency);
 
         final SavingsInterestCalculationType interestCalculationType = SavingsInterestCalculationType.fromInt(this.interestCalculationType);
         final BigDecimal interestRateAsFraction = getEffectiveInterestRateAsFraction(mc, maturityDate, isPreMatureClosure);
@@ -349,6 +376,91 @@ public class FixedDepositAccount extends SavingsAccount {
         return allPostingPeriods;
     }
 
+    /**
+     * Read-only period-by-period (e.g. month-wise, when posting is Monthly) projected interest schedule across
+     * the account's current term -- built with the exact same {@link PostingPeriod} engine as
+     * {@link #calculateInterestPayable}, but deliberately NOT sharing that method's body: that one also calls
+     * {@code this.summary.updateFromInterestPeriodSummaries(...)}, which overwrites the account's real
+     * totalInterestEarned/lastInterestCalculationDate -- fine when it runs once as part of an actual save, but
+     * corrupting if repeated on every GET request. This variant skips that call entirely, so it is safe to
+     * invoke as many times as a read-service likes without ever mutating the account. Used to show FD Special
+     * customers/staff exactly how much interest is projected to post each month across the whole term, since
+     * that figure otherwise only exists internally as a discarded intermediate value.
+     */
+    public List<PostingPeriod> projectInterestSchedule(final MathContext mc, final boolean isSavingsInterestPostingAtCurrentPeriodEnd,
+            final Integer financialYearBeginningMonth) {
+        List<SavingsAccountTransaction> transactions = retreiveOrderedNonInterestPostingTransactions();
+        if (transactions.isEmpty()) {
+            // Account activated but not yet funded (funding is a separate deposit step) -- project the
+            // schedule as if the planned deposit amount lands on day one, the same synthetic-transaction
+            // approach updateMaturityDateAndAmountBeforeAccountActivation uses for the pre-activation
+            // maturity preview. Without this every period here would show zero interest against a real,
+            // still-empty transaction history, while the maturity amount (forced to depositAmount for
+            // SPECIAL FDs) already assumes the account gets funded -- this keeps the two consistent.
+            final Money transactionAmountMoney = Money.of(getCurrency(), this.accountTermAndPreClosure.depositAmount());
+            final SavingsAccountTransaction syntheticDeposit = SavingsAccountTransaction.deposit(null, office(), null,
+                    this.accountSubmittedOrActivationDate(), transactionAmountMoney, null);
+            syntheticDeposit.setRunningBalance(transactionAmountMoney);
+            syntheticDeposit.updateCumulativeBalanceAndDates(this.getCurrency(), interestCalculatedUpto());
+            transactions = new ArrayList<>();
+            transactions.add(syntheticDeposit);
+        }
+        final LocalDate maturityDate = maturityDate() != null ? maturityDate() : calculateMaturityDate();
+        // calculateInterestPayable's own "maturityDate" parameter is always fed maturityDate.minusDays(1)
+        // by its one real caller (see updateMaturityDateAndAmount above) -- the raw maturity date is only
+        // used for the end-of-day-balance reset either side of the calculation. Missing this -1 here made
+        // determineInterestPostingPeriods run one day too far, pushing the final period's end date (and
+        // therefore its amount) past the account's actual maturity date.
+        final LocalDate interestCalculationUpto = maturityDate.minusDays(1);
+        final boolean isPreMatureClosure = false;
+
+        this.resetAccountTransactionsEndOfDayBalances(transactions, maturityDate);
+        try {
+            final SavingsPostingInterestPeriodType postingPeriodType = SavingsPostingInterestPeriodType
+                    .fromInt(this.interestPostingPeriodType);
+            final SavingsCompoundingInterestPeriodType compoundingPeriodType = SavingsCompoundingInterestPeriodType
+                    .fromInt(this.interestCompoundingPeriodType);
+            final SavingsInterestCalculationDaysInYearType daysInYearType = SavingsInterestCalculationDaysInYearType
+                    .fromInt(this.interestCalculationDaysInYearType);
+            final List<LocalDate> postedAsOnTransactionDates = getManualPostingDates();
+
+            final List<LocalDateInterval> postingPeriodIntervals = this.savingsHelper.determineInterestPostingPeriods(
+                    depositStartDate(), interestCalculationUpto, postingPeriodType, financialYearBeginningMonth,
+                    postedAsOnTransactionDates);
+
+            final List<PostingPeriod> allPostingPeriods = new ArrayList<>();
+            Money periodStartingBalance = isRenewedTerm() ? Money.of(currency, this.accountTermAndPreClosure.depositAmount())
+                    : Money.zero(currency);
+
+            final SavingsInterestCalculationType interestCalculationType = SavingsInterestCalculationType
+                    .fromInt(this.interestCalculationType);
+            final BigDecimal interestRateAsFraction = getEffectiveInterestRateAsFraction(mc, interestCalculationUpto, isPreMatureClosure);
+            final Collection<Long> interestPostTransactions = this.savingsHelper.fetchPostInterestTransactionIds(getId());
+            final boolean isInterestTransfer = false;
+            final Money minBalanceForInterestCalculation = Money.of(getCurrency(), minBalanceForInterestCalculation());
+            final List<SavingsAccountTransactionDetailsForPostingPeriod> savingsAccountTransactionDetailsForPostingPeriodList = toSavingsAccountTransactionDetailsForPostingPeriodList(
+                    transactions);
+
+            for (final LocalDateInterval periodInterval : postingPeriodIntervals) {
+                final boolean isUserPosting = postedAsOnTransactionDates.contains(periodInterval.endDate());
+                final PostingPeriod postingPeriod = PostingPeriod.createFrom(periodInterval, periodStartingBalance,
+                        savingsAccountTransactionDetailsForPostingPeriodList, this.currency, compoundingPeriodType,
+                        interestCalculationType, interestRateAsFraction, daysInYearType.getValue(), interestCalculationUpto,
+                        interestPostTransactions, isInterestTransfer, minBalanceForInterestCalculation,
+                        isSavingsInterestPostingAtCurrentPeriodEnd, isUserPosting, financialYearBeginningMonth);
+
+                periodStartingBalance = postingPeriod.closingBalance();
+                allPostingPeriods.add(postingPeriod);
+            }
+
+            this.savingsHelper.calculateInterestForAllPostingPeriods(this.currency, allPostingPeriods, getLockedInUntilDate(),
+                    isTransferInterestToOtherAccount());
+            return allPostingPeriods;
+        } finally {
+            this.resetAccountTransactionsEndOfDayBalances(transactions, DateUtils.getBusinessLocalDate());
+        }
+    }
+
     public void prematureClosure(final AppUser currentUser, final JsonCommand command, final Map<String, Object> actualChanges) {
         final List<ApiParameterError> dataValidationErrors = new ArrayList<>();
         final DataValidatorBuilder baseDataValidator = new DataValidatorBuilder(dataValidationErrors)
@@ -564,7 +676,13 @@ public class FixedDepositAccount extends SavingsAccount {
                         interestPostingTransactionDate, interestEarnedToBePostedForPeriod, interestPostingPeriod.isUserPosting());
                 this.transactions.add(newPostingTransaction);
                 recalucateDailyBalanceDetails = true;
-            } else {
+            } else if (!interestAlreadyPaidOut(postingTransaction)) {
+                // Once a period's interest has actually been swept out to the linked savings account it is
+                // settled history: reversing and re-posting it here would rewrite interest the customer was
+                // already paid and leave this account's books disagreeing with the cash that left it. But a
+                // posting still sitting IN the account is fair game -- that is how a stale amount (e.g. one
+                // the batch engine compounded) gets corrected at maturity. Testing the individual period,
+                // not the account-wide transfer flag, is the distinction that matters here.
                 final boolean correctionRequired = postingTransaction.hasNotAmount(interestEarnedToBePostedForPeriod);
                 if (correctionRequired) {
                     postingTransaction.reverse();
@@ -586,6 +704,57 @@ public class FixedDepositAccount extends SavingsAccount {
         this.summary.updateSummary(this.currency, this.savingsAccountTransactionSummaryWrapper, this.transactions);
     }
 
+    /**
+     * Whether this period's posted interest has already left the account for the linked savings account.
+     * <p>
+     * The sweep withdrawal carries the same transaction date as the interest posting it pays out (see
+     * DepositAccountReadPlatformService#retrieveDataForInterestTransfer, which pairs them by date), and
+     * {@link #interestTransferWithdrawalTransactionIds()} returns those WITHDRAWAL ids -- not the posting
+     * ids -- so the match has to be on date, not on id.
+     */
+    private boolean interestAlreadyPaidOut(final SavingsAccountTransaction postingTransaction) {
+        final Collection<Long> sweepWithdrawalIds = interestTransferWithdrawalTransactionIds();
+        if (sweepWithdrawalIds.isEmpty()) {
+            return false;
+        }
+        for (final SavingsAccountTransaction transaction : this.transactions) {
+            if (transaction.isNotReversed() && sweepWithdrawalIds.contains(transaction.getId())
+                    && DateUtils.isEqual(transaction.getTransactionDate(), postingTransaction.getTransactionDate())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Guards the base {@link SavingsAccount#postInterest} correction loop, which base
+     * {@code SavingsAccountDomainServiceJpa#handleWithdrawal} re-triggers after every withdrawal -- including the
+     * sweep withdrawal that transfers a period's interest out to the linked savings account. Without this guard,
+     * that recalculation reverses and reposts the just-paid-out period at a freshly-recomputed (and slightly
+     * different, e.g. rounding) amount, leaving the already-executed sweep withdrawal mismatched against the new
+     * posting.
+     */
+    @Override
+    protected boolean isInterestPostingCorrectionAllowed(final SavingsAccountTransaction postingTransaction) {
+        return !interestAlreadyPaidOut(postingTransaction);
+    }
+
+    /**
+     * The interest-transfer sweep withdrawal only ever fires for a period whose interest is already posted (see
+     * DepositAccountReadPlatformService#retrieveDataForInterestTransfer), so there is nothing new for this
+     * recalculation to find. Worse, at the moment this withdrawal's own post-withdrawal recalculation would run,
+     * the m_account_transfer_transaction linking row that marks it as a transfer withdrawal does not exist yet
+     * (it is created by AccountTransfersWritePlatformServiceImpl only after both transfer legs are booked) -- so
+     * the exclusion in {@link #resetAccountTransactionsEndOfDayBalances} cannot yet recognise it, and the
+     * recalculation would wrongly treat it as a real balance-reducing transaction for its own and every later
+     * period, reversing and reposting already-settled interest at a corrupted amount. Skipping the recalculation
+     * for this specific withdrawal avoids the corruption at its source.
+     */
+    @Override
+    public boolean isPostWithdrawalInterestRecalculationRequired(final boolean isInterestTransfer) {
+        return !isInterestTransfer;
+    }
+
     public void postPreMaturityInterest(final LocalDate accountCloseDate, final boolean isPreMatureClosure,
             final boolean isSavingsInterestPostingAtCurrentPeriodEnd, final Integer financialYearBeginningMonth) {
 
@@ -686,6 +855,60 @@ public class FixedDepositAccount extends SavingsAccount {
         return this.accountTermAndPreClosure.maturityAmount();
     }
 
+    /**
+     * The stable customer-facing FD number: the account number of the first account in this renewal chain. Falls back to
+     * this account's own number when it has never been renewed, so callers always get a usable FD number.
+     */
+    public String fdAccountNumber() {
+        final String carried = this.accountTermAndPreClosure.getFdAccountNumber();
+        return carried != null ? carried : getAccountNumber();
+    }
+
+    /** 0 for the originally opened term, 1 for the first renewal, and so on. */
+    public Integer renewalCycleNo() {
+        return this.accountTermAndPreClosure.getRenewalCycleNo();
+    }
+
+    public Integer depositPeriod() {
+        return this.accountTermAndPreClosure.depositPeriod();
+    }
+
+    public Integer depositPeriodFrequency() {
+        return this.accountTermAndPreClosure.depositPeriodFrequency();
+    }
+
+    public Long reinvestedFromSavingsId() {
+        return this.accountTermAndPreClosure.getReinvestedFromSavingsId();
+    }
+
+    /**
+     * The name of the chart currently priced on this account. Read before a renewal overwrites it, so the closing term's
+     * chart identity can be archived rather than lost.
+     */
+    public String currentChartName() {
+        return this.chart == null ? null : this.chart.chartFields().getName();
+    }
+
+    /**
+     * The slabs of the chart currently priced on this account -- each paired with its senior-citizen premium -- detached
+     * from the chart's own persistence lifecycle.
+     * <p>
+     * Read before a renewal overwrites the account's chart in place ({@link #renewInPlace}), so the closing term's full
+     * rate-by-tenure breakdown (including the premium) can be archived -- not just the single effective rate the renewal
+     * history records -- rather than being silently deleted when the new term's slabs replace it.
+     */
+    public List<DepositAccountInterestRateChart.SlabSnapshot> currentChartSlabFields() {
+        return this.chart == null ? java.util.Collections.emptyList() : this.chart.currentSlabSnapshots();
+    }
+
+    /**
+     * This deposit's FD type (SINGLE / DOUBLE / SPECIAL), which lives on the product rather than the account. Null when
+     * the product is not a Fixed Deposit product or has no type set.
+     */
+    public String fdType() {
+        return this.product instanceof FixedDepositProduct ? ((FixedDepositProduct) this.product).getFdType() : null;
+    }
+
     private Money totalInterestPosted() {
         Money interestPostedToDate = Money.zero(this.currency);
         for (final SavingsAccountTransaction transaction : this.transactions) {
@@ -715,11 +938,26 @@ public class FixedDepositAccount extends SavingsAccount {
         return actualChanges;
     }
 
+    /**
+     * The start of the term currently running, which is what the deposit's tenure and rate must be measured from.
+     * <p>
+     * For an FD that has never been renewed this is the activation date, exactly as before. A renewal advances
+     * startInterestCalculationDate to the renewal date, so from then on the interest-rate chart slab is chosen by THIS
+     * term's tenure rather than the cumulative tenure since the account was opened, and maturity is measured from the
+     * renewal rather than from the original activation.
+     */
     private LocalDate depositStartDate() {
-        // TODO: Support to add deposit start date which can be a date after
-        // account activation date.
-        final LocalDate depositStartDate = accountSubmittedOrActivationDate();
-        return depositStartDate;
+        final LocalDate currentTermStartDate = getStartInterestCalculationDate();
+        return currentTermStartDate != null ? currentTermStartDate : accountSubmittedOrActivationDate();
+    }
+
+    /**
+     * True once this FD has been renewed at least once, i.e. the term now running started later than the account did.
+     * Everything keyed off this keeps its original, pre-renewal behaviour for an FD still on its first term.
+     */
+    private boolean isRenewedTerm() {
+        final LocalDate termStart = getStartInterestCalculationDate();
+        return termStart != null && getActivationDate() != null && !termStart.equals(getActivationDate());
     }
 
     private LocalDate interestCalculatedUpto() {
@@ -731,6 +969,24 @@ public class FixedDepositAccount extends SavingsAccount {
         return uptoMaturityDate;
     }
 
+    /**
+     * An FD that pays its interest out monthly (FD Special) carries a transfer-out WITHDRAWAL for every posted
+     * period, and {@link #retreiveOrderedNonInterestPostingTransactions()} strips those out before the
+     * interest engine sees them. The balance-segment walk has to strip the same ones: that withdrawal is dated
+     * the same day as the posting it pays out, so leaving it in ends the funding deposit's balance segment one
+     * day early while the engine's own list has nothing to cover that day -- costing the first period one
+     * earning day (e.g. 6 days instead of 25-Jul..31-Jul's real 7).
+     * <p>
+     * A no-op for every other account: the excluded-id lookup short-circuits to empty unless
+     * {@link #isTransferInterestToOtherAccount()} is true.
+     */
+    @Override
+    protected void resetAccountTransactionsEndOfDayBalances(final List<SavingsAccountTransaction> accountTransactionsSorted,
+            final LocalDate interestPostingUpToDate) {
+        super.resetAccountTransactionsEndOfDayBalances(excludeInterestTransferWithdrawals(accountTransactionsSorted),
+                interestPostingUpToDate);
+    }
+
     public void validateDomainRules() {
         final List<ApiParameterError> dataValidationErrors = new ArrayList<>();
         final DataValidatorBuilder baseDataValidator = new DataValidatorBuilder(dataValidationErrors)
@@ -814,28 +1070,142 @@ public class FixedDepositAccount extends SavingsAccount {
         return this.accountTermAndPreClosure.getTransferToSavingsAccountId();
     }
 
+    /**
+     * Rolls this FD into a new term on the SAME account, so the customer keeps one account number however many times it
+     * renews. No new account is opened and no money moves: the balance simply carries into the next term.
+     * <p>
+     * What changes is the term itself. startInterestCalculationDate advances to the renewal date, which is what confines
+     * interest posting to the new term and thereby leaves the closing term's postings untouched -- they fall outside the
+     * posting periods the engine now generates, so nothing recalculates or reverses them. The term's principal becomes
+     * {@code renewedAmount}, and every interest-mechanics setting plus the rate chart is re-taken from the product as it
+     * stands today, so a renewal is priced on current terms rather than the ones frozen at account opening.
+     * <p>
+     * The caller must have posted the closing term's interest first, and must record the renewal in the FD's renewal
+     * history so each term's own figures remain reportable.
+     *
+     * @param renewedAmount
+     *            what carries into the new term: the full maturity amount, or the principal only
+     * @param renewedOn
+     *            the renewal date, which becomes the new term's start
+     * @param currentSeniorCitizenRate
+     *            the senior-citizen premium the bank publishes on the renewal date for this FD type and tenure, or null to
+     *            keep the rate the account already holds. Only applied to an account already flagged senior-citizen; the
+     *            renewal never turns that flag on or off.
+     * @param baseChartFields
+     *            identity of the CBS base rate version being applied, or null to keep the existing chart's
+     * @param baseChartSlabs
+     *            the slabs of the active CBS base interest-rate version, each paired with its senior-citizen premium -- the
+     *            rate card staff maintain and see on the Base Interest Rates screen. When empty or null the account falls
+     *            back to the product's own chart, so a product with no base rate version still renews on something.
+     */
+    public void renewInPlace(final BigDecimal renewedAmount, final LocalDate renewedOn, final BigDecimal currentSeniorCitizenRate,
+            final InterestRateChartFields baseChartFields, final Collection<DepositAccountInterestRateChart.SlabSnapshot> baseChartSlabs) {
+
+        final SavingsProduct product = this.product;
+
+        // Confines interest posting to the new term. Set before recomputing maturity, since maturity is
+        // measured from the current term's start.
+        setStartInterestCalculationDate(renewedOn);
+
+        this.accountTermAndPreClosure.updateDepositAmount(renewedAmount);
+        this.accountTermAndPreClosure.setRenewalCycleNo(this.accountTermAndPreClosure.getRenewalCycleNo() + 1);
+        // Pin the chain number now that this account has renewed at least once, so a non-zero cycle number
+        // is never paired with a blank FD number. fdAccountNumber() resolves to the chain's original number
+        // if there is one and to this account's own otherwise, which is the same value every reader derives.
+        this.accountTermAndPreClosure.setFdAccountNumber(fdAccountNumber());
+
+        // Re-price off the CURRENT product, exactly as opening a fresh deposit today would.
+        this.nominalAnnualInterestRate = product.nominalAnnualInterestRate();
+        this.interestCompoundingPeriodType = product.interestCompoundingPeriodType().getValue();
+        this.interestPostingPeriodType = product.interestPostingPeriodType().getValue();
+        this.interestCalculationType = product.interestCalculationType().getValue();
+        this.interestCalculationDaysInYearType = product.interestCalculationDaysInYearType().getValue();
+        this.withHoldTax = product.withHoldTax();
+
+        // Lock-in is re-taken from the product and re-measured from this renewal, exactly as the legacy
+        // close-and-reopen reInvest() does for the account it creates. Left alone, a renewed term would
+        // carry the lock-in window computed at the original activation -- long expired -- so a product with
+        // a statutory lock-in (a Tax Saver, say) would hold the customer for the first term only.
+        final SavingsPeriodFrequencyType renewedLockinPeriodFrequencyType = product.lockinPeriodFrequencyType();
+        this.lockinPeriodFrequency = product.lockinPeriodFrequency();
+        this.lockinPeriodFrequencyType = renewedLockinPeriodFrequencyType == null ? null
+                : renewedLockinPeriodFrequencyType.getValue();
+        this.lockedInUntilDate = this.lockinPeriodFrequencyType == null || this.lockinPeriodFrequency == null ? null
+                : calculateDateAccountIsLockedUntil(renewedOn);
+
+        // The new term is priced off the CBS base interest-rate master -- the rate card staff maintain on
+        // the Base Interest Rates screen, per FD type, with its own active version. That master is what
+        // the bank publishes and what the account-opening wizard already shows, so pricing a renewal off
+        // anything else would put the deposit on rates nobody chose.
+        if (this.chart != null && baseChartSlabs != null && !baseChartSlabs.isEmpty()) {
+            this.chart.refreshFromSlabSnapshots(baseChartFields, baseChartSlabs);
+        } else if (this.chart != null) {
+            // No active base version for this FD type: fall back to the product's own chart so the
+            // renewal still gets current product rates rather than the ones frozen at opening.
+            // activeChart, not applicableChart -- the latter treats a chart with no end date as valid only
+            // up to today's business date, so a renewal dated in the future would find nothing.
+            final InterestRateChart productChart = product instanceof FixedDepositProduct
+                    ? ((FixedDepositProduct) product).activeChart(renewedOn)
+                    : null;
+            if (productChart != null) {
+                this.chart.refreshFrom(productChart);
+            }
+        }
+
+        // The senior-citizen premium is stored per account and takes priority over the chart in
+        // getEffectiveInterestRateAsFraction(), so leaving it alone would price every future term of a
+        // senior-citizen deposit at the rate captured when the account was opened. Only overwritten when
+        // the caller found a currently published rate -- otherwise the existing one stands, so a missing
+        // rate version can never silently drop the depositor's premium.
+        if (isSeniorCitizen() && currentSeniorCitizenRate != null && currentSeniorCitizenRate.compareTo(BigDecimal.ZERO) > 0) {
+            setSeniorCitizenInterestRate(currentSeniorCitizenRate);
+        }
+
+        // The account never left ACTIVE, but updateMaturityStatus() flipped it to MATURED just before
+        // this ran, so the new term has to put it back.
+        this.status = SavingsAccountStatusType.ACTIVE.getValue();
+        setClosedOnDate(null);
+    }
+
     public FixedDepositAccount reInvest(BigDecimal depositAmount, ExternalId externalId) {
 
         final DepositAccountTermAndPreClosure newAccountTermAndPreClosure = this.accountTermAndPreClosure.copy(depositAmount);
         final SavingsProduct product = this.product;
-        final InterestRateChart productChart = product.applicableChart(getClosedOnDate());
+        // Effective-dated pick, same as renewInPlace: an open-ended chart stays valid past today's
+        // business date, and the most recently effective chart wins when more than one covers the date.
+        // Falls back to applicableChart so a product whose charts have no usable from-date still resolves
+        // as it did before.
+        InterestRateChart productChart = product instanceof FixedDepositProduct
+                ? ((FixedDepositProduct) product).activeChart(getClosedOnDate())
+                : null;
+        if (productChart == null) {
+            productChart = product.applicableChart(getClosedOnDate());
+        }
         final DepositAccountInterestRateChart newChart = DepositAccountInterestRateChart.from(productChart);
 
         final AccountType accountType = AccountType.fromInt(this.accountType);
-        final SavingsPostingInterestPeriodType postingPeriodType = SavingsPostingInterestPeriodType.fromInt(this.interestPostingPeriodType);
-        final SavingsCompoundingInterestPeriodType compoundingPeriodType = SavingsCompoundingInterestPeriodType
-                .fromInt(this.interestCompoundingPeriodType);
-        final SavingsInterestCalculationType interestCalculationType = SavingsInterestCalculationType.fromInt(this.interestCalculationType);
-        final SavingsInterestCalculationDaysInYearType daysInYearType = SavingsInterestCalculationDaysInYearType
-                .fromInt(this.interestCalculationDaysInYearType);
+        // Re-price every interest-mechanics setting off the CURRENT product, not this (old) account's
+        // frozen-at-opening snapshot -- same reasoning as interestRate/newChart below. Without this, a
+        // renewed FD kept running on whatever compounding/posting/calculation-type/lock-in/tax setting
+        // was in force when the ORIGINAL account was opened, silently ignoring every product edit made
+        // since (e.g. Daily->Quarterly compounding, or a lock-in added later).
+        final SavingsPostingInterestPeriodType postingPeriodType = product.interestPostingPeriodType();
+        final SavingsCompoundingInterestPeriodType compoundingPeriodType = product.interestCompoundingPeriodType();
+        final SavingsInterestCalculationType interestCalculationType = product.interestCalculationType();
+        final SavingsInterestCalculationDaysInYearType daysInYearType = product.interestCalculationDaysInYearType();
         final BigDecimal minRequiredOpeningBalance = null;
-        final BigDecimal interestRate = BigDecimal.ZERO;
+        // Falls back to the product's own flat rate -- same fallback DepositAccountAssembler uses
+        // for a brand-new account -- so a product with no chart slab covering this tenure/amount
+        // doesn't silently reinvest the customer at 0%. getEffectiveInterestRateAsFraction() still
+        // re-prices off newChart (the product's CURRENT chart, reflecting any edits made since the
+        // original account was opened) whenever a matching slab exists.
+        final BigDecimal interestRate = product.nominalAnnualInterestRate();
         final Set<SavingsAccountCharge> savingsAccountCharges = null;
-        final SavingsPeriodFrequencyType lockinPeriodFrequencyType = SavingsPeriodFrequencyType.fromInt(this.lockinPeriodFrequencyType);
-        final Integer lockinPeriodFrequency = this.lockinPeriodFrequency;
+        final SavingsPeriodFrequencyType lockinPeriodFrequencyType = product.lockinPeriodFrequencyType();
+        final Integer lockinPeriodFrequency = product.lockinPeriodFrequency();
         final boolean withdrawalFeeApplicableForTransfer = false;
         final String accountNumber = null;
-        final boolean withHoldTax = this.withHoldTax;
+        final boolean withHoldTax = product.withHoldTax();
         final FixedDepositAccount reInvestedAccount = FixedDepositAccount.createNewApplicationForSubmittal(client, group, product,
                 savingsOfficer, accountNumber, externalId, accountType, getClosedOnDate(), closedBy, interestRate, compoundingPeriodType,
                 postingPeriodType, interestCalculationType, daysInYearType, minRequiredOpeningBalance, lockinPeriodFrequency,
@@ -845,6 +1215,30 @@ public class FixedDepositAccount extends SavingsAccount {
         newAccountTermAndPreClosure.updateAccountReference(reInvestedAccount);
         newChart.updateDepositAccountReference(reInvestedAccount);
 
+        // Carry the senior-citizen premium forward -- without this, a senior-citizen depositor's
+        // reinvested FD silently drops back to the standard rate on the new term.
+        reInvestedAccount.setSeniorCitizen(this.isSeniorCitizen());
+        reInvestedAccount.setSeniorCitizenInterestRate(this.getSeniorCitizenInterestRate());
+
+        // Track which account this was reinvested from, so staff/UI can trace the two accounts to
+        // each other instead of the link disappearing the moment the old one closes.
+        newAccountTermAndPreClosure.setReinvestedFromSavingsId(this.getId());
+
+        // Carry the ORIGINAL account's number forward across every renewal, so the customer keeps
+        // seeing one recognisable FD number even though each term is its own account/ledger row.
+        final String rootFdAccountNumber = this.accountTermAndPreClosure.getFdAccountNumber() != null
+                ? this.accountTermAndPreClosure.getFdAccountNumber()
+                : this.getAccountNumber();
+        newAccountTermAndPreClosure.setFdAccountNumber(rootFdAccountNumber);
+
+        // Number this term within the chain, so the UI can label it "Renewal 2 of FD ...048".
+        newAccountTermAndPreClosure.setRenewalCycleNo(this.accountTermAndPreClosure.getRenewalCycleNo() + 1);
+
+        // Without this the renewed deposit has no maturity instruction, so it would mature once more and
+        // then sit idle rather than rolling over again as the customer asked. Done here rather than in
+        // the shared copy(), which Recurring Deposit renewal also uses.
+        newAccountTermAndPreClosure.carryForwardStandingInstructionsFrom(this.accountTermAndPreClosure);
+
         return reInvestedAccount;
 
     }
@@ -886,7 +1280,9 @@ public class FixedDepositAccount extends SavingsAccount {
     @Override
     public void loadLazyCollections() {
         super.loadLazyCollections();
-        this.chart.getId();
+        if (this.chart != null) {
+            this.chart.getId();
+        }
     }
 
     public BigDecimal getDepositAmount() {
@@ -902,6 +1298,52 @@ public class FixedDepositAccount extends SavingsAccount {
         return SavingsAccountStatusType.MATURED.getValue().equals(this.status);
     }
 
+    /**
+     * Exposes the parent class's protected lock-in check to callers outside this class hierarchy. Needed by the
+     * Payment action's domain-service method, which enforces this itself for its reinvest branches rather than going
+     * through {@link #prematureClosure}, since those branches keep the account open on the same term instead of
+     * closing it.
+     */
+    public boolean isLockedOnDate(final LocalDate transactionDate) {
+        return isAccountLocked(transactionDate);
+    }
+
+    /**
+     * The date guards {@link #close} and {@link #prematureClosure} apply, minus the maturity-date bound, for a Payment
+     * that renews the deposit instead of closing it and so never reaches either of those methods.
+     * <p>
+     * Dropping the maturity bound is the point: Payment is allowed on an already-matured deposit. The other three
+     * matter more here than they do on a closure, because a renewal turns this date into the new term's interest
+     * pivot -- backdate it behind interest that has already been posted and the engine regenerates those posting
+     * periods, reverses the settled postings and re-posts them, which is exactly what the pivot exists to prevent.
+     */
+    public void validateRenewalDate(final LocalDate renewedOn) {
+        final List<ApiParameterError> dataValidationErrors = new ArrayList<>();
+        final DataValidatorBuilder baseDataValidator = new DataValidatorBuilder(dataValidationErrors)
+                .resource(FIXED_DEPOSIT_ACCOUNT_RESOURCE_NAME + DepositsApiConstants.preMatureCloseAction);
+
+        if (DateUtils.isAfterBusinessDate(renewedOn)) {
+            baseDataValidator.reset().parameter(SavingsApiConstants.closedOnDateParamName).value(renewedOn)
+                    .failWithCode("cannot.be.a.future.date");
+        }
+        if (DateUtils.isBefore(renewedOn, getActivationDate())) {
+            baseDataValidator.reset().parameter(SavingsApiConstants.closedOnDateParamName).value(renewedOn)
+                    .failWithCode("must.be.after.activation.date");
+        }
+        final List<SavingsAccountTransaction> savingsAccountTransactions = retrieveListOfTransactions();
+        if (!savingsAccountTransactions.isEmpty()) {
+            final SavingsAccountTransaction lastTransaction = savingsAccountTransactions.get(savingsAccountTransactions.size() - 1);
+            if (lastTransaction.isAfter(renewedOn)) {
+                baseDataValidator.reset().parameter(SavingsApiConstants.closedOnDateParamName).value(renewedOn)
+                        .failWithCode("must.be.after.last.transaction.date");
+            }
+        }
+
+        if (!dataValidationErrors.isEmpty()) {
+            throw new PlatformApiDataValidationException(dataValidationErrors);
+        }
+    }
+
     public void setClosedOnDate(final LocalDate closedOnDate) {
         this.closedOnDate = closedOnDate;
     }

fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/domain/FixedDepositRenewalChartSlabHistory.java

@@ -0,0 +1,99 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+package org.apache.fineract.portfolio.savings.domain;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import java.math.BigDecimal;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+/**
+ * One slab of the full tenure-by-rate chart a term of an FD was priced on, archived against that term's
+ * {@link FixedDepositRenewalHistory} row.
+ * <p>
+ * {@code renewInPlace} reuses the same account row across renewals, overwriting the account's own interest-rate chart in
+ * place at every renewal. {@code FixedDepositRenewalHistory} preserves the single effective rate that resulted, but not
+ * the chart it came from -- this table is what lets a later query answer "what did the whole rate card look like during
+ * term 2", not just "what rate applied".
+ */
+@Entity
+@Table(name = "m_fd_renewal_chart_slab_history")
+@Getter
+@NoArgsConstructor
+public class FixedDepositRenewalChartSlabHistory {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "fd_renewal_history_id", nullable = false)
+    private Long fdRenewalHistoryId;
+
+    @Column(name = "chart_name", length = 100)
+    private String chartName;
+
+    @Column(name = "description", length = 200)
+    private String description;
+
+    @Column(name = "period_type_enum")
+    private Integer periodTypeEnum;
+
+    @Column(name = "from_period")
+    private Integer fromPeriod;
+
+    @Column(name = "to_period")
+    private Integer toPeriod;
+
+    @Column(name = "amount_range_from", scale = 6, precision = 19)
+    private BigDecimal amountRangeFrom;
+
+    @Column(name = "amount_range_to", scale = 6, precision = 19)
+    private BigDecimal amountRangeTo;
+
+    @Column(name = "annual_interest_rate", scale = 6, precision = 19)
+    private BigDecimal annualInterestRate;
+
+    @Column(name = "currency_code", length = 3)
+    private String currencyCode;
+
+    /**
+     * The senior-citizen premium published for this tenure band at the time this term was priced, carried through from the
+     * CBS Base Interest Rates screen rather than looked up live against whatever is published now. Null when the term was
+     * priced off the product's own chart (which has no senior-citizen concept) or predates this column.
+     */
+    @Column(name = "senior_citizen_rate", scale = 6, precision = 19)
+    private BigDecimal seniorCitizenRate;
+
+    public static FixedDepositRenewalChartSlabHistory create(final Long fdRenewalHistoryId, final String chartName,
+            final String description, final Integer periodTypeEnum, final Integer fromPeriod, final Integer toPeriod,
+            final BigDecimal amountRangeFrom, final BigDecimal amountRangeTo, final BigDecimal annualInterestRate,
+            final String currencyCode, final BigDecimal seniorCitizenRate) {
+        final FixedDepositRenewalChartSlabHistory slab = new FixedDepositRenewalChartSlabHistory();
+        slab.fdRenewalHistoryId = fdRenewalHistoryId;
+        slab.chartName = chartName;
+        slab.description = description;
+        slab.periodTypeEnum = periodTypeEnum;
+        slab.fromPeriod = fromPeriod;
+        slab.toPeriod = toPeriod;
+        slab.amountRangeFrom = amountRangeFrom;
+        slab.amountRangeTo = amountRangeTo;
+        slab.annualInterestRate = annualInterestRate;
+        slab.currencyCode = currencyCode;
+        slab.seniorCitizenRate = seniorCitizenRate;
+        return slab;
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/domain/FixedDepositRenewalChartSlabHistoryRepository.java

@@ -0,0 +1,21 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+package org.apache.fineract.portfolio.savings.domain;
+
+import java.util.List;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface FixedDepositRenewalChartSlabHistoryRepository extends JpaRepository<FixedDepositRenewalChartSlabHistory, Long> {
+
+    /** The full chart a term was priced on, unordered -- callers typically sort by fromPeriod for display. */
+    List<FixedDepositRenewalChartSlabHistory> findByFdRenewalHistoryId(Long fdRenewalHistoryId);
+}

fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/domain/FixedDepositRenewalHistory.java

@@ -0,0 +1,158 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+package org.apache.fineract.portfolio.savings.domain;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+/**
+ * One row per term of one logical Fixed Deposit, recording the renewal event that started it.
+ * <p>
+ * Each term runs as its own deposit instance (its own {@code m_savings_account} row) so that term keeps an immutable
+ * ledger, interest postings and GL entries, while {@link #fdAccountNumber} stays the same across the whole chain and is
+ * what the customer sees. What that structure alone cannot tell you is the intent and outcome of each rollover, which is
+ * what this table captures: the previous term's principal and interest earned, what it matured at, how much was carried
+ * forward, the rate applied to the new term, whether the renewal ran automatically at maturity or was performed by a
+ * user, and by whom.
+ */
+@Entity
+@Table(name = "m_fd_renewal_history")
+@Getter
+@NoArgsConstructor
+public class FixedDepositRenewalHistory {
+
+    /** Renewal ran automatically when the maturity job processed the account's maturity instruction. */
+    public static final String RENEWAL_TYPE_AUTO = "AUTO";
+    /** A user closed the account with a re-invest instruction. */
+    public static final String RENEWAL_TYPE_MANUAL = "MANUAL";
+
+    public static final String STATUS_ACTIVE = "ACTIVE";
+    public static final String STATUS_MATURED = "MATURED";
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    /** The stable customer-facing FD number, shared by every term in the chain. */
+    @Column(name = "fd_account_number", length = 20, nullable = false)
+    private String fdAccountNumber;
+
+    /** The account the customer originally opened, i.e. the anchor of the chain. */
+    @Column(name = "original_savings_account_id", nullable = false)
+    private Long originalSavingsAccountId;
+
+    /** The deposit instance this term runs on. */
+    @Column(name = "savings_account_id", nullable = false)
+    private Long savingsAccountId;
+
+    /** The term this one was renewed from; null on the chain's first row. */
+    @Column(name = "previous_savings_account_id")
+    private Long previousSavingsAccountId;
+
+    @Column(name = "previous_renewal_id")
+    private Long previousRenewalId;
+
+    /** 0 for the originally opened term, 1 for the first renewal, and so on. */
+    @Column(name = "renewal_no", nullable = false)
+    private Integer renewalNo;
+
+    @Column(name = "previous_principal", scale = 6, precision = 19)
+    private BigDecimal previousPrincipal;
+
+    @Column(name = "interest_earned", scale = 6, precision = 19)
+    private BigDecimal interestEarned;
+
+    @Column(name = "maturity_amount", scale = 6, precision = 19)
+    private BigDecimal maturityAmount;
+
+    /** What actually carried into this term: the full maturity amount, or principal only. */
+    @Column(name = "renewed_amount", scale = 6, precision = 19)
+    private BigDecimal renewedAmount;
+
+    @Column(name = "interest_rate", scale = 6, precision = 19)
+    private BigDecimal interestRate;
+
+    @Column(name = "start_date")
+    private LocalDate startDate;
+
+    @Column(name = "maturity_date")
+    private LocalDate maturityDate;
+
+    @Column(name = "tenure")
+    private Integer tenure;
+
+    @Column(name = "tenure_frequency_enum")
+    private Integer tenureFrequencyEnum;
+
+    @Column(name = "renewal_type", length = 10)
+    private String renewalType;
+
+    @Column(name = "renewal_status", length = 20)
+    private String renewalStatus;
+
+    @Column(name = "renewed_on")
+    private LocalDate renewedOn;
+
+    @Column(name = "created_by_id")
+    private Long createdById;
+
+    public static FixedDepositRenewalHistory create(final String fdAccountNumber, final Long originalSavingsAccountId,
+            final Long savingsAccountId, final Long previousSavingsAccountId, final Long previousRenewalId, final Integer renewalNo,
+            final BigDecimal previousPrincipal, final BigDecimal interestEarned, final BigDecimal maturityAmount,
+            final BigDecimal renewedAmount, final BigDecimal interestRate, final LocalDate startDate, final LocalDate maturityDate,
+            final Integer tenure, final Integer tenureFrequencyEnum, final String renewalType, final LocalDate renewedOn,
+            final Long createdById) {
+        final FixedDepositRenewalHistory history = new FixedDepositRenewalHistory();
+        history.fdAccountNumber = fdAccountNumber;
+        history.originalSavingsAccountId = originalSavingsAccountId;
+        history.savingsAccountId = savingsAccountId;
+        history.previousSavingsAccountId = previousSavingsAccountId;
+        history.previousRenewalId = previousRenewalId;
+        history.renewalNo = renewalNo;
+        history.previousPrincipal = previousPrincipal;
+        history.interestEarned = interestEarned;
+        history.maturityAmount = maturityAmount;
+        history.renewedAmount = renewedAmount;
+        history.interestRate = interestRate;
+        history.startDate = startDate;
+        history.maturityDate = maturityDate;
+        history.tenure = tenure;
+        history.tenureFrequencyEnum = tenureFrequencyEnum;
+        history.renewalType = renewalType;
+        history.renewalStatus = STATUS_ACTIVE;
+        history.renewedOn = renewedOn;
+        history.createdById = createdById;
+        return history;
+    }
+
+    /** Called on the previous term's row once its successor takes over. */
+    public void markMatured() {
+        this.renewalStatus = STATUS_MATURED;
+    }
+
+    /**
+     * Fills in what this term actually earned and matured at, which is only known once it closes. Written on the term's
+     * own row so each term reports its own outcome rather than that of its predecessor.
+     */
+    public void recordOutcome(final BigDecimal interestEarned, final BigDecimal maturityAmount) {
+        this.interestEarned = interestEarned;
+        this.maturityAmount = maturityAmount;
+    }
+}

fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/domain/FixedDepositRenewalHistoryRepository.java

@@ -0,0 +1,30 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+package org.apache.fineract.portfolio.savings.domain;
+
+import java.util.List;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface FixedDepositRenewalHistoryRepository extends JpaRepository<FixedDepositRenewalHistory, Long> {
+
+    /** One FD's whole history, oldest term first. */
+    List<FixedDepositRenewalHistory> findByFdAccountNumberOrderByRenewalNoAsc(String fdAccountNumber);
+
+    /**
+     * An account's terms, newest first.
+     * <p>
+     * Deliberately a list, not a single row: an FD that renews on the same account has one row per term all pointing at
+     * that one account, so callers wanting the term currently running take the first element. Empty for an account that
+     * pre-dates this table or was never renewed.
+     */
+    List<FixedDepositRenewalHistory> findBySavingsAccountIdOrderByRenewalNoDesc(Long savingsAccountId);
+}

fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/domain/SavingsAccountAssembler.java

@@ -43,6 +43,7 @@ import static org.apache.fineract.portfolio.savings.SavingsApiConstants.nominati
 import static org.apache.fineract.portfolio.savings.SavingsApiConstants.autoDebitFacilityParamName;
 import static org.apache.fineract.portfolio.savings.SavingsApiConstants.introducerRequiredParamName;
 import static org.apache.fineract.portfolio.savings.SavingsApiConstants.shareLinkingEnabledParamName;
+import static org.apache.fineract.portfolio.savings.SavingsApiConstants.shareAccountIdParamName;
 import static org.apache.fineract.portfolio.savings.DepositsApiConstants.isSeniorCitizenParamName;
 import static org.apache.fineract.portfolio.savings.DepositsApiConstants.seniorCitizenInterestRateParamName;
 import static org.apache.fineract.portfolio.savings.SavingsApiConstants.allowOverdraftParamName;
@@ -81,6 +82,7 @@ import java.util.List;
 import java.util.Set;
 import org.apache.fineract.infrastructure.configuration.domain.ConfigurationDomainService;
 import org.apache.fineract.infrastructure.core.api.JsonCommand;
+import org.apache.fineract.infrastructure.core.exception.GeneralPlatformDomainRuleException;
 import org.apache.fineract.infrastructure.core.exception.UnsupportedParameterException;
 import org.apache.fineract.infrastructure.core.serialization.FromJsonHelper;
 import org.apache.fineract.infrastructure.core.service.ExternalIdFactory;
@@ -406,6 +408,28 @@ public class SavingsAccountAssembler {
             account.setShareLinkingEnabled(account.savingsProduct().isShareLinkingEnabled());
         }
 
+        // Which share account this savings account is linked to - required once Share Linking is
+        // enabled, since a "Yes" with nothing chosen would leave the toggle meaning nothing. Checked
+        // against m_share_account directly (raw SQL, not the JPA entity - fineract-savings has no
+        // dependency on the shareaccounts domain class) rather than trusted blindly, the same way an
+        // account number typed for a linked savings/loan account elsewhere in this form is verified
+        // before being accepted.
+        if (Boolean.TRUE.equals(account.getShareLinkingEnabled())) {
+            final Long shareAccountId = this.fromApiJsonHelper.extractLongNamed(shareAccountIdParamName, element);
+            if (shareAccountId == null) {
+                throw new GeneralPlatformDomainRuleException("error.msg.savingsaccount.share.account.required",
+                        "A share account must be chosen when Share Linking is enabled.");
+            }
+            final Integer matches = this.jdbcTemplate.queryForObject(
+                    "SELECT COUNT(*) FROM m_share_account WHERE id = ? AND client_id = ? AND status_enum = 300", Integer.class,
+                    shareAccountId, account.clientId());
+            if (matches == null || matches == 0) {
+                throw new GeneralPlatformDomainRuleException("error.msg.savingsaccount.share.account.not.active.for.client",
+                        "Share account " + shareAccountId + " is not an active share account for this client.");
+            }
+            account.setShareAccountId(shareAccountId);
+        }
+
         // Senior citizen rate — runs after validateDomainRules so it is the final persisted value
         if (command.parameterExists(isSeniorCitizenParamName)) {
             final Boolean scFlag = this.fromApiJsonHelper.extractBooleanNamed(isSeniorCitizenParamName, element);

fineract-provider/src/main/java/org/apache/fineract/portfolio/savings/domain/SavingsAccountDomainServiceJpa.java

@@ -114,13 +114,17 @@ public class SavingsAccountDomainServiceJpa implements SavingsAccountDomainServi
 
         final LocalDate today = DateUtils.getBusinessLocalDate();
 
-        if (account.isBeforeLastPostingPeriod(transactionDate, backdatedTxnsAllowedTill)) {
-            account.postInterest(mc, today, transactionBooleanValues.isInterestTransfer(), isSavingsInterestPostingAtCurrentPeriodEnd,
-                    financialYearBeginningMonth, postInterestOnDate, backdatedTxnsAllowedTill, postReversals);
+        if (account.isPostWithdrawalInterestRecalculationRequired(transactionBooleanValues.isInterestTransfer())) {
+            if (account.isBeforeLastPostingPeriod(transactionDate, backdatedTxnsAllowedTill)) {
+                account.postInterest(mc, today, transactionBooleanValues.isInterestTransfer(), isSavingsInterestPostingAtCurrentPeriodEnd,
+                        financialYearBeginningMonth, postInterestOnDate, backdatedTxnsAllowedTill, postReversals);
+            } else {
+                account.calculateInterestUsing(mc, today, transactionBooleanValues.isInterestTransfer(),
+                        isSavingsInterestPostingAtCurrentPeriodEnd, financialYearBeginningMonth, postInterestOnDate,
+                        backdatedTxnsAllowedTill, postReversals);
+            }
         } else {
-            account.calculateInterestUsing(mc, today, transactionBooleanValues.isInterestTransfer(),
-                    isSavingsInterestPostingAtCurrentPeriodEnd, financialYearBeginningMonth, postInterestOnDate, backdatedTxnsAllowedTill,
-                    postReversals);
+            account.refreshBalancesAndSummaryAfterTransfer(today, backdatedTxnsAllowedTill, postReversals);
         }
 
         List<DepositAccountOnHoldTransaction> depositAccountOnHoldTransactions = null;