Bahasa kontrak pintar

Aspek hebat dari Ethereum adalah kontrak pintar dapat diprogram menggunakan bahasa yang relatif ramah pengembang. Jika Anda berpengalaman dengan Python atau bahasa kurung kurawal (buka di tab baru) apa pun, Anda dapat menemukan bahasa dengan sintaksis yang familier.

Dua bahasa yang paling aktif dan dipelihara adalah:

• Solidity
• Vyper

Lingkungan pengembangan terpadu (IDE) Remix menyediakan lingkungan pengembangan yang komprehensif untuk membuat dan menguji kontrak di Solidity dan Vyper. Coba IDE Remix di peramban (buka di tab baru) untuk mulai membuat kode.

Pengembang yang lebih berpengalaman mungkin juga ingin menggunakan Yul, bahasa perantara untuk Mesin Virtual Ethereum (EVM), atau Yul+, sebuah ekstensi untuk Yul.

Jika Anda penasaran dan ingin membantu menguji bahasa baru yang masih dalam tahap pengembangan intensif, Anda dapat bereksperimen dengan Fe, bahasa kontrak pintar baru yang saat ini masih dalam tahap awal.

Prasyarat

Pengetahuan sebelumnya tentang bahasa pemrograman, terutama JavaScript atau Python, dapat membantu Anda memahami perbedaan dalam bahasa kontrak pintar. Kami juga menyarankan Anda untuk memahami kontrak pintar sebagai sebuah konsep sebelum menggali terlalu dalam tentang perbandingan bahasa. Pengantar kontrak pintar.

Solidity

• Bahasa tingkat tinggi berorientasi objek untuk mengimplementasikan kontrak pintar.
• Bahasa kurung kurawal yang paling banyak dipengaruhi oleh C++.
• Diketik secara statis (tipe variabel diketahui pada saat kompilasi).
• Mendukung:
  • Pewarisan (Anda dapat memperluas kontrak lain).
  • Pustaka (Anda dapat membuat kode yang dapat digunakan kembali yang dapat Anda panggil dari kontrak yang berbeda – seperti fungsi statis di kelas statis dalam bahasa pemrograman berorientasi objek lainnya).
  • Tipe kompleks yang ditentukan pengguna.

Tautan penting

• Dokumentasi (buka di tab baru)
• Portal Bahasa Solidity (buka di tab baru)
• Solidity by Example (buka di tab baru)
• GitHub (buka di tab baru)
• Ruang Obrolan Gitter Solidity (buka di tab baru) yang dijembatani ke Ruang Obrolan Matrix Solidity (buka di tab baru)
• Lembar Sontekan (buka di tab baru)
• Blog Solidity (buka di tab baru)
• Twitter Solidity (buka di tab baru)

Contoh kontrak

// SPDX-License-Identifier: GPL-3.0
pragma solidity >= 0.7.0;

contract Coin {
    // Kata kunci "public" membuat variabel
    // dapat diakses dari kontrak lain
    address public minter;
    mapping (address => uint) public balances;

    // Event memungkinkan klien untuk bereaksi terhadap
    // perubahan kontrak spesifik yang Anda deklarasikan
    event Sent(address from, address to, uint amount);

    // Kode konstruktor hanya dijalankan ketika kontrak
    // dibuat
    constructor() {
        minter = msg.sender;
    }

    // Mengirim sejumlah koin yang baru dibuat ke sebuah alamat
    // Hanya dapat dipanggil oleh pembuat kontrak
    function mint(address receiver, uint amount) public {
        require(msg.sender == minter);
        require(amount < 1e60);
        balances[receiver] += amount;
    }

    // Mengirim sejumlah koin yang ada
    // dari pemanggil mana pun ke sebuah alamat
    function send(address receiver, uint amount) public {
        require(amount <= balances[msg.sender], "Insufficient balance.");
        balances[msg.sender] -= amount;
        balances[receiver] += amount;
        emit Sent(msg.sender, receiver, amount);
    }
}

Contoh ini akan memberi Anda gambaran tentang seperti apa sintaksis kontrak Solidity. Untuk deskripsi yang lebih mendetail tentang fungsi dan variabel, lihat dokumentasinya (buka di tab baru).

Vyper

• Bahasa pemrograman bergaya Python (Pythonic)
• Pengetikan kuat (Strong typing)
• Kode kompilator yang kecil dan mudah dipahami
• Pembuatan kode bita yang efisien
• Sengaja memiliki lebih sedikit fitur daripada Solidity dengan tujuan membuat kontrak lebih aman dan lebih mudah diaudit. Vyper tidak mendukung:
  • Pengubah (Modifiers)
  • Pewarisan
  • Rakitan sebaris (Inline assembly)
  • Kelebihan beban fungsi (Function overloading)
  • Kelebihan beban operator (Operator overloading)
  • Pemanggilan rekursif
  • Perulangan dengan panjang tak terbatas
  • Titik tetap biner (Binary fixed points)

Sejak v0.4.0, Vyper mendukung sistem modul (buka di tab baru). Penggunaan kembali kode dicapai melalui komposisi, bukan pewarisan kelas.

Untuk informasi lebih lanjut, baca dasar pemikiran Vyper (buka di tab baru).

Tautan penting

• Dokumentasi (buka di tab baru)
• Vyper by Example (buka di tab baru)
• Lebih Banyak Vyper by Example (buka di tab baru)
• GitHub (buka di tab baru)
• Obrolan Discord komunitas Vyper (buka di tab baru)
• Lembar Sontekan (buka di tab baru)
• Kerangka kerja dan alat pengembangan kontrak pintar untuk Vyper
• VyperPunk - belajar mengamankan dan meretas kontrak pintar Vyper (buka di tab baru)
• Vyper Hub untuk pengembangan (buka di tab baru)
• Contoh kontrak pintar terbaik Vyper (buka di tab baru)
• Sumber daya kurasi Awesome Vyper (buka di tab baru)

Contoh

# Lelang Terbuka

# Parameter lelang
# Penerima manfaat menerima uang dari penawar tertinggi
beneficiary: public(address)
auctionStart: public(uint256)
auctionEnd: public(uint256)

# Status lelang saat ini
highestBidder: public(address)
highestBid: public(uint256)

# Ditetapkan ke true pada akhirnya, tidak mengizinkan perubahan apa pun
ended: public(bool)

# Melacak tawaran yang dikembalikan dananya sehingga kita dapat mengikuti pola penarikan
pendingReturns: public(HashMap[address, uint256])

# Membuat lelang sederhana dengan `_bidding_time`
# detik waktu penawaran atas nama
# alamat penerima manfaat `_beneficiary`.
@deploy
def __init__(_beneficiary: address, _bidding_time: uint256):
    self.beneficiary = _beneficiary
    self.auctionStart = block.timestamp
    self.auctionEnd = self.auctionStart + _bidding_time

# Menawar pada lelang dengan nilai yang dikirimkan
# bersama dengan transaksi ini.
# Nilai hanya akan dikembalikan dananya jika
# lelang tidak dimenangkan.
@external
@payable
def bid():
    # Memeriksa apakah periode penawaran telah berakhir.
    assert block.timestamp < self.auctionEnd
    # Memeriksa apakah tawaran cukup tinggi
    assert msg.value > self.highestBid
    # Melacak pengembalian dana untuk penawar tertinggi sebelumnya
    self.pendingReturns[self.highestBidder] += self.highestBid
    # Melacak tawaran tertinggi baru
    self.highestBidder = msg.sender
    self.highestBid = msg.value

# Menarik tawaran yang sebelumnya dikembalikan dananya. Pola penarikan
# digunakan di sini untuk menghindari masalah keamanan. Jika pengembalian dana langsung
# dikirim sebagai bagian dari bid(), kontrak penawaran yang berbahaya dapat memblokir
# pengembalian dana tersebut dan dengan demikian memblokir tawaran baru yang lebih tinggi untuk masuk.
@external
def withdraw():
    pending_amount: uint256 = self.pendingReturns[msg.sender]
    self.pendingReturns[msg.sender] = 0
    send(msg.sender, pending_amount)

# Mengakhiri lelang dan mengirimkan tawaran tertinggi
# ke penerima manfaat.
@external
def endAuction():
    # Ini adalah pedoman yang baik untuk menyusun fungsi yang berinteraksi
    # dengan kontrak lain (yaitu, mereka memanggil fungsi atau mengirim ether)
    # ke dalam tiga fase:
    # 1. memeriksa kondisi
    # 2. melakukan tindakan (berpotensi mengubah kondisi)
    # 3. berinteraksi dengan kontrak lain
    # Jika fase-fase ini dicampuradukkan, kontrak lain dapat memanggil
    # kembali ke dalam kontrak saat ini dan memodifikasi status atau menyebabkan
    # efek (pembayaran ether) dilakukan berkali-kali.
    # Jika fungsi yang dipanggil secara internal mencakup interaksi dengan
    # kontrak eksternal, fungsi tersebut juga harus dianggap sebagai interaksi dengan
    # kontrak eksternal.

    # 1. Kondisi
    # Memeriksa apakah waktu akhir lelang telah tercapai
    assert block.timestamp >= self.auctionEnd
    # Memeriksa apakah fungsi ini telah dipanggil
    assert not self.ended

    # 2. Efek
    self.ended = True

    # 3. Interaksi
    send(self.beneficiary, self.highestBid)

Contoh ini akan memberi Anda gambaran tentang seperti apa sintaksis kontrak Vyper. Untuk deskripsi yang lebih mendetail tentang fungsi dan variabel, lihat dokumentasinya (buka di tab baru).

Yul dan Yul+

Jika Anda baru mengenal Ethereum dan belum pernah melakukan pengodean dengan bahasa kontrak pintar, kami menyarankan Anda untuk memulai dengan Solidity atau Vyper. Pelajari Yul atau Yul+ hanya setelah Anda familier dengan praktik terbaik keamanan kontrak pintar dan secara spesifik bekerja dengan EVM.

Yul

• Bahasa perantara untuk Ethereum.
• Mendukung EVM dan Ewasm (buka di tab baru), WebAssembly dengan cita rasa Ethereum, dan dirancang untuk menjadi penyebut umum yang dapat digunakan dari kedua platform tersebut.
• Target yang baik untuk tahap pengoptimalan tingkat tinggi yang dapat menguntungkan platform EVM dan Ewasm secara setara.

Yul+

• Ekstensi tingkat rendah yang sangat efisien untuk Yul.
• Awalnya dirancang untuk kontrak rollup Optimistic.
• Yul+ dapat dilihat sebagai proposal peningkatan eksperimental untuk Yul, yang menambahkan fitur-fitur baru ke dalamnya.

Tautan penting

• Dokumentasi Yul (buka di tab baru)
• Dokumentasi Yul+ (buka di tab baru)
• Pos Pengantar Yul+ (buka di tab baru)

Contoh kontrak

Contoh sederhana berikut mengimplementasikan fungsi pangkat. Ini dapat dikompilasi menggunakan solc --strict-assembly --bin input.yul. Contoh ini harus disimpan dalam berkas input.yul.

{
    function power(base, exponent) -> result
    {
        switch exponent
        case 0 { result := 1 }
        case 1 { result := base }
        default
        {
            result := power(mul(base, base), div(exponent, 2))
            if mod(exponent, 2) { result := mul(base, result) }
        }
    }
    let res := power(calldataload(0), calldataload(32))
    mstore(0, res)
    return(0, 32)
}

Jika Anda sudah sangat berpengalaman dengan kontrak pintar, implementasi ERC-20 penuh di Yul dapat ditemukan di sini (buka di tab baru).

Fe

• Bahasa yang diketik secara statis untuk Mesin Virtual Ethereum (EVM).
• Terinspirasi oleh Python dan Rust.
• Bertujuan agar mudah dipelajari -- bahkan untuk pengembang yang baru mengenal ekosistem Ethereum.
• Pengembangan Fe masih dalam tahap awal, bahasa ini merilis versi alfanya pada Januari 2021.

Tautan penting

• GitHub (buka di tab baru)
• Pengumuman Fe (buka di tab baru)
• Peta Jalan Fe 2021 (buka di tab baru)
• Obrolan Discord Fe (buka di tab baru)
• Twitter Fe (buka di tab baru)

Contoh kontrak

Berikut ini adalah kontrak sederhana yang diimplementasikan di Fe.

type BookMsg = bytes[100]

contract GuestBook:
    pub guest_book: map<address, BookMsg>

    event Signed:
        book_msg: BookMsg

    pub def sign(book_msg: BookMsg):
        self.guest_book[msg.sender] = book_msg

        emit Signed(book_msg=book_msg)

    pub def get_msg(addr: address) -> BookMsg:
        return self.guest_book[addr].to_mem()

Cara memilih

Sama seperti bahasa pemrograman lainnya, ini sebagian besar tentang memilih alat yang tepat untuk pekerjaan yang tepat serta preferensi pribadi.

Berikut adalah beberapa hal yang perlu dipertimbangkan jika Anda belum mencoba salah satu bahasa tersebut:

Apa yang hebat dari Solidity?

• Jika Anda seorang pemula, ada banyak tutorial dan alat pembelajaran di luar sana. Lihat selengkapnya tentang hal itu di bagian Belajar dengan Membuat Kode.
• Alat pengembang yang baik tersedia.
• Solidity memiliki komunitas pengembang yang besar, yang berarti Anda kemungkinan besar akan menemukan jawaban atas pertanyaan Anda dengan cukup cepat.

Apa yang hebat dari Vyper?

• Cara yang bagus untuk memulai bagi pengembang Python yang ingin menulis kontrak pintar.
• Vyper memiliki jumlah fitur yang lebih sedikit yang membuatnya bagus untuk pembuatan prototipe ide secara cepat.
• Vyper bertujuan agar mudah diaudit dan dapat dibaca manusia secara maksimal.

Apa yang hebat dari Yul dan Yul+?

• Bahasa tingkat rendah yang sederhana dan fungsional.
• Memungkinkan untuk lebih dekat dengan EVM mentah, yang dapat membantu mengoptimalkan penggunaan gas kontrak Anda.

Perbandingan bahasa

Untuk perbandingan sintaksis dasar, siklus hidup kontrak, antarmuka, operator, struktur data, fungsi, alur kontrol, dan lainnya, lihat lembar sontekan oleh Auditless (buka di tab baru) ini

Bacaan lebih lanjut

• Pustaka Kontrak Solidity oleh OpenZeppelin (buka di tab baru)
• Solidity by Example (buka di tab baru)