Vai al contenuto principale
Change page

Linguaggi per i contratti intelligenti

Ultimo aggiornamento della pagina: 26 febbraio 2026

Herbie_23H (opens in a new tab)
ametel01a (opens in a new tab)
jhonnyvianelloj (opens in a new tab)
+18

Un grande aspetto di Ethereum è che i contratti intelligenti possono essere programmati utilizzando linguaggi relativamente facili per gli sviluppatori. Se hai esperienza con Python o con qualsiasi linguaggio a parentesi graffe (opens in a new tab), puoi trovare un linguaggio con una sintassi familiare.

I due linguaggi più attivi e mantenuti sono:

  • Solidity
  • Vyper

Remix IDE fornisce un ambiente di sviluppo completo per creare e testare contratti sia in Solidity che in Vyper. Prova l'IDE Remix nel browser (opens in a new tab) per iniziare a programmare.

Gli sviluppatori più esperti potrebbero anche voler utilizzare Yul, un linguaggio intermedio per la macchina virtuale di Ethereum, o Yul+, un'estensione di Yul.

Se sei curioso e ti piace aiutare a testare nuovi linguaggi che sono ancora in forte sviluppo, puoi sperimentare con Fe, un linguaggio emergente per i contratti intelligenti che è attualmente ancora agli inizi.

Prerequisiti

Una conoscenza pregressa dei linguaggi di programmazione, specialmente di JavaScript o Python, può aiutarti a comprendere le differenze nei linguaggi per i contratti intelligenti. Ti consigliamo inoltre di comprendere i contratti intelligenti come concetto prima di addentrarti troppo nei confronti tra i linguaggi. Introduzione ai contratti intelligenti.

Solidity

  • Linguaggio di alto livello orientato agli oggetti per l'implementazione di contratti intelligenti.
  • Linguaggio a parentesi graffe che è stato profondamente influenzato dal C++.
  • Tipizzato staticamente (il tipo di una variabile è noto al momento della compilazione).
  • Supporta:
    • Ereditarietà (puoi estendere altri contratti).
    • Librerie (puoi creare codice riutilizzabile che puoi chiamare da contratti diversi, come le funzioni statiche in una classe statica in altri linguaggi di programmazione orientati agli oggetti).
    • Tipi complessi definiti dall'utente.

Link importanti

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 permettono ai client di reagire a specifiche
11    // modifiche del contratto che dichiari
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}
Mostra tutto

Questo esempio dovrebbe darti un'idea di come sia la sintassi dei contratti in Solidity. Per una descrizione più dettagliata delle funzioni e delle variabili, consulta la documentazione (opens in a new tab).

Vyper

  • Linguaggio di programmazione pythonico
  • Tipizzazione forte
  • Codice del compilatore piccolo e comprensibile
  • Generazione efficiente del bytecode
  • Ha deliberatamente meno funzionalità rispetto a Solidity con l'obiettivo di rendere i contratti più sicuri e facili da verificare. Vyper non supporta:
    • Modificatori
    • Ereditarietà
    • Assembly in linea
    • Sovraccarico delle funzioni
    • Sovraccarico degli operatori
    • Chiamate ricorsive
    • Cicli di lunghezza infinita
    • Punti fissi binari

Per maggiori informazioni, leggi le motivazioni di Vyper (opens in a new tab).

Link importanti

Esempio

1# Asta aperta
2
3# Parametri dell'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# Impostato su true alla fine, impedisce qualsiasi modifica
14ended: public(bool)
15
16# Tieni traccia delle offerte rimborsate in modo da poter seguire il pattern di prelievo
17pendingReturns: public(HashMap[address, uint256])
18
19# Crea una semplice asta con `_bidding_time`
20# secondi di tempo per le offerte per conto dell'
21# 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# Fai un'offerta all'asta con il valore inviato
29# insieme a questa transazione.
30# Il valore sarà rimborsato solo se l'
31# asta non viene vinta.
32@external
33@payable
34def bid():
35    # Controlla se il periodo delle offerte è terminato.
36    assert block.timestamp < self.auctionEnd
37    # Controlla se l'offerta è abbastanza alta
38    assert msg.value > self.highestBid
39    # Tieni traccia del rimborso per il precedente miglior offerente
40    self.pendingReturns[self.highestBidder] += self.highestBid
41    # Tieni traccia della nuova offerta più alta
42    self.highestBidder = msg.sender
43    self.highestBid = msg.value
44
45# Preleva un'offerta precedentemente rimborsata. Il pattern di prelievo è
46# usato qui per evitare un problema di sicurezza. Se i rimborsi fossero direttamente
47# inviati come parte di bid(), un contratto di offerta malevolo potrebbe bloccare
48# quei rimborsi e quindi bloccare l'arrivo di nuove offerte più alte.
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    # È una buona linea guida strutturare le funzioni che interagiscono
60    # con altri contratti (cioè, chiamano funzioni o inviano ether)
61    # in tre fasi:
62    # 1. controllo delle condizioni
63    # 2. esecuzione delle azioni (potenzialmente modificando le condizioni)
64    # 3. interazione con altri contratti
65    # Se queste fasi vengono mescolate, l'altro contratto potrebbe richiamare
66    # il contratto corrente e modificare lo stato o causare
67    # l'esecuzione multipla di effetti (pagamento di ether).
68    # Se le funzioni chiamate internamente includono l'interazione con
69    # contratti esterni, devono anche essere considerate interazioni con
70    # contratti esterni.
71
72    # 1. Condizioni
73    # Controlla se l'ora di fine dell'asta è stata raggiunta
74    assert block.timestamp >= self.auctionEnd
75    # Controlla 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)
Mostra tutto

Questo esempio dovrebbe darti un'idea di come sia la sintassi dei contratti in Vyper. Per una descrizione più dettagliata delle funzioni e delle variabili, consulta la documentazione (opens in a new tab).

Yul e Yul+

Se sei nuovo su Ethereum e non hai ancora programmato con i linguaggi per i contratti intelligenti, ti consigliamo di iniziare con Solidity o Vyper. Esamina Yul o Yul+ solo quando avrai familiarità con le migliori pratiche di sicurezza dei contratti intelligenti e con le specifiche del lavoro con l'EVM.

Yul

  • Linguaggio intermedio per Ethereum.
  • Supporta l'EVM ed Ewasm (opens in a new tab), un WebAssembly in stile Ethereum, ed è progettato per essere un denominatore comune utilizzabile per entrambe le piattaforme.
  • Ottimo obiettivo per le fasi di ottimizzazione di alto livello che possono avvantaggiare equamente sia le piattaforme EVM che Ewasm.

Yul+

  • Un'estensione di Yul di basso livello e altamente efficiente.
  • Inizialmente progettato per un contratto di rollup ottimistico.
  • Yul+ può essere considerato come una proposta di aggiornamento sperimentale per Yul, aggiungendovi nuove funzionalità.

Link importanti

Esempio di contratto

Il seguente semplice esempio implementa una funzione di potenza. Può essere compilato utilizzando solc --strict-assembly --bin input.yul. L'esempio dovrebbe essere salvato 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}
Mostra tutto

Se hai già molta esperienza con i contratti intelligenti, puoi trovare un'implementazione completa di ERC20 in Yul qui (opens in a new tab).

Fe

  • Linguaggio tipizzato staticamente per la macchina virtuale di Ethereum (EVM).
  • Ispirato a Python e Rust.
  • Mira a essere facile da imparare, anche per gli sviluppatori che sono nuovi nell'ecosistema di Ethereum.
  • Lo sviluppo di Fe è ancora nelle sue fasi iniziali, il linguaggio ha avuto la sua versione alpha a gennaio 2021.

Link importanti

Esempio di contratto

Di seguito è riportato un semplice contratto 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
Mostra tutto

Come scegliere

Come per qualsiasi altro linguaggio di programmazione, si tratta principalmente di scegliere lo strumento giusto per il lavoro giusto, oltre che di preferenze personali.

Ecco alcune cose da considerare se non hai ancora provato nessuno dei linguaggi:

Cosa c'è di fantastico in Solidity?

  • Se sei un principiante, ci sono molti tutorial e strumenti di apprendimento disponibili. Scopri di più nella sezione Impara programmando.
  • Buoni strumenti per sviluppatori disponibili.
  • Solidity ha una grande community di sviluppatori, il che significa che molto probabilmente troverai risposte alle tue domande abbastanza rapidamente.

Cosa c'è di fantastico in Vyper?

  • Ottimo modo per iniziare per gli sviluppatori Python che vogliono scrivere contratti intelligenti.
  • Vyper ha un numero minore di funzionalità, il che lo rende ottimo per la prototipazione rapida di idee.
  • Vyper mira a essere facile da verificare e massimamente leggibile dall'uomo.

Cosa c'è di fantastico in Yul e Yul+?

  • Linguaggio di basso livello semplicistico e funzionale.
  • Permette di avvicinarsi molto di più all'EVM grezza, il che può aiutare a ottimizzare l'utilizzo del gas dei tuoi contratti.

Confronti tra i linguaggi

Per confronti sulla sintassi di base, il ciclo di vita del contratto, le interfacce, gli operatori, le strutture dati, le funzioni, il flusso di controllo e altro ancora, dai un'occhiata a questo cheat sheet di Auditless (opens in a new tab)

Letture consigliate

Questo articolo è stato utile?