> ## 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 ტოკენის მექანიკა

> 21M მკაცრი ზღვარი, 100% USDT უზრუნველყოფა, წვის სამი მექანიზმი.

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-ით ლიკვიდურობის პულში, რომელიც ინახება Binance Smart Chain-ზე.
  </Card>

  <Card title="წვა ყოველ გაყიდვაზე" icon="fire">
    გაყიდული ტოკენების 100% სამუდამოდ იწვება. მომხმარებელი იღებს ღირებულების 75%-ს (ხელით) ან 70%-ს (ავტო) USDT-ში. დარჩენილი 25% (ხელით) ან 30% (ავტო) წარმოადგენს პროტოკოლის საკომისიოს, რომელიც რჩება პულში როგორც უზრუნველყოფა — სწორედ ეს ანდევს DA-ს ფასს ზევით.
  </Card>

  <Card title="P2P გადაცემა შეუძლებელია" icon="ban">
    DA შეიძლება მხოლოდ გაიყიდოს, გაიცეს სესხად ან გადახდილი იქნას — peer-to-peer გადაცემა შეუძლებელია.
  </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-ს ლიკვიდურობის პული?

ლიკვიდურობის პული არის DA-ს ეკონომიკის საფუძველი. ის ფინანსდება მრავალი წყაროდან RWANFTFI ეკოსისტემაში, რაც უზრუნველყოფს ტოკენის უზრუნველყოფის უწყვეტ ზრდას. პროტოკოლის შემოსავლის ყოველი ნაკადი შედის ერთიან პულში, რაც აძლიერებს ფორმულას ფასი = ლიკვიდურობა ÷ მოცულობა.

<AccordionGroup>
  <Accordion title="NFT აქტივობა">
    **NFT შესყიდვები** — ყოველი NFT შესყიდვის 20% ავტომატურად მიემართება ლიკვიდურობის პულში ახალი DA-ს მინტინგისთვის.

    **ხელახალი შესყიდვა და Autobuy** — დამატებითი 20% ყოველი განმეორებითი ან ავტომატური NFT შესყიდვიდან მიემართება ლიკვიდურობის პულში. ეს ასტიმულირებს პოზიციის განახლებას და მხარს უჭერს სისტემის ზრდას.
  </Accordion>

  <Accordion title="საფასურები და საკომისიოები">
    **მარკეტინგული ჯილდოების გადასახადი** — ყველა მარკეტინგული ჯილდოს 5% რეფერალურ ქსელში ავტომატურად მიემართება ლიკვიდურობის პულში. ქსელის აქტივობა პირდაპირ აძლიერებს DA-ს უზრუნველყოფას.

    **აკუმულაციური ბალანსის გადაცემის საკომისიო** — სხვა მომხმარებელზე აკუმულაციური ბალანსის გადაცემისას გადაცემის თანხის 20% მიემართება DA-ს ლიკვიდურობის პულში. აკუმულაციური ბალანსის ნებისმიერი მოძრაობა — იქნება ის გამოყენებული NFT შესყიდვაში თუ გადაცემული საფულეებს შორის — წარმოქმნის 20% შემოდინებას პულში.

    **აკუმულაციური ბალანსის შესყიდვის საკომისიო** — აკუმულაციური ბალანსის გამოყენებით NFT-ის შესყიდვისას, ინტეგრირებული თანხის 20% მიემართება DA-ს ლიკვიდურობის პულში ახალი DA-ს მინტინგისთვის. მაგალითი: 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% მიემართება ლიკვიდურობის პულში. ეს თავიდან აიცილებს უმოქმედო სახსრებს და აუქმებს არააქტიურ ვალდებულებებს.

    **გამოუყენებელი აკუმულაციური ბალანსი** — თუ აკუმულაციური ბალანსი გამოუყენებელი რჩება 120 დღე, სახსრების 70% მიემართება ლიკვიდურობის პულში ახალი DA-ს მინტინგისთვის.
  </Accordion>

  <Accordion title="გარე შემოსავლები">
    **SWAP საკომისიოები** — ყველა გაცვლის (SWAP) ოპერაციიდან საკომისიოები ავტომატურად მიემართება ლიკვიდურობის პულში.

    **სადებეტო ბარათის საკომისიოები** — სადებეტო ბარათის პროგრამიდან საკომისიოები შემოდის ლიკვიდურობის პულში, რაც ქმნის რეალურ ფულად ნაკადს გარე ეკონომიკიდან.

    **RWA შემოსავალი** — შემოსავლის ნაწილი უძრავი ქონებიდან, საიჯარო შემოსავლიდან, კომერციული აქტივებიდან და სხვა რეალური აქტივებიდან მიემართება ლიკვიდურობის პულში, რაც სისტემას აანკერებს რეალურ ეკონომიკაში.

    **FinPro შემოსავალი** — მოგების ნაწილი ფინანსური პროდუქტებიდან (კრედიტირება, საინვესტიციო პროდუქტები, ფინანსური სერვისები) შემოდის ლიკვიდურობის პულში.

    **ეკოსისტემის შემოსავალი** — პროტოკოლის ჯამური შემოსავლის ნაწილი შეიძლება მიემართოს ლიკვიდურობის პულში ან გამოყენებული იქნას დამატებითი ლიკვიდურობის შესაქმნელად ახალი DA-ს მინტინგისთვის.
  </Accordion>
</AccordionGroup>

## როგორ იწვება DA?

DA-ს წვა არის ძირითადი დეფლაციური მექანიზმი — ის ამცირებს ტოკენის მიწოდებას და ქმნის მუდმივ აღმავალ წნევას აქტივის ღირებულებაზე.

<CardGroup cols={3}>
  <Card title="ხელით გაყიდვა" icon="fire">
    გაყიდული DA-ს 100% სამუდამოდ იწვება. მომხმარებელი იღებს ღირებულების 75%-ს USDT-ში. დარჩენილი 25% არის პროტოკოლის საკომისიო, რომელიც რჩება პულში როგორც უზრუნველყოფა და ასტიმულირებს ფასის ზრდას.
  </Card>

  <Card title="ავტო-გაყიდვა" icon="clock">
    ავტო-გაყიდული DA-ს 100% სამუდამოდ იწვება. მომხმარებელი იღებს ღირებულების 70%-ს USDT-ში. დარჩენილი 30% არის პროტოკოლის საკომისიო, რომელიც რჩება პულში როგორც უზრუნველყოფა და ასტიმულირებს ფასის ზრდას. ირთვება პროგრესიულად დარჩენილი ბალანსიდან 4 პერიოდის განმავლობაში (365 დღე / 1 წელი ჯამში).
  </Card>

  <Card title="სესხის დეფოლტი" icon="ban">
    თუ სესხი არ არის გადახდილი, გირაოდ ჩადებული DA პროგრესიულად იწვება ავტო-გაყიდვის ციკლის მეშვეობით. იცავს სისტემის ლიკვიდურობას და განამტკიცებს ფინანსურ დისციპლინას.
  </Card>
</CardGroup>

## დაუყოვნებელი წვდომა და ავტო-გაყიდვის ციკლი

### დაუყოვნებელი წვდომა

DA ტოკენები 100% ხელმისაწვდომია მომხმარებლისთვის ფარმინგის მომენტიდანვე. დაკეტვის პერიოდი არ არის. მომხმარებელს დაუყოვნებლივ შეუძლია:

* **გაყიდოს ხელით** — მიიღოს ღირებულების 75% USDT-ში, ტოკენების 100% იწვება
* **აიღოს სესხი** — 70% LTV DA გირაოს ქვეშ, 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% იწვება, ხოლო მომხმარებელი იღებს ღირებულების 70%-ს USDT-ში ავტო-გაყიდვის თარიღის ფასით. რადგან ფასი დროთა განმავლობაში იზრდება, გვიანდელი პერიოდები წვავს ტოკენებს უფრო მაღალი ფასით, რაც აჩქარებს დეფლაციას.

მომხმარებელს შეუძლია გაყიდოს ხელით ნებისმიერ დროს ავტო-გაყიდვის ჩართვამდე, მიიღოს 75% 70%-ის ნაცვლად.

<Tip>
  ხელით გაყიდვა (75% გადახდა) ყოველთვის უფრო მომგებიანია ერთ ტოკენზე, ვიდრე ავტო-გაყიდვა (70% გადახდა). თუმცა ავტო-გაყიდვა ისარგებლებს ფასის ზრდით დროთა განმავლობაში — გვიანდელი პერიოდები სრულდება უფრო მაღალი DA ფასით.
</Tip>

<Warning>
  **ავტო-გაყიდვა ნულოვანი შემოსავლის ლიმიტით:** თუ ავტო-გაყიდვა ირთვება და მომხმარებელს აქვს ნულოვანი შემოსავლის ლიმიტი (NFT არ არის განახლებული), შემოსულობის 100% მიემართება ლიკვიდურობის პულში ან DA-ს წვაში (განისაზღვრება DAO-ს მიერ). მომხმარებელი არაფერს იღებს. ყოველთვის შეინარჩუნეთ აქტიური შემოსავლის ლიმიტი.
</Warning>

## როგორ მუშაობს მრავალპაკეტიანი კრედიტირება DA-ს ქვეშ?

თითოეული DA პაკეტი თითოეული მაინინგ ციკლიდან ემსახურება როგორც დამოუკიდებელი გირაო. ეს უზრუნველყოფს უწყვეტ მიკრო-სასესხო ციკლს:

<Steps>
  <Step title="მოიპოვეთ პაკეტი 1">
    მომხმარებელი ასრულებს მაინინგ ციკლს და იღებს DA პაკეტს 1.
  </Step>

  <Step title="ისესხეთ პაკეტ 1-ის ქვეშ">
    მომხმარებელი იღებს 70% LTV სესხს პაკეტ 1-ის ქვეშ (5% საკომისიო ლიკვიდურობის პულში).
  </Step>

  <Step title="მოიპოვეთ პაკეტი 2">
    მომხმარებელი იწყებს ახალ მაინინგ ციკლს და იღებს DA პაკეტს 2.
  </Step>

  <Step title="ისესხეთ პაკეტ 2-ის ქვეშ">
    მომხმარებელი იღებს კიდევ ერთ 70% LTV სესხს პაკეტ 2-ის ქვეშ (ცალკე 5% საკომისიო).
  </Step>
</Steps>

ეს იძლევა მრავალი ერთდროული მიკრო-სესხის შესაძლებლობას, თითო თითოეულ DA პაკეტზე. თითოეული სესხი დამოუკიდებელია — მიბმულია თავის პაკეტზე — და აქტიური რჩება, სანამ ამ პაკეტის სტეკი არ შევა ავტო-გაყიდვის ციკლში. თუ რომელიმე სესხზე დადგება დეფოლტი, მხოლოდ ამ პაკეტის გირაო იწვება — და არა მთელი DA-ს მფლობელობა.

გაყიდვისა და კრედიტირების დეტალური შედარებისთვის იხილეთ [გაყიდვა და კრედიტირება](/ka/da-selling-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 />