Maker collateral

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

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 reads the maker vault exactly as the contract sees it. All amounts are atomic USDC.

curl https://hip4-api.totalis.trade/v1/makers/$MAKER_ID/capital \
  -H "Authorization: Bearer $TOTALIS_MAKER_KEY"

{
  "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.

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.

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.

Start a job

Create collateral reduction. It takes no body. You get a job_id and next_eligible_at, the earliest time a new discount can land.

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"

{
  "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"
}

Wait for the certificate

Follow COLLATERAL_REDUCTION_UPDATED on the maker channel, or poll 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 and submit it

Sign that call as an EIP-1559 transaction from any wallet that holds HYPE for gas. Send it to 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.

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..." }'

Collect the headroom

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’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. 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’s maker.controller() builds each call for your wallet to send.

Get started

Guides

Resources

Maker collateral

Your capital

How each step moves it

When collateral is checked

Reduce collateral

What nets

Undo a discount

Move maker funds

​Your capital

​How each step moves it

​When collateral is checked

​Reduce collateral

​What nets

​Undo a discount

​Move maker funds

Your capital

How each step moves it

When collateral is checked

Reduce collateral

What nets

Undo a discount

Move maker funds