Membina Aplikasi Kewangan Terdesentralisasi (DeFi) menggunakan Ekosistem Python

Decentralized Finance (DeFi) sedang merevolusikan industri kewangan dengan menyediakan perkhidmatan kewangan yang terbuka, telus dan tanpa kebenaran menggunakan teknologi blockchain. Dalam artikel ini, kami akan meneroka cara membina aplikasi DeFi mudah menggunakan ekosistem Python. Kami akan membincangkan topik berikut:

• Pengenalan kepada DeFi
• Menyediakan Persekitaran Pembangunan
• Berinteraksi dengan Blockchain
• Mencipta Kontrak Pintar
• Membina Bahagian Belakang dengan FastAPI
• Mengintegrasikan Frontend dengan Web3.py
• Menggunakan Aplikasi
• Menguji Aplikasi DeFi
• Pertimbangan Keselamatan
• Kesimpulan dan Hala Tuju Masa Depan

Pengenalan kepada DeFi

DeFi memanfaatkan teknologi blockchain untuk menyediakan perkhidmatan kewangan seperti meminjamkan, meminjam, berdagang dan memperoleh faedah tanpa bergantung pada pengantara kewangan tradisional seperti bank. Komponen utama DeFi termasuk kontrak pintar, aplikasi terdesentralisasi (dApps) dan platform rantaian blok seperti Ethereum.

Menyediakan Persekitaran Pembangunan

Sebelum kami bermula, pastikan anda telah memasang Python. Kami akan menggunakan beberapa perpustakaan Python termasuk Web3.py, FastAPI dan Brownie. Cipta persekitaran maya dan pasang pakej yang diperlukan:

python -m venv venv
sumber venv/bin/activate # Pada Windows, gunakanvenvScriptsactivate
pip pasang web3 fastapi uvicorn pydantic brownie

Berinteraksi dengan Blockchain

Kami akan menggunakan Web3.py untuk berinteraksi dengan blockchain Ethereum. Mari mulakan dengan menyambung ke rangkaian blockchain (kami akan menggunakan testnet Ropsten) dan menyemak baki alamat.

blockchain.py

from web3 import Web3

# Connect to the Ropsten testnet
infura_url = 'https://ropsten.infura.io/v3/YOUR_INFURA_PROJECT_ID'
web3 = Web3(Web3.HTTPProvider(infura_url))

def check_balance(address):
    balance = web3.eth.get_balance(address)
    return web3.fromWei(balance, 'ether')

Mencipta Kontrak Pintar

Kontrak pintar ialah kontrak yang dilaksanakan sendiri dengan syarat perjanjian yang ditulis terus ke dalam kod. Kami akan menggunakan Solidity untuk menulis kontrak pintar mudah untuk token.

kontrak/Token.sol

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

contract Token {
    string public name = "MyToken";
    string public symbol = "MTK";
    uint8 public decimals = 18;
    uint256 public totalSupply = 1000000 * (10 ** uint256(decimals));
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

    constructor() {
        balanceOf[msg.sender] = totalSupply;
    }

    function transfer(address _to, uint256 _value) public returns (bool success) {
        require(_to != address(0));
        require(balanceOf[msg.sender] >= _value);

        balanceOf[msg.sender] -= _value;
        balanceOf[_to] += _value;

        emit Transfer(msg.sender, _to, _value);
        return true;
    }

    function approve(address _spender, uint256 _value) public returns (bool success) {
        allowance[msg.sender][_spender] = _value;
        emit Approval(msg.sender, _spender, _value);
        return true;
    }

    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
        require(_to != address(0));
        require(balanceOf[_from] >= _value);
        require(allowance[_from][msg.sender] >= _value);

        balanceOf[_from] -= _value;
        balanceOf[_to] += _value;
        allowance[_from][msg.sender] -= _value;

        emit Transfer(_from, _to, _value);
        return true;
    }
}

Kompil dan gunakan kontrak menggunakan Brownie:

brownie init
penyusun brownies
pengagih baharu akaun brownie
brownie run scripts/deploy.py

skrip/deploy.py

from brownie import Token, accounts

def main():
    deployer = accounts.load('deployer')
    token = Token.deploy({'from': deployer})

Membina Bahagian Belakang dengan FastAPI

Kami akan mencipta bahagian belakang FastAPI untuk berinteraksi dengan kontrak pintar kami. Bahagian belakang akan menyediakan titik akhir untuk menyemak baki dan memindahkan token.

app.py

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from web3 import Web3
import json

app = FastAPI()

infura_url = 'https://ropsten.infura.io/v3/YOUR_INFURA_PROJECT_ID'
web3 = Web3(Web3.HTTPProvider(infura_url))
contract_address = 'YOUR_CONTRACT_ADDRESS'
abi = json.loads('[YOUR_CONTRACT_ABI]')

contract = web3.eth.contract(address=contract_address, abi=abi)
deployer = web3.eth.account.privateKeyToAccount('YOUR_PRIVATE_KEY')

class TransferRequest(BaseModel):
    to: str
    amount: float

@app.get("/balance/{address}")
async def get_balance(address: str):
    try:
        balance = contract.functions.balanceOf(address).call()
        return {"balance": web3.fromWei(balance, 'ether')}
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))

@app.post("/transfer")
async def transfer_tokens(transfer_request: TransferRequest):
    try:
        to_address = transfer_request.to
        amount = web3.toWei(transfer_request.amount, 'ether')
        nonce = web3.eth.getTransactionCount(deployer.address)
        txn = contract.functions.transfer(to_address, amount).buildTransaction({
            'chainId': 3,
            'gas': 70000,
            'gasPrice': web3.toWei('1', 'gwei'),
            'nonce': nonce,
        })
        signed_txn = web3.eth.account.signTransaction(txn, private_key=deployer.key)
        tx_hash = web3.eth.sendRawTransaction(signed_txn.rawTransaction)
        return {"transaction_hash": web3.toHex(tx_hash)}
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))

Mengintegrasikan Frontend dengan Web3.py

Kami boleh membina bahagian hadapan yang mudah untuk berinteraksi dengan bahagian belakang FastAPI kami dan memaparkan baki token serta memudahkan pemindahan. Di sini, kami akan menggunakan persediaan HTML dan JavaScript yang minimum untuk menunjukkan interaksi ini.

index.html

    <title>DeFi Application</title>


    <h1>DeFi Application</h1>
    <div>
        <h2>Check Balance</h2>
        <input type="text" id="address" placeholder="Enter address">
        <button onclick="checkBalance()">Check Balance</button>
        <p id="balance"></p>
    </div>
    <div>
        <h2>Transfer Tokens</h2>
        <input type="text" id="to" placeholder="To address">
        <input type="text" id="amount" placeholder="Amount">
        <button onclick="transferTokens()">Transfer</button>
        <p id="transaction"></p>
    </div>
    <script>
        async function checkBalance() {
            const address = document.getElementById('address').value;
            const response = await fetch(`http://localhost:8000/balance/${address}`);
            const data = await response.json();
            document.getElementById('balance').innerText = `Balance: ${data.balance} MTK`;
        }

        async function transferTokens() {
            const to = document.getElementById('to').value;
            const amount = document.getElementById('amount').value;
            const response = await fetch('http://localhost:8000/transfer', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify({ to, amount })
            });
            const data = await response.json();
            document.getElementById('transaction').innerText = `Transaction Hash: ${data.transaction_hash}`;
        }
    </script>

Meletakkan Aplikasi

Untuk menggunakan aplikasi FastAPI, kami boleh menggunakan Uvicorn. Jalankan arahan berikut untuk memulakan pelayan:

apl uvicorn:apl --muat semula

Menguji Aplikasi DeFi

Untuk menguji aplikasi DeFi kami, buka fail index.html dalam penyemak imbas web dan gunakan antara muka yang disediakan untuk menyemak baki dan memindahkan token.

1. Semak Baki: Masukkan alamat Ethereum dan klik "Semak Baki" untuk melihat baki token.

2. Token Pemindahan: Masukkan alamat penerima dan jumlah token untuk dipindahkan, kemudian klik "Pindahan" untuk memulakan transaksi.

Pertimbangan Keselamatan

Apabila membina aplikasi DeFi, keselamatan adalah amat penting. Pertimbangkan amalan terbaik berikut:

1. Audit Kontrak Pintar: Pastikan kontrak pintar anda diaudit oleh firma keselamatan profesional.

2. Pengurusan Kunci Peribadi: Jangan sekali-kali kod keras kunci peribadi dalam aplikasi anda. Gunakan sistem pengurusan kunci yang selamat.

3. Pengesahan Input: Sahkan dan bersihkan semua input pengguna untuk mengelakkan kelemahan biasa seperti serangan masuk semula dan limpahan.

4. Penghadan Kadar: Laksanakan pengehadan kadar pada titik akhir anda untuk mengelakkan penyalahgunaan.

5. Kemas Kini Biasa: Pastikan perpustakaan dan tanggungan anda dikemas kini untuk mengurangkan kelemahan yang diketahui.

Kesimpulan dan Hala Tuju Masa Depan

Dalam artikel ini, kami telah membina aplikasi DeFi mudah menggunakan ekosistem Python. Kami merangkumi asas DeFi, berinteraksi dengan blockchain Ethereum menggunakan Web3.py, mencipta kontrak pintar, membina bahagian belakang dengan FastAPI dan menyepadukan bahagian hadapan.

DeFi ialah bidang yang berkembang pesat dengan potensi yang besar. Arah masa hadapan untuk projek anda boleh termasuk:

• Mengintegrasikan Lebih Banyak Protokol DeFi: Terokai penyepaduan protokol DeFi lain seperti platform pinjaman (cth., Aave) atau pertukaran terdesentralisasi (cth., Uniswap).

• Meningkatkan Bahagian Depan: Bina bahagian hadapan yang lebih canggih menggunakan rangka kerja seperti React.js atau Vue.js.

• Menambahkan Pengesahan Pengguna: Laksanakan pengesahan dan kebenaran pengguna untuk mencipta pengalaman yang lebih diperibadikan.

• Meluaskan Fungsi Kontrak Pintar: Tambahkan lebih banyak ciri pada kontrak pintar anda, seperti staking, tadbir urus atau pertanian hasil.

Jangan ragu untuk mengembangkan sistem ini dan bereksperimen dengan ciri dan protokol baharu. Selamat mengekod!

Atas ialah kandungan terperinci Membina Aplikasi Kewangan Terdesentralisasi (DeFi) menggunakan Ekosistem Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!