Blokkjede-smartkontrakter med Solidity · leksjon

Utlåns- og låneprotokoller

Undersøk smartkontraktarkitekturen bak desentraliserte plattformer for utlån og låneopptak, som Aave og Compound.

Leksjon 2 av 411 trinn

Utlåns- og låneprotokoller er en gratis leksjon i Blokkjede-smartkontrakter med Solidity på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Blokkjede-smartkontrakter med Solidity, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Blokkjede-smartkontrakter med Solidity inneholder totalt 4 leksjoner.

Velkommen til DeFi-utlån!

Plattformer for desentralisert finans (DeFi)-utlån lar brukere låne ut kryptoaktiva for å tjene renter eller låne aktiva ved å stille sikkerhet.

Disse plattformene fungerer uten tradisjonelle banker og bruker smartkontrakter til å automatisere hele prosessen, noe som gjør den transparent og tilgjengelig for alle med internettilkobling.

Hvem er aktørene?

I en DeFi-utlånsprotokoll finnes det to hoveddeltakere:

Utlånere: Brukere som setter inn kryptovalutaene sine i en smartkontrakt for å tjene renter. De tilfører likviditet.
Låntakere: Brukere som ønsker å ta opp et lån. De må stille sikkerhet, vanligvis mer enn låneverdien (overpantsetting).

Utlånspooler: Kjernen

I stedet for matching mellom enkeltpersoner bruker DeFi-utlånsplattformer likviditetspooler. Utlånere setter aktivaene sine inn i disse poolene.

Låntakere henter deretter midler fra de samme poolene. Denne modellen sikrer kontinuerlig tilgang på aktiva og effektiv fastsettelse av renter.

Dynamiske renter

Renter i DeFi-utlån er vanligvis algoritmiske, noe som betyr at de justeres automatisk basert på tilbud og etterspørsel i likviditetspoolen.

Når en pool har høy utnyttelsesgrad (mye utlån), øker rentene for låntakere, noe som gir utlånere insentiver.
Når utnyttelsesgraden er lav, synker rentene, noe som oppmuntrer til låneopptak.

Sikre lånet med sikkerhet

For å låne aktiva må De stille sikkerhet. Sikkerheten låses i smartkontrakten og fungerer som garanti for lånet.

DeFi-lån er nesten alltid overpantsettede, noe som betyr at verdien av sikkerheten er høyere enn låneverdien. Loan-to-Value-forholdet (LTV-forholdet) angir hvor mye De kan låne i forhold til sikkerheten.

Når sikkerheten ikke er tilstrekkelig

Hvis verdien av sikkerheten faller betydelig og LTV-forholdet dermed overstiger en bestemt terskel, blir lånet kvalifisert for likvidering.

Det betyr at sikkerheten automatisk selges for å tilbakebetale lånet, slik at protokollen unngår tap på utlån. Denne prosessen utføres ofte av eksterne «likvidatorer» som mottar et gebyr.

Inne i utlånsprotokollen

En DeFi-utlånsprotokoll består vanligvis av flere smartkontraktkomponenter:

LendingPool Contract: Håndterer innskudd, lån, renter og likvideringer.
ERC-20 Token Contracts: For aktivaene som faktisk lånes ut eller lånes (for eksempel DAI, USDC og WETH).
Oracle Contracts: Leverer prisdata i sanntid for aktivaene, slik at LTV kan beregnes.

Kodeeksempel: Innskuddslogikk

La oss se på en forenklet deposit-funksjon. Brukere godkjenner at kontrakten kan bruke tokenene deres, og kaller deretter denne funksjonen for å tilføre likviditet. Kontrakten registrerer innskuddet.

Prøv å kjøre koden for å se strukturen!

/* SPDX-License-Identifier: MIT */
pragma solidity ^0.8.0;

interface IERC20 {
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
}

contract SimpleLendingPool {
    // Mapping to track deposits: asset address => user address => amount
    mapping(address => mapping(address => uint256)) public deposits;

    // Function to deposit collateral
    function deposit(address asset, uint256 amount) public {
        require(amount > 0, "Deposit amount must be > 0");
        // Transfer tokens from sender to this contract
        bool success = IERC20(asset).transferFrom(msg.sender, address(this), amount);
        require(success, "Token transfer failed");
        
        deposits[asset][msg.sender] += amount;
        // In a real protocol, you'd mint interest-bearing tokens here
    }

    // Placeholder for other functions like borrow, repay, withdraw
    // ...
}

Kodeeksempel: Lånelogikk

Med utgangspunkt i innskuddet ser De her en forenklet borrow-funksjon. Den kontrollerer om brukeren har tilstrekkelig sikkerhet, og overfører deretter det forespurte aktivumet fra poolen til låntakeren.

Legg merke til den forenklede getAssetPrice-funksjonen, som brukes for å illustrere konseptet. Virkelige systemer bruker robuste orakler.

/* SPDX-License-Identifier: MIT */
pragma solidity ^0.8.0;

interface IERC20 {
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
}

contract SimpleLendingPool {
    mapping(address => mapping(address => uint256)) public deposits;
    mapping(address => mapping(address => uint256)) public borrows;

    // Simplified price oracle for demonstration
    function getAssetPrice(address asset) internal pure returns (uint256) {
        // Assume all assets have a price of 1 ether for simplicity (1e18 wei)
        // In a real system, this would fetch actual prices from a robust oracle.
        return 1 ether; 
    }

    function deposit(address asset, uint256 amount) public {
        require(amount > 0, "Deposit amount must be > 0");
        IERC20(asset).transferFrom(msg.sender, address(this), amount);
        deposits[asset][msg.sender] += amount;
    }

    // Function to borrow assets against collateral
    function borrow(address assetToBorrow, uint256 amount, address collateralAsset) public {
        require(amount > 0, "Borrow amount must be > 0");
        require(deposits[collateralAsset][msg.sender] > 0, "No collateral deposited");

        // Calculate collateral value and borrow value (simplified LTV of 50% for demo)
        uint256 userCollateralValue = deposits[collateralAsset][msg.sender] * getAssetPrice(collateralAsset);
        uint256 borrowValue = amount * getAssetPrice(assetToBorrow);
        require(borrowValue <= userCollateralValue / 2, "Insufficient collateral for loan");

        // Transfer tokens from this contract to the borrower
        bool success = IERC20(assetToBorrow).transfer(msg.sender, amount);
        require(success, "Token transfer failed");

        borrows[assetToBorrow][msg.sender] += amount;
        // A real contract would also track interest and repayment schedules
    }
    // ... (repay, withdraw functions would also be here in a full contract)
}

Hurtigsjekk: Utlånskonsepter

De har lært om de grunnleggende mekanismene i DeFi-utlån. La oss nå se hvor godt De forstår rollen til sikkerhet.

Besvar den i den interaktive leksjonen

Viktigste punkter

I denne leksjonen utforsket De hvordan desentraliserte plattformer for utlån og låneopptak fungerer. De lærte om:

Rollene til långivere og låntakere.
Bruken av likviditetspooler for effektiv forvaltning av aktiva.
Dynamiske renter basert på tilbud og etterspørsel.
Den avgjørende rollen overkollateralisering og LTV spiller.
Hvordan likvideringsmekanismer beskytter protokollen.
En forenklet gjennomgang av smartkontraktfunksjonene deposit og borrow.

Deretter skal vi se nærmere på et annet avansert DeFi-konsept: flashlån!

Gratis å komme i gang

Lær deg Blokkjede-smartkontrakter med Solidity med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 12
Leksjoner: 48

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Utlåns- og låneprotokoller» gratis?

Ja – hele teksten i «Utlåns- og låneprotokoller» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Blokkjede-smartkontrakter med Solidity-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Blokkjede-smartkontrakter med Solidity inneholder totalt 4 leksjoner.

Hva lærer jeg i «Utlåns- og låneprotokoller»?

Undersøk smartkontraktarkitekturen bak desentraliserte plattformer for utlån og låneopptak, som Aave og Compound. Du øver på Blokkjede-smartkontrakter med Solidity med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Blokkjede-smartkontrakter med Solidity?

Ingen tidligere erfaring er nødvendig. Blokkjede-smartkontrakter med Solidity på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «Utlåns- og låneprotokoller»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Blokkjede-smartkontrakter med Solidity-leksjonen?

Ja. Alle Blokkjede-smartkontrakter med Solidity-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Blokkjede-smartkontrakter med Solidity