Aave v3 में liquidation कैसे काम करता है और यूज़र का अकाउंट कब liquidate होता है?

Aave v3 में liquidation तब निष्पादित होता है जब उधारकर्ता का Health Factor 1.0 से नीचे गिर जाता है, जिसका अर्थ है कि उसके द्वारा जमा की गई collateral का मूल्य लिए गए कर्ज़ को कवर करने के लिए पर्याप्त नहीं है। बाहरी liquidators Pool अनुबंध पर liquidationCall फ़ंक्शन को निष्पादित करके यूज़र के कुल कर्ज़ का 50% तक चुकाते हैं और इसके बदले में बराबर की collateral तथा 1% से 15% तक का liquidation bonus प्राप्त करते हैं।

Aave v3 में Health Factor की गणना का सटीक सूत्र क्या है और इसे कैसे बनाए रखें?

Health Factor की गणना जमा की गई कुल collateral के ETH मूल्य को उसके weighted average liquidation threshold से गुणा करके, और फिर उस परिणाम को कुल कर्ज़ के ETH मूल्य से विभाजित करके की जाती है। इस सूचकांक को 1.0 से ऊपर सुरक्षित रखने के लिए उधारकर्ता को बाज़ार की अस्थिरता की निगरानी करनी होती है, Pool अनुबंध में अतिरिक्त स्वीकृत संपत्तियाँ जमा करनी होती हैं, या liquidation की स्थिति आने से पहले अपने कर्ज़ का आंशिक भुगतान करना होता है।

Aave v3 liquidation bot बनाने के लिए गैस शुल्क और लाभप्रदता का अनुमान कैसे लगाया जाता है?

Liquidation bot की लाभप्रदता प्राप्त होने वाले collateral bonus और EIP-1559 तंत्र के तहत लगने वाले कुल गैस शुल्क के अंतर पर निर्भर करती है। Bot डेवलपर लेन-देन भेजने से पहले estimateGas विधि के माध्यम से static simulation चलाते हैं, जिससे यह सत्यापित किया जा सके कि maxFeePerGas और maxPriorityFeePerGas के मापदंड DEX पर ज़ब्त की गई संपत्तियों को स्वैप करते समय slippage घटाने के बाद भी शुद्ध लाभ सुनिश्चित करते हैं।

Crypto Loans कैसे काम करते हैं? LTV और Liquidation का सच

Summary: इस पोस्ट में हम Web3 protocols (Aave v3, Morpho Blue) में crypto lending और liquidations के अंदर के खेल को समझेंगे। Key metrics (Health Factor, LTV, Liquidation Threshold), Chainlink oracles की गड़बड़ी के वक्त slippage के सीन, और ऑटोमैटिक liquidation के लिए एक Python monitoring script का पूरा Breakdown दिया गया है।

Crypto Lending कैसे काम करता है और Liquidation का असली खतरा

Crypto loan कोई नॉर्मल बैंक लोन नहीं है, जहाँ बैंक का बाबू आपके सैलरी स्लिप और कागजात देखकर दादाजी के मकान के बदले होम लोन पास करता है। Web3 में आपकी साख, CIBIL score, या आपकी लाइफ प्लानिंग से किसी को कोई रत्ती भर फर्क नहीं पड़ता। यहाँ सिर्फ smart contracts का टका सा गणित चलता है: collateral जमा करो, overcollateralized loan उठाओ, और अगर Health Factor पर ध्यान नहीं दिया — तो liquidator bots मिलीसेकंड के हिस्से में आपके फंड्स को कच्चा चबा जाएँगे।

Aave v3 या Morpho Blue का सिंपल सीन पकड़ते हैं। आपने $6,000 USDC उठाने के लिए $10,000 मूल्य का WBTC जमा किया। क्यों? ताकि बिटकॉइन बेचना न पड़े, capital gains tax से बचा जा सके, और साथ ही किसी नए shitcoin को टू-द-मून ले जाने या रिग के लिए बढ़िया हार्डवेयर खरीदने का कैश मिल जाए। पेपर पर तो यह स्कीम एकदम सॉलिड और 'होली ग्रिल' लगती है।

फिर आता है असली मोड़ — 15 मिनट में मार्केट 18% धड़ाम! Orderbook से सारी liquidity गायब। नेटवर्क में स्पैम की वजह से Chainlink oracle का प्राइस अपडेट दो ब्लॉक लेट हो जाता है, और आपकी पोजीशन सीधे liquidation के जहन्नुम में लैंड करती है।

Liquidation की एनाटॉमी: Collateral गायब होने का पूरा गणित

एक इकलौती मीट्रिक जिस पर आपको 24/7 नज़र रखनी है, वो है Health Factor (HF)। फॉर्मूला बेहद सिंपल है:

HF = ∑ (Collateral_i × LTV_i) / Total Borrowed

अगर HF > 1 है, तो आप एकदम सेफ हैं। लेकिन जैसे ही HF ≤ 1 हुआ, आपकी पोजीशन पूरे नेटवर्क के उस हर बंदे के लिए खुली बलि का बकरा बन जाती है जिसका liquidation script चालू है।

पैरामीटर	मतलब	रियल एग्जांपल (ETH Pool)
Max LTV	Collateral के मुकाबले आप मैक्सिमम कितना लोन उठा सकते हैं	80% ($1000 ETH पर $800 का लोन)
Liquidation Threshold (LT)	वो कट-ऑफ सीमा जहाँ पहुँचते ही पोजीशन liquidatable हो जाती है	82.5%
Liquidation Bonus	Liquidator को मिलने वाला Collateral का डिस्काउंट (कमीशन)	5%
Reserve Factor	ब्याज की कमाई में से Protocol का अपना कट	15%

अरे रुकिए, कागज़ पर 82.5% काफी सेफ लगता है, पर असलियत में आपको phantom slippage और mainnet gas cost का हिसाब भी रखना होगा। जैसे ही push-type oracle नया प्राइस कॉन्ट्रैक्ट में पुश करता है, MEV-bots पहले से Flashbots bundle बनाकर कतार में तैयार खड़े रहते हैं। वो 5% डिस्काउंट पर आपकी पोजीशन निपटाते हैं, Uniswap v3 पर flash loan के ज़रिए तुरंत कर्ज़ चुकाते हैं, और सीधा अपना कट जेब में डालते हैं।

नतीजा? आपके पास वो USDC तो बचे हैं जिन्हें आप शायद कहीं उड़ा चुके हैं, लेकिन आपका WBTC हमेशा के लिए गया। Protocol ने पेनल्टी काट ली, bot ने अपना स्प्रेड छाप लिया। और आप सीधे घाटे में।

Liquidator Script: बॉट्स आपकी कमज़ोरी कैसे पकड़ते हैं

6 महीने पहले की बात है, मैंने खुद देखा कि Arbitrum पर एक गलत oracle के चक्कर में मात्र तीन ब्लॉक के अंदर $200k का डिपॉज़िट पानी में बह गया। Liquidation script लिखना कोई रॉकेट साइंस नहीं है, पर असली खेल मिलीसेकंड्स और MEV relays के डायरेक्ट एक्सेस का है।

यहाँ web3.py में एक वर्किंग Python प्रोटोटाइप है जो LendingPool में borrower को लगातार मॉनिटर करता है और HF के 1 से नीचे गिरते ही तुरंत ट्रांजेक्शन ठोकने के लिए रेडी कर देता है।

import os
import time
from web3 import Web3
from web3.exceptions import ContractLogicError, TransactionNotFound

# ------------------------------------------------------------------------------
# 1. सेटअप और कनेक्ट करना / Setup & Connection
# ------------------------------------------------------------------------------
RPC_URL = os.getenv("RPC_URL", "https://arb-mainnet.g.alchemy.com/v2/YOUR_API_KEY")
PRIVATE_KEY = os.getenv("PRIVATE_KEY", "0x_YOUR_PRIVATE_KEY")

w3 = Web3(Web3.HTTPProvider(RPC_URL))
if not w3.is_connected():
    raise RuntimeError("RPC कनेक्शन फेल हो गया! अपनी RPC_URL चेक करो बॉस।")

ACCOUNT = w3.eth.account.from_key(PRIVATE_KEY)

# Arbitrum पर Aave v3 के कांट्रैक्ट्स
POOL_ADDRESS = Web3.to_checksum_address("0x794a61358D6845594F94dc1DB02A252b5b4814aD")
DATA_PROVIDER_ADDRESS = Web3.to_checksum_address("0x69FA0fee221AD11012B2f52097e8F6B7EAcF57E7")

TARGET_USER = Web3.to_checksum_address("0x0000000000000000000000000000000000000000")

COLLATERAL_ASSET = Web3.to_checksum_address("0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f")  # WBTC
DEBT_ASSET = Web3.to_checksum_address("0xaf88d065e77c8cC2239327C5EDb3A432268e5831")        # USDC

# ------------------------------------------------------------------------------
# 2. ABI
# ------------------------------------------------------------------------------
POOL_ABI = [
    {
        "inputs": [{"internalType": "address", "name": "user", "type": "address"}],
        "name": "getUserAccountData",
        "outputs": [
            {"internalType": "uint256", "name": "totalCollateralBase", "type": "uint256"},
            {"internalType": "uint256", "name": "totalDebtBase", "type": "uint256"},
            {"internalType": "uint256", "name": "availableBorrowsBase", "type": "uint256"},
            {"internalType": "uint256", "name": "currentLiquidationThreshold", "type": "uint256"},
            {"internalType": "uint256", "name": "ltv", "type": "uint256"},
            {"internalType": "uint256", "name": "healthFactor", "type": "uint256"}
        ],
        "stateMutability": "view",
        "type": "function"
    },
    {
        "inputs": [
            {"internalType": "address", "name": "collateralAsset", "type": "address"},
            {"internalType": "address", "name": "debtAsset", "type": "address"},
            {"internalType": "address", "name": "user", "type": "address"},
            {"internalType": "uint256", "name": "debtToCover", "type": "uint256"},
            {"internalType": "bool", "name": "receiveAToken", "type": "bool"}
        ],
        "name": "liquidationCall",
        "outputs": [],
        "stateMutability": "nonpayable",
        "type": "function"
    }
]

DATA_PROVIDER_ABI = [
    {
        "inputs": [
            {"internalType": "address", "name": "asset", "type": "address"},
            {"internalType": "address", "name": "user", "type": "address"}
        ],
        "name": "getUserReserveData",
        "outputs": [
            {"internalType": "uint256", "name": "currentATokenBalance", "type": "uint256"},
            {"internalType": "uint256", "name": "currentStableDebt", "type": "uint256"},
            {"internalType": "uint256", "name": "currentVariableDebt", "type": "uint256"},
            {"internalType": "uint256", "name": "principalStableDebt", "type": "uint256"},
            {"internalType": "uint256", "name": "scaledVariableDebt", "type": "uint256"},
            {"internalType": "uint256", "name": "stableBorrowRate", "type": "uint256"},
            {"internalType": "uint256", "name": "liquidityRate", "type": "uint256"},
            {"internalType": "uint40", "name": "stableRateLastUpdated", "type": "uint40"},
            {"internalType": "bool", "name": "usageAsCollateralEnabled", "type": "bool"}
        ],
        "stateMutability": "view",
        "type": "function"
    }
]

ERC20_ABI = [
    {
        "inputs": [
            {"internalType": "address", "name": "owner", "type": "address"},
            {"internalType": "address", "name": "spender", "type": "address"}
        ],
        "name": "allowance",
        "outputs": [{"internalType": "uint256", "name": "", "type": "uint256"}],
        "stateMutability": "view",
        "type": "function"
    },
    {
        "inputs": [
            {"internalType": "address", "name": "spender", "type": "address"},
            {"internalType": "uint256", "name": "amount", "type": "uint256"}
        ],
        "name": "approve",
        "outputs": [{"internalType": "bool", "name": "", "type": "bool"}], # FIX: टाइप को सुधारकर bool किया गया है
        "stateMutability": "nonpayable",
        "type": "function"
    },
    {
        "inputs": [{"internalType": "address", "name": "account", "type": "address"}],
        "name": "balanceOf",
        "outputs": [{"internalType": "uint256", "name": "", "type": "uint256"}],
        "stateMutability": "view",
        "type": "function"
    }
]

pool = w3.eth.contract(address=POOL_ADDRESS, abi=POOL_ABI)
data_provider = w3.eth.contract(address=DATA_PROVIDER_ADDRESS, abi=DATA_PROVIDER_ABI)
debt_token = w3.eth.contract(address=DEBT_ASSET, abi=ERC20_ABI)

tx_in_flight = False

# ------------------------------------------------------------------------------
# 3. सेफ गैस और नॉन्स (Nonce) हेल्पर्स
# ------------------------------------------------------------------------------
def get_fee_parameters():
    """EIP-1559 फी पैरामीटर्स फेच करता है, बिना baseFeePerGas वाले नेटवर्क के लिए फॉलबैक के साथ।"""
    latest_block = w3.eth.get_block('latest')
    base_fee = latest_block.get('baseFeePerGas')
    
    if base_fee is not None:
        max_priority_fee = w3.to_wei(0.1, 'gwei')
        max_fee = base_fee * 2 + max_priority_fee
        return {
            'maxFeePerGas': max_fee,
            'maxPriorityFeePerGas': max_priority_fee
        }
    else:
        # Legacy नेटवर्क / कस्टम L2s के लिए फॉलबैक
        return {'gasPrice': w3.eth.gas_price}

def ensure_allowance(required_amount: int) -> bool:
    """अलाउंस चेक करके अप्रूव मारता है, साथ में रिसीट स्टेटस की पक्की वेरिफिकेशन भी करता है।"""
    current_allowance = debt_token.functions.allowance(ACCOUNT.address, POOL_ADDRESS).call()
    if current_allowance >= required_amount:
        return True

    print("[*] अलाउंस कम है बॉस। Approve ट्रांजैक्शन भेज रहे हैं...")
    nonce = w3.eth.get_transaction_count(ACCOUNT.address, 'pending')
    
    tx_params = {
        'chainId': w3.eth.chain_id,
        'from': ACCOUNT.address,
        'nonce': nonce,
        **get_fee_parameters()
    }
    
    tx = debt_token.functions.approve(POOL_ADDRESS, 2**256 - 1).build_transaction(tx_params)
    signed_tx = w3.eth.account.sign_transaction(tx, PRIVATE_KEY)
    tx_hash = w3.eth.send_raw_transaction(signed_tx.raw_transaction)
    
    receipt = w3.eth.wait_for_transaction_receipt(tx_hash, timeout=30)
    if receipt['status'] == 1:
        print(f"[+] Approve एकदम परफेक्टली कन्फर्म हो गया ब्लॉक {receipt['blockNumber']} में!")
        return True
    else:
        print(f"[!] ERROR: Approve ट्रांजैक्शन रिवर्ट (revert) हो गई बॉस!")
        return False

# ------------------------------------------------------------------------------
# 4. लिक्विडेशन कॉल की मेन लॉजिक
# ------------------------------------------------------------------------------
def execute_liquidation(user_address: str):
    global tx_in_flight
    if tx_in_flight:
        print("[!] लोकल प्रोसेस लॉक्ड है (पहले से एक tx फ्लाइट में है)।")
        return

    # FIX #9: भारी सेटअप से पहले क्विक HF री-चेक
    account_data = pool.functions.getUserAccountData(user_address).call()
    health_factor = account_data[5] / 10**18
    if health_factor >= 1.0:
        print(f"[-] Cancel: पोजीशन का HF बदलकर {health_factor:.6f} हो गया (>= 1.0)")
        return

    # FIX #11: सटीक USDC डेट टोकन्स का हिसाब लगाना
    reserve_data = data_provider.functions.getUserReserveData(DEBT_ASSET, user_address).call()
    actual_debt_tokens = reserve_data[1] + reserve_data[2]  # stable + variable
    
    if actual_debt_tokens == 0:
        print("[!] सेलेक्टेड टोकन में कोई डेट (उधार) नहीं है।")
        return

    debt_to_cover = actual_debt_tokens // 2

    # अपना खुद का USDC बैलेंस चेक करो
    our_balance = debt_token.functions.balanceOf(ACCOUNT.address).call()
    if our_balance < debt_to_cover:
        print(f"[!] बैलेंस में USDC कम हैं। चाहिए: {debt_to_cover}, मौजूद हैं: {our_balance}")
        debt_to_cover = our_balance
        if debt_to_cover == 0:
            return

    # FIX #8: अप्रूव सक्सेसफुल हुआ या नहीं उसकी वेरिफिकेशन
    if not ensure_allowance(debt_to_cover):
        return

    # सेम अकाउंट में कॉलिजन्स से बचने के लिए 'pending' नॉन्स यूज़ कर रहे हैं
    nonce = w3.eth.get_transaction_count(ACCOUNT.address, 'pending')
    tx_params = {
        'chainId': w3.eth.chain_id,
        'from': ACCOUNT.address,
        'nonce': nonce,
        **get_fee_parameters()
    }

    # FIX #5: बिल्ड करने से ठीक पहले सिमुलेशन रन करना
    try:
        estimated_gas = pool.functions.liquidationCall(
            COLLATERAL_ASSET,
            DEBT_ASSET,
            user_address,
            debt_to_cover,
            False
        ).estimate_gas(tx_params)
        
        tx_params['gas'] = int(estimated_gas * 1.2)
    except ContractLogicError as e:
        print(f"[!] स्मार्ट कांट्रैक्ट ने liquidationCall सिमुलेशन रिजेक्ट कर दिया: {e}")
        return
    except Exception as e:
        print(f"[!] गैस एस्टीमेशन के टाइम एरर आया: {e}")
        return

    # बिल्ड और ब्रॉडकास्ट
    try:
        tx_in_flight = True
        tx_data = pool.functions.liquidationCall(
            COLLATERAL_ASSET,
            DEBT_ASSET,
            user_address,
            debt_to_cover,
            False
        ).build_transaction(tx_params)

        signed_tx = w3.eth.account.sign_transaction(tx_data, PRIVATE_KEY)
        tx_hash = w3.eth.send_raw_transaction(signed_tx.raw_transaction)
        print(f"[+] ट्रांजैक्शन शूट हो गई! Tx Hash: {tx_hash.hex()}")
        
        # FIX #10: लिक्विडेशन रिसीट स्टेटस का पूरा पोस्ट-मॉर्टम
        receipt = w3.eth.wait_for_transaction_receipt(tx_hash, timeout=30)
        if receipt['status'] == 1:
            print(f"[SUCCESS] पोजीशन सक्सेसफुली लिक्विडेट हो गई ब्लॉक {receipt['blockNumber']} में!")
        else:
            print(f"[FAIL] Tx माइन तो हुई पर REVERT हो गई (Status 0)। गैस फुक गया सर!")

    except Exception as e:
        print(f"[!] ब्रॉडकास्ट में क्रिटिकल एरर आया: {e}")
    finally:
        tx_in_flight = False

# ------------------------------------------------------------------------------
# 5. मॉनिटरिंग लूप
# ------------------------------------------------------------------------------
def monitor_user(user_address: str):
    account_data = pool.functions.getUserAccountData(user_address).call()
    health_factor = account_data[5] / 10**18
    
    print(f"Target: {user_address} | Health Factor: {health_factor:.6f}")

    if health_factor < 1.0:
        print("[!] लिक्विडेशन टारगेट मिल गया!")
        execute_liquidation(user_address)

if __name__ == "__main__":
    while True:
        try:
            monitor_user(TARGET_USER)
            time.sleep(1)
        except KeyboardInterrupt:
            print("\nयूज़र ने बॉट स्टॉप कर दिया।")
            break
        except Exception as e:
            print(f"ERROR: {e}")
            time.sleep(3)

L2 में तो mempool जैसी कोई चीज़ होती ही नहीं। सब कुछ FCFS (First-Come, First-Served) पर चलता है। जो पहले आया, माल उसी का।

और जब तक आपकी स्क्रिप्ट time.sleep(1) पर अटकी रहेगी, तब तक HFT bots उसी डेटा सेंटर की रैक में डायरेक्ट सॉकेट्स पर बैठे होंगे जहाँ वैलिडेटर चल रहा है। मैन्युअली इस मार्जिन कॉल को बीट करने के चांसेस शून्य हैं।

असली मलाई कहाँ छिपा है (और लोग फिर भी कर्ज़ क्यों ले रहे हैं)

तो फिर बंदे इतना जोखिम लेते ही क्यों हैं?

Interest Rate Arbitrage: आपने प्लेटफॉर्म A से 4% APY पर USDT उठाया और प्लेटफॉर्म B के Vault में 12% APY पर चेप दिया। बीच का 8% मार्जिन सीधा आपकी जेब में। लेकिन यहाँ स्मार्ट कॉन्ट्रैक्ट का असली रिस्क छुपा है: अगर प्लेटफॉर्म B का कॉइन depeg हुआ या reentrancy hack हो गया, तो आप प्लेटफॉर्म A को असली माल देने के लिए देनदार बन जाएँगे।
Liquidity Delegation और Collateral Tokenization: Pendle या Morpho का सीन देखो। आप stETH ज़मानत पर रखते हैं, उसके बदले स्टेबलकॉइन्स निकालते हैं, और उससे फिक्स्ड यील्ड वाले PT (Principal Tokens) खरीद लेते हैं। कॉम्प्लेक्स लगता है? बिलकुल। तगड़ी कमाई है? हाँ, जब तक LST tokens के ओरेकल में कोई ब्लीडिंग न हो जाए।
Tax Optimization: प्रॉफ़िट बुक करना मतलब टैक्स डिपार्टमेंट को हिस्सा देना। वहीं अपनी बढ़ी हुई संपत्ति के बदले लोन उठाना = कागज़ों पर कोई बिक्री नहीं। नो सेल, नो टैक्स! प्रैक्टिकल है? 100%।

लेकिन लोग cascade liquidations का भयानक रूप भूल जाते हैं। मई 2021 के क्रैश और FTX के ढहने के दौरान पूरे के पूरे प्रोटोकॉल्स कंगाल (bad debt) हो गए थे, क्योंकि collateral की कीमत इतनी तेजी से गिरी कि बॉट्स को कर्ज़ बंद करने का मौका ही नहीं मिला। आख़िरकार गाज़ गिरी उन आम lenders पर, जिन्होंने सीधे-सच्चे मन से अपने स्टेबलकॉइन्स ब्याज कमाने के लिए दिए थे।

Isolated Margin Pools vs Cross-Margin: असली खतरा कहाँ छिपा है

बहुत से नए लोग (noobs) रिस्क मैनेजमेंट के बेसिक आर्किटेक्चर को समझे बिना ही अपना भारी नुकसान करवा बैठते हैं। DeFi में दो बिल्कुल अलग अप्रोच हैं: Cross-Margin (एक ही कॉमन पूल) और Isolated Markets (अलग-अलग मार्केट जैसे Morpho या Euler v2)।

Cross-Margin में (जो Aave पर डिफॉल्ट होता है) आपका पूरा कोलैटरल पोर्टफोलियो एक सिंगल शील्ड की तरह काम करता है। आपने WBTC, ETH और DAI जमा किया — और बदले में USDC उधार ले लिया। अगर सिर्फ WBTC का प्राइस गिरता है, तो आपकी DAI की कुशन आपको बचा लेगी। सुविधाजनक है? बिल्कुल। लेकिन अगर आपका कोई एक कोलैटरल एसेट पूरी तरह डूब जाता है (याद कीजिए 2022 का stETH depeg या किसी ब्रिग्ड-टोकन का स्कैम), तो वो आपकी पूरी पोजीशन को अपने साथ ले डूबता है। आपका पूरा अकाउंट एक झटके में लिक्विडेट (REKT) हो जाएगा।

दूसरी तरफ, Isolated pools में आप रिस्क को सिर्फ एक स्पेसिफिक पेयर तक सीमित रखते हैं — जैसे wstETH / USDC का एक कस्टम वॉल्ट।

[आपका डिपॉजिट] ---> [Isolated Pool A (ETH/USDC)]  ---> रिस्क सिर्फ Pool A तक सीमित
               ---> [Isolated Pool B (PEPE/USDC)] ---> PEPE स्कैम हुआ = सिर्फ Pool B में नुकसान

अगर Pool B का कोई शिटकॉइन 99% क्रैश भी हो जाए, तो आपका सिर्फ उतना ही नुकसान होगा जितना आपने Pool B में डाला था। Pool A में पड़ा आपका मेन ईथर पूरी तरह से सेफ रहेगा।

हाँ, तीन अलग-अलग पोजीशंस को मैनेज करना थोड़ा झंझट भरा है और गैस फीस भी ज्यादा लगती है। लेकिन जब मार्केट में भयंकर वोलेटिलिटी हो, तो यही एक समझदारी भरी स्ट्रैटेजी है।

Oracles: बिना स्मार्ट कॉन्ट्रैक्ट हैक हुए कैसे लिक्विडेट हो जाते हैं आप

किसी भी लेंडिंग प्रोटोकॉल का स्मार्ट कॉन्ट्रैक्ट अपने आप में पूरी तरह अंधा और बहरा होता है। उसे नहीं पता कि इस सेकंड ETH का लाइव प्राइस क्या है — वो आँख बंद करके ओरेकल पर भरोसा करता है। और असली खेल यहीं से शुरू होता है।

ओरेकल के वो बड़े लूपहोल्स जिनकी वजह से ट्रेडर्स के डिपॉजिट उड़ जाते हैं:

Stale Prices (पुराने या अटके हुए प्राइस). ओरेकल हर सेकंड प्राइस अपडेट नहीं करता (इससे गैस फीस में ही कोई भी बर्बाद हो जाएगा)। वो सिर्फ प्राइस में बड़े बदलाव पर (जैसे 0.5%) या फिर एक फिक्स्ड टाइम इंटरवल पर (heartbeat, जैसे हर 24 घंटे में) अपडेट पुश करता है। अगर मार्केट 3 सेकंड में 5% का डंप मारकर तुरंत रिकवर कर जाए, तो हो सकता है ओरेकल प्राइस को ठीक उसी बॉटम (SINK) पर अपडेट कर दे। कॉन्ट्रैक्ट को '0.99 HF' दिखेगा, वो लिक्विडेटर्स को सिग्नल दे देगा, और आपका पत्ता साफ। मार्केट वापस ऊपर आ जाएगा, लेकिन आप हाथ मलते रह जाएंगे।
Illiquid DEX Feeds (स्पॉट प्राइस मैनिपुलेशन). अगर कोई प्रोटोकॉल किसी कम लिक्विडिटी वाले टोकन के लिए Uniswap v3 आधारित TWAP ओरेकल का यूज़ कर रहा है, तो एक व्हेल सिर्फ एक बड़ा सेल ऑर्डर मारकर प्राइस को क्रैश करा सकती है। इससे लेंडिंग प्लेटफॉर्म पर लिक्विडेशन का कस्केड शुरू हो जाएगा, और बाद में वही व्हेल कौड़ियों के भाव में एसेट वापस खरीद लेगी। यह एकदम क्लासिक स्कैम पैटर्न है।

नीचे दी गई टेबल दिखाती है कि कोलैटरल की कीमत गिरने पर लिक्विडेशन के वक्त असल में कितना नुकसान होता है (75% के शुरुआती LTV और 5% के Liquidation Bonus के साथ):

कोलैटरल प्राइस में गिरावट	Health Factor	पोजीशन का स्टेटस	शुरुआती डिपॉजिट पर उधारकर्ता का नुकसान
-5%	1.26	सेफ जोन	0% (सिर्फ कोलैटरल की वैल्यू में अनरियलाइज्ड लॉस)
-15%	1.13	वार्निंग जोन	0% (टॉप-अप या कोलैटरल जोड़ने की जरूरत)
-25%	0.99	LIQUIDATION	~15-20% (लिक्विडेशन पेनल्टी + स्प्रेड)
-40% (Flash Crash)	< 0.80	पूरी तरह खात्मा (Total Wipeout)	100% कोलैटरल साफ़ (पास में सिर्फ borrowed अमाउंट बचा)

Survival Checklist: लोन भी लो और REKT होने से भी बचो

अगर आप डिसेंट्रलाइज्ड लेंडिंग/बोरोइंग के मैदान में उतर ही रहे हैं, तो इन रूल्स को कड़ाई से फॉलो करें। ये वो सबक हैं जो मैंने खुद कई बार रीवर्ट्स और जबरन बंद हुई पोजीशंस का दर्द झेलने के बाद सीखे हैं।

Health Factor हमेशा 1.5 से 1.8 के ऊपर रखें। 1.05 HF पर रिस्क लेने की बेवकूफी बिल्कुल मत कीजिए। चार्ट पर एक छोटी सी रेड कैंडल बनेगी और आपकी पोजीशन खत्म।
टॉप-अप को ऑटोमेट करें (Self-Kicker). Gelato Automation या Chainlink Automation जैसे टूल्स का इस्तेमाल करें। एक सिंपल बोट सेट करें जो HF के 1.2 से नीचे जाते ही आपके वॉलेट से ऑटोमैटिकली स्टेबलकॉइन्स निकालकर लोन का कुछ हिस्सा रीपे कर दे।
ओरेकल्स पर नजर रखें। आपको पता होना चाहिए कि आपके पूल में कौन सा ओरेकल इस्तेमाल हो रहा है। अगर Chainlink push-type है तो उसका heartbeat चेक करें। अगर Pyth है तो उसका confidence interval देखें।
Perps के जरिए अपनी पोजीशन हेज (Hedge) करें। आपने ETH गिरवी रखकर लोन लिया है? तो डेरिवेटिव्स पर उधार ली गई रकम के बराबर 1x लेवरेज के साथ ETH शॉर्ट कर दें। इससे आपका रिस्क डॉलर टर्म्स में लॉक हो जाएगा (Delta-Neutral Position)।

क्रिप्टो क्रेडिट आपके कैपिटल की एफिशिएंसी बढ़ाने का बहुत तगड़ा हथियार है, लेकिन अगर बिना समझे इस्तेमाल किया तो यह एक टाइम बम की तरह काम करता है। स्मार्ट कॉन्ट्रैक्ट को आपकी मार्केट प्रेडिक्शन से कोई लेना-देना नहीं होता।

इस ब्लॉग पोस्ट का सारांश इसके साथ बनाएं:

ChatGPT Perplexity Claude Grok

Crypto Loans कैसे काम करते हैं? LTV और Liquidation का सच

Crypto Lending कैसे काम करता है और Liquidation का असली खतरा

Liquidation की एनाटॉमी: Collateral गायब होने का पूरा गणित

Liquidator Script: बॉट्स आपकी कमज़ोरी कैसे पकड़ते हैं

असली मलाई कहाँ छिपा है (और लोग फिर भी कर्ज़ क्यों ले रहे हैं)

Isolated Margin Pools vs Cross-Margin: असली खतरा कहाँ छिपा है

Oracles: बिना स्मार्ट कॉन्ट्रैक्ट हैक हुए कैसे लिक्विडेट हो जाते हैं आप

Survival Checklist: लोन भी लो और REKT होने से भी बचो

FAQ

अपनी राय साझा करें

Tag Clouds

Discover

Company

बंद करने के लिए ESC दबाएँ

Crypto Loans कैसे काम करते हैं? LTV और Liquidation का सच

Crypto Lending कैसे काम करता है और Liquidation का असली खतरा

Liquidation की एनाटॉमी: Collateral गायब होने का पूरा गणित

Liquidator Script: बॉट्स आपकी कमज़ोरी कैसे पकड़ते हैं

असली मलाई कहाँ छिपा है (और लोग फिर भी कर्ज़ क्यों ले रहे हैं)

Isolated Margin Pools vs Cross-Margin: असली खतरा कहाँ छिपा है

Oracles: बिना स्मार्ट कॉन्ट्रैक्ट हैक हुए कैसे लिक्विडेट हो जाते हैं आप

Survival Checklist: लोन भी लो और REKT होने से भी बचो

FAQ

Aave v3 में liquidation कैसे काम करता है और यूज़र का अकाउंट कब liquidate होता है?

Aave v3 में Health Factor की गणना का सटीक सूत्र क्या है और इसे कैसे बनाए रखें?

Aave v3 liquidation bot बनाने के लिए गैस शुल्क और लाभप्रदता का अनुमान कैसे लगाया जाता है?

आपके लिए अनुशंसित

अपनी राय साझा करें

Tag Clouds

समाचार पत्रिका