Deposit capacity - Robin Markets

The vault can only absorb so much USDC at once. A deposit that would exceed capacity reverts, so check capacity before you build the batch — either over HTTP (GET /api/v1/capacity) or trustlessly on-chain (RobinLens.checkBatchDepositCapacity).

Capacity is global (vault-wide), not per-market. A deposit is a batch across markets, so always check the whole batch together — two batches that each fit on their own can exceed capacity when combined.

The two tiers

A deposit pairs opposing YES/NO tokens, merges each pair to USDC, and supplies that USDC to the external yield (ERC-4626) vault. Capacity is enforced at two points along that pipeline.

Tier	What it checks	Enforced	Reverts
1 — internal	Forward-looking: the worst-case USDC if all currently-unpaired tokens got paired must fit the vault caps.	Admin-disableable	`CapacityExceeded`
2 — external	Real-time: the actually-paired USDC must fit the live ERC-4626 vault’s headroom right now.	Always	`SupplyOverflow`

Tier 1 is a conservative guard against a large, unbalanced deposit that could later need more USDC than the vault can hold. Tier 2 is the hard limit — paired USDC must fit the external vault’s current maxDeposit. For a balanced (fully-matched) deposit, tier 2 is the binding constraint; a very one-sided deposit can hit tier 1 first.

Check via the API

GET /api/v1/capacity returns the global headroom and, when you pass a prospective batch, whether it fits. No wallet needed.

# Headroom only
curl "https://app.robin.markets/api/v1/capacity"

# Will this batch fit? (amounts are 6-dec micro-units, aligned 1:1 with conditionIds)
curl "https://app.robin.markets/api/v1/capacity?conditionIds=0x1234…,0xabcd…&yesAmounts=1000000,0&noAmounts=0,2000000"

{
  "fits": true, // would the supplied batch deposit without reverting
  "remainingUsdc": "1234000000" // USDC the vault can still absorb; null = uncapped
}

remainingUsdc already accounts for which tiers are active (a disabled internal guard simply drops out), so it’s the single number to gate a UI on.

Read it on-chain

For a trustless pre-flight, call RobinLens.checkBatchDepositCapacity — it simulates both tiers for a prospective batch and returns a single bool. GET /capacity runs the same simulation, but additionally honors the internal-guard flag (the raw on-chain view does not — see the warning below).

function checkBatchDepositCapacity(
    bytes32[] conditionIds,
    uint256[] yesAmounts,
    uint256[] noAmounts
) external view returns (bool fits);

To read the raw headroom yourself, the vault exposes each tier (USDC, 6-dec; type(uint256).max = uncapped):

Function	Returns
`getTotalAvailableCapacity()`	Tier 2 — USDC that can be supplied to the external vaults right now.
`getTotalAvailableInternalCapacity()`	Tier 1 — USDC the vault caps still allow.
`getMaximumAdditionalMatchedTokens()`	Current global worst-case pairing total; tier 1 passes while this stays ≤ `getTotalAvailableInternalCapacity()`.
`isInternalCapacityCheckDisabled()`	Whether tier 1 is currently disabled (then it never blocks a deposit).

checkBatchDepositCapacity enforces the internal guard even when an admin has disabled it, so it can be slightly stricter than the live vault — it never returns a false “fits”, only, rarely, a false “won’t fit”.

Next steps

Deposits

Build the deposit batch once capacity confirms it fits.

Reading on-chain state

The rest of the RobinLens read surface.

​The two tiers

​Check via the API

​Read it on-chain

​Next steps

Deposits

Reading on-chain state

The two tiers

Check via the API

Read it on-chain

Next steps