Vai al contenuto principale

Aiuta ad aggiornare questa pagina

🌏

C'è una nuova versione di questa pagina, ma al momento è solo in inglese. Aiutaci a tradurre l'ultima versione.

Traduci la pagina
Visualizza in inglese

Nessun bug qui!🐛

Questa pagina non è stata tradotta. Per il momento, è stata intenzionalmente lasciata in inglese.

Linguaggi degli Smart Contract

Ultima modifica: , Invalid DateTime
Modifica la pagina

Uno degli aspetti positivi di Ethereum è che gli Smart Contract possono essere programmati utilizzando linguaggi relativamente comodi per gli sviluppatori. Se hai esperienza con Python o altri linguaggi a parentesi graffa, troverai un linguaggio con una sintassi familiare.

I due linguaggi più attivi e gestiti sono:

  • Solidity
  • Vyper

Gli sviluppatori più esperti potrebbero prendere in considerazione anche Yul, un linguaggio intermedio per la macchina virtuale Ethereum, oppure Yul +, un'estensione di Yul.

Se sei curioso e vorresti aiutare a testare nuovi linguaggi ancora in via di forte sviluppo, puoi sperimentare con Fe, un linguaggio emergente nel campo degli smart contract che al momento è ancora agli inizi.

Prerequisiti

Una conoscenza pregressa dei linguaggi di programmazione, in particolare JavaScript o Python, può aiutarti a capire le differenze tra i linguaggi degli Smart Contract. Ti consigliamo inoltre di approfondire le nozioni connesse agli smart contract prima di addentrarti nei confronti tra i vari linguaggi. Introduzione agli smart contract.

Solidity

  • Linguaggio d'alto livello orientato agli oggetti per l'implementazione di smart contract.
  • Linguaggio a parentesi graffa profondamente influenzato da C++.
  • Statico (il tipo di una variabile è noto al momento della compilazione).
  • Supporta:
    • Ereditarietà (è possibile estendere altri contratti).
    • Librerie (è possibile creare codice riutilizzabile che può essere chiamato da contratti diversi, come le funzioni statiche in una classe statica in altri linguaggi di programmazione orientati agli oggetti).
    • Tipi di dati complessi definiti dall'utente.

Esempio di contratto

1// SPDX-License-Identifier: GPL-3.0
2pragma solidity >= 0.7.0;
3
4contract Coin {
5 // La parola chiave "public" rende le variabili
6 // accessibili da altri contratti
7 address public minter;
8 mapping (address => uint) public balances;
9
10 // Gli eventi consentono ai client di reagire a specifiche
11 // modifiche ai contratti che vengono dichiarate
12 event Sent(address from, address to, uint amount);
13
14 // Il codice del costruttore viene eseguito solo quando il contratto
15 // viene creato
16 constructor() {
17 minter = msg.sender;
18 }
19
20 // Invia una quantità di monete appena create a un indirizzo
21 // Può essere chiamato solo dal creatore del contratto
22 function mint(address receiver, uint amount) public {
23 require(msg.sender == minter);
24 require(amount < 1e60);
25 balances[receiver] += amount;
26 }
27
28 // Invia una quantità di monete esistenti
29 // da qualsiasi chiamante a un indirizzo
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}
37
Mostra tutto
📋 Copia

Questo esempio dà un'idea della sintassi di un contratto in Solidity. Per una descrizione più dettagliata di funzioni e variabili, consulta la documentazione.

Vyper

  • Linguaggio di programmazione Pythonic
  • Tipizzazione forte
  • Codice del compilatore contenuto e comprensibile
  • Ha volutamente meno funzionalità di Solidity con l'obiettivo di rendere i contratti più sicuri e più facili da controllare. Vyper non supporta:
    • Modificatori
    • Ereditarietà
    • Assembly inline
    • Overloading delle funzioni
    • Overloading degli operatori
    • Chiamate ricorsive
    • Cicli di lunghezza infinita
    • Punti fissi binari

Per ulteriori informazioni, consulta la logica Vyper.

Esempio

1# Apertura asta
2
3# Parametri d'asta
4# Il beneficiario riceve denaro dal miglior offerente
5beneficiary: public(address)
6auctionStart: public(uint256)
7auctionEnd: public(uint256)
8
9# Stato attuale dell'asta
10highestBidder: public(address)
11highestBid: public(uint256)
12
13# Imposta a true alla fine per non permettere più modifiche
14ended: public(bool)
15
16# Tiene traccia delle offerte rimborsate in modo da poter seguire il modello di prelievo
17pendingReturns: public(HashMap[address, uint256])
18
19# Crea una semplice asta con `_bidding_time`
20# tempo di offerta in secondi per conto
21# dell'indirizzo del beneficiario `_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# Offerta sull'asta con il valore inviato
29# insieme a questa transazione.
30# Il valore sarà rimborsato solo se l'asta
31# non viene vinta.
32@external
33@payable
34def bid():
35 # Controlla se il periodo di offerta è finito.
36 assert block.timestamp < self.auctionEnd
37 # Verifica se l'offerta è abbastanza alta
38 assert msg.value > self.highestBid
39 # Tiene traccia del rimborso all'offerente più alto precedente
40 self.pendingReturns[self.highestBidder] += self.highestBid
41 # Tiene traccia della nuova offerta più alta
42 self.highestBidder = msg.sender
43 self.highestBid = msg.value
44
45# Preleva un'offerta precedentemente rimborsata. Il modello di prelievo è
46# utilizzato qui per evitare un problema di sicurezza. Se i rimborsi venissero inviati direttamente
47# come parte di bid(), un contratto di offerta malevolo potrebbe bloccarli
48# e quindi bloccare le nuove offerte più alte in arrivo.
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# Termina l'asta e invia l'offerta più alta
56# al beneficiario.
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. controllo delle condizioni
63 # 2. esecuzione delle azioni (potenzialmente modificando le condizioni)
64 # 3. interazione con altri contratti
65 # Se queste fasi sono mischiate, l'altro contratto potrebbe eseguire
66 # nuove chiamate al contratto corrente e modificare lo stato o causare
67 # effetti (pagamento di ether) da eseguire più volte.
68 # Se le funzioni chiamate internamente includono l'interazione con contratti esterni
69 # devono essere considerate anche interazioni con
70 # contratti esterni.
71
72 # 1. Condizioni
73 # Controlla se la fine dell'asta è stata raggiunta
74 assert block.timestamp >= self.auctionEnd
75 # Verifica se questa funzione è già stata chiamata
76 assert not self.ended
77
78 # 2. Effetti
79 self.ended = True
80
81 # 3. Interazione
82 send(self.beneficiary, self.highestBid)
83
Mostra tutto
📋 Copia

Questo esempio dovrebbe dare un'idea della sintassi di un contratto in Vyper. Per una descrizione più dettagliata di funzioni e variabili, consulta la documentazione.

Yul e Yul+

Se non hai esperienza con Ethereum e non hai ancora usato i linguaggi degli Smart Contract, consigliamo di iniziare con Solidity o Vyper. Prendi in considerazione Yul o Yul+ solo quando hai acquisito familiarità con le best practice di sicurezza per gli smart contract e le specifiche per l'utilizzo dell'EVM.

Yul

  • Linguaggio di livello intermedio per Ethereum.
  • Supporta l'EVM ed Ewasm, un WebAssembly orientato a Ethereum ed è progettato per essere un denominatore comune utilizzabile di entrambe le piattaforme.
  • Buona soluzione per le fasi di ottimizzazione di alto livello che possono essere utili per entrambe le piattaforme, EVM ed eWASM.

Yul+

  • Un'estensione a Yul molto efficiente e di basso livello.
  • Inizialmente progettata per un contratto optimistic rollup.
  • Yul+ può essere considerato come una proposta di upgrade sperimentale a Yul che aggiunge nuove funzionalità.

Esempio di contratto

Il seguente esempio semplice implementa una funzione di potenza. Può essere compilato usando solc --strict-assembly --bin input.yul. L'esempio deve essere incluso nel file input.yul.

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}
17
Mostra tutto

Se hai già una buona esperienza con gli Smart Contract, un'implementazione completa di ERC20 in Yul è disponibile qui.

Fe

  • Linguaggio digitato staticamente per la Macchina Virtuale di Ethereum (EVM).
  • Ispirato da Python e Rust.
  • Mira a esser facile da imparare, anche per sviluppatori nuovi all'ecosistema di Ethereum.
  • Lo sviluppo di Fe è ancora alle fasi iniziali e a gennaio 2021 è stata rilasciata la versione alfa del linguaggio.

Esempio di contratto

Il seguente è un contratto semplice implementato in Fe.

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
17
Mostra tutto

Come scegliere

Come avviene con qualsiasi altro linguaggio di programmazione, si tratta principalmente di scegliere lo strumento giusto per l'operazione da svolgere, in base alle preferenze personali.

Ecco alcuni aspetti da considerare se non hai ancora provato i vari linguaggi:

Quali vantaggi offre Solidity?

  • Se non hai esperienza, sono disponibili molti tutorial e strumenti di apprendimento. Scopri di più nella sezione Impara scrivendo codice.
  • Disponibilità di strumenti utili per sviluppatori.
  • Solidity ha un'estesa community di sviluppatori, quindi probabilmente troverai risposte alle tue domande abbastanza rapidamente.

Quali vantaggi offre Vyper?

  • Ottimo modo per iniziare per gli sviluppatori di Python che vogliono scrivere smart contract.
  • Vyper ha un numero minore di funzionalità che lo rendono perfetto per la prototipazione rapida di idee.
  • Vyper vuole facilitare l'audit del codice ed essere leggibile il più possibile.

Quali vantaggi offrono Yul e Yul+?

  • Linguaggio di basso livello, semplicistico e funzionale.
  • Consente di avvicinarsi all'EVM grezza, il che può aiutare a ottimizzare il consumo di carburante da parte dei contratti.

Confronto tra linguaggi

Per confrontare sintassi di base, ciclo di vita del contratto, interfacce, operatori, strutture di dati, funzioni, flusso di controllo e altro, consulta questo contenuto riassuntivo di Auditless

Letture consigliate

Questo articolo è stato utile?

👈

Indietro

Smart contract

Avanti

Anatomia dello Smart Contract
👉