> ## Documentation Index
> Fetch the complete documentation index at: https://whitepaper.rwanftfi.com/llms.txt
> Use this file to discover all available pages before exploring further.

# DA Token Mechanics

> The Deflationary Asset (DA) is a 21M hard-capped, 100% USDT-backed BEP20 token whose price grows via the Liquidity ÷ Supply formula, three burn mechanisms, and a biannual deflationary cycle.

export const DaPriceSimulator = () => {
  if (typeof window === 'undefined') {
    return null;
  }
  var [minted, setMinted] = useState(1000000);
  var [liquidity, setLiquidity] = useState(1000000);
  var [burned, setBurned] = useState(0);
  var [dbMinted, setDbMinted] = useState(1000000);
  var [dbLiquidity, setDbLiquidity] = useState(1000000);
  var [dbBurned, setDbBurned] = useState(0);
  var timerRef = useRef(null);
  useEffect(function () {
    if (timerRef.current) clearTimeout(timerRef.current);
    timerRef.current = setTimeout(function () {
      setDbMinted(minted);
      setDbLiquidity(liquidity);
      setDbBurned(burned);
    }, 150);
    return function () {
      if (timerRef.current) clearTimeout(timerRef.current);
    };
  }, [minted, liquidity, burned]);
  var fmtUsd = function (n) {
    if (n >= 1000000) return '$' + (n / 1000000).toFixed(1) + 'M';
    if (n >= 1000) return '$' + (n / 1000).toFixed(1) + 'K';
    if (n >= 100) return '$' + Math.round(n);
    if (n >= 10) return '$' + n.toFixed(1);
    return '$' + n.toFixed(2);
  };
  var fmtUsdFull = function (n) {
    var digits = Math.abs(n) >= 10000 ? 0 : 2;
    return new Intl.NumberFormat('en-US', {
      style: 'currency',
      currency: 'USD',
      maximumFractionDigits: digits
    }).format(n);
  };
  var fmtNum = function (n) {
    return new Intl.NumberFormat('en-US').format(Math.round(n));
  };
  var circulating = minted - burned;
  if (circulating < 1) circulating = 1;
  var price = liquidity / circulating;
  var basePrice = liquidity / minted;
  var priceChange = (price - basePrice) / Math.max(basePrice, 0.0001) * 100;
  var burnedMax = minted - 1;
  var actualBurned = burned > burnedMax ? burnedMax : burned;
  var moonCirculating = Math.max(minted * 0.05, 1);
  var moonPrice = liquidity / moonCirculating;
  var chartData = useMemo(function () {
    var points = [];
    var steps = 200;
    for (var i = 0; i <= steps; i++) {
      var pct = i / steps * 95;
      var b = pct / 100 * dbMinted;
      var s = dbMinted - b;
      if (s < 1) s = 1;
      var p = dbLiquidity / s;
      points.push({
        pct: pct,
        burned: b,
        price: p
      });
    }
    return points;
  }, [dbMinted, dbLiquidity]);
  var W = 640, H = 280;
  var PAD = {
    top: 28,
    right: 56,
    bottom: 44,
    left: 64
  };
  var cW = W - PAD.left - PAD.right;
  var cH = H - PAD.top - PAD.bottom;
  var minP = chartData[0] ? chartData[0].price : 1;
  var maxP = chartData[chartData.length - 1] ? chartData[chartData.length - 1].price : minP * 2;
  var capP = minP * 50;
  var displayMaxP = Math.min(maxP, capP);
  var yPad = (displayMaxP - minP) * 0.08 || 0.01;
  displayMaxP = displayMaxP + yPad;
  var sqrtScale = function (val) {
    var norm = (Math.min(val, displayMaxP) - minP) / (displayMaxP - minP || 0.01);
    if (norm < 0) norm = 0;
    return Math.sqrt(norm);
  };
  var getX = function (pct) {
    return PAD.left + pct / 95 * cW;
  };
  var getY = function (p) {
    return PAD.top + cH - sqrtScale(p) * cH;
  };
  var currentPct = dbMinted > 0 ? dbBurned / dbMinted * 100 : 0;
  if (currentPct > 95) currentPct = 95;
  var currentChartPrice = dbLiquidity / Math.max(dbMinted - dbBurned, 1);
  var pathParts = [];
  for (var k = 0; k < chartData.length; k++) {
    var d = chartData[k];
    var px = getX(d.pct).toFixed(1);
    var py = getY(d.price).toFixed(1);
    pathParts.push((k === 0 ? 'M' : 'L') + ' ' + px + ' ' + py);
  }
  var pathD = pathParts.join(' ');
  var lastPt = chartData[chartData.length - 1];
  var areaD = pathD + ' L ' + getX(lastPt.pct).toFixed(1) + ' ' + (PAD.top + cH) + ' L ' + getX(0).toFixed(1) + ' ' + (PAD.top + cH) + ' Z';
  var dotX = getX(currentPct);
  var dotY = getY(currentChartPrice);
  var milestones = [10, 100, 1000, 10000];
  var visibleMilestones = milestones.filter(function (m) {
    return m > minP * 1.2 && m < displayMaxP * 0.95;
  });
  var xPcts = [0, 20, 40, 60, 80];
  var yLabelFracs = [0, 0.25, 0.5, 0.75, 1];
  var hdZoneX = getX(50);
  var hdZoneW = getX(95) - hdZoneX;
  var sliderStyle = {
    touchAction: 'manipulation',
    height: '6px',
    borderRadius: '3px',
    background: 'linear-gradient(to right, rgba(255,255,255,0.4), rgba(255,255,255,0.15))',
    outline: 'none',
    WebkitAppearance: 'none',
    appearance: 'none'
  };
  var pulseKeyframes = '@keyframes daPulse{0%,100%{opacity:0.6;r:12}50%{opacity:0.2;r:18}}';
  return <div style={{
    backgroundColor: '#000000',
    color: '#FFFFFF',
    border: '1px solid rgba(255,255,255,0.05)'
  }} className="p-6 rounded-xl not-prose">

      {}
      <style>{pulseKeyframes}</style>

      {}
      <div className="flex items-center justify-between mb-6">
        <h3 style={{
    color: '#FFFFFF',
    margin: 0
  }} className="text-lg font-serif italic">DA Price Simulator</h3>
        <span style={{
    color: 'rgba(255,255,255,0.6)',
    backgroundColor: 'rgba(255,255,255,0.1)',
    border: '1px solid rgba(255,255,255,0.2)',
    fontSize: '11px',
    padding: '4px 12px',
    borderRadius: '9999px',
    fontWeight: 500
  }}>Interactive</span>
      </div>

      {}
      <div className="grid grid-cols-1 sm:grid-cols-3 gap-4 mb-6">
        {}
        <div style={{
    backgroundColor: '#383838',
    border: '1px solid rgba(255,255,255,0.05)'
  }} className="rounded-xl p-4">
          <label style={{
    color: 'rgba(255,255,255,0.5)',
    fontSize: '11px',
    fontWeight: 500,
    display: 'block',
    marginBottom: '4px',
    textTransform: 'uppercase',
    letterSpacing: '0.05em'
  }}>DA Minted</label>
          <span style={{
    color: '#FFFFFF',
    fontSize: '18px',
    fontWeight: 800,
    display: 'block',
    marginBottom: '8px'
  }}>{fmtNum(minted)} DA</span>
          <input type="range" min="10000" max="21000000" step="10000" value={minted} onChange={function (e) {
    var val = Number(e.target.value);
    setMinted(val);
    if (burned >= val) setBurned(val - 1);
  }} className="w-full cursor-pointer" style={sliderStyle} />
          <div className="flex justify-between text-[10px] mt-1">
            <span style={{
    color: 'rgba(255,255,255,0.5)'
  }}>10,000</span>
            <span style={{
    color: 'rgba(255,255,255,0.5)'
  }}>21,000,000</span>
          </div>
        </div>
        {}
        <div style={{
    backgroundColor: '#383838',
    border: '1px solid rgba(255,255,255,0.05)'
  }} className="rounded-xl p-4">
          <label style={{
    color: 'rgba(255,255,255,0.5)',
    fontSize: '11px',
    fontWeight: 500,
    display: 'block',
    marginBottom: '4px',
    textTransform: 'uppercase',
    letterSpacing: '0.05em'
  }}>USDT Liquidity Pool</label>
          <span style={{
    color: '#FFFFFF',
    fontSize: '18px',
    fontWeight: 800,
    display: 'block',
    marginBottom: '8px'
  }}>{fmtUsdFull(liquidity)}</span>
          <input type="range" min="10000" max="100000000" step="10000" value={liquidity} onChange={function (e) {
    setLiquidity(Number(e.target.value));
  }} className="w-full cursor-pointer" style={sliderStyle} />
          <div className="flex justify-between text-[10px] mt-1">
            <span style={{
    color: 'rgba(255,255,255,0.5)'
  }}>$10,000</span>
            <span style={{
    color: 'rgba(255,255,255,0.5)'
  }}>$100,000,000</span>
          </div>
        </div>
        {}
        <div style={{
    backgroundColor: '#383838',
    border: '1px solid rgba(255,255,255,0.05)'
  }} className="rounded-xl p-4">
          <label style={{
    color: 'rgba(255,255,255,0.5)',
    fontSize: '11px',
    fontWeight: 500,
    display: 'block',
    marginBottom: '4px',
    textTransform: 'uppercase',
    letterSpacing: '0.05em'
  }}>DA Burned</label>
          <span style={{
    color: '#FFFFFF',
    fontSize: '18px',
    fontWeight: 800,
    display: 'block',
    marginBottom: '8px'
  }}>{fmtNum(actualBurned)} DA</span>
          <input type="range" min="0" max={burnedMax} step="10000" value={actualBurned} onChange={function (e) {
    setBurned(Number(e.target.value));
  }} className="w-full cursor-pointer" style={sliderStyle} />
          <div className="flex justify-between text-[10px] mt-1">
            <span style={{
    color: 'rgba(255,255,255,0.5)'
  }}>0</span>
            <span style={{
    color: 'rgba(255,255,255,0.5)'
  }}>{fmtNum(burnedMax)}</span>
          </div>
        </div>
      </div>

      {}
      <div className="mb-6" style={{
    display: 'flex',
    flexWrap: 'wrap',
    gap: '16px',
    alignItems: 'center'
  }}>
        {}
        <div style={{
    flexShrink: 0,
    display: 'flex',
    justifyContent: 'center'
  }} className="w-[160px] sm:w-[140px] mx-auto sm:mx-0">
          <video autoPlay muted loop playsInline style={{
    borderRadius: '12px',
    objectFit: 'cover'
  }} className="w-[160px] h-[160px] sm:w-[140px] sm:h-[140px]">
            <source src="/DAalpha-Uncompressed8-bit422.webm" type="video/webm" />
          </video>
        </div>
        {}
        <div style={{
    flex: '1 1 0%',
    minWidth: '240px',
    display: 'flex',
    flexWrap: 'wrap',
    gap: '12px'
  }}>
          {}
          <div style={{
    backgroundColor: '#383838',
    border: '1px solid rgba(255,255,255,0.05)',
    flex: '1 1 160px'
  }} className="rounded-xl p-4">
            <div style={{
    color: 'rgba(255,255,255,0.5)',
    fontSize: '10px',
    textTransform: 'uppercase',
    letterSpacing: '0.05em',
    marginBottom: '4px'
  }}>DA Price</div>
            <div style={{
    color: '#4ade80',
    fontSize: '28px',
    fontWeight: 900,
    lineHeight: 1.2
  }}>{fmtUsdFull(price)}</div>
            <div style={{
    color: 'rgba(255,255,255,0.7)',
    fontSize: '12px',
    fontWeight: 600,
    marginTop: '4px'
  }}>
              {priceChange >= 0 ? 'Up' : 'Down'} {Math.abs(priceChange).toFixed(2)}% from base
            </div>
          </div>
          {}
          <div style={{
    backgroundColor: '#383838',
    border: '1px solid rgba(255,255,255,0.05)',
    flex: '1 1 160px'
  }} className="rounded-xl p-4">
            <div style={{
    color: 'rgba(255,255,255,0.5)',
    fontSize: '10px',
    textTransform: 'uppercase',
    letterSpacing: '0.05em',
    marginBottom: '4px'
  }}>Circulating Supply</div>
            <div style={{
    color: '#FFFFFF',
    fontSize: '20px',
    fontWeight: 900
  }}>{fmtNum(circulating)} DA</div>
            <div style={{
    color: 'rgba(255,255,255,0.4)',
    fontSize: '12px',
    marginTop: '4px'
  }}>of 21M hard cap</div>
          </div>
          {}
          <div style={{
    backgroundColor: '#383838',
    border: '1px solid rgba(255,255,255,0.05)',
    flex: '1 1 160px'
  }} className="rounded-xl p-4">
            <div style={{
    color: 'rgba(255,255,255,0.5)',
    fontSize: '10px',
    textTransform: 'uppercase',
    letterSpacing: '0.05em',
    marginBottom: '4px'
  }}>Liquidity Pool</div>
            <div style={{
    color: '#FFFFFF',
    fontSize: '20px',
    fontWeight: 900
  }}>{fmtUsdFull(liquidity)}</div>
            <div style={{
    color: 'rgba(255,255,255,0.4)',
    fontSize: '12px',
    marginTop: '4px'
  }}>100% USDT backed</div>
          </div>
        </div>
      </div>

      {}
      <div style={{
    backgroundColor: '#383838',
    border: '1px solid rgba(255,255,255,0.05)'
  }} className="rounded-xl p-4 overflow-x-auto">
        <div style={{
    color: 'rgba(255,255,255,0.6)',
    fontSize: '12px',
    fontWeight: 600,
    marginBottom: '8px'
  }}>Price vs Burn Percentage</div>
        <svg viewBox={'0 0 ' + W + ' ' + H} className="w-full" style={{
    minWidth: '400px'
  }}>
          <defs>
            <linearGradient id="daAreaGrad" x1="0" y1="0" x2="1" y2="0">
              <stop offset="0%" stopColor="#4ade80" stopOpacity="0.03" />
              <stop offset="100%" stopColor="#4ade80" stopOpacity="0.25" />
            </linearGradient>
          </defs>

          {}
          <rect x={hdZoneX} y={PAD.top} width={hdZoneW} height={cH} fill="rgba(251,191,36,0.04)" />
          <text x={hdZoneX + 6} y={PAD.top + 12} fill="rgba(251,191,36,0.3)" style={{
    fontSize: '8px',
    fontWeight: 500
  }}>High Deflation Zone</text>

          {}
          {yLabelFracs.map(function (frac, idx) {
    var val = minP + (displayMaxP - minP) * frac;
    var y = getY(val);
    return <line key={'yg-' + idx} x1={PAD.left} y1={y} x2={W - PAD.right} y2={y} stroke="rgba(255,255,255,0.05)" strokeWidth="0.5" />;
  })}

          {}
          {visibleMilestones.map(function (m) {
    var y = getY(m);
    return <g key={'ms-' + m}>
                <line x1={PAD.left} y1={y} x2={W - PAD.right} y2={y} stroke="rgba(255,255,255,0.08)" strokeWidth="0.5" strokeDasharray="4 4" />
                <text x={W - PAD.right + 4} y={y + 3} fill="rgba(255,255,255,0.35)" style={{
      fontSize: '8px'
    }}>{fmtUsd(m)}</text>
              </g>;
  })}

          {}
          {yLabelFracs.map(function (frac, idx) {
    var val = minP + (displayMaxP - minP) * frac;
    var y = getY(val);
    return <text key={'yl-' + idx} x={PAD.left - 8} y={y} textAnchor="end" dominantBaseline="middle" fill="rgba(255,255,255,0.4)" style={{
      fontSize: '9px'
    }}>
                {fmtUsd(val)}
              </text>;
  })}

          {}
          <path d={areaD} fill="url(#daAreaGrad)" />

          {}
          <path d={pathD} fill="none" stroke="#4ade80" strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round" />

          {}
          <line x1={dotX} y1={PAD.top} x2={dotX} y2={PAD.top + cH} stroke="rgba(255,255,255,0.15)" strokeWidth="1" strokeDasharray="4 3" />

          {}
          <circle cx={dotX} cy={dotY} r="12" fill="none" stroke="#4ade80" strokeWidth="1.5" opacity="0.4" style={{
    animation: 'daPulse 2s ease-in-out infinite'
  }} />

          {}
          <circle cx={dotX} cy={dotY} r="6" fill="#4ade80" stroke="#000000" strokeWidth="2" />

          {}
          <rect x={dotX + 10} y={dotY - 12} width={Math.max(fmtUsd(currentChartPrice).length * 7 + 12, 48)} height={20} rx="4" fill="rgba(0,0,0,0.7)" stroke="rgba(74,222,128,0.3)" strokeWidth="1" />
          <text x={dotX + 16} y={dotY + 2} fill="#4ade80" style={{
    fontSize: '10px',
    fontWeight: 700
  }}>{fmtUsd(currentChartPrice)}</text>

          {}
          {xPcts.map(function (pct) {
    return <text key={'xl-' + pct} x={getX(pct)} y={H - PAD.bottom + 18} textAnchor="middle" fill="rgba(255,255,255,0.4)" style={{
      fontSize: '9px'
    }}>
                {pct}%
              </text>;
  })}
          <text x={W / 2} y={H - 4} textAnchor="middle" fill="rgba(255,255,255,0.3)" style={{
    fontSize: '8px'
  }}>Burn Percentage (% of Minted Supply)</text>
        </svg>

        {}
        <div className="flex items-center gap-4 mt-2" style={{
    paddingLeft: PAD.left + 'px'
  }}>
          <div className="flex items-center gap-1">
            <span style={{
    display: 'inline-block',
    width: '8px',
    height: '8px',
    borderRadius: '50%',
    backgroundColor: '#4ade80'
  }} />
            <span style={{
    color: 'rgba(255,255,255,0.5)',
    fontSize: '10px'
  }}>DA Price</span>
          </div>
          <div className="flex items-center gap-1">
            <span style={{
    display: 'inline-block',
    width: '8px',
    height: '8px',
    borderRadius: '50%',
    backgroundColor: '#4ade80',
    boxShadow: '0 0 6px rgba(74,222,128,0.6)'
  }} />
            <span style={{
    color: 'rgba(255,255,255,0.5)',
    fontSize: '10px'
  }}>Current Position</span>
          </div>
          <div className="flex items-center gap-1">
            <span style={{
    display: 'inline-block',
    width: '12px',
    height: '6px',
    backgroundColor: 'rgba(251,191,36,0.15)',
    borderRadius: '2px'
  }} />
            <span style={{
    color: 'rgba(255,255,255,0.5)',
    fontSize: '10px'
  }}>High Deflation Zone</span>
          </div>
        </div>

        {}
        <div style={{
    marginTop: '10px',
    paddingLeft: PAD.left + 'px'
  }}>
          <span style={{
    color: 'rgba(255,255,255,0.4)',
    fontSize: '12px'
  }}>
            If 95% of supply is burned:{' '}
            <span style={{
    color: '#FFFFFF',
    fontWeight: 700
  }}>{fmtUsdFull(moonPrice)}</span>
            {' '}USDT per DA
          </span>
        </div>
      </div>

      {}
      <p style={{
    color: 'rgba(255,255,255,0.4)',
    fontSize: '12px',
    lineHeight: 1.6,
    marginTop: '16px',
    marginBottom: 0
  }}>
        Direct formula calculator. DA Price = Liquidity Pool ÷ Circulating Supply. Supply starts at 0 and grows via farming — hard cap 21M. Every sale burns 100% of sold tokens. On every sale, 25% (manual) or 30% (auto) of USDT backing stays in the pool — this drives the price upward.
      </p>
    </div>;
};

<CardGroup cols={2}>
  <Card title="21M Hard Cap" icon="cube">
    Maximum supply fixed forever. No inflation, no minting.
  </Card>

  <Card title="100% USDT Backed" icon="shield-check">
    Every DA token backed by real [USDT](https://tether.to/) in the liquidity pool, held on the [Binance Smart Chain](https://www.bnbchain.org/en/bnb-smart-chain).
  </Card>

  <Card title="Burn on Every Sale" icon="fire">
    100% of sold tokens are permanently burned. User receives 75% (manual) or 70% (auto) of value in USDT. The remaining 25% (manual) or 30% (auto) is a protocol commission that stays as backing in the pool — this is what drives the DA price upward.
  </Card>

  <Card title="No P2P Transfers" icon="ban">
    DA can only be sold, lent, or repaid — no peer-to-peer transfers.
  </Card>
</CardGroup>

## How does the "only upward" price formula work?

Price = Liquidity ÷ Circulating Supply

Every time DA is sold, tokens are burned (supply goes down) while USDT stays in the pool (liquidity stays or grows). Less tokens ÷ same or more USDT = higher price per token.

<Info>
  **How it works:** 200 DA in circulation, 200 USDT in the liquidity pool. Price = 1.00 USDT per DA. A user sells 100 DA. The pool pays out 70 USDT (70% of 100 USDT value). All 100 DA are burned. Result: 100 DA remain, 130 USDT in the pool. New price = 130 ÷ 100 = **1.30 USDT per DA**.
</Info>

<Tip>
  The 5% commission on all marketing rewards flows directly into the DA liquidity pool — separate from sell percentages. Additional liquidity comes from Lending fees, RWA income, and FinPro revenue.
</Tip>

<Info>
  **Seed Supply Protection:** A small permanent DA reserve — the **Seed Supply** — is pre-deposited into the protocol at launch as a technical safeguard for the pricing formula.

  * **Permanent and non-sellable.** The Seed Supply is locked at the protocol level: it **cannot be burned**, **cannot be sold** (manually or via auto-sell), and is **excluded from auto-sell cycles**.
  * **Outside circulation.** It is **not counted as circulating supply** and never participates in user balances, farming, lending, or marketing distributions.
  * **Guarantees a non-zero denominator.** Because `Price = Liquidity ÷ Circulating Supply`, the formula must never divide by zero. The Seed Supply guarantees `totalSupply > 0` at all times, so the price function is always defined — even in the extreme edge case where every other token in circulation has been burned.
  * **Edge-case-only protection.** Under normal operation the Seed Supply has no effect on price discovery. It exists purely as a deterministic floor that keeps `getPrice()` well-defined when liquidity is present but circulating supply would otherwise reach zero.
</Info>

## How is the DA Liquidity Pool funded?

The Liquidity Pool is the foundation of DA economics. It is funded from multiple sources across the RWANFTFI ecosystem, ensuring continuous growth of the token's backing. Every protocol revenue stream flows into a single pool, reinforcing the Price = Liquidity ÷ Supply formula.

<AccordionGroup>
  <Accordion title="NFT Activity">
    **NFT Purchases** — 20% of every NFT purchase is automatically routed to the Liquidity Pool for minting new DA.

    **Rebuy & Autobuy** — an additional 20% from every repeat or automatic NFT purchase flows into the Liquidity Pool. This incentivizes position renewal and supports system growth.
  </Accordion>

  <Accordion title="Fees & Commissions">
    **Marketing Rewards Tax** — 5% of all marketing rewards across the referral network are automatically directed to the Liquidity Pool. Network activity directly strengthens DA backing.

    **Accumulative Balance Transfer Fee** — when transferring Accumulative Balance to another user, 20% of the transfer amount is routed to the DA Liquidity Pool. Any movement of the Accumulative Balance — whether used in an NFT purchase or transferred between wallets — generates a 20% inflow to the Pool.

    **Accumulative Balance Purchase Fee** — when purchasing an NFT using Accumulative Balance, 20% of the integrated amount is routed to the DA Liquidity Pool for minting new DA. Example: 898 USDT on the Accumulative Balance — when integrated into an NFT purchase, 718 USDT goes toward the NFT cost, and 180 USDT (20% of 898) flows into the DA Liquidity Pool. Every such purchase replenishes the Pool and creates the basis for new DA.

    **Lending Commission** — when taking a loan, the borrower pays a one-time 5% commission directed to the Liquidity Pool. Example: loan \$1,000, borrower receives \$950, \$50 goes to Pool. The commission is collected with every new loan.
  </Accordion>

  <Accordion title="Expired & Unused Funds">
    **Auto-Sell with Zero Income Limit** — if DA auto-sell triggers and the user has zero Income Limit on their NFT, 100% of proceeds go either to the Liquidity Pool or to DA burn (exact mechanism determined by DAO settings).

    **Expired Vouchers** — if Vouchers remain unused for 365 days, 100% of funds are directed to the Liquidity Pool. This prevents idle funds and eliminates inactive liabilities.

    **Unused Accumulative Balance** — if the Accumulative Balance remains unused for 120 days, 70% of funds are directed to the Liquidity Pool for minting new DA.
  </Accordion>

  <Accordion title="External Revenue">
    **SWAP Commissions** — commissions from all exchange (SWAP) operations are automatically routed to the Liquidity Pool.

    **Debit Card Commissions** — commissions from the Debit Card program flow into the Liquidity Pool, creating real cash flow from the external economy.

    **RWA Income** — a portion of revenue from real estate, rental income, commercial assets, and other real-world assets is directed to the Liquidity Pool, anchoring the system to the real economy.

    **FinPro Revenue** — a portion of profits from financial products (Lending, investment products, financial services) flows into the Liquidity Pool.

    **Ecosystem Revenue** — a portion of total protocol revenue may be directed to the Liquidity Pool or used to create additional liquidity for minting new DA.
  </Accordion>
</AccordionGroup>

## How is DA burned?

DA burning is the core deflationary mechanism — it reduces token supply and creates sustained upward pressure on the asset's value.

<CardGroup cols={3}>
  <Card title="Manual Sale" icon="fire">
    100% of sold DA is permanently burned. User receives 75% of value in USDT. The remaining 25% is a protocol commission that stays in the pool as backing, driving price growth.
  </Card>

  <Card title="Auto-Sell" icon="clock">
    100% of auto-sold DA is permanently burned. User receives 70% of value in USDT. The remaining 30% is a protocol commission that stays in the pool as backing, driving price growth. Triggers progressively from remaining balance over 4 periods (365 days / 1 year total).
  </Card>

  <Card title="Lending Default" icon="ban">
    If a loan is not repaid, collateralized DA is progressively burned through the auto-sell cycle. Protects system liquidity and enforces financial discipline.
  </Card>
</CardGroup>

## Instant Access & Auto-Sell Cycle

### Instant Access

DA tokens are 100% available to the user from the moment they are farmed. There is no lock-up period. The user can immediately:

* **Sell manually** — receive 75% of value in USDT, 100% of tokens are burned
* **Take a loan** — 70% LTV against DA collateral, 5% commission fee
* **Hold and wait** — keep tokens and benefit from price growth over time

### Auto-Sell Cycle

If the user does not sell manually, the system triggers automatic sales from the **remaining balance** over 4 periods spanning **365 days (1 year)** total. Period durations are denominated in days on-chain (120 / 90 / 90 / 65 days); the month references below are approximations for readability.

**Example starting with 100 DA:**

<Steps>
  <Step title="Period 1 — After 120 days (~4 months)">
    25% of current balance is auto-sold. 25% of 100 = **25 DA sold** → Remaining: **75 DA**
  </Step>

  <Step title="Period 2 — After 90 more days (~3 months, day 210)">
    40% of remaining balance is auto-sold. 40% of 75 = **30 DA sold** → Remaining: **45 DA**
  </Step>

  <Step title="Period 3 — After 90 more days (~3 months, day 300)">
    50% of remaining balance is auto-sold. 50% of 45 = **22.5 DA sold** → Remaining: **22.5 DA**
  </Step>

  <Step title="Period 4 — After 65 more days (~2 months, day 365)">
    100% of remaining balance is auto-sold. 100% of 22.5 = **22.5 DA sold** → Remaining: **0 DA**
  </Step>
</Steps>

<Note>
  The auto-sell percentages (25% / 40% / 50% / 100%) shown above represent the current protocol configuration. Specific values are stored as protocol parameters and are subject to standard governance procedures. Always check the smart contract or current protocol documentation for the latest values.
</Note>

Each auto-sell executes at the DA price at the time of that period's trigger — not the original farming price. 100% of auto-sold tokens are burned, and the user receives 70% of value in USDT at the price on the date of auto-sell. Since the price grows over time, later periods burn tokens at a higher price, accelerating deflation.

The user can sell manually at any time before auto-sell triggers, receiving 75% instead of 70%.

<Tip>
  Manual sell (75% payout) is always more profitable per token than auto-sell (70% payout). However, auto-sell benefits from price growth over time — later periods execute at a higher DA price.
</Tip>

<Warning>
  **Auto-Sell with Zero Income Limit:** If auto-sell triggers and the user has zero Income Limit (NFT not renewed), 100% of proceeds go to the Liquidity Pool or DA burn (determined by DAO). The user receives nothing. Always maintain an active Income Limit.
</Warning>

## How does multi-batch lending against DA work?

Each DA batch from each mining cycle serves as independent collateral. This enables a continuous micro-loan cycle:

<Steps>
  <Step title="Mine Batch 1">
    User completes a mining cycle and receives DA batch 1.
  </Step>

  <Step title="Borrow against Batch 1">
    User takes a **fixed 70% LTV** loan against batch 1. The 5% commission is charged once at issuance and routed to the Liquidity Pool - it is not re-charged at repayment.
  </Step>

  <Step title="Mine Batch 2">
    User starts a new mining cycle and receives DA batch 2.
  </Step>

  <Step title="Borrow against Batch 2">
    User takes another **fixed 70% LTV** loan against batch 2. A separate one-time 5% commission is charged at issuance for this new loan.
  </Step>
</Steps>

This allows multiple simultaneous micro-loans, one per DA batch. Each loan is independent - bound to its own batch - and stays active until that batch's stack enters the auto-sell cycle. If any individual loan defaults, only that batch's collateral is burned - not all DA holdings.

For detailed sell vs. lend comparison, see [Selling & Lending](/en/da-selling-lending). Lending also supports partial repayments and proportional default recovery. See [Lending Mechanics](/en/da-lending) for the full breakdown.

## What is the biannual Deflationary Cycle?

Twice a year the system triggers a special Deflationary Cycle lasting up to 30 days, designed to intensify token scarcity.

<Steps>
  <Step title="Pause new cycles">
    Starting new cycles of NFTM mining, staking, and DA generation is paused for the duration of the Deflationary Cycle. **Active cycles started before the Deflationary Cycle continue running and complete on schedule** — users with mining already in progress do not lose their progress.
  </Step>

  <Step title="Activate sale mechanisms">
    Automatic or voluntary DA sale mechanisms are activated.
  </Step>

  <Step title="Daily burn">
    A portion of tokens is burned daily.
  </Step>

  <Step title="Supply shrinks">
    Market supply shrinks, strengthening upward price pressure.
  </Step>
</Steps>

<Info>
  The Deflationary Cycle makes the DA economy predictable, manageable, and sustainable over the long term.
</Info>

Increased activity → increased liquidity → increased DA issuance → increased burning → increased scarcity → increased asset value. This closed-loop system means the more actively the ecosystem develops, the stronger the DA economy becomes.

<DaPriceSimulator />
