# Capital Raise Limit

Source: https://docs.settlemint.com/docs/architecture/security/compliance/capital-raise-limit
CapitalRaiseLimit module for fiat-denominated gross capital raise caps, fixed or rolling accounting windows, and PriceResolver-backed mint valuation.



The CapitalRaiseLimit module caps the gross fiat value raised through minting during a configured accounting window. DALP converts each minted amount through the installed PriceResolver addon before it checks the cap.

Related compliance references:

* [Compliance overview](/docs/architecture/security/compliance)
* [Supply and investor limits](/docs/architecture/security/compliance/supply-investor-limits)
* [Issuance volume limit](/docs/architecture/security/compliance/issuance-volume-limit)

## Where this module applies [#where-this-module-applies]

| Concern   | CapitalRaiseLimit                                              |
| --------- | -------------------------------------------------------------- |
| Minting   | Enforces gross raised fiat cap in the active window            |
| Transfers | Pass through; transfers do not change the tracker              |
| Burns     | Pass through; burns do not release capacity                    |
| Pricing   | Converts mint amount through the installed PriceResolver addon |

## When to use this module [#when-to-use-this-module]

Use `capital-raise-limit` when a token needs a periodic fundraising cap expressed in fiat value instead of token units. The module measures gross capital raised through issuance in a fixed or rolling window.

It is not:

* A token-unit issuance quota. Use [Issuance volume limit](/docs/architecture/security/compliance/issuance-volume-limit).
* An absolute outstanding-supply cap. Use [Supply cap](/docs/architecture/security/compliance/supply-cap-collateral).
* A net-outstanding-value control; burns do not release capacity.

## Configuration [#configuration]

```solidity
struct RaiseLimitConfig {
    uint256 maxSupply;      // Maximum gross raised fiat in the window, normalized to 18 decimals.
    uint256 periodLength;   // Window length in days. Must be 1..730.
    bool    rolling;        // true = rolling window, false = fixed window.
    address priceResolver;  // Injected by dapi from the installed PriceResolver addon.
    uint256 priceTopicId;   // Injected by dapi; defaults to keccak256("basePrice").
}
```

| Field           | Client supplied? | Mutable after install? | Notes                                                                       |
| --------------- | ---------------- | ---------------------- | --------------------------------------------------------------------------- |
| `maxSupply`     | Yes              | No                     | Maximum gross raised fiat in the window, stored as 18-decimal fiat.         |
| `periodLength`  | Yes              | No                     | Window length in days. The module rejects `0` and values above `730`.       |
| `rolling`       | Yes              | No                     | Chooses rolling-window or fixed-window accounting.                          |
| `priceResolver` | No               | No                     | Resolved and injected by the DALP API from the indexed PriceResolver addon. |
| `priceTopicId`  | No               | No                     | Resolved and injected by the DALP API, defaulting to the `basePrice` topic. |

Installed configuration is immutable. The dapp disables the form once the module is enabled and shows a notice that a different configuration requires deploying a new module instance.

## PriceResolver prerequisite [#priceresolver-prerequisite]

`capital-raise-limit` requires a `PriceResolver` addon on the same system. The dapp checks the addon factory list for `typeId: "price-resolver"` and shows a warning only when the lookup succeeds and confirms the addon is missing.

Clients do not provide a resolver address. During current compliance install flows, the DALP API resolves the PriceResolver addon address for the token's system. It then merges the address into the compliance parameters and injects the default price topic ID `keccak256("basePrice")` before ABI encoding.

If the DALP API cannot find a PriceResolver addon for the system, the install request fails with `TOKEN_COMPLIANCE_PRICE_RESOLVER_ADDON_NOT_INSTALLED` (`DALP-0474`). The error maps to HTTP 409 (`CONFLICT`) and gives SDK and frontend clients a stable typed error to branch on. This prevents deployment with an absent resolver. The contract also rejects zero `priceResolver` and zero `priceTopicId` during config validation.

## Accounting [#accounting]

The module enforces only on mints (`from == address(0)`). For each mint, it calls `PriceResolver.getBasePrice(token, priceTopicId)` and converts the raw token amount into 18-decimal fiat using the token decimals. The mint is allowed only when the active-window gross total plus the new fiat amount stays within `maxSupply`.

| Mode    | Tracker                                                                         | Rollover behavior                                                                                   |
| ------- | ------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- |
| Fixed   | Single current-period total with `periodStart`.                                 | When the period elapses, the current raised fiat reads as `0`; the next mint starts a fresh period. |
| Rolling | 730-slot circular daily buffer keyed by day, summed over the configured window. | Daily slots age out as time advances.                                                               |

Burns and regular transfers do not change the raised-fiat tracker. A burn therefore cannot make room for additional issuance in the same window.

## Failure behavior [#failure-behavior]

The module fails closed when pricing is not usable. A mint check fails if the resolver address is zero, if the resolver returns a zero or negative price, or if the resolver call itself reverts. A mint that would exceed the configured raise cap reverts with the module's raise-limit compliance reason.