/* Time-boxed liquidity — the flash-loan-with-horizon primitive (asset holds a balance) */ function TimeBoxedLiquidity() { return (
A NEW PRIMITIVE · What couldn’t exist before?

One asset.
One new market.

{/* The time horizon — text left, code right */}

Wrap a balance in a key + store vault, integrate in usufruct and the same engine makes it rentable.

Rent a 1,000,000 SUI vault for a day — then flash-loan it across as many transactions as you like, each one atomic, the vault always returned whole.

Flash loans existed. Flash loans with a time horizon did not.

THE TIME HORIZON

A Move hot-potato is atomic — borrow and return inside one transaction, settled by the type system. That existed before usufruct.

usufruct adds two things on top: a time horizon and {' '}asset issuer-set terms. Rent the vault for a day and the right to borrow it reopens across the whole tenure — a fresh atomic transaction now, another two hours later, on terms the asset issuer fixed at integration.

Each transaction is atomic. The right to open the next one lasts the tenure.

{/* Note — emergent, not designed */}
NOTE — EMERGENT, NOT DESIGNED

usufruct never set out to build this. Time-boxed liquidity falls out of Sui objects being composable — the same key + store bound that makes anything rentable lets the borrowed asset nest inside other protocols within one transaction. The protocol provides the window; composability does the rest.

The vault here is just one shape. Each asset issuer designs their own wrapper — its balance, its terms, its own take / {' '}put hot-potato. usufruct shows the pattern; what flows through the window is yours to build.

{/* chrome */}
one tenure · many transactions MOVE 2024 
{``}{`// rent the vault — pay up front, receive a usufructCap.`}{`
let usufruct_cap = usufruct::`}rent{`(&`}mut{` escrow, payment, tenures, &clock, ctx);

`}{`// usufruct hands you the vault — asset_receipt forces its return.`}{`
let (vault, asset_receipt) =
    usufruct::`}borrow_asset{`(&`}mut{` escrow, &usufruct_cap, &clock, ctx);

`}{`// the vault emits its OWN hot potato: VaultBorrow.`}{`
let (coin, borrow_receipt) = vault::`}take{`(&`}mut{` vault, 1_000_000, ctx);
let coin = deepbook::`}swap{`(coin, ...);
let coin = cetus::`}swap{`(coin, ...);
vault::`}put{`(&`}mut{` vault, coin, borrow_receipt);

usufruct::`}return_asset{`(&`}mut{` escrow, vault, asset_receipt);


`}{`// ── two hours later ──────────────────`}{`


`}{`// same tenure, a fresh transaction on the same vault.`}{`
let (vault, asset_receipt) =
    usufruct::`}borrow_asset{`(&`}mut{` escrow, &usufruct_cap, &clock, ctx);

let (coin, borrow_receipt) = vault::`}take{`(&`}mut{` vault, 400_000, ctx);
let coin = lending::`}liquidate{`(coin, ...);
vault::`}put{`(&`}mut{` vault, coin, borrow_receipt);

usufruct::`}return_asset{`(&`}mut{` escrow, vault, asset_receipt);


`}{`// ── 30 minutes later ──────────────────`}{`
`}{`// ... and again, until the tenure expires.`}
); } window.TimeBoxedLiquidity = TimeBoxedLiquidity;