Taler

QuantstampCode version: not recorded (see the report)

Quantstamp reviewed Taler Finance (Taler) on 21 Apr 2026: 9 findings, 0 critical; all marked fixed.

No open critical findings
Open the reportOpen Taler Finance’s security record

Report hosted on certificate.quantstamp.com.

Trustblock does not review code.

Findings16

Statuses are the security firm’s own, from its report.

SeverityOpenAcknowledgedFixed
Critical000
High000
Medium002
Low007

Marked Informational by the firm. Not counted as findings.

InformationalDirect Token Donation Can Trigger NAV Circuit Breaker, Causing Temporary DoS on Deposits and SettlementsAcknowledged

The NAV circuit breaker in `Vault._checkNavCircuitBreaker()` compares the live `totalAssets()` against `cachedNav`, which is only updated during deposits, settlements, and executions. Since `Accounting.totalAssets()` reads the vault's raw `asset.balanceOf()`, an attacker can inflate the live NAV by transferring tokens directly to the vault without updating the cache. If the donation exceeds the `navSpikeThresholdBps` (default 20%), the circuit breaker will revert all subsequent deposits and redemption settlements until the `VAULT_OWNER` calls `refreshNavCache()`.

InformationalNegative Total Assets Blocks All Recovery ActionsAcknowledged

The `Accounting` module's `totalAssets()` function computes the sum of all position NAVs. If debt positions exceed asset positions such that the aggregate value becomes negative, the function reverts with `Accounting_NegativeTotalAssets`. This total is referenced by all core vault operations to ensure accounting consistency. However, this revert also blocks `executeAction()`, which calls `totalAssets()` for its post-execution NAV slippage check. The `executeAction()` function is the primary mechanism through which vault managers can interact with external protocols to unwind positions, repay debt, or otherwise restore the vault to solvency. When `totalAssets()` reverts, the very operations needed to recover from insolvency are themselves blocked. This could lead to a vault that becomes permanently stuck in an insolvent state, unable to recover through normal operations. The only recourse would be a UUPS contract upgrade, which introduces governance delay and operational complexity during what is likely already a time-sensitive scenario.

InformationalUnbounded Position and Fee Entry Counts Can Make Vault Operations ExpensiveAcknowledged

The protocol has no explicit upper bounds on two lists that are iterated in frequently used execution paths. In both cases, runtime cost scales linearly with list length, so sufficiently large lists can make vaults expensive for their users. This behavior requires privileged configuration and does not appear likely during normal operations based on current gas measurements, which is why the issue is informational. The occurrences are: 1. `Accounting.addPosition()` has no maximum position count. `totalAssets()` iterates all positions and calls `calculateNav()` for each adapter, so deposit and settlement related flows inherit this scaling behavior. 2. `FeeModule.addFeeEntry()` has no maximum entry count. `claimFees()` iterates all entries, calls `_settleEntry()`, and can call `vault.mintFeeShares()` per entry, so claiming cost increases with the number of entries and recipients.

Informational`ExecutionFromModuleFailure` Event Is Unreachable with Current Vault Error FlowFixed

In both gateway execution paths, the event `ExecutionFromModuleFailure` is effectively unreachable under the current vault implementation. `ExecutionGateway.execTransactionFromModule()` performs a low level call to `Vault.executeAction()` and immediately bubbles the revert data if that call fails. `ExecutionGateway.execTransactionFromModuleReturnData()` invokes `Vault.executeAction()` through a Solidity external call, which also bubbles reverts by default. Inside `Vault.executeAction()`, the downstream call result is checked and the function reverts with `Vault_ActionFailed()` whenever the action result is false, instead of returning `(false, returnData)`. As a result, both gateway functions proceed to event emission only on successful execution, making `ExecutionFromModuleFailure` a dead monitoring signal for offchain services. Integrators that rely on that event for failure detection will miss failed executions and must parse revert traces instead.

InformationalManagement Fee Accumulator Desync via Zero-RoundingFixed

The management fee accrual path in `_accrueFees()` computes two values on each call: the accumulator delta `mgmtAccumDelta` which is unconditionally added to `mgmtSharesPerBps`, and the total management shares `totalMgmtShares` derived by multiplying the delta back by `totalMgmtBps` divided by `ACCUMULATOR_PRECISION`. The `totalPendingFeeShares` tracker is only incremented when `totalMgmtShares` is non-zero. However, when `mgmtAccumDelta * totalMgmtBps` is less than `ACCUMULATOR_PRECISION`, the floor division produces zero shares and `totalPendingFeeShares` is not incremented while the accumulator continues to advance. Over many such zero-rounding calls, the accumulated delta grows large enough that `_settleEntry()` produces non-zero shares that were never tracked in `totalPendingFeeShares`. The subtraction in `claimFees()` then underflows and reverts. This requires an active attacker calling `accrueFees()` at high frequency on vaults with low supply and low-decimal underlying tokens such as WBTC or USDC. The thresholds are restrictive: a WBTC vault at 200 bps must hold under approximately 9,450 dollars worth of assets for the zero-rounding condition to trigger on per-second accruals. For 18-decimal tokens the threshold is below one billionth of a dollar, making them immune. The attack cost in gas significantly exceeds the value of fees denied, making it economically irrational.

InformationalMissing L2 Sequencer Uptime Check for Future L2 DeploymentsFixed

The protocol currently targets Ethereum L1, where Chainlink feeds update independently and no sequencer exists. However, the team has stated the code should be compatible with L2 networks. When the sequencer goes down and later recovers, it replays queued transactions against oracle prices that may not have been updated during the outage. Chainlink provides [L2 Sequencer Uptime Feeds](https://docs.chain.link/data-feeds/l2-sequencer-feeds) specifically for this scenario. Neither `OracleMiddleware` nor any of the NAV adapters check the sequencer uptime feed or enforce a grace period after the sequencer restarts. If the protocol is deployed to an L2 without adding this check, the adapters could read stale prices immediately after a sequencer recovery, before Chainlink feeds have had the opportunity to update. This can lead to incorrect NAV calculations during the post recovery window, potentially allowing deposits or redemption settlements at mispriced values.

InformationalZero-Fee Entry with Null Recipient Blocks All Fee ClaimsFixed

The `FeeModule`'s `_validateFeeEntry()` function validates new and updated fee entries. The validation check for the recipient address is conditional: it only requires a non-zero recipient when at least one of `managementFeeBps` or `performanceFeeBps` is greater than zero. When both bps values are zero, the validation passes regardless of the recipient address, allowing entries with `recipient` set to `address(0)`. However, when an existing entry with accrued shares is updated to `0/0/address(0)` via `updateFeeEntry()`, the `_settleEntry()` call during the update moves accumulated shares into `entry.accruedShares`. The entry now holds a zero-fee configuration with a null recipient but non-zero `accruedShares`. When `claimFees()` iterates all entries, it attempts to mint fee shares to `address(0)` for this entry, which triggers a revert from OpenZeppelin's `ERC20._mint()` with `ERC20InvalidReceiver(address(0))`. This could lead to a complete denial of service on the fee claiming system. Since `claimFees()` processes all entries in a single transaction, the revert from the broken entry propagates and blocks claiming for all entries. The issue requires the `FEE_MANAGER` role to trigger, but a manager might reasonably expect that setting an entry to 0/0 effectively disables it rather than creating a permanent claim blocker.

Contracts in scope

No deployed address is recorded for this audit.

The report names a repository or files. Open the report to see its scope.

Part of Taler Finance’s security record

Taler Finance
Audits1 audit by 1 firmLast audit Apr 2026, by Quantstamp.
Critical findingsNo open critical findingsIn 1 report.
Open Taler Finance’s security record

Security firm

Quantstamp

240 projects reviewed · 338 reports · latest Nov 2026

See Quantstamp’s audits

Something wrong on this page? A missing report, a wrong date, a finding that was fixed since. Tell us and we check it against its source.

Tell us