Ana içeriğe geç
Change page

Akıllı sözleşme dilleri

Son düzenleme: @selcuk45(opens in a new tab), 9 Ocak 2024

Ethereum'un harika yönlerinden birisi, akıllı sözleşmelerin nispeten geliştirici dostu dillerle yazılabilmesidir. Eğer Python veya herhangi bir süslü ayraç dilinde(opens in a new tab) deneyimliyseniz, benzer söz dizimi olan bir dil bulabilirsiniz.

En aktif ve sürdürülen iki dil ise şunlardır:

  • Solidity
  • Vyper

Daha deneyimli geliştiricilerin Ethereum Sanal Makinesi için orta seviye bir dil olan Yul ya da Yul'un bir eklentisi olan Yul+'ı kullanması uygun olur.

Eğer meraklıysanız ve hâlâ ağır geliştirme altında olan yeni dilleri test etmeye yardımcı olmak istiyorsanız, daha başlangıç aşamasında ve yakın zamanda ortaya çıkmış bir akıllı sözleşme dili olan Fe'yi deneyebilirsiniz.

Ön koşullar

Programlama dilleri, özellikle JavaScript veya Python hakkında önceden bilgiye sahip olmak akıllı sözleşme dillerindeki farklılıkları bir mantığa oturtabilmenize yardımcı olur. Ayrıca dil karşılaştırmalarında çok derine dalmadan önce akıllı sözleşmeleri konsept olarak anlamanızı öneriyoruz. Akıllı sözleşmelere giriş.

Solidity

  • Akıllı sözleşmeler yapmak için nesne odaklı ve yüksek düzey bir dil.
  • En çok C++'tan etkilenmiş olan bir süslü ayraç dili.
  • Statik şekilde yazılır (bir değişkenin türü derleme esnasında bilinir).
  • Şunları destekler:
    • Kalıtım (başka sözleşmeleri ekleyebilirsiniz).
    • Kütüphaneler (başka nesne odaklı programlama dillerinde statik bir sınıftaki statik fonksiyonlar gibi başka sözleşmelerden çağırabileceğiniz yeniden kullanılabilir kodlar oluşturabilirsiniz).
    • Karışık, kullanıcı tarafından tanımlanan türler.

Örnek sözleşme

1// SPDX-License-Identifier: GPL-3.0
2pragma solidity >= 0.7.0;
3
4contract Coin {
5    // The keyword "public" makes variables
6    // accessible from other contracts
7    address public minter;
8    mapping (address => uint) public balances;
9
10    // Events allow clients to react to specific
11    // contract changes you declare
12    event Sent(address from, address to, uint amount);
13
14    // Constructor code is only run when the contract
15    // is created
16    constructor() {
17        minter = msg.sender;
18    }
19
20    // Sends an amount of newly created coins to an address
21    // Can only be called by the contract creator
22    function mint(address receiver, uint amount) public {
23        require(msg.sender == minter);
24        require(amount < 1e60);
25        balances[receiver] += amount;
26    }
27
28    // Sends an amount of existing coins
29    // from any caller to an address
30    function send(address receiver, uint amount) public {
31        require(amount <= balances[msg.sender], "Insufficient balance.");
32        balances[msg.sender] -= amount;
33        balances[receiver] += amount;
34        emit Sent(msg.sender, receiver, amount);
35    }
36}
Tümünü göster
 Kopyala

Bu örnek size Solidity sözleşme söz dizimi hakkında bir fikir verecektir. Fonksiyonlar ve değişkenler hakkında daha detaylı bir açıklama için belgelere bakın(opens in a new tab).

Vyper

  • Python'a benzer programlama dili
  • Güçlü tipleme
  • Küçük ve anlaşılabilir derleyici kodu
  • Etkili bit kodu oluşturma
  • Sözleşmeleri daha güvenli ve denetlenmesi daha kolay hâle getirmek amacıyla bilinçli olarak Solidity'den daha az özelliğe sahiptir. Vyper şunları desteklemez:
    • Niteleyiciler
    • Kalıtım
    • Satır içi derleme
    • Fonksiyon aşırı yüklemesi
    • Operatör aşırı yüklemesi
    • Özyinelemeli çağrı
    • Sonsuz uzunlukta döngüler
    • İkili sabit noktalar

Daha fazla bilgi için Vyper mantığını okuyun(opens in a new tab).

Örnek

1# Open Auction
2
3# Auction params
4# Beneficiary receives money from the highest bidder
5beneficiary: public(address)
6auctionStart: public(uint256)
7auctionEnd: public(uint256)
8
9# Current state of auction
10highestBidder: public(address)
11highestBid: public(uint256)
12
13# Set to true at the end, disallows any change
14ended: public(bool)
15
16# Keep track of refunded bids so we can follow the withdraw pattern
17pendingReturns: public(HashMap[address, uint256])
18
19# Create a simple auction with `_bidding_time`
20# seconds bidding time on behalf of the
21# beneficiary address `_beneficiary`.
22@external
23def __init__(_beneficiary: address, _bidding_time: uint256):
24    self.beneficiary = _beneficiary
25    self.auctionStart = block.timestamp
26    self.auctionEnd = self.auctionStart + _bidding_time
27
28# Bid on the auction with the value sent
29# together with this transaction.
30# The value will only be refunded if the
31# auction is not won.
32@external
33@payable
34def bid():
35    # Check if bidding period is over.
36    assert block.timestamp < self.auctionEnd
37    # Check if bid is high enough
38    assert msg.value > self.highestBid
39    # Track the refund for the previous high bidder
40    self.pendingReturns[self.highestBidder] += self.highestBid
41    # Track new high bid
42    self.highestBidder = msg.sender
43    self.highestBid = msg.value
44
45# Withdraw a previously refunded bid. The withdraw pattern is
46# used here to avoid a security issue. If refunds were directly
47# sent as part of bid(), a malicious bidding contract could block
48# those refunds and thus block new higher bids from coming in.
49@external
50def withdraw():
51    pending_amount: uint256 = self.pendingReturns[msg.sender]
52    self.pendingReturns[msg.sender] = 0
53    send(msg.sender, pending_amount)
54
55# End the auction and send the highest bid
56# to the beneficiary.
57@external
58def endAuction():
59    # It is a good guideline to structure functions that interact
60    # with other contracts (i.e. they call functions or send ether)
61    # into three phases:
62    # 1. checking conditions
63    # 2. performing actions (potentially changing conditions)
64    # 3. interacting with other contracts
65    # If these phases are mixed up, the other contract could call
66    # back into the current contract and modify the state or cause
67    # effects (ether payout) to be performed multiple times.
68    # If functions called internally include interaction with external
69    # contracts, they also have to be considered interaction with
70    # external contracts.
71
72    # 1. Conditions
73    # Check if auction endtime has been reached
74    assert block.timestamp >= self.auctionEnd
75    # Check if this function has already been called
76    assert not self.ended
77
78    # 2. Effects
79    self.ended = True
80
81    # 3. Interaction
82    send(self.beneficiary, self.highestBid)
Tümünü göster
 Kopyala

Bu örnek size Vyper sözleşme söz dizimi hakkında bir fikir verecektir. Fonksiyonlar ve değişkenler hakkında daha detaylı bir açıklama için belgelere bakın(opens in a new tab).

Yul ve Yul+

Eğer Ethereum'da yeniyseniz ve akıllı sözleşme dilleriyle henüz herhangi bir kodlama yapmadıysanız, Solidity veya Vyper ile başlamanızı öneririz. Akıllı sözleşme güvenliğinin en iyi yöntemleri ve EVM ile çalışmanın şartları ile aşina olduğunuz zaman Yul veya Yul+ dillerine bakın.

Yul

  • Ethereum için orta seviye dil.
  • EVM ve Ethereum öğeleri barındıran bir WebAssembly olan Ewasm(opens in a new tab) platformlarını destekler ve iki platformun da yaygın ve kullanılabilir bir paydası olacak şekilde dizayn edilmiştir.
  • EVM ve Ewasm platformlarına eşit derece katkı sağlayabilecek yüksek seviye optimizasyon aşamaları için iyi bir hedeftir.

Yul+

  • Yüksek derecede verimli bir alt düzey Yul eklentisi.
  • Aslen bir iyimser toplama sözleşmesi için dizayn edilmiştir.
  • Yul+, Yul'a yeni özellikler ekleyen deneysel bir yükseltme tasarısı olarak görülebilir.

Örnek sözleşme

Aşağıdaki basit örnek bir üs fonksiyonu uygular. solc --strict-assembly --bin input.yul ile derlenebilir. Örnek input.yul dosyasında depolanmalıdır.

1{
2    function power(base, exponent) -> result
3    {
4        switch exponent
5        case 0 { result := 1 }
6        case 1 { result := base }
7        default
8        {
9            result := power(mul(base, base), div(exponent, 2))
10            if mod(exponent, 2) { result := mul(base, result) }
11        }
12    }
13    let res := power(calldataload(0), calldataload(32))
14    mstore(0, res)
15    return(0, 32)
16}
Tümünü göster

Hâlihazırda akıllı sözleşmeler konusunda deneyimliyseniz, buradan(opens in a new tab) Yul'daki tam bir ERC20 uygulamasına ulaşabilirsiniz.

Fe

  • Ethereum Sanal Makinesi (EVM) için statik olarak yazılmış dil.
  • Python ve Rust'tan ilham almıştır.
  • Ethereum ekosistemine yabancı geliştiriciler için bile kolay öğrenilebilir olmayı hedefler.
  • Fe geliştirilmesi henüz erken aşamalarındadır: Alpha sürümü Ocak 2021'de yayınlanmıştır.

Örnek sözleşme

Aşağıda Fe ile uygulanan basit bir sözleşme bulunuyor.

1type BookMsg = bytes[100]
2
3contract GuestBook:
4    pub guest_book: map<address, BookMsg>
5
6    event Signed:
7        book_msg: BookMsg
8
9    pub def sign(book_msg: BookMsg):
10        self.guest_book[msg.sender] = book_msg
11
12        emit Signed(book_msg=book_msg)
13
14    pub def get_msg(addr: address) -> BookMsg:
15        return self.guest_book[addr].to_mem()
16
Tümünü göster

Seçim yapmak

Her diğer programlama dilinde olduğu gibi, kişisel tercihlerin yanı sıra çoğunlukla doğru iş için doğru aracı seçmekle de ilgilidir.

Eğer dillerden herhangi birini denemediyseniz burada akılda tutulabilecek birkaç şey bulunmaktadır:

Solidity'nin harika olan tarafı nedir?

  • Eğer acemiyseniz, birçok öğretici ve öğrenim aracı bulunmaktadır. Bunun hakkında daha fazlasına Kodlayarak Öğren bölümünden ulaşabilirsiniz.
  • İyi geliştirici araçları bulunur.
  • Solidity büyük bir geliştirici topluluğuna sahiptir, bu da sorularınıza büyük ihtimalle hızlıca cevaplar bulabileceğiniz anlamına gelir.

Vyper'ın harika olan tarafı nedir?

  • Akıllı sözleşmeler yazmak isteyen Python geliştiricileri için iyi bir başlangıç yolu.
  • Vyper daha az özellik sayısına sahip olduğu için fikirlerin hızlı prototiplenmesi için harikadır.
  • Vyper kolay denetlenebilirliği ve en yüksek seviyede insan tarafından okunabilmeyi hedefler.

Yul ve Yul+'ın harika olan tarafları nedir?

  • Basite indirgenmiş ve işlevsel alt düzey dil.
  • Saf EVM'ye çok daha yakınlaşmayı sağlar, bu da sözleşmelerinizin gaz kullanımını optimize etmeye yardımcı olabilir.

Dil karşılaştırmaları

Temel söz dizimi, sözleşme yaşam döngüsü, arayüzler, operatörler, veri yapıları, fonksiyonlar, kontrol akışı ve daha fazlasının karşılaştırmaları için Auditless tarafından hazırlanan kopya kağıdına(opens in a new tab) bakabilirsiniz

Daha fazla bilgi

back-to-top ↑

Bu makale yararlı oldu mu?