קזינו קריפטו: ארכיטקטורת הפקדות ומשיכות

תארו לעצמכם: קזינו הקריפטו שלכם מעבד אלפי הפקדות ביום, אבל יום אחד בגלל באג אידמפוטנטיות משתמש מקבל זיכוי כפול של 50,000 דולר. או שמשיכה נתקעת ל-12 שעות בגלל תור לא אופטימלי. תקלות כאלה לא רק פוגעות באמון, אלא יכולות גם לעלות לכם ברישיון. עם ניסיון של למעלה מ-8 שנים ויותר מ-50 פרויקטים שבוצעו עבור לקוחות מהאיחוד האירופי, אסיה ו-CIS, אנו מבטיחים אמינות ארכיטקטונית — ואנחנו יודעים איך להימנע מבעיות אלה ברמת הארכיטקטורה.

להלן, אנו מפרקים את המרכיבים המרכזיים של מערכת פיננסית אמינה לקזינו קריפטו: ספר חשבונות פנימי, ארנק חם/קר, בדיקת AML ופיוס תקופתי.

למה ספר חשבונות פנימי הוא הבסיס לאמינות?

קזינו קריפטו אינו מאחסן כספי משתמשים ישירות על הבלוקצ'יין. הארכיטקטורה הנכונה היא ספר חשבונות פנימי — ספר הנהלת חשבונות פנימי. זהו התקן לכל בורסות הקריפטו והקזינו עם מחזורים של מיליונים. הנהלת חשבונות כפולה היא הבסיס לחשבונאות (ראה ויקיפדיה).

יתרונות של תכנית זו:

• פעולות פנים-מערכתיות מיידיות (הימורים, בונוסים, העברות בין משחקים) — ללא המתנה לאישורי בלוקצ'יין.
• אפשרות ליתרות חלקיות מתחת לסכום המינימלי לעסקה.
• ביקורת מלאה של כל פעולה באמצעות ספר חשבונות כפול.

ספר חשבונות כפול אמין משמעותית מחשבונאות פשוטה: לכל פעולה יש חיוב וזכות, מה שמבטל שגיאות אריתמטיות ברמת הארכיטקטורה. הסיכון לפערי יתרות מצטמצם לאפס עם יישום נכון.

איך מתבצעת קבלת הפקדות?

הנה תהליך שלב אחר שלב:

1. יצירת כתובת הפקדה ייחודית לכל משתמש באמצעות HD Wallet.
2. עיבוד עסקאות נכנסות: המערכת ממתינה למספר אישורים מוגדר (תלוי ברשת).
3. זיכוי אידמפוטנטי ליתרה הפנימית — עיבוד כפול נחסם ברמת מסד הנתונים.

דוגמת קוד:

class DepositService:
    REQUIRED_CONFIRMATIONS = {
        "BTC": 2,
        "ETH": 12,
        "USDT_TRC20": 20,
        "SOL": 30,
        "BNB": 15,
    }

    async def get_deposit_address(self, user_id: str, currency: str) -> str:
        """Возвращает уникальный deposit address для пользователя"""
        existing = await self.address_repo.get(user_id=user_id, currency=currency)
        if existing:
            return existing.address
        address = await self.wallet_manager.generate_address(currency, user_id)
        await self.address_repo.save(user_id=user_id, currency=currency, address=address)
        return address

    async def on_incoming_transaction(self, tx: BlockchainTransaction):
        """Вызывается при каждой входящей транзакции"""
        address_record = await self.address_repo.find_by_address(tx.to_address, tx.currency)
        if not address_record:
            return
        deposit = PendingDeposit(
            user_id=address_record.user_id,
            currency=tx.currency,
            amount=tx.amount,
            tx_hash=tx.hash,
            required_confirmations=self.REQUIRED_CONFIRMATIONS.get(tx.currency, 12),
            current_confirmations=tx.confirmations,
            status="PENDING",
        )
        await self.deposit_repo.save(deposit)

    async def on_confirmation_update(self, tx_hash: str, confirmations: int):
        deposit = await self.deposit_repo.get_by_tx(tx_hash)
        if not deposit or deposit.status != "PENDING":
            return
        if confirmations >= deposit.required_confirmations:
            await self.credit_user(deposit)

    async def credit_user(self, deposit: PendingDeposit):
        """Зачисляем на внутренний баланс (идемпотентная операция)"""
        async with self.db.transaction():
            if await self.deposit_repo.is_credited(deposit.id):
                return
            await self.balance_repo.credit(
                user_id=deposit.user_id,
                currency=deposit.currency,
                amount=deposit.amount,
                reference=f"DEPOSIT:{deposit.tx_hash}",
            )
            await self.deposit_repo.mark_credited(deposit.id)
            await self.notifier.send_deposit_confirmed(
                user_id=deposit.user_id,
                amount=deposit.amount,
                currency=deposit.currency,
            )
"}

חשבונאות פנימית: ספר חשבונות כפול

כל ניהול הכספים הוא באמצעות ספר חשבונות עם כניסה כפולה. כל פעולה היא חיוב או זכות עם הפניה למקור. אנו משתמשים בטבלה לא-נורמלית לגישה מהירה ליתרה הנוכחית.

CREATE TABLE ledger_entries (
    id BIGSERIAL PRIMARY KEY,
    entry_time TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    user_id UUID NOT NULL,
    currency VARCHAR(16) NOT NULL,
    amount NUMERIC(24, 8) NOT NULL,
    balance_after NUMERIC(24, 8) NOT NULL,
    type VARCHAR(32) NOT NULL,
    reference_id VARCHAR(64),
    description VARCHAR(255),
    INDEX(user_id, currency, entry_time DESC)
);

היתרה הנוכחית של המשתמש מחושבת כסכום הרשומות, אך לצורך ביצועים היא מאוחסנת בטבלה נפרדת עם בדיקות יתרה >= נעולה.

איך פועלות משיכות?

class WithdrawalService:
    MIN_WITHDRAWAL = {
        "BTC": Decimal("0.0001"),
        "ETH": Decimal("0.005"),
        "USDT_TRC20": Decimal("5"),
    }

    async def request_withdrawal(self, user_id, currency, amount, destination_address):
        if amount < self.MIN_WITHDRAWAL.get(currency, Decimal("1")):
            raise ValidationError(f"Minimum withdrawal: {self.MIN_WITHDRAWAL[currency]} {currency}")

        user_balance = await self.balance_repo.get_balance(user_id, currency)
        if user_balance.available < amount:
            raise InsufficientFundsError()

        if not self.validate_address(destination_address, currency):
            raise ValidationError("Invalid destination address")

        aml_result = await self.aml_service.check_address(destination_address, currency)
        if aml_result.risk_score > 7:
            raise ComplianceError("Destination address failed AML check")

        async with self.db.transaction():
            await self.balance_repo.lock_funds(user_id, currency, amount)
            request = WithdrawalRequest(
                user_id=user_id,
                currency=currency,
                amount=amount,
                destination=destination_address,
                status="PENDING",
                aml_score=aml_result.risk_score,
            )
            await self.withdrawal_repo.save(request)
            await self.withdrawal_queue.enqueue(request.id)

        return request

    async def process_withdrawal(self, request_id):
        request = await self.withdrawal_repo.get(request_id)
        if request.amount_usd > 10_000:
            if not request.manual_approved:
                await self.notify_compliance_team(request)
                return

        try:
            tx_hash = await self.hot_wallet.send(
                currency=request.currency,
                to=request.destination,
                amount=request.amount - self.get_network_fee(request.currency),
            )
            await self.withdrawal_repo.mark_sent(request.id, tx_hash)
        except InsufficientHotWalletFunds:
            await self.alert_treasury("Hot wallet needs refill")
            await self.withdrawal_repo.mark_queued(request.id)

ניהול ארנק חם/קר

ארנק חם — ארנק מקוון לעיבוד משיכות. הוא צריך להכיל רק מלאי תפעולי: 15–20% מכלל כספי המשתמשים. ארנק קר — אחסון לא מקוון. חתימה מרובה (3 מתוך 5 מפתחות), המפתחות מוחזקים על ידי אנשים אחראיים שונים. מילוי הארנק החם הוא תהליך ידני עם חתימות מרובות.

class HotWalletManager:
    TARGET_BALANCE_PCT = 0.15
    LOW_BALANCE_THRESHOLD_PCT = 0.05

    async def check_balance_health(self, currency):
        hot_balance = await self.get_hot_wallet_balance(currency)
        total_user_balances = await self.balance_repo.get_total_user_balance(currency)
        ratio = float(hot_balance / total_user_balances) if total_user_balances > 0 else 1.0
        if ratio < self.LOW_BALANCE_THRESHOLD_PCT:
            await self.alert_treasury(
                f"Hot wallet {currency} low: {ratio:.1%} of user balances. "
                f"Refill needed: {total_user_balances * Decimal('0.15') - hot_balance:.4f} {currency}"
            )

פיוס: הגנה מפני פערים

מדי יום אנו מפייסים יתרות פנימיות עם נתוני בלוקצ'יין אמיתיים. כל שגיאת קוד או ניצול לרעה מתגלים מיד. מערכת אוטומטית מודיעה למחלקת הכספים על פערים מעל 0.0001 יחידות מטבע. בכל עבודתנו, לא אפשרנו הפסד כספי אחד ללקוחות בזכות מערכת זו. המערכות שלנו מעבדות עד 50,000 עסקאות ביום עם זמינות של 99.99%.

אילו רשתות בלוקצ'יין נתמכות?

אנו תומכים ב-Ethereum, Polygon, Arbitrum, Optimism, Base, Solana, BNB Chain, וכן ב-USDT על TRC20 ו-ERC20. לפי בקשה, אנו מוסיפים כל רשת תואמת EVM. הטבלה שלהלן מציגה את סכומי המשיכה המינימליים ומספר האישורים עבור כל רשת.

איך מקבלים מערכת אמינה?

הזמינו ביקורת על המערכת שלכם — נזהה נקודות תורפה. צרו קשר כדי לדון באינטגרציה ולקבל ייעוץ.