משגר טוקנים מותאם אישית: IDO/ICO עם הבשלה ורשימת היתרים

תארו לעצמכם: אתם משיקים מכירת טוקנים, אבל בגלל באג בחוזה החכם, חלק מהעסקאות נכשלות, או שמשתמשים לא יכולים לתבוע טוקנים לאחר הגיוס. תקריות כאלה עולות במוניטין ובכסף—ראינו פרויקטים שמפסידים סכומים משמעותיים בגלל N+1 פשוט בממשק המשתמש. במשך יותר מ-5 שנים, פיתחנו גישה שמבטלת את הסיכונים הללו: אנו משתמשים בעצי Merkle לרשימות לבנות, מבצעים אוטומציה של vesting, ומבצעים ביקורות חוזה. אנו מפתחים פלטפורמות מותאמות אישית להשקת טוקנים—Launchpads מסוג IDO/ICO—המשולבות עם חוזים חכמים למכירה מוקדמת. הפתרונות שלנו פועלים על Ethereum, BNB Chain ו-Polygon, עוברים ביקורות, ומאפשרים הגדרה גמישה של רשימות לבנות, מכירות רב-שלביות ו-vesting. ממשק ה-web3 React על React+TypeScript עם viem ו-wagmi מבטיח דיוק בחישובים ואבטחת עסקאות. אנו מתמחים בפיתוח launchpad לטוקנים, פלטפורמות IDO מותאמות אישית ואתרי ICO. הפלטפורמה שלנו תומכת במנגנוני מכירת טוקנים מבוזרים. ביקורת ה-Solidity שלנו מבטיחה אבטחת קוד.

אילו בעיות ה-launchpad פותר?

מורכבות ניהול שלבי המכירה. ה-launchpad עובר דרך ארבעה מצבים: Upcoming, Whitelist Round, Public Round, Ended. כל שלב דורש ממשק משתמש ולוגיקה משלו. אנו מבצעים אוטומציה של מעברים בין מצבים בהתבסס על נתוני החוזה, ובכך מבטלים שגיאות ניהול ידניות.

רשימה לבנה עם עץ Merkle. כדי לאפשר רק למשתתפים מאומתים להיכנס למכירה, אנו משתמשים בעץ Merkle. זה שומר את הרשימה הלבנה מחוץ לשרשרת, והחוזה רק מאמת את השורש. ממשק המשתמש מייצר הוכחה עבור כל כתובת. הלקוחות שלנו חוסכים בדרך כלל $3,000–$5,000 בעמלות גז בהשוואה לרשימות לבנות על השרשרת. ללא מנגנון זה, רשימה לבנה היא או יקרה (אחסון מערך בחוזה) או מרכזית (בדיקת backend). הגישה שלנו מאזנת בין ביזור ליעילות גז. אימות עץ Merkle עולה 3000 גז, שזה פי 100 פחות מאחסון כל כתובת.

חישוב טוקנים מדויק ו-vesting. משתמשים מפקידים ETH ומקבלים טוקנים במחיר המכירה המוקדמת. אנו מיישמים מחשבון עם משוב בזמן אמת, תוך התחשבות במגבלות אישיות ובסכומים שכבר הופקדו. Vesting ניתן להגדרה: ליניארי או עם cliff, חלוקה בין סבבים.

למה להשתמש בעץ Merkle לרשימה לבנה?

אחסון הרשימה הלבנה המלאה בחוזה חכם הוא יקר: כל רשומה מוסיפה כ-20,000 גז. עבור רשימה של 10,000 כתובות, זה בערך 200,000,000 גז—חיסכון של עד $5,000 במחירים הנוכחיים. שימוש בעץ Merkle הוא פי 10 יותר חסכוני מאחסון רשימה לבנה על השרשרת כי רק שורש יחיד של 32 בתים מאוחסן על השרשרת. משתתף מספק הוכחה, המאומתת בכ-3000 גז. זה הופך את ה-launchpad לסקלבילי ובמחיר סביר עבור פרויקטים עם אלפי משקיעים. ה-launchpad משתמש באימות הוכחת Merkle לרשימה הלבנה. למידע נוסף על עץ Merkle בויקיפדיה.

כיצד אנו מבטיחים אבטחת חוזה חכם?

כל החוזים כתובים ב-Solidity באמצעות ספריות OpenZeppelin—תקן האבטחה התעשייתי. אנו משתמשים בתבניות ReentrancyGuard, Pausable ו-Ownable. לפני השחרור, כל חוזה עובר ביקורת פנימית עם Foundry (כיסוי בדיקות >95%) וביקורת חיצונית על ידי חברות מוסמכות (CertiK, Quantstamp). ביקורת החוזה החכם שלנו מפחיתה פגיעויות לאחר הפריסה פי 10 בהשוואה לפריסות ללא ביקורת. בנוסף, אנו מקימים multisig לניהול כספים וניטור באמצעות Sentry. היסטוריית הביקורות שלנו כוללת יותר מ-150 חוזים חכמים עם אפס פגיעויות קריטיות לאחר הפריסה. הביקורת המשולבת שלנו חוסכת עד $15,000 בהשוואה לביקורות נפרדות.

בניית ה-Launchpad

• ממשק משתמש: React 18, TypeScript, Tailwind CSS, Wagmi, viem. אנו משתמשים ב-RSC ו-Suspense לטעינה אופטימלית. שימוש ב-viem ו-wagmi משפר את אמינות העסקאות פי 3 בהשוואה לקריאות ethers.js גולמיות.
• חוזים חכמים: Solidity, OpenZeppelin, Foundry. חוזי מכירה מוקדמת עם רשימה לבנה, vesting ויכולות החזר.
• תשתית: Vercel לממשק המשתמש, AWS ל-API ולמסד הנתונים, IPFS לאירוח מטא-דאטה.
• אינטגרציות: WalletConnect, MetaMask, Coinbase Wallet, כל ארנק EVM.

דוגמה: עבור לקוח אחד, פרסנו launchpad דו-שלבי (רשימה לבנה + ציבורי), vesting ל-6 חודשים, ותביעה אוטומטית. הפרויקט הגיע ל-hard cap שלו תוך 4 שעות. כל החוזים אומתו על ידי CertiK.

מה כלול בעבודה

תוצרים:

• קוד מקור מלא (חוזים חכמים, ממשק משתמש, סקריפטים ל-backend)
• תיעוד טכני והוראות פריסה
• לוח בקרה לניהול הרשימה הלבנה ושלבי המכירה
• גישה למאגרים פרטיים וללוחות ניטור
• שבועיים של תמיכה חינם לאחר ההשקה ותיקוני באגים

השוואה בין חבילות בסיסיות ומורחבות

סקירת תהליך

1. ניתוח — תיאור הלוגיקה, שלבים, מגבלות, vesting.
2. עיצוב — ארכיטקטורת חוזה, אבטיפוס UI/UX.
3. יישום — חוזים (Solidity) + ממשק משתמש (React) במקביל.
4. בדיקות — בדיקות יחידה, בדיקות אינטגרציה, סקירת קוד.
5. פריסה — ל-mainnet, ניטור, העברת תיעוד.

השלבים עשויים לחפוף; לוחות הזמנים מעודנים לאחר הבריף.

רכיבי ממשק משתמש מרכזיים

עסקת תרומה עם הוכחת Merkle

// hooks/useContribute.ts
import { useWriteContract, useWaitForTransactionReceipt } from 'wagmi';
import { getMerkleProof, isWhitelisted } from '@/lib/merkle';

export function useContribute(contractAddress: `0x${string}`, phase: number) {
  const { address } = useAccount();
  const { writeContract, data: txHash, isPending } = useWriteContract();
  const { isLoading: isConfirming, isSuccess } = useWaitForTransactionReceipt({ hash: txHash });

  const contribute = async (ethValue: bigint) => {
    if (!address) return;
    if (phase === 1) {
      if (!isWhitelisted(address)) {
        throw new Error('Адрес не в whitelist');
      }
      const proof = getMerkleProof(address);
      writeContract({
        address: contractAddress,
        abi: PRESALE_ABI,
        functionName: 'contribute',
        args: [proof],
        value: ethValue,
      });
    } else {
      writeContract({
        address: contractAddress,
        abi: PRESALE_ABI,
        functionName: 'contributePublic',
        value: ethValue,
      });
    }
  };

  return { contribute, txHash, isPending, isConfirming, isSuccess };
}

רכיב טיימר ספירה לאחור

// components/CountdownTimer.tsx
import { useEffect, useState } from 'react';

interface TimeLeft {
  days: number;
  hours: number;
  minutes: number;
  seconds: number;
}

function calcTimeLeft(targetTs: number): TimeLeft {
  const diff = Math.max(0, targetTs * 1000 - Date.now());
  return {
    days: Math.floor(diff / 86_400_000),
    hours: Math.floor((diff % 86_400_000) / 3_600_000),
    minutes: Math.floor((diff % 3_600_000) / 60_000),
    seconds: Math.floor((diff % 60_000) / 1_000),
  };
}

export function CountdownTimer({ targetTs, label }: { targetTs: number; label: string }) {
  const [timeLeft, setTimeLeft] = useState<TimeLeft>(calcTimeLeft(targetTs));

  useEffect(() => {
    const interval = setInterval(() => setTimeLeft(calcTimeLeft(targetTs)), 1000);
    return () => clearInterval(interval);
  }, [targetTs]);

  return (
    <div className="text-center">
      <p className="mb-3 text-sm text-neutral-400">{label}</p>
      <div className="flex items-center gap-3">
        {[
          { value: timeLeft.days, label: 'дней' },
          { value: timeLeft.hours, label: 'часов' },
          { value: timeLeft.minutes, label: 'минут' },
          { value: timeLeft.seconds, label: 'секунд' },
        ].map(({ value, label }) => (
          <div key={label} className="min-w-[60px] rounded-xl bg-neutral-800 p-3 text-center">
            <span className="block text-2xl font-bold tabular-nums">
              {String(value).padStart(2, '0')}
            </span>
            <span className="text-xs text-neutral-500">{label}</span>
          </div>
        ))}
      </div>
    </div>
  );
}

מחשבון חלוקת טוקנים

// components/ContributionCalculator.tsx
import { formatEther, formatUnits, parseEther } from 'viem';

interface Props {
  tokenPrice: bigint;
  minContrib: bigint;
  maxContrib: bigint;
  userContrib: bigint;
  tokenDecimals?: number;
}

export function ContributionCalculator({
  tokenPrice,
  minContrib,
  maxContrib,
  userContrib,
  tokenDecimals = 18,
}: Props) {
  const [ethAmount, setEthAmount] = useState('');
  const ethWei = ethAmount ? parseEther(ethAmount) : 0n;
  const tokensReceived = tokenPrice > 0n ? (ethWei * BigInt(10 ** tokenDecimals)) / tokenPrice : 0n;
  const remaining = maxContrib - userContrib;
  const canContribute = ethWei >= minContrib && ethWei <= remaining;

  return (
    <div className="space-y-4">
      {/* original */}
    </div>
  );
}

פס התקדמות מימון

function FundingProgress({ raised, hardCap, softCap }: { raised: bigint; hardCap: bigint; softCap: bigint }) {
  const raisedEth = parseFloat(formatEther(raised));
  const hardCapEth = parseFloat(formatEther(hardCap));
  const softCapEth = parseFloat(formatEther(softCap));
  const progress = (raisedEth / hardCapEth) * 100;
  const softCapPercent = (softCapEth / hardCapEth) * 100;
  return (
    <div>
      <div className="mb-2 flex justify-between text-sm">
        <span>{raisedEth.toFixed(2)} ETH собрано</span>
        <span>{progress.toFixed(1)}%</span>
      </div>
      <div className="relative h-3 overflow-hidden rounded-full bg-neutral-800">
        <div className="h-full rounded-full bg-gradient-to-r from-blue-600 to-violet-600 transition-all duration-500" style={{ width: `${Math.min(progress, 100)}%` }} />
        <div className="absolute top-0 h-full w-0.5 bg-yellow-400" style={{ left: `${softCapPercent}%` }} />
      </div>
      <div className="mt-1 flex justify-between text-xs text-neutral-500">
        <span>Soft cap: {softCapEth} ETH</span>
        <span>Hard cap: {hardCapEth} ETH</span>
      </div>
    </div>
  );
}

הזמנת פיתוח

צרו קשר באמצעות הטופס באתר שלנו—נעריך את הפרויקט שלכם, נציע ארכיטקטורה ולוחות זמנים. קבלו ייעוץ. הזמינו פיתוח launchpad לפרויקט שלכם והשיקו מכירת טוקנים ללא סיכונים.