> ## 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 टोकन मैकेनिक्स

> केवल-ऊपर की ओर मूल्य मॉडल।

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 हार्ड कैप" icon="cube">
    अधिकतम आपूर्ति हमेशा के लिए तय। कोई मुद्रास्फीति नहीं, कोई नई माइंटिंग नहीं।
  </Card>

  <Card title="100% USDT समर्थित" icon="shield-check">
    प्रत्येक DA टोकन लिक्विडिटी पूल में वास्तविक USDT द्वारा समर्थित।
  </Card>

  <Card title="हर बिक्री पर बर्न" icon="fire">
    बेचे गए टोकनों का 100% स्थायी रूप से बर्न होता है। उपयोगकर्ता को USDT में मूल्य का 75% (मैन्युअल) या 70% (ऑटो) मिलता है। शेष 25% (मैन्युअल) या 30% (ऑटो) एक प्रोटोकॉल कमीशन है जो बैकिंग के रूप में पूल में रहता है — यही DA की कीमत को ऊपर ले जाता है।
  </Card>

  <Card title="कोई P2P स्थानांतरण नहीं" icon="ban">
    DA को केवल बेचा, उधार दिया, या चुकाया जा सकता है — कोई पीयर-टू-पीयर स्थानांतरण नहीं।
  </Card>
</CardGroup>

## "केवल ऊपर की ओर" मूल्य फ़ॉर्मूला

मूल्य = लिक्विडिटी ÷ सर्कुलेटिंग सप्लाई

जब भी DA बेचा जाता है, टोकन बर्न होते हैं (आपूर्ति घटती है) जबकि USDT पूल में रहता है (लिक्विडिटी समान या बढ़ती है)। कम टोकन ÷ समान या अधिक USDT = प्रति टोकन उच्च मूल्य।

<Info>
  **यह कैसे काम करता है:** सर्कुलेशन में 200 DA, लिक्विडिटी पूल में 200 USDT। मूल्य = 1.00 USDT प्रति DA। एक उपयोगकर्ता 100 DA बेचता है। पूल 70 USDT का भुगतान करता है (100 USDT मूल्य का 70%)। सभी 100 DA बर्न हो जाते हैं। परिणाम: 100 DA शेष, पूल में 130 USDT। नया मूल्य = 130 ÷ 100 = **1.30 USDT प्रति DA**।
</Info>

<Tip>
  सभी मार्केटिंग रिवॉर्ड्स पर 5% कमीशन सीधे DA लिक्विडिटी पूल में जाता है — सेल प्रतिशत से अलग। अतिरिक्त लिक्विडिटी लेंडिंग शुल्क, RWA आय और FinPro राजस्व से आती है।
</Tip>

<Info>
  **Seed Supply सुरक्षा:** एक छोटा स्थायी DA रिज़र्व — **Seed Supply** — मूल्य निर्धारण फ़ॉर्मूला के लिए तकनीकी सुरक्षा के रूप में लॉन्च के समय प्रोटोकॉल में पूर्व-जमा किया जाता है।

  * **स्थायी और गैर-बिक्री योग्य।** Seed Supply प्रोटोकॉल स्तर पर लॉक है: इसे **बर्न नहीं किया जा सकता**, **बेचा नहीं जा सकता** (मैन्युअल या ऑटो-सेल के माध्यम से), और **ऑटो-सेल चक्रों से बाहर रखा गया है**।
  * **सर्कुलेशन से बाहर।** इसे **सर्कुलेटिंग सप्लाई के रूप में नहीं गिना जाता** और यह कभी भी उपयोगकर्ता बैलेंस, फार्मिंग, लेंडिंग, या मार्केटिंग वितरण में भाग नहीं लेता।
  * **गैर-शून्य भाजक की गारंटी।** क्योंकि `मूल्य = लिक्विडिटी ÷ सर्कुलेटिंग सप्लाई`, फ़ॉर्मूला को कभी भी शून्य से विभाजित नहीं करना चाहिए। Seed Supply हमेशा `totalSupply > 0` की गारंटी देता है, इसलिए मूल्य फ़ंक्शन हमेशा परिभाषित होता है — यहाँ तक कि उस चरम स्थिति में भी जहाँ सर्कुलेशन में हर दूसरा टोकन बर्न हो चुका हो।
  * **केवल एज-केस सुरक्षा।** सामान्य संचालन के तहत Seed Supply का मूल्य खोज पर कोई प्रभाव नहीं पड़ता। यह केवल एक नियतात्मक मंजिल के रूप में मौजूद है जो `getPrice()` को तब अच्छी तरह से परिभाषित रखता है जब लिक्विडिटी मौजूद है लेकिन सर्कुलेटिंग सप्लाई अन्यथा शून्य तक पहुँच जाएगी।
</Info>

## लिक्विडिटी पूल स्रोत

लिक्विडिटी पूल DA अर्थशास्त्र की नींव है। इसे RWANFTFI इकोसिस्टम के कई स्रोतों से वित्त पोषित किया जाता है, जो टोकन की बैकिंग की निरंतर वृद्धि सुनिश्चित करता है। प्रोटोकॉल का प्रत्येक राजस्व स्रोत एकल पूल में प्रवाहित होता है, जो मूल्य = लिक्विडिटी ÷ सप्लाई फ़ॉर्मूला को सुदृढ़ करता है।

<AccordionGroup>
  <Accordion title="NFT गतिविधि">
    **NFT खरीद** — हर NFT खरीद का 20% स्वचालित रूप से नए DA की माइंटिंग के लिए लिक्विडिटी पूल में जाता है।

    **रीबाय और Autobuy** — हर बार-बार या स्वचालित NFT खरीद से अतिरिक्त 20% लिक्विडिटी पूल में जाता है। यह पोज़िशन नवीनीकरण को प्रोत्साहित करता है और सिस्टम वृद्धि का समर्थन करता है।
  </Accordion>

  <Accordion title="शुल्क और कमीशन">
    **मार्केटिंग रिवॉर्ड्स कर** — रेफरल नेटवर्क में सभी मार्केटिंग रिवॉर्ड्स का 5% स्वचालित रूप से लिक्विडिटी पूल में निर्देशित होता है। नेटवर्क गतिविधि सीधे DA बैकिंग को मज़बूत करती है।

    **Accumulative Balance ट्रांसफ़र शुल्क** — किसी अन्य उपयोगकर्ता को Accumulative Balance स्थानांतरित करते समय, ट्रांसफ़र राशि का 20% DA लिक्विडिटी पूल में जाता है। Accumulative Balance का कोई भी मूवमेंट — चाहे वह NFT खरीद में उपयोग किया जाए या वॉलेट के बीच स्थानांतरित किया जाए — पूल में 20% प्रवाह उत्पन्न करता है।

    **Accumulative Balance खरीद शुल्क** — Accumulative Balance का उपयोग करके NFT खरीदते समय, एकीकृत राशि का 20% नए DA की माइंटिंग के लिए DA लिक्विडिटी पूल में जाता है। उदाहरण: Accumulative Balance पर 898 USDT — जब NFT खरीद में एकीकृत होता है, तो 718 USDT NFT लागत की ओर जाता है, और 180 USDT (898 का 20%) DA लिक्विडिटी पूल में जाता है। ऐसी हर खरीद पूल को फिर से भरती है और नए DA के लिए आधार बनाती है।

    **लेंडिंग कमीशन** — लोन लेते समय, उधारकर्ता एक बार 5% कमीशन का भुगतान करता है जो लिक्विडिटी पूल में जाता है। उदाहरण: \$1,000 का लोन, उधारकर्ता को \$950 मिलते हैं, \$50 पूल में जाते हैं। यह कमीशन हर नए लोन के साथ एकत्र किया जाता है।
  </Accordion>

  <Accordion title="समाप्त और अप्रयुक्त फंड">
    **शून्य आय सीमा के साथ ऑटो-सेल** — यदि DA ऑटो-सेल ट्रिगर होता है और उपयोगकर्ता के NFT पर शून्य आय सीमा है, तो 100% आय या तो लिक्विडिटी पूल में या DA बर्न में जाती है (सटीक तंत्र DAO सेटिंग्स द्वारा निर्धारित)।

    **समाप्त वाउचर** — यदि वाउचर 365 दिनों तक अप्रयुक्त रहते हैं, तो 100% फंड लिक्विडिटी पूल में निर्देशित होते हैं। यह निष्क्रिय फंडों को रोकता है और निष्क्रिय देनदारियों को समाप्त करता है।

    **अप्रयुक्त Accumulative Balance** — यदि Accumulative Balance 120 दिनों तक अप्रयुक्त रहता है, तो 70% फंड नए DA की माइंटिंग के लिए लिक्विडिटी पूल में निर्देशित होते हैं।
  </Accordion>

  <Accordion title="बाहरी राजस्व">
    **SWAP कमीशन** — सभी एक्सचेंज (SWAP) ऑपरेशन्स से कमीशन स्वचालित रूप से लिक्विडिटी पूल में निर्देशित होते हैं।

    **Debit Card कमीशन** — Debit Card कार्यक्रम से कमीशन लिक्विडिटी पूल में जाते हैं, जो बाहरी अर्थव्यवस्था से वास्तविक नकदी प्रवाह बनाते हैं।

    **RWA आय** — रियल एस्टेट, किराये की आय, वाणिज्यिक संपत्तियों, और अन्य रियल-वर्ल्ड एसेट्स से राजस्व का एक हिस्सा लिक्विडिटी पूल में निर्देशित होता है, जो सिस्टम को वास्तविक अर्थव्यवस्था से जोड़ता है।

    **FinPro राजस्व** — वित्तीय उत्पादों (लेंडिंग, निवेश उत्पाद, वित्तीय सेवाएँ) से लाभ का एक हिस्सा लिक्विडिटी पूल में जाता है।

    **इकोसिस्टम राजस्व** — कुल प्रोटोकॉल राजस्व का एक हिस्सा लिक्विडिटी पूल में निर्देशित किया जा सकता है या नए DA की माइंटिंग के लिए अतिरिक्त लिक्विडिटी बनाने के लिए उपयोग किया जा सकता है।
  </Accordion>
</AccordionGroup>

## DA बर्न मैकेनिक्स

DA बर्निंग मुख्य डिफ्लेशनरी तंत्र है — यह टोकन आपूर्ति को कम करता है और संपत्ति के मूल्य पर निरंतर ऊपर की ओर दबाव बनाता है।

<CardGroup cols={3}>
  <Card title="मैन्युअल बिक्री" icon="fire">
    बेचे गए DA का 100% स्थायी रूप से बर्न होता है। उपयोगकर्ता को USDT में मूल्य का 75% मिलता है। शेष 25% प्रोटोकॉल कमीशन है जो बैकिंग के रूप में पूल में रहता है, मूल्य वृद्धि को बढ़ाता है।
  </Card>

  <Card title="ऑटो-सेल" icon="clock">
    ऑटो-सोल्ड DA का 100% स्थायी रूप से बर्न होता है। उपयोगकर्ता को USDT में मूल्य का 70% मिलता है। शेष 30% प्रोटोकॉल कमीशन है जो बैकिंग के रूप में पूल में रहता है, मूल्य वृद्धि को बढ़ाता है। शेष बैलेंस से 4 अवधियों (कुल 365 दिन / 1 वर्ष) में प्रगतिशील रूप से ट्रिगर होता है।
  </Card>

  <Card title="लेंडिंग डिफ़ॉल्ट" icon="ban">
    यदि लोन नहीं चुकाया जाता, तो कोलैटरलाइज़्ड DA ऑटो-सेल चक्र के माध्यम से प्रगतिशील रूप से बर्न होता है। सिस्टम लिक्विडिटी की रक्षा करता है और वित्तीय अनुशासन लागू करता है।
  </Card>
</CardGroup>

## तत्काल पहुँच और ऑटो-सेल चक्र

### तत्काल पहुँच

DA टोकन फार्म होते ही उपयोगकर्ता के लिए 100% उपलब्ध हैं। कोई लॉक-अप अवधि नहीं है। उपयोगकर्ता तुरंत:

* **मैन्युअल रूप से बेच सकता है** — USDT में मूल्य का 75% प्राप्त करें, 100% टोकन बर्न होते हैं
* **लोन ले सकता है** — DA कोलैटरल के विरुद्ध 70% LTV, 5% कमीशन शुल्क
* **होल्ड कर सकता है और प्रतीक्षा कर सकता है** — टोकन रखें और समय के साथ मूल्य वृद्धि से लाभ उठाएँ

### ऑटो-सेल चक्र

यदि उपयोगकर्ता मैन्युअल रूप से नहीं बेचता, तो सिस्टम **शेष बैलेंस** से 4 अवधियों में स्वचालित बिक्री ट्रिगर करता है, जो कुल **365 दिनों (1 वर्ष)** तक फैली होती हैं। ऑन-चेन अवधि की अवधि दिनों में निर्दिष्ट होती है (120 / 90 / 90 / 65 दिन); नीचे महीनों के संदर्भ केवल पठनीयता के लिए अनुमान हैं।

**100 DA से शुरू करने का उदाहरण:**

<Steps>
  <Step title="अवधि 1 — 120 दिनों के बाद (~4 महीने)">
    वर्तमान बैलेंस का 25% ऑटो-सोल्ड होता है। 100 का 25% = **25 DA बेचे गए** → शेष: **75 DA**
  </Step>

  <Step title="अवधि 2 — 90 और दिनों के बाद (~3 महीने, दिन 210)">
    शेष बैलेंस का 40% ऑटो-सोल्ड होता है। 75 का 40% = **30 DA बेचे गए** → शेष: **45 DA**
  </Step>

  <Step title="अवधि 3 — 90 और दिनों के बाद (~3 महीने, दिन 300)">
    शेष बैलेंस का 50% ऑटो-सोल्ड होता है। 45 का 50% = **22.5 DA बेचे गए** → शेष: **22.5 DA**
  </Step>

  <Step title="अवधि 4 — 65 और दिनों के बाद (~2 महीने, दिन 365)">
    शेष बैलेंस का 100% ऑटो-सोल्ड होता है। 22.5 का 100% = **22.5 DA बेचे गए** → शेष: **0 DA**
  </Step>
</Steps>

<Note>
  ऊपर दिखाए गए ऑटो-सेल प्रतिशत (25% / 40% / 50% / 100%) वर्तमान प्रोटोकॉल कॉन्फ़िगरेशन का प्रतिनिधित्व करते हैं। विशिष्ट मान प्रोटोकॉल पैरामीटर के रूप में संग्रहीत होते हैं और मानक गवर्नेंस प्रक्रियाओं के अधीन हैं। नवीनतम मानों के लिए हमेशा स्मार्ट कॉन्ट्रैक्ट या वर्तमान प्रोटोकॉल दस्तावेज़ की जाँच करें।
</Note>

प्रत्येक ऑटो-सेल उस अवधि के ट्रिगर के समय DA मूल्य पर निष्पादित होता है — मूल फार्मिंग मूल्य पर नहीं। ऑटो-सोल्ड टोकनों का 100% बर्न होता है, और उपयोगकर्ता को ऑटो-सेल की तारीख पर मूल्य पर USDT में मूल्य का 70% मिलता है। चूँकि मूल्य समय के साथ बढ़ता है, बाद की अवधियाँ उच्च मूल्य पर टोकन बर्न करती हैं, जिससे अपस्फीति तेज़ होती है।

उपयोगकर्ता ऑटो-सेल ट्रिगर होने से पहले किसी भी समय मैन्युअल रूप से बेच सकता है, जिससे 70% के बजाय 75% प्राप्त होगा।

<Tip>
  मैन्युअल सेल (75% पेआउट) हमेशा प्रति टोकन ऑटो-सेल (70% पेआउट) से अधिक लाभदायक होती है। हालाँकि, ऑटो-सेल समय के साथ मूल्य वृद्धि से लाभ उठाती है — बाद की अवधियाँ उच्च DA मूल्य पर निष्पादित होती हैं।
</Tip>

<Warning>
  **शून्य आय सीमा के साथ ऑटो-सेल:** यदि ऑटो-सेल ट्रिगर होता है और उपयोगकर्ता की शून्य आय सीमा है (NFT नवीनीकृत नहीं), तो 100% आय लिक्विडिटी पूल या DA बर्न में जाती है (DAO द्वारा निर्धारित)। उपयोगकर्ता को कुछ नहीं मिलता। हमेशा एक सक्रिय आय सीमा बनाए रखें।
</Warning>

## मल्टी-बैच लेंडिंग

प्रत्येक माइनिंग चक्र से प्रत्येक DA बैच स्वतंत्र कोलैटरल के रूप में कार्य करता है। यह एक निरंतर माइक्रो-लोन चक्र को सक्षम बनाता है:

<Steps>
  <Step title="बैच 1 माइन करें">
    उपयोगकर्ता एक माइनिंग चक्र पूरा करता है और DA बैच 1 प्राप्त करता है।
  </Step>

  <Step title="बैच 1 के विरुद्ध उधार लें">
    उपयोगकर्ता बैच 1 के विरुद्ध निश्चित 70% LTV लोन लेता है (जारी करने पर एकमुश्त 5% कमीशन, DA Liquidity Pool में)।
  </Step>

  <Step title="बैच 2 माइन करें">
    उपयोगकर्ता एक नया माइनिंग चक्र शुरू करता है और DA बैच 2 प्राप्त करता है।
  </Step>

  <Step title="बैच 2 के विरुद्ध उधार लें">
    उपयोगकर्ता बैच 2 के विरुद्ध निश्चित 70% LTV पर एक और लोन लेता है (जारी करने पर अलग एकमुश्त 5% कमीशन)।
  </Step>
</Steps>

यह कई एक साथ माइक्रो-लोन की अनुमति देता है, प्रति DA बैच एक। प्रत्येक लोन स्वतंत्र है - अपने स्वयं के बैच से बंधा है - और तब तक सक्रिय रहता है जब तक उस बैच का स्टैक ऑटो-सेल चक्र में प्रवेश न कर ले। यदि कोई व्यक्तिगत लोन डिफ़ॉल्ट होता है, तो केवल उस बैच का कोलैटरल बर्न होता है - सभी DA होल्डिंग्स नहीं। लेंडिंग आंशिक चुकौती और आनुपातिक डिफ़ॉल्ट रिकवरी को भी सपोर्ट करती है। पूरी जानकारी के लिए देखें [लेंडिंग मैकेनिक्स](/hi/da-lending)।

## डिफ्लेशनरी चक्र

वर्ष में दो बार सिस्टम एक विशेष डिफ्लेशनरी चक्र ट्रिगर करता है जो 30 दिनों तक चलता है, जिसे टोकन दुर्लभता को तीव्र करने के लिए डिज़ाइन किया गया है।

<Steps>
  <Step title="नए चक्रों को रोकें">
    NFTM माइनिंग, स्टेकिंग, और DA जनरेशन के नए चक्र शुरू करना डिफ्लेशनरी चक्र की अवधि के लिए रुक जाता है। **डिफ्लेशनरी चक्र से पहले शुरू हुए सक्रिय चक्र चलते रहते हैं और निर्धारित समय पर पूरे होते हैं** — पहले से माइनिंग चल रही उपयोगकर्ताओं की प्रगति नहीं खोती।
  </Step>

  <Step title="बिक्री तंत्र सक्रिय करें">
    स्वचालित या स्वैच्छिक DA बिक्री तंत्र सक्रिय किए जाते हैं।
  </Step>

  <Step title="दैनिक बर्न">
    टोकनों का एक हिस्सा दैनिक रूप से बर्न होता है।
  </Step>

  <Step title="आपूर्ति सिकुड़ती है">
    बाज़ार आपूर्ति सिकुड़ती है, ऊपर की ओर मूल्य दबाव को मज़बूत करती है।
  </Step>
</Steps>

<Info>
  डिफ्लेशनरी चक्र DA अर्थव्यवस्था को पूर्वानुमेय, प्रबंधनीय, और दीर्घकाल में टिकाऊ बनाता है।
</Info>

बढ़ी हुई गतिविधि → बढ़ी हुई लिक्विडिटी → बढ़ा हुआ DA जारीकरण → बढ़ी हुई बर्निंग → बढ़ी हुई दुर्लभता → बढ़ा हुआ संपत्ति मूल्य। यह क्लोज्ड-लूप सिस्टम का अर्थ है कि इकोसिस्टम जितना अधिक सक्रिय रूप से विकसित होता है, DA अर्थव्यवस्था उतनी ही मज़बूत होती है।

<DaPriceSimulator />