deviant/contracts/DeviantOpenMintNBA.cash

pragma cashscript ^0.12.0;

// DeviantOpenMintNBA — permissionless draw-from-reservoir for a NON-BACKED
// CashTokens FT category (the NBA family, V2.7 §2.4 — PTU / PTL).
//
// Sibling to DeviantOpenMintFT, and the difference is the entire point:
//
//   DeviantOpenMintFT (MBA/DEA):  output[1].value == tokenAmount * backingRate
//       The BCH the claimer pays is LOCKED INSIDE the token UTXO. Redemption is
//       a plain P2PKH spend of that UTXO — the peg is the coin itself.
//
//   DeviantOpenMintNBA (NBA):     output[1].value >= UNIT_DUST  (no rate at all)
//       The BCH the drawer pays is PAID AWAY to the founder. Nothing is locked,
//       nothing is redeemable, there is no protocol floor. Value is market-set.
//
// So this covenant does not "back" anything; it only decides WHO may take units
// out of the reservoir and ON WHAT TERMS. That is exactly what the NBA
// permissionless-mint axis means.
//
// RESERVOIR MODEL (inherited, and unavoidable):
//   CashTokens fixes fungible supply at genesis — no transaction can ever
//   increase a category's FT supply, and a minting NFT creates only new NFTs.
//   So "mint" is always a transfer from a genesis-minted reservoir, and the
//   genesis amount IS the hard cap. See ADR-0054: for fungible NBAs, "limited"
//   means a published, economically meaningful cap and "unlimited" means a
//   reservoir sized so the cap never binds. Neither is a mint capability.
//
// The two knobs that separate a faucet from a mineable coin:
//   pricePerUnitSats  — 0 makes it a free tap (PTU / game currency, faucet);
//                       > 0 makes extraction cost real BCH (PTL / "mined by
//                       anyone" — finite, unbacked, costly to acquire).
//   cooldownBlocks    — relative-age gate on the reservoir UTXO. Because every
//                       draw re-creates the reservoir, this rate-limits the
//                       WHOLE reservoir to one draw per N blocks — the only
//                       thing that keeps a free tap from being emptied in one
//                       transaction. 0 disables it.
//   maxUnitsPerDraw   — per-transaction ceiling (anti-drain, always on).
//
// Output layout (draw):
//   [0] reservoir back to this contract: minting NFT + (remaining FT), >= dust
//   [1] FT to recipient at dust value — NOT backed
//   [2] price to founder, if pricePerUnitSats > 0
//   [3+] BCH change (unconstrained)
//
// Category byte order: same as DeviantOpenMintFT — the constructor takes the
// bare 32-byte category id in CashTokens consensus (little-endian) order.

contract DeviantOpenMintNBA(
    bytes tokenCategory,           // bare 32-byte category id == genesis TXID (LE)
    int pricePerUnitSats,          // 0 = free faucet; > 0 = pay-to-extract
    int maxUnitsPerDraw,           // per-tx ceiling, must be > 0
    int cooldownBlocks,            // 0 = no rate limit; else reservoir min age
    bytes founderLockingBytecode   // 25-byte P2PKH bytecode of the price recipient
) {
    // draw() — permissionless transfer-from-reservoir, unbacked.
    function draw(int tokenAmount, bytes recipientLockingBytecode) {
        require(tokenAmount > 0);
        require(tokenAmount <= maxUnitsPerDraw);

        // Rate limit. Guarded so the default (0) costs no sequence-number
        // constraint on the spending transaction.
        if (cooldownBlocks > 0) {
            require(this.age >= cooldownBlocks);
        }

        int costSats = tokenAmount * pricePerUnitSats;

        // [0] reservoir back to this contract — same script, same category
        // (preserving the minting NFT capability), FT reduced by exactly the
        // amount that appears in [1].
        require(tx.outputs[0].lockingBytecode == tx.inputs[this.activeInputIndex].lockingBytecode);
        require(tx.outputs[0].tokenCategory == tx.inputs[this.activeInputIndex].tokenCategory);
        require(tx.outputs[0].tokenAmount == tx.inputs[this.activeInputIndex].tokenAmount - tokenAmount);
        require(tx.outputs[0].value >= 546);

        // [1] FT to the recipient. Dust-valued: no rate, no backing, no floor.
        // The absence of a `value == tokenAmount * rate` constraint here is the
        // structural statement that this asset carries no peg.
        require(tx.outputs[1].lockingBytecode == recipientLockingBytecode);
        require(tx.outputs[1].tokenCategory == tokenCategory);
        require(tx.outputs[1].tokenAmount == tokenAmount);
        require(tx.outputs[1].value >= 546);

        // [2] Price to the founder — only constrained when non-zero, so a free
        // tap leaves index 2 onward unrestricted (change, etc.).
        if (costSats > 0) {
            // Anti-dust: rounding noise must not produce non-standard outputs.
            // The off-chain planner mirrors this as a minimum viable draw.
            require(costSats >= 546);
            require(tx.outputs[2].lockingBytecode == founderLockingBytecode);
            require(tx.outputs[2].value == costSats);
            require(tx.outputs[2].tokenCategory == 0x);
        }
    }
}