PUT Position Management is Live: Hold, Divest, Withdraw or Trade the PUT (with a real-time dashboard)

PUT Position Management is Live: Hold, Divest, Withdraw or Trade the PUT (with a real-time dashboard)

If you participated in Flying Tulip’s Capital Allocation, you didn’t just buy a token, you minted a Perpetual PUT position.

An on-chain, permanent redemption right attached to primary‑issued FT. That position is represented as an ERC‑721 (ftPUT). It encodes your capital protection by including information on the denomination of the capital, the remaining backing, the remaining FT, and the strike reference.

For more information on how the PUT position works, see the documentation: https://docs.flyingtulip.com/capital-allocation.

Today we’re shipping the control plane for that position:

This post stays technical: it describes what each action does, when a rational actor should choose which route, and how each route maps to the contracts.

First: two risks

1) Always verify you’re using the official UI + addresses

The Invest UI finalizes the active investment and position contracts in‑app. Do not rely on screenshots, private messages, or old browser bookmarks.
Reference: https://docs.flyingtulip.com/contract-addresses

2) Market FT ≠ Perpetual PUT

FT purchased on the open market does not include a Perpetual PUT. The PUT attaches only to primary‑issued FT from Capital Allocation (Private + Public).
Reference: https://docs.flyingtulip.com/capital-allocation

Mental model: what you actually own

Your position is an ERC‑721 (ftPUT)

Every Capital Allocation position is an NFT (ftPUT) whose tokenId points to a Put struct containing (simplified):

  • token — the collateral asset you contributed (USDC, WETH, etc.)
  • amount / amountRemaining — the original and remaining backing in that asset
  • ft / ft_bought — remaining and originally allocated FT (18 decimals)
  • strike — the collateral USD price at the time of mint (oracle scale)
  • ftPerUSD — the FT‑per‑USD conversion rate snapshotted at mint

Key invariant: redemption math is anchored to the position’s stored fields at mint time. That’s why “divest” is a par return of the original asset/amount.

Your three core choices (mixable, partial, repeatable)

  1. Hold
    Do nothing. Keep protection permanent and retain the right to exit at par any time.
  2. Divest (par return)
    Redeem back the exact asset and amount you originally committed, proportional to the FT you divest.
  3. Withdraw (unlock FT; destroy PUT on that portion)
    Unlock FT into your wallet. This permanently invalidates the PUT on that portion. The reserved backing for that portion is released and used by the protocol for operations, market buybacks and burns (benefiting those who remain).

And because your position is an ERC‑721:

A) Divest: recover your original asset at par

What you get: the same token you deposited, in the same amount (pro‑rata to the FT you divest).
What happens to FT: the divested portion of FT is consumed by the PUT (i.e., it’s not yours anymore on that portion).

Example (par return):

  • Contribute 1,000 USDC → receive 10,000 FT → later divest 10,000 FT → receive 1,000 USDC
  • Contribute 2 ETH (at the then‑oracle price) → receive FT → later divest that FT → receive 2 ETH

On‑chain path (high level):

  1. PutManager.divest(id, amountFT)
  2. PutManager computes how much collateral corresponds to amountFT using the position’s stored strike + ftPerUSD
  3. PutManager updates accounting and calls:
    • pFT.divest(owner, id, amountFT, collateralAmount)
  4. PutManager pulls backing from the per‑asset wrapper:
    • ftYieldWrapper.withdraw(collateralAmount, owner)
  5. Events emitted for indexers.

Formula (single source of truth in PutManager):

  • ftOut = ftFromCollateral(collateral, strike, decimals, ftPerUSD)
  • collateralOut = collateralFromFT(ftAmount, strike, decimals, ftPerUSD)

These functions are intended inverses (modulo rounding dust).

Rational actor rule of thumb:
If your goal is “get my original asset back” (certainty, par), divest is the clean path.

B) Withdraw: unlock FT and invalidate the PUT on that portion

What you get: FT in your wallet (liquid, transferable, usable).
What you give up: the PUT protection on that withdrawn portion is permanently invalidated.

Withdraw releases the reserved backing for that portion and routes it to protocol buybacks.

On‑chain path (high level):

  1. PutManager.withdrawFT(id, amountFT)
  2. Requires transferable == true (post‑offering lifecycle)
  3. PutManager computes “released backing” via collateralFromFT(...)
  4. Calls:
    • pFT.withdrawFT(owner, id, amountFT, capitalReleased)
  5. Transfers FT to you:
    • FT.transfer(owner, amountFT)
  6. Tracks released backing:
    • capitalDivesting[token] += capitalReleased

The treasury later withdraws released backing via:

  • PutManager.withdrawDivestedCapital(token, amount) (multisig)

Rational actor rule of thumb:
If you want FT liquidity (hold/trade/use), withdraw is the explicit “remove protection” action.

C) Selling or transferring: two very different things

There are two “sell” concepts people mix up:

1) Selling FT (spot market)

To sell or transfer FT, you first have to withdraw it from your Perpetual PUT. Withdraw permanently invalidates the PUT on that portion, and the buyer of FT does not receive the PUT.

2) Selling the PUT position (ftPUT marketplace)

If you sell the ftPUT NFT on the marketplace, you are selling a collateral‑backed claim: remaining wrapped FT + remaining backing + strike reference. You are transferring control of the PUT to someone else.
Docs: https://docs.flyingtulip.com/product-suite/ftput-marketplace
Marketplace UI: https://marketplace.flyingtulip.com

Always review bid/ask vs collateral (net of fees)

The marketplace includes validation to prevent trades on outdated/modified positions — but that is not a fair‑price oracle.

Before you accept a bid or hit buy:

  • Collateral floor: check put.token + put.amountRemaining
  • Remaining wrapped FT: check put.ft
  • Fees: maker/taker fees change the effective price (net proceeds ≠ headline bid).
    Marketplace includes current fee rates and the maker/taker model; verify in‑UI before confirming.
    Docs: https://docs.flyingtulip.com/product-suite/ftput-marketplace
If you wouldn’t be comfortable selling the collateral floor at the effective (net) price, don’t accept the bid.

Why the dashboard exists (and when you should use it)

The only time the system says “slow down” is when backing outflows spike above the configured safety envelope — that’s what the Circuit Breaker is for.

  • Deposits are never rate‑limited.
  • Most normal user activity should be unaffected.
  • In high-traffic exit windows, withdrawals/divests can take longer while outflow capacity replenishes.

Circuit Breaker docs: https://docs.flyingtulip.com/risks/circuit-breaker

Status / dashboard: https://flyingtulip.com/allocation/dashboard

Per the Circuit Breaker docs, the status page exposes:

  • current withdrawal capacity,
  • any active rate limits,
  • estimated recovery times if usage is high.

If you plan to divest size (or you’re evaluating a market price vs collateral floor), check the dashboard first — it’s a real constraint in extreme flow conditions.

Choosing the right route (rational actor playbook)

Define:

  • par = your effective issuance cost per FT (10 FT per $1 contributed → implied $0.10 baseline)
  • P = market price of FT

If your goal is to reclaim your original asset

Choose Divest.

  • deterministic par return of the original asset/amount
  • no market dependency

If your goal is to own/use FT directly

Choose Withdraw.

  • you get liquid FT
  • you permanently remove protection on that withdrawn portion
  • released backing funds operations + buybacks + burns over time (per docs)

If your goal is to exit immediately and let the market price optionality

Choose Sell the ftPUT position.

This is useful when:

  • you want to monetize the PUT premium / optionality,
  • you prefer market execution over waiting for redemption liquidity,
  • you’re satisfied the executed price is sensible vs the collateral floor net of fees.

If you want optionality

Do nothing (Hold) or mix actions:

  • divest part to de‑risk,
  • withdraw part to gain FT liquidity,
  • keep part protected to retain the par floor.

How the UI maps to code (builders / auditors)

Invest (mint a position)

  • PutManager.invest(token, amount, ...)
    • oracle prices (getAssetFTPrice())
    • deposits to ftYieldWrapper.deposit()
    • mints via pFT.mint()

Divest (redeem backing)

  • PutManager.divest(id, amountFT)
    • computes collateralFromFT(...)
    • pFT.divest(...) updates position state
    • ftYieldWrapper.withdraw(...) returns backing (subject to outflow checks)

Withdraw (unlock FT)

  • PutManager.withdrawFT(id, amountFT)
    • requires transferable
    • computes released backing via collateralFromFT(...)
    • pFT.withdrawFT(...) updates position state
    • transfers FT to user
    • accounts released backing in capitalDivesting[token]

Not investment advice. DeFi involves market, smart contract, and operational risks. Yields are variable and not guaranteed.

Read more