> For the complete documentation index, see [llms.txt](https://docs.takara.gg/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.takara.gg/using-takara/consignment.md).

# Consignment

Lend a won card back to the machine. It sits on its rack earning a cut of **every spin**, and if someone draws it, you're paid its face.

## How it pays

Two streams.

### While it sits there

Your card earns a share of the consignors' cut on every spin, pro-rated by its share of the rack. This accrues **whether or not your card is the one drawn**.

It's paid from the house's share before the vault sees it, through an O(1) accumulator, so settlement stays constant-cost no matter how many cards are lent.

### When it gets drawn

The player takes the card. You're paid:

```
full face − a small fee   +   everything it earned while racked
```

Credited immediately, claimable any time in USDG, not the stock.

### When you take it back

```solidity
unconsign(uint256 certId)
```

Returns the card and pays out what it earned. Blocked while any spin is in flight shrinking a rack mid-flight would shift the draw for a spin already paid for.

## Why the house can afford it

The consignors' cut scales with the consigned **share of the rack.**

A flat fee would be paid on *every* spin, while the offsetting discount that the house keeps when a consigned card is drawn and only lands when a consigned card actually comes off the shelf. Those two wouldn't net out, and consignment would bleed the bankroll.

Scaled by share, they move together. The draw discount is tuned against the table's payout rate so it offsets the fee stream, and consignment nets to roughly zero for LPs at **any** level of participation — one card or a fully consigned rack. That's what lets the house pay consignors without diluting the vault's edge.

## Rules

### Only machine-won cards

`consign` opens with:

```solidity
if (m.face == 0) revert NotMachineCard();
```

A certificate you minted by wrapping your own tokens has no face and can't be consigned.

### Only within the buyback window

`wonAt + buybackWindow` (2 days), after which it reverts `BuybackExpired`.

A consigned card pays its **frozen** face when drawn, so an unbounded entry would be a free look: hold the card, watch the stock, and lend it to the house only after it fell. Bounding entry means you decide while the card is still worth roughly its face.

Once consigned, it can sit as long as you like during the window limits when you *enter*, never how long it earns.

### No split cards

Splitting voids the face permanently, and the face is what the payout is computed from (`CardSplit`).

### Face must still match its tier

If the table was re-rated while the card was out of circulation, `consign` reverts `BadFace` rather than shelving a mispriced card.

### Mid-flight consigns queue

If a spin is pending, your card is accepted but **not racked** — it queues and lands on a shelf when the queue is flushed:

```solidity
bool racked = spinsInFlight == 0;
if (racked) _rackCard(certId, m); else _pendingConsign.push(certId);
```

`flushConsignments(max)` is permissionless — anyone can clear the queue.

A queued card **doesn't earn until it actually reaches a shelf**: it's undrawable while queued, so it collects nothing for that gap.

## The risk

You swap card ownership for a fee stream plus a claim on the frozen face.

**If it's drawn**, you get face minus the fee, in USDG not the stock. If the underlying rose since the card was minted, you've given up that upside: face is frozen at acquisition.

**If it's not drawn**, you keep accruing and can reclaim the card whenever no spin is in flight.

So consignment is a bet that fee income beats the stock's drift over the period you lend it. On a card you meant to hold anyway, it's close to free income. On one whose stock you expect to rip, it isn't.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.takara.gg/using-takara/consignment.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.