property.deposit-cap Unreviewed

pub fn deposit_cap(rent: &Money, rent_period: &str, jurisdiction: &str, on_date: &str) -> DepositCap

// RentPeriod is a string in Rust, one of: "weekly", "monthly", "annual".
// Parameters take it as &str and results hold it as String.

/// The cap and how it was reached.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DepositCap {
    /// rent for a year: weekly × 52, monthly × 12, or the annual rent
    pub annual_rent: Money,
    /// annual rent ÷ 52, rounded down to the penny
    pub weekly_rent: Money,
    /// 5 below the threshold, 6 at or above it
    pub weeks: i64,
    /// annual rent × weeks ÷ 52, rounded down to the penny
    pub maximum: Money,
}

fune!(property.deposit-cap@^1);  // then call deposit_cap(…)

use super::funejson::Value;  ← the fune runtime: the JSON value the test vectors use; fune build keeps it only where a signature takes one
use super::money_amount::{money, money_from_value, money_to_value, Money};  ← from money.amount ^1.0.0 · built alongside by fune
use super::property_deposit_cap_data::{DepositCapRule, DEPOSIT_CAPS, DEPOSIT_CAPS_HISTORY};  ← this capability’s own data, compiled from data/deposit-caps.json into the same file by fune build

// Keeps annual rent × 6 exact as a JavaScript number; the same limit here.
const MAX_MINOR: i64 = 1_000_000_000_000;

fn is_iso_date(value: &str) -> bool {
    let bytes = value.as_bytes();
    bytes.len() == 10
        && bytes.iter().enumerate().all(|(i, b)| if i == 4 || i == 7 { *b == b'-' } else { b.is_ascii_digit() })
}

fn find_rule(jurisdiction: &str, on_date: &str) -> &'static DepositCapRule {
    let mut best: Option<&'static DepositCapRule> = None;
    let mut earliest: Option<&'static str> = None;
    for rule in DEPOSIT_CAPS {
        if rule.jurisdiction != jurisdiction {
            continue;
        }
        if earliest.map_or(true, |e| rule.valid_from < e) {
            earliest = Some(rule.valid_from);
        }
        if on_date < rule.valid_from {
            continue;
        }
        if let Some(to) = rule.valid_to {
            if on_date > to {
                continue;
            }
        }
        if best.map_or(true, |b| rule.valid_from > b.valid_from) {
            best = Some(rule);
        }
    }
    if let Some(rule) = best {
        return rule;
    }
    // A build installed with a pruned history must not answer an old date
    // with today's rule, so it says what happened instead.
    if DEPOSIT_CAPS_HISTORY != "full" {
        if let Some(e) = earliest {
            if on_date < e {
                panic!(
                    "no deposit cap rule for {} on {}: this build was installed with history={}, so it only carries rules from {}",
                    jurisdiction, on_date, DEPOSIT_CAPS_HISTORY, e
                );
            }
        }
    }
    panic!("no deposit cap rule for {} on {}", jurisdiction, on_date)
}

/// The maximum tenancy deposit: five weeks' rent below the annual-rent
/// threshold, six at or above it. The threshold is tested on the exact annual
/// rent, and the cap is annual rent × weeks ÷ 52 rounded down once, so it can
/// never sit a fraction of a penny over the statutory limit.
///
/// # Panics
/// Panics on a malformed date, rent not in GBP or negative, an unknown rent
/// period, or no rule for the jurisdiction on that date.
pub fn deposit_cap(rent: &Money, rent_period: &str, jurisdiction: &str, on_date: &str) -> DepositCap {
    if !is_iso_date(on_date) {
        panic!("onDate must be an ISO date (YYYY-MM-DD), received \"{}\"", on_date);
    }
    if rent.currency != "GBP" {
        panic!("rent must be in GBP, received {}", rent.currency);
    }
    if rent.minor < 0 {
        panic!("rent must not be negative, received {}", rent.minor);
    }
    let annual = match rent_period {
        "weekly" => rent.minor.checked_mul(52),
        "monthly" => rent.minor.checked_mul(12),
        "annual" => Some(rent.minor),
        other => panic!("unknown rent period \"{}\"", other),
    };
    let annual = match annual {
        Some(a) if a <= MAX_MINOR => a,
        _ => panic!("annual rent must be at most {} minor units", MAX_MINOR),
    };
    let rule = find_rule(jurisdiction, on_date);
    let weeks = if annual < rule.annual_rent_threshold_minor { rule.weeks_below } else { rule.weeks_at_or_above };
    DepositCap {
        annual_rent: money(annual, "GBP"),
        weekly_rent: money(annual / 52, "GBP"),
        weeks,
        maximum: money(annual * weeks / 52, "GBP"),
    }
}

pub fn deposit_cap_to_value(cap: &DepositCap) -> Value {
    Value::obj(vec![
        ("annualRent", money_to_value(&cap.annual_rent)),
        ("weeklyRent", money_to_value(&cap.weekly_rent)),
        ("weeks", Value::Int(cap.weeks)),
        ("maximum", money_to_value(&cap.maximum)),
    ])
}

pub fn fune_vector(args: &[Value]) -> Value {
    deposit_cap_to_value(&deposit_cap(
        &money_from_value(&args[0]),
        args[1].as_str(),
        args[2].as_str(),
        args[3].as_str(),
    ))
}

Install

fune build

With that line in your source, in a Rust project (language rust in fune.project), fune build resolves it and its 1 dependency, pins them in fune.lock, downloads only the Rust package of each, and builds the code above into your project’s .fune/build, one readable file per capability with a header linking back here. A crate’s build.rs runs it before every compile. Or pin a range in fune.project and build in one step:

fune add property.deposit-cap

The manifest, vectors and README with only the Rust implementation. Install it without the registry with fune add ./property.deposit-cap-1.0.2-rust.fune, or fetch it from a terminal with fune pull property.deposit-cap@1.0.2:rust.

The whole function, every language, is one file too: property.deposit-cap-1.0.2.fune, 25,804 bytes, sha256 95c34f3aa1cf27cc69d6a003d2105754225142fe70affebf4fca94b38300fb8e. It installs into a project of any language.

// fune: before property.deposit-cap

// fune: after property.deposit-cap

// fune: replace money.amount in property.deposit-cap

// fune: step property.deposit-cap after <n|label>

More from the author

## How it is calculated

The Act defines a week's rent as the annual rent divided by 52, and the government guidance gives the formulae: annual rent is monthly rent × 12 or weekly rent × 52, and weekly rent is (monthly rent × 12) ÷ 52.

- The threshold test is made on the exact annual rent, so £4,166.66 a month (£49,999.92 a year) is five weeks and £4,166.67 (£50,000.04) is six. - The maximum is annual rent × weeks ÷ 52, computed exactly and **rounded down** to the penny once. Rounding the weekly rent first and multiplying by five can land a penny or more away; rounding up would put the deposit a fraction of a penny over the statutory cap. The Act and guidance do not state a rounding rule, so down is the one that can never breach it. - `weeklyRent` is shown for reference, rounded down too.

Pass the total rent for the property: for a joint tenancy the cap applies to the rent all the tenants are jointly liable for, not to each tenant.

## Dates and jurisdictions

The rule is a dated row in `data/deposit-caps.json`. England's cap applies to tenancies granted, renewed or continued on or after 1 June 2019; an earlier date is refused rather than answered. The Renters' Rights Act 2025 amended the Tenant Fees Act but left the deposit cap unchanged (statutory guidance updated 1 May 2026). Wales and Scotland have different regimes and no data here yet; asking for them is an error, not a guess.

## Sources

- Tenant Fees Act 2019, Schedule 1 paragraph 2 (tenancy deposit; "one week's rent" is the annual rent divided by 52): https://www.legislation.gov.uk/ukpga/2019/4/schedule/1 - Ministry of Housing, Communities and Local Government, "Tenant Fees Act 2019: Guidance for landlords and agents" (tenancy deposits: the annual and weekly rent formulae; the cap applies from 1 June 2019): https://assets.publishing.service.gov.uk/media/5f745d308fa8f5189a93d141/Tenant_Fees_Act_2019_-_Guidance_for_landlords_and_agents.pdf - "Tenant Fees Act 2019: statutory guidance for enforcement authorities" (as amended by the Renters' Rights Act 2025): https://www.gov.uk/government/publications/tenant-fees-act-amended-by-the-renters-rights-act-2025/tenant-fees-act-2019-statutory-guidance-for-enforcement-authorities

1.0.1 fixes Python accepting a trailing newline or non-ASCII digits in onDate; adds tests.

## Before you rely on this

**Not professional advice.** This capability calculates property figures from published rules. It is a software component for developers, not legal or financial advice. Rules change and every rate here has an effective date. Check that the dates cover your case. Verify results against the official sources listed above, and have a conveyancer or tax adviser review how you use it, before anyone relies on the output. Provided "as is" under its licence, without warranty.

**Unreviewed.** This capability's implementations agree in every language and pass its published test vectors, which were worked out from the official sources cited. But no qualified conveyancer or tax adviser has yet checked those vectors, or confirmed that the capability covers the cases it claims. Treat it as a draft. Do not use it for real people, money or decisions without your own expert review. Once a qualified reviewer signs off, this notice is replaced with their name, qualification and the date. Each new version needs fresh sign-off.

## Notices

Contains public sector information licensed under the Open Government Licence v3.0 (https://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/).

Legislation: Crown copyright and database right.

1.0.2 marks it unreviewed and adds its attribution notices (NOTICE). The code and the tests are unchanged.

Files