> ## Documentation Index > Fetch the complete documentation index at: https://docs.totalis.trade/llms.txt > Use this file to discover all available pages before exploring further. # Maker collateral > What backs your quotes: the maker vault, every capital field and how it moves, and collateral reduction, which lowers your requirement to what your open positions can lose together. Every position you confirm is backed by your maker vault. When you fill, the vault locks that position's worst case: what you pay if every leg wins. Positions that cannot all win at once still lock in full until you run a **collateral reduction**. A reduction lowers your requirement to what your whole book can lose together. Two positions on the same tournament, only one of which can win: backed one by one they lock 13,000, reduced they lock 8,000 Two positions on the same tournament, only one of which can win: backed one by one they lock 13,000, reduced they lock 8,000 In the picture you back two positions on one tournament winner market. Only one team can win. Backed one by one they lock 13,000 USDC. After a reduction they lock 8,000, the larger of the two. ## Your capital [Get maker capital](/hyperliquid/api-reference/makers/get-maker-capital) reads the maker vault exactly as the contract sees it. All amounts are atomic USDC. ```bash theme={null} curl https://hip4-api.totalis.trade/v1/makers/$MAKER_ID/capital \ -H "Authorization: Bearer $TOTALIS_MAKER_KEY" ``` ```json theme={null} { "context": { "as_of": "2026-09-26T12:00:02Z", "status": "CURRENT" }, "owner": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "signer": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "vault_gross": "5250000000", "stake_escrow": "150000000", "payable_owed": "40000000", "gross_open": "300000000", "discount": "0", "requirement": "300000000", "free_collateral": "4760000000", "floor_bps": 0, "pending_commitments": "25000000", "free_after_pending": "4735000000" } ``` | Field | Meaning | | - | - | | `vault_gross` | All USDC in your maker vault, including takers' stakes held in it. | | `stake_escrow` | Takers' net stakes on your open positions. You keep them if the positions lose. | | `payable_owed` | Winnings you owe on settled positions that are not yet claimed. | | `gross_open` | The sum of `payout - net stake` over your open positions: your worst case, position by position. | | `discount` | What your last collateral reductions took off `gross_open`. | | `requirement` | What must stay locked for your open positions: `max(gross_open - min(discount, gross_open), ceil(gross_open * floor_bps / 10000))`. With a `floor_bps` of 0 that is `gross_open - discount`. `null` when `floor_bps` is `null`. | | `floor_bps` | The share of `gross_open` that stays locked whatever the discount. `null` when it cannot be read. | | `free_collateral` | `vault_gross - stake_escrow - payable_owed - requirement`, never below zero. What can back new fills, or be withdrawn. | | `pending_commitments` | Fills accepted but not yet on-chain. | | `free_after_pending` | `free_collateral - pending_commitments`, never below zero. Size new quotes from this. | | `context.status` | `CURRENT`, or `STALE` or `UNAVAILABLE` when a source lags. A stale read never authorizes an action. | Re-read capital on every `MAKER_CAPITAL_UPDATED` on the [maker channel](/hyperliquid/api-reference/websocket/maker). ## How each step moves it | When | What changes | | - | - | | You confirm a fill | The taker's net stake joins `vault_gross` and `stake_escrow`. `gross_open` rises by the position's `payout - net stake`. `discount` does not change, so the new position locks in full. | | A position loses | You keep the stake: it leaves `stake_escrow` and stays in `vault_gross`. `gross_open` falls by the position's worst case. | | A position wins | The taker's stake goes back to them. You owe the profit, held in `payable_owed` until Totalis claims it for the taker. `gross_open` falls. | | A position closes either way | `discount` falls by the part of the closed position's worst case you did not pay, so the credit it earned leaves with it. | | You buy a position back (`SELL_BACK`) | The price comes out of `vault_gross`. The position closes as above. | | Another maker buys it (`TRANSFER`) | Nothing changes for you. You still back it, for its new owner. | | You deposit or withdraw | `vault_gross` moves. A withdrawal must leave `free_collateral` covered. | The profit fee comes out of the taker's winnings, not your vault. The entry fee comes out of the taker's stake before it reaches you. Rates are on [Limits](/hyperliquid/limits-and-fees). ## When collateral is checked Creating a quote reserves nothing. Your capacity is checked when you confirm a fill, against `free_collateral` less every fill not yet on-chain. If several of your quotes are accepted at once, a later confirm can fail with `QUOTE_CAPACITY_EXCEEDED`. The contract checks again when the trade lands. Quote only what `free_after_pending` covers. ## Reduce collateral A reduction looks at every open position you back, finds the most your book can lose under any way the markets can resolve, and certifies the difference as your `discount`. You submit that certificate on-chain from a wallet that pays the gas. Totalis does not run reductions for you, and it does not pay their gas. [Create collateral reduction](/hyperliquid/api-reference/makers/create-collateral-reduction). It takes no body. You get a `job_id` and `next_eligible_at`, the earliest time a new discount can land. ```bash theme={null} curl -X POST https://hip4-api.totalis.trade/v1/makers/$MAKER_ID/collateral-reductions \ -H "Authorization: Bearer $TOTALIS_MAKER_KEY" \ -H "Idempotency-Key: 01998713-2f4a-7c3e-9b1d-6a0e4f5c8d20" ``` ```json theme={null} { "job_id": "01998713-2f4a-7c3e-9b1d-6a0e4f5c8d21", "status": "QUEUED", "next_eligible_at": "2026-09-26T14:07:00Z", "status_url": "/v1/makers/7/collateral-reductions/01998713-2f4a-7c3e-9b1d-6a0e4f5c8d21" } ``` Follow `COLLATERAL_REDUCTION_UPDATED` on the maker channel, or poll [Get collateral reduction](/hyperliquid/api-reference/makers/get-collateral-reduction), until `status` is `DURABLE`. The job then holds a `transaction`: `to`, `data`, `value` and `chain_id` for one call to the vault. Sign that call as an EIP-1559 transaction from any wallet that holds HYPE for gas. Send it to [Submit self-funded transaction](/hyperliquid/api-reference/makers/submit-self-funded-transaction) with the job's `operation_id` and the same `Idempotency-Key` that created the job, before the job's `expiry`. Totalis checks the transaction matches the job and broadcasts it. It never holds that wallet's key or picks its nonce. ```bash theme={null} curl https://hip4-api.totalis.trade/v1/makers/$MAKER_ID/operations/$OPERATION_ID/self-funded-transaction \ -H "Authorization: Bearer $TOTALIS_MAKER_KEY" \ -H "Idempotency-Key: 01998713-2f4a-7c3e-9b1d-6a0e4f5c8d20" \ -H "Content-Type: application/json" \ -d '{ "signed_transaction": "0x02f8d4..." }' ``` When the transaction lands, `MAKER_CAPITAL_UPDATED` follows. `discount` is higher, `requirement` lower, and `free_collateral` higher by the same amount. No funds move: the freed USDC stays in your maker vault, ready to back fills or be withdrawn. | Job `status` | Meaning | | - | - | | `QUEUED` | Waiting for `next_eligible_at`. | | `SOLVING` | Computing your book's worst case. | | `DURABLE` | The certificate is signed and `transaction` is ready. Your requirement drops only once it lands. | | `NO_IMPROVEMENT` | Your book has nothing to net. Nothing to submit. | | `FAILED` | No certificate. `failure_code` says why. Start a new job. | * One job runs per maker at a time. Creating another while one is open returns the open one. * A new discount only ever raises the old one. It never undoes a larger discount still in force. * New fills do not use the discount, and closing positions use it up. Run a reduction again after your book grows. [The TypeScript SDK](/hyperliquid/sdk#make-markets)'s `reduceCollateral` runs all four steps. * `COLLATERAL_REDUCTION_UNAVAILABLE` means reductions are switched off for this vault right now. Retry later. ### What nets The reduction treats these positions as linked, and every other pair as independent: | Linked | Why | | - | - | | The legs of one position | It pays only if every leg wins. | | `YES` and `NO` of the same outcome | Only one side can win. | | Outcomes of one tournament winner question | Only one named outcome can win. | Treating two markets as independent can only overstate your worst case, never understate it. The certificate never lowers your requirement below what your book can actually lose. ### Undo a discount Your wallet can call `resetDiscount` on the vault at any time. It sets `discount` to zero, so every open position locks in full again. It can only raise your requirement, never lower it. ## Move maker funds Your wallet calls the vault directly and pays the gas in HYPE. Totalis does not relay these. | Vault call | Does | | - | - | | USDC `approve(vault, amount)`, then `depositMaker` | Deposits into the maker vault. Anyone can deposit for your maker. | | `requestMakerWithdraw`, then `executeMakerWithdraw` | Withdraws after the [delay](/hyperliquid/limits-and-fees). The execute fails if it would leave your positions uncovered. | | `cancelMakerWithdraw` | Cancels a pending withdrawal. One can be pending at a time. | | `setQuoteSigner` | Moves confirm signing to another key at once. The zero address stops all fills. | | `resetDiscount` | Sets your collateral discount to zero. | The [SDK](/hyperliquid/sdk#make-markets)'s `maker.controller()` builds each call for your wallet to send. This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.