From 358c299987afc00b1c1727397b8dd758455e3682 Mon Sep 17 00:00:00 2001
From: Al <develop0to1@gmail.com>
Date: Mon, 18 Jul 2022 16:26:09 +0200
Subject: Translate Solidity introduction into italian

---
 it-it/solidity.html.markdown | 44 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 it-it/solidity.html.markdown

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
new file mode 100644
index 00000000..e12e6e22
--- /dev/null
+++ b/it-it/solidity.html.markdown
@@ -0,0 +1,44 @@
+---
+language: Solidity
+filename: learnSolidity.sol
+contributors:
+  - ["Nemil Dalal", "https://www.nemil.com"]
+  - ["Joseph Chow", ""]
+  - ["Bhoomtawath Plinsut", "https://github.com/varshard"]
+  - ["Shooter", "https://github.com/liushooter"]
+  - ["Patrick Collins", "https://gist.github.com/PatrickAlphaC"]
+translators:
+    - ["Alias", "http://github.com/al-ias"]
+lang: it-it
+---
+
+Solidity permette di programmare su [Ethereum](https://www.ethereum.org/), una
+macchina virtuale basata sulla blockchain che consente la creazione e
+l'esecuzione degli smart contract senza che sia richiesta centralizzazione o
+fiducia negli attori coinvolti.
+
+Solidity è un linguaggio di programmazione di contratti tipizzato staticamente e
+ha molte cose in comune con Javascript e C. Come per gli oggetti nella
+programmazione ad oggetti, ogni contratto contiene variabili di stato, funzioni
+e tipi di dato semplici. Tra le funzionalità specifiche dei contratti troviamo
+le clausole (guardie) dei modifier, gli event notifier per i listener, e le
+variabili globali custom.
+
+Come esempi di contratti su Ethereum troviamo sistemi di crowdfunding, voto,
+[finanza decentralizzata](https://defipulse.com/) e aste al buio.
+
+Compiere errori nel codice Solidity può portare a rischi e costi alti, quindi
+bisogna fare attenzione a testare e rilasciare le modifiche lentamente. A
+CAUSA DEI CONTINUI CAMBIAMENTI DI ETHEREUM È IMPROBABILE CHE QUESTO DOCUMENTO
+RESTI AGGIORNATO, QUINDI COSNIGLIAMO DI SEGUIRE LA CHAT ROOM DI SOLIDITY E IL
+BLOG DI ETHEREUM PER TENERSI AGGIORNATI. TUTTO IL CODICE QUI PRESENTE E' FORNITO
+COSÌ COM'È, CON ANNESSI RISCHI SOSTANZIALI DI ERRORI O PATTERN DI PROGRAMMAZIONE
+DEPRECATI. 
+
+A differenza di altri tipi di codice, potresti aver bisogno di usare pattern di
+pausing, deprecation e throttling usage per ridurre il rischio. Questo documento
+tratta principalmene la sintassi e quindi esclude molti design pattern in voga.
+
+Visto che Solidity e Ethereum sono in continuo sviluppo, le funzionalità
+sperimentali o beta sono evidenziate e soggette a cambiamenti. Ogni Pull Request
+è ben accetta.
\ No newline at end of file
-- 
cgit v1.2.3


From 72cc375abc2150d4c3b49d573681b88c2cf46651 Mon Sep 17 00:00:00 2001
From: Al <develop0to1@gmail.com>
Date: Mon, 18 Jul 2022 16:27:30 +0200
Subject: Translate "working with remix and metamask" section

---
 it-it/solidity.html.markdown | 35 ++++++++++++++++++++++++++++++++++-
 1 file changed, 34 insertions(+), 1 deletion(-)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index e12e6e22..5d022c1a 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -41,4 +41,37 @@ tratta principalmene la sintassi e quindi esclude molti design pattern in voga.
 
 Visto che Solidity e Ethereum sono in continuo sviluppo, le funzionalità
 sperimentali o beta sono evidenziate e soggette a cambiamenti. Ogni Pull Request
-è ben accetta.
\ No newline at end of file
+è ben accetta.
+
+
+## Lavorare su una testnet
+
+Distribuire e testare su una testnet è il modo più accurato per mettere alla
+prova i tuoi smart contract in Solidity. Per farlo procuriamoci prima degli ETH
+di test dalla testnet Kovan.
+
+[Entra in questo Gitter Channel](https://gitter.im/kovan-testnet/faucet) e
+scrivici l'indirizzo del tuo wallet Metamask.
+
+Sul tuo Metamask, dovrai cambiare la testnet in `Kovan`.
+
+![Solidity-in-remix](../images/solidity/metamask-kovan.png)
+
+Rivecerai degli Ethereum di test gratuiti. Per distribuire degli smart contract
+su una testnet abbiamo bisogno di Ethereum.
+
+Nell'esempio precedente non avevamo usato una testnet, ma avevamo distribuito
+su un ambiente virtuale fittizio. Quando si lavora su una testnet, possiamo
+davvero monitorare e interagire con i nostri contratti in maniera persistente.
+
+Per distribuire su una testnet, allo step `#4 Fai il deploy`, cambia
+l'`environment` selezionato in `injected web3`. In questo modo verrà usato
+come network su cui fare il deploy qualsiasi network selezionato sul tuo
+Metamask.
+
+![Solidity-in-remix](../images/solidity/remix-testnet.png)
+
+Per ora continua a usare la `Javascript VM` a meno che non ti sia detto di cambiarla. Quando distribuisci su una testnet, Metamask aprirà un pop up che
+ti chiederà di "confermare" la transazione. Premi `yes` e dopo un certo lasso
+di tempo, ti apparirà la stessa interfaccia per il contratto nella parte
+inferiore dello schermo.
\ No newline at end of file
-- 
cgit v1.2.3


From eabe2cfbcef6e212b1d2ef7af7dd3114d2534d14 Mon Sep 17 00:00:00 2001
From: Al <develop0to1@gmail.com>
Date: Mon, 18 Jul 2022 16:29:15 +0200
Subject: Translate "working on a testnet" intro

---
 it-it/solidity.html.markdown | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index 5d022c1a..c562cdb9 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -44,6 +44,39 @@ sperimentali o beta sono evidenziate e soggette a cambiamenti. Ogni Pull Request
 è ben accetta.
 
 
+## Lavorare su una testnet
+
+Distribuire e testare su una testnet è il modo più accurato per mettere alla
+prova i tuoi smart contract in Solidity. Per farlo procuriamoci prima degli ETH
+di test dalla testnet Kovan.
+
+[Entra in questo Gitter Channel](https://gitter.im/kovan-testnet/faucet) e
+scrivici l'indirizzo del tuo wallet Metamask.
+
+Sul tuo Metamask, dovrai cambiare la testnet in `Kovan`.
+
+![Solidity-in-remix](../images/solidity/metamask-kovan.png)
+
+Rivecerai degli Ethereum di test gratuiti. Per distribuire degli smart contract
+su una testnet abbiamo bisogno di Ethereum.
+
+Nell'esempio precedente non avevamo usato una testnet, ma avevamo distribuito
+su un ambiente virtuale fittizio. Quando si lavora su una testnet, possiamo
+davvero monitorare e interagire con i nostri contratti in maniera persistente.
+
+Per distribuire su una testnet, allo step `#4 Fai il deploy`, cambia
+l'`environment` selezionato in `injected web3`. In questo modo verrà usato
+come network su cui fare il deploy qualsiasi network selezionato sul tuo
+Metamask.
+
+![Solidity-in-remix](../images/solidity/remix-testnet.png)
+
+Per ora continua a usare la `Javascript VM` a meno che non ti sia detto di cambiarla. Quando distribuisci su una testnet, Metamask aprirà un pop up che
+ti chiederà di "confermare" la transazione. Premi `yes` e dopo un certo lasso
+di tempo, ti apparirà la stessa interfaccia per il contratto nella parte
+inferiore dello schermo.
+
+
 ## Lavorare su una testnet
 
 Distribuire e testare su una testnet è il modo più accurato per mettere alla
-- 
cgit v1.2.3


From c8a397d1039982ede004d9e1576eb1e4171114f9 Mon Sep 17 00:00:00 2001
From: Al <develop0to1@gmail.com>
Date: Tue, 19 Jul 2022 11:52:04 +0200
Subject: Fix wrong "working with remix and metamask" section

---
 it-it/solidity.html.markdown | 51 +++++++++++++++++++++++++-------------------
 1 file changed, 29 insertions(+), 22 deletions(-)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index c562cdb9..be8815ce 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -44,37 +44,44 @@ sperimentali o beta sono evidenziate e soggette a cambiamenti. Ogni Pull Request
 è ben accetta.
 
 
-## Lavorare su una testnet
+# Lavorare con Remix e Metamask
 
-Distribuire e testare su una testnet è il modo più accurato per mettere alla
-prova i tuoi smart contract in Solidity. Per farlo procuriamoci prima degli ETH
-di test dalla testnet Kovan.
+Uno dei modi più semplici di scrivere, distribuire e testare il codice Solidity
+è usare :
 
-[Entra in questo Gitter Channel](https://gitter.im/kovan-testnet/faucet) e
-scrivici l'indirizzo del tuo wallet Metamask.
+1. [L'ambiente di sviluppo online Remix](https://remix.ethereum.org/) 
+2. [Il wallet Metamask](https://metamask.io/).
 
-Sul tuo Metamask, dovrai cambiare la testnet in `Kovan`.
+Per cominciare, [scarichiamo l'estesione per browser di Metamask](https://metamask.io/). 
 
-![Solidity-in-remix](../images/solidity/metamask-kovan.png)
+Una volta installata, potremo iniziare ad usare Remix. Il codice seguente è
+pre-inizializzato, ma prima di addentrarci, diamo un'occhiata a qualche
+trucchetto per iniziare ad usare Remix. Carica tutto il necessario [clickando su questo link](https://remix.ethereum.org/#version=soljson-v0.6.6+commit.6c089d02.js&optimize=false&evmVersion=null&gist=f490c0d51141dd0515244db40bbd0c17&runs=200).
 
-Rivecerai degli Ethereum di test gratuiti. Per distribuire degli smart contract
-su una testnet abbiamo bisogno di Ethereum.
+1. Scegli il compilatore per Solidity
 
-Nell'esempio precedente non avevamo usato una testnet, ma avevamo distribuito
-su un ambiente virtuale fittizio. Quando si lavora su una testnet, possiamo
-davvero monitorare e interagire con i nostri contratti in maniera persistente.
+![Solidity-in-remix](../images/solidity/remix-solidity.png)
 
-Per distribuire su una testnet, allo step `#4 Fai il deploy`, cambia
-l'`environment` selezionato in `injected web3`. In questo modo verrà usato
-come network su cui fare il deploy qualsiasi network selezionato sul tuo
-Metamask.
+2. Apri il file che si caricherà su quel link
 
-![Solidity-in-remix](../images/solidity/remix-testnet.png)
+![Solidity-choose-file](../images/solidity/remix-choose-file.png)
 
-Per ora continua a usare la `Javascript VM` a meno che non ti sia detto di cambiarla. Quando distribuisci su una testnet, Metamask aprirà un pop up che
-ti chiederà di "confermare" la transazione. Premi `yes` e dopo un certo lasso
-di tempo, ti apparirà la stessa interfaccia per il contratto nella parte
-inferiore dello schermo.
+3. Compila il file
+
+![Solidity-compile](../images/solidity/remix-compile.png)
+
+4. Fai il deploy
+
+![Solidity-deploy](../images/solidity/remix-deploy.png)
+
+5. Smanetta con i contratti
+
+![Solidity-deploy](../images/solidity/remix-interact.png)
+
+Hai distribuito il tuo primo contrattto! Congratulazioni!
+
+Potrai testarlo e smanettare con le funzioni già definite. Dai un'occhiata ai
+commenti per scoprire cosa fanno.
 
 
 ## Lavorare su una testnet
-- 
cgit v1.2.3


From a7ace9ee1f468e39e9f3ffeaaa58ccd04c827a52 Mon Sep 17 00:00:00 2001
From: Al <develop0to1@gmail.com>
Date: Tue, 19 Jul 2022 11:53:03 +0200
Subject: Fix typo

---
 it-it/solidity.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index be8815ce..8eb1b537 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -97,7 +97,7 @@ Sul tuo Metamask, dovrai cambiare la testnet in `Kovan`.
 
 ![Solidity-in-remix](../images/solidity/metamask-kovan.png)
 
-Rivecerai degli Ethereum di test gratuiti. Per distribuire degli smart contract
+Riceverai degli Ethereum di test gratuiti. Per distribuire degli smart contract
 su una testnet abbiamo bisogno di Ethereum.
 
 Nell'esempio precedente non avevamo usato una testnet, ma avevamo distribuito
-- 
cgit v1.2.3


From a35979214c3d83e201e7874658c75ed598635e55 Mon Sep 17 00:00:00 2001
From: Al <develop0to1@gmail.com>
Date: Tue, 19 Jul 2022 11:54:15 +0200
Subject: Fix line length

---
 it-it/solidity.html.markdown | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index 8eb1b537..84680ba1 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -111,7 +111,8 @@ Metamask.
 
 ![Solidity-in-remix](../images/solidity/remix-testnet.png)
 
-Per ora continua a usare la `Javascript VM` a meno che non ti sia detto di cambiarla. Quando distribuisci su una testnet, Metamask aprirà un pop up che
+Per ora continua a usare la `Javascript VM` a meno che non ti sia detto di
+cambiarla. Quando distribuisci su una testnet, Metamask aprirà un pop up che
 ti chiederà di "confermare" la transazione. Premi `yes` e dopo un certo lasso
 di tempo, ti apparirà la stessa interfaccia per il contratto nella parte
 inferiore dello schermo.
\ No newline at end of file
-- 
cgit v1.2.3


From 7b47a236637e5769788bda2616cc916233531238 Mon Sep 17 00:00:00 2001
From: Al <develop0to1@gmail.com>
Date: Tue, 19 Jul 2022 12:16:02 +0200
Subject: Translate bank example

---
 it-it/solidity.html.markdown | 102 ++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 101 insertions(+), 1 deletion(-)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index 84680ba1..c08f0355 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -115,4 +115,104 @@ Per ora continua a usare la `Javascript VM` a meno che non ti sia detto di
 cambiarla. Quando distribuisci su una testnet, Metamask aprirà un pop up che
 ti chiederà di "confermare" la transazione. Premi `yes` e dopo un certo lasso
 di tempo, ti apparirà la stessa interfaccia per il contratto nella parte
-inferiore dello schermo.
\ No newline at end of file
+inferiore dello schermo.
+
+
+```javascript
+// Iniziamo con un semplice contratto su una Banca
+// Permette di depositare, prelevare e fare l'estratto conto
+
+// simple_bank.sol (nota l'estensione .sol)
+/* **** INIZIO DELL'ESEMPIO **** */
+
+// Dichiara la versione del compilatore per il file sorgente
+pragma solidity ^0.6.6;
+
+// Inizia con il commento Natspec (i tre slash)
+// viene usato per la documentazione - e per i dati descrittivi per gli elementi
+// dell'interfaccia utente / azioni
+
+/// @title SimpleBank
+/// @author nemild
+
+/* 'contract' somiglia a 'class' in altri linguaggi (ha variabili di classe,
+ereditarietà, etc.) */
+contract SimpleBank { // CapWords
+    // Dichiariamo le variabili di stato fuori dalle funzioni, persisteranno
+    // durante tutta la vita del contratto
+
+    // i dizionari mappano gli indirizzi con i saldi
+    // fai sempre attenzione agli overflow attack che sfruttano i numeri
+    mapping (address => uint) private balances;
+
+    // "private" significa che che altri contratti non possono leggere i
+    // saldi ma le informazioni restano visibili ad altri attori sulla blockchain
+
+    address public owner;
+    // 'public' lo rende leggibile dall'esterno (ma non modificabile) dagli
+    // utenti e dai contratti
+
+    // Gli 'event' pubblicano le azioni in modo che siano ascoltabili da
+    // listener esterni
+    event LogDepositMade(address accountAddress, uint amount);
+
+    // I 'constructor' possono ricevere una o più parametri; Si può
+    // dichiarare un solo costruttore
+    constructor() public {
+        // 'msg' fornisce i dettagli sul messaggio che è stato mandato al contratto
+        // 'msg.sender' è chi invoca il contratto (l'indirizzo di chi lo crea)
+        owner = msg.sender;
+    }
+
+    /// @notice Deposita ether nella banca
+    /// @return Il saldo dell'utente dopo che è stato effettualto il deposito
+    function deposit() public payable returns (uint) {
+        // Usiamo 'require' per testare gli input dell'utente, 'assert' per gli
+        // invarianti interni. Qui ci assicuriamo di non avere a che fare con
+        // un overflow
+        require((balances[msg.sender] + msg.value) >= balances[msg.sender]);
+
+        balances[msg.sender] += msg.value;
+        // Non servono "this." o "self." con le variabili di stato
+        // Tutti i valori iniziali delle variabili sono impostati automaticamente
+        // al valore di default per quel tipo di dato
+
+        emit LogDepositMade(msg.sender, msg.value); // Fa scattare l'evento
+
+        return balances[msg.sender];
+    }
+
+    /// @notice Preleva ether dalla banca
+    /// @dev Non restituisce gli ether inviati in eccesso
+    /// @param withdrawAmount L'importo che si vuole ritirare
+    /// @return remainingBal
+    function withdraw(uint withdrawAmount) public returns (uint remainingBal) {
+        require(withdrawAmount <= balances[msg.sender]);
+
+        // Notiamo come per prima cosa scaliamo i soldi dal saldo, prima di
+        // invarli. Ogni .transfer/.send in questo contratto può chiamare una 
+        // funzione esterna. Questa cosa potrebbe permettere a chi invoca la
+        // funzione di richiedere un importo maggiore del suo saldo usando
+        // una chiamata ricorsiva. Miriamo ad aggiornare lo stato prima che sia
+        // chiamata una funzione esterna, incluse .transfer/.send
+        balances[msg.sender] -= withdrawAmount;
+
+        // Qui lancia automaticamente un errore se fallisce, il che implica
+        // che il saldo (non più aggiornato) viene ripristinato a prima della
+        // transazione
+        msg.sender.transfer(withdrawAmount);
+
+        return balances[msg.sender];
+    }
+
+    /// @notice Recupera il saldo
+    /// @return Il saldo dell'utente
+    // 'view' (ex: constant) impedisce alle funzioni di modificare lo stato
+    // delle variabili; consente alle le funzioni di essere disponibili in
+    // locale/fuori dalla blockchain
+    function balance() view public returns (uint) {
+        return balances[msg.sender];
+    }
+}
+// ** FINE DELL'ESEMPIO **
+```
-- 
cgit v1.2.3


From fa5e509d43b080eb3017d53984296848d3e784cf Mon Sep 17 00:00:00 2001
From: Al <develop0to1@gmail.com>
Date: Tue, 19 Jul 2022 15:28:28 +0200
Subject: Translate solidity basics (1) section

---
 it-it/solidity.html.markdown | 118 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 118 insertions(+)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index c08f0355..5d34379e 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -215,4 +215,122 @@ contract SimpleBank { // CapWords
     }
 }
 // ** FINE DELL'ESEMPIO **
+
+
+// Passiamo alle basi di Solidity
+
+// 1. TIPI DI DATO E I LORO METODI
+// uint viene usato per gli importi in valuta (non ci sono double o float)
+// e per le date (in unix time)
+uint x;
+
+// int di 256 bit, non possono essere modificati dopo l'istanziazione
+int constant a = 8;
+int256 constant a = 8; // stesso effetto della riga prima, qui viene
+// dichiarato esplicitamente che è di 256 bit
+uint constant VERSION_ID = 0x123A1; // Una costante esadecimale
+// con 'constant', il compilatore rimpiazza ogni occorrenza con il valore
+
+// Tutte le variabili di stato (quelle fuori da una funzione)
+// sono 'interne' di default e accessibili SOLO dall'interno del contratto 
+// e da tutti contratti che le ereditano
+// Bisogna usare esplicitamente 'public' per consentire l'accesso dai contratti 
+// esterni
+int256 public a = 8;
+
+// Per int e uint possiamo esplicitamente assegnare una dimensione tra 8 e 256
+// es. int8, int16, int24
+uint8 b;
+int64 c;
+uint248 e;
+
+// Attenzione a non andare in overflow, e a proteggersi dagli attacchi che lo fanno
+// Ad esempio per quanto rigrada l'addizione, conviene fare:
+uint256 c = a + b;
+assert(c >= a); // 'assert' testa gli invarianti interni; require viene usato 
+// per gli input
+// Per altri esempi di problemi comuni con le operazioni aritmentiche, dai una
+// occhiata alla Zeppelin's SafeMath library
+// https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/math/SafeMath.sol
+
+
+// Non ci sono funzioni random built-in, puoi ottenere un numero pseudo-casuale
+// hashando l'ultimo blockhash, o ottenere un numero realmente casuale usando
+// qualcosa come Chainlink VRF. 
+// https://docs.chain.link/docs/get-a-random-number
+
+// Conversione di tipo
+int x = int(b);
+
+bool b = true; // oppure 'var b = true;' per l'inferenza di tipo
+
+// Indirizzi - contengono indirizzi Ethereum di 20 byte/160 bit
+// Non sono consentite operazioni aritmetiche
+address public owner;
+
+// Tipi di account:
+// Contract account: l'indirizzo viene impostato quando lo si crea (funzione con
+// l'indirzzo di chi lo crea, il numero della transazione inviata)
+// External Account: (persona/enitità esterna): l'indirizzo viene creato dala
+// chiave pubblica
+
+// Aggiungi il campo 'public' per indicare che è pubblico/accessibile dall'esterno
+// un getter viene creato automaticamente, ma NON un setter
+
+// Si possono mandare ether a tutti gli indirizzi
+owner.transfer(SOME_BALANCE); // fallisce e, in tal caso, ripristina
+// lo stato precedente
+
+// Possiamo anche usare la funzione di livello più basso .send, che restituisce
+// false se fallisce
+if (owner.send) {} // RICORDA: metti la send in un 'if' dato che gli indirizzi
+// usati nei contratti hanno delle funzioni, che vengono eseguite quando viene
+// fatta una send, che possono fallire
+// Inoltre fai attenzione a scalare i saldi PRIMA di provare a fare una send,
+// dato il rischio di chiamate riscorsive che potrebbero prosciugare il contratto
+
+// Possiamo controllare il saldo
+owner.balance; // il saldo del propietario (utente o contratto)
+
+
+// I Byte sono disposibili in dimensioni da 1 a 32
+byte a; // 'byte' è la stessa cosa di 'bytes1'
+bytes2 b;
+bytes32 c;
+
+// Byte con dimensione dinamica
+bytes m; // Un array particolare, la stessa cosa dell'array 'byte[]' (ma scritto stringato)
+// È più dispendioso di byte1-byte32, che di solito sono preferibili
+
+// come bytes, ma non permette di accedere alla lunghezza o all'indice (per ora)
+string n = "hello"; // salvato in UTF8, nota i doppi apici, non singoli
+// le utility function per le stringhe saranno aggiunte in futuro
+// sono preferibili bytes32/bytes, dato che UTF8 occupa più memoria
+
+// Inferenza di tipo
+// 'var' fa inferenza di tipo a seconda del primo assegnamento,
+// non può essere usata tra i parametri di una funzione
+var a = true;
+// da usare con cautela, può inferire un tipo errato
+// es. un int8 quando un contatore dev'essere un int16
+
+// var può essere usata per assegnare una funzione ad una variabile
+function a(uint x) returns (uint) {
+    return x * 2;
+}
+var f = a;
+f(22); // chiamata
+
+// di default, tutte le variabili sono impostate a 0 durante l'istanziazione
+
+
+// Delete può essere chiamato sulla maggior parte dei valori
+// (NON distrugge il valore, ma lo setta a 0, il valore did default)
+uint x = 5;
+
+
+// Destructuring/Tuple
+(x, y) = (2, 7); // assegna/scambia più valori
+
+
 ```
-- 
cgit v1.2.3


From b887c1a5f7a3dcb04a214eb154fb045056eb2688 Mon Sep 17 00:00:00 2001
From: Al <develop0to1@gmail.com>
Date: Tue, 19 Jul 2022 15:32:39 +0200
Subject: Edit translator name

---
 it-it/solidity.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index 5d34379e..3f735b3f 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -8,7 +8,7 @@ contributors:
   - ["Shooter", "https://github.com/liushooter"]
   - ["Patrick Collins", "https://gist.github.com/PatrickAlphaC"]
 translators:
-    - ["Alias", "http://github.com/al-ias"]
+    - ["Al", "http://github.com/al-ias"]
 lang: it-it
 ---
 
-- 
cgit v1.2.3


From 632cd0cd967cacdbae242811fcfe483379d984c6 Mon Sep 17 00:00:00 2001
From: Al <develop0to1@gmail.com>
Date: Wed, 20 Jul 2022 20:52:57 +0200
Subject: Translate structs (2)

---
 it-it/solidity.html.markdown | 71 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 71 insertions(+)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index 3f735b3f..2ad5b0c5 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -333,4 +333,75 @@ uint x = 5;
 (x, y) = (2, 7); // assegna/scambia più valori
 
 
+// 2. STRUTTURE DATI
+// Array
+bytes32[5] nicknames; // array statico
+bytes32[] names; // array dinamico
+uint newLength = names.push("John"); // aggiungere un elemento restituisce
+// la nuova dimensione dell'array
+// Dimesione
+names.length; // ottenere la dimensione
+names.length = 1; // la dimensione può essere assegnata (solo per gli array nello storage)
+
+// array multidimensionali
+uint[][5] x; // array con 5 array dinamici (ordine opposto rispetto ad
+// altri linguaggi)
+
+// Dizionari (da un tipo qualsiasi a un tipo qualsiasi)
+mapping (string => uint) public balances;
+balances["charles"] = 1;
+// il risultato balances["ada"] è 0, tutte le chiavi non settate 
+// restituiscono zero
+// 'public' permette che si possa fare questo da un altro contratto:
+contractName.balances("charles"); // restituisce 1
+// 'public' ha creato getter (ma non un setter), come il seguente:
+function balances(string _account) returns (uint balance) {
+    return balances[_account];
+}
+
+//  Mapping annidati
+mapping (address => mapping (address => uint)) public custodians;
+
+// Fare una delete
+delete balances["John"];
+delete balances; // assegna 0 a tutti gli elementi
+
+// Diversamente da altri linguaggi NON si può iterare tra gli elementi di un
+// mapping senza conoscere le chiavi - ma si può costruire una struttura dati a monte
+// che lo faccia
+
+// Strutture dati
+struct Bank {
+    address owner;
+    uint balance;
+}
+Bank b = Bank({
+    owner: msg.sender,
+    balance: 5
+});
+// oppure
+Bank c = Bank(msg.sender, 5);
+
+c.balance = 5; // imposta ad un nuovo valore
+delete b;
+// reimposta, imposta tutte le variabili della struttura a 0, tranne i mapping
+
+// Enumerazioni
+enum State { Created, Locked, Inactive }; // di solito si usano per le macchine di stato
+State public state; // Dichiara una variabile da un enum
+state = State.Created;
+// Le enum possono essere convertite esplicitamente in int
+uint createdState = uint(State.Created); //  0
+
+// Data location: Memory vs. storage vs. calldata - tutti i tipi complessi
+// (array, struct) hanno una data location
+// 'memory' non è persistente, 'storage' sì
+// Il default è 'storage' per varibili locali e di stato; 
+// 'memory' per i parametri delle funzioni
+// Lo stack può contenere poche varaibili locali
+
+// Per la maggior parte dei tipi, si può impostare esplicitamente
+// quale data location usare
+
+
 ```
-- 
cgit v1.2.3


From bbef62f314f35146924a98055c0f6d6ca0810533 Mon Sep 17 00:00:00 2001
From: Al <develop0to1@gmail.com>
Date: Wed, 20 Jul 2022 21:00:05 +0200
Subject: Translate simple operators (3)

---
 it-it/solidity.html.markdown | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index 2ad5b0c5..ef769345 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -404,4 +404,11 @@ uint createdState = uint(State.Created); //  0
 // quale data location usare
 
 
+// 3. Operatori semplici
+// Ci sono operatori logici, a bit e aritmetici
+// Potenza: **
+// Or esclusivo: ^
+// Negazione bitwise: ~
+
+
 ```
-- 
cgit v1.2.3


From a94c428ff9442daaf9bd94f501a7d0b491f3cc3c Mon Sep 17 00:00:00 2001
From: Al <80943867+al-ias@users.noreply.github.com>
Date: Thu, 21 Jul 2022 15:40:20 +0200
Subject: Translate global variables of note (4)

---
 it-it/solidity.html.markdown | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index ef769345..5de6a652 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -411,4 +411,38 @@ uint createdState = uint(State.Created); //  0
 // Negazione bitwise: ~
 
 
+// 4. Variabili globali degne di nota
+// ** this **
+this; // indirizzo del contratto
+// di solito si usa per trasferire il aldo rimanente altrove 
+// al termine della vita del contratto 
+this.balance;
+this.someFunction(); // invoca una funzione esterna tramite chiamata,
+// non attraverso un salto interno
+
+// ** msg - Il messaggio corrente ricevuto dal contratto **
+msg.sender; // indirizzo di chi ha inviato msg
+msg.value; // l'importo di ether forniti a questo contratto espresso in "wei",
+// la funzione dovrebbe essere marcata come "payable"
+msg.data; // in bytes, tutti gli argomenti del messaggio
+msg.gas; // 'gas' restante
+
+// ** tx - Questa transazione **
+tx.origin; // l'indirizzo di chi ha avviato questa transazione
+tx.gasprice; // il prezzo del "gas" per la transazione
+
+// ** block - Informazioni sul blocco attuale **
+now; // ora corrente (approssimatamente), alias di block.timestamp (in Unix time)
+// Da notare come può essere manipolata dai miner, quindi da usare con cautela
+
+block.number; // numero del blocco attuale
+block.difficulty; // difficulty del blocco attuale
+block.blockhash(1); // restituisce un bytes32, funziona solo per i 256 blocchi
+// più recenti
+block.gasLimit();
+
+// ** storage - Memoria persistente (in hash) **
+storage['abc'] = 'def'; // mappa da parole di 256 bit a parole di 256 bit
+
+
 ```
-- 
cgit v1.2.3


From e108748836af5f795c99937062c72fac94993f50 Mon Sep 17 00:00:00 2001
From: Al <80943867+al-ias@users.noreply.github.com>
Date: Fri, 22 Jul 2022 19:35:35 +0200
Subject: Translate function section (5.A)

---
 it-it/solidity.html.markdown | 66 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index 5de6a652..a77f7d8c 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -445,4 +445,70 @@ block.gasLimit();
 storage['abc'] = 'def'; // mappa da parole di 256 bit a parole di 256 bit
 
 
+// 4. FUNZIONI E ALTRO
+// A. Funzioni
+// Una semplice funzione
+function increment(uint x) returns (uint) {
+    x += 1;
+    return x;
+}
+
+// Le funzioni possono restituire molti valori,
+// e visto che i valori di ritorno vengono dichiarati prima
+// non è richiesta un'instruzione return esplicita
+function increment(uint x, uint y) returns (uint x, uint y) {
+    x += 1;
+    y += 1;
+}
+// Chiama la funzione di cui sopra
+uint (a,b) = increment(1,1);
+
+// 'view' (un alias di 'constant')
+// indica che la funzione non cambia / non può cambiare le variabili persistenti
+// Le funzioni definite con view vengono eseguite localmente, non sulla blockchain
+// N.B. la keyword constant sarà presto deprecata
+uint y = 1;
+
+function increment(uint x) view returns (uint x) {
+    x += 1;
+    y += 1; // questa riga fallirebbe
+    // y è una variabile di stato, e non può essere cambiata in una funzione di view
+}
+
+// 'pure' è più restrittivo di 'view' o 'constant', e non
+// permette nemmeno di leggere le varaibili di stato
+// In realtà è più complicato, per approfondire su
+// view/pure:
+// http://solidity.readthedocs.io/en/develop/contracts.html#view-functions
+
+// Modificatori di visibilità per le funzioni
+// Possono essere messi vicino a 'view' e includono:
+// public - visibile esternamente e internamente (di default per function)
+// external - visible solo esternamente (comprese le chiamate fatte con this.)
+// private - visibile slo dal contratto attuale
+// internal - visibile solo dal contratto attuale, e da quelli che ne derivano
+
+// Di solito è una buona idea marcare esplicitamente ogni funzione
+
+// Funzioni hoisted - e si può assegnare una funzione ad una variabile
+function a() {
+    var z = b;
+    b();
+}
+
+function b() {
+
+}
+
+// Tutte le funzioni che ricevono ether devono essere dichiarate come 'payable'
+function depositEther() public payable {
+    balances[msg.sender] += msg.value;
+}
+
+
+// I cicli sono da preferire alla ricorsione
+// (la profondità massima dello stack è 1024)
+// Inoltre, non impostare dei loop senza limiti,
+// perchè potresti reggiungere il limite per il gas
+
 ```
-- 
cgit v1.2.3


From 51bef478319962e26964abd36594037cf4455b07 Mon Sep 17 00:00:00 2001
From: Al <80943867+al-ias@users.noreply.github.com>
Date: Fri, 22 Jul 2022 22:01:48 +0200
Subject: Translate event section (5.B)

---
 it-it/solidity.html.markdown | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index a77f7d8c..5bf2c9e1 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -511,4 +511,40 @@ function depositEther() public payable {
 // Inoltre, non impostare dei loop senza limiti,
 // perchè potresti reggiungere il limite per il gas
 
+// B. Eventi
+// Gli eventi notificano a terze parti; è facile ispezionare e
+// accedere agli eventi al di fuori della blockchain (con client leggeri);
+// Tipicamente si dichiarano dopo i parametri del contratto
+
+// Tipicamente, sono capitalized - si usa Log come prefisso per esplicitarli
+// meglio ed evitare che si confondano con una chiamata a funzione
+
+// Dichiarazione
+event LogSent(address indexed from, address indexed to, uint amount); 
+// Da notare le prime lettere maiuscole
+
+// Chiamata
+LogSent(from, to, amount);
+
+/**
+
+Una terza parte esterna (entità o contratto), può osservare usando
+la libreria Javascript Web3:
+
+// Quel che se segue è codice Javascript, non Solidity
+Coin.LogSent().watch({}, '', function(error, result) {
+    if (!error) {
+        console.log("Trasferimento valuta: " + result.args.amount +
+            " la valuta è stata mandata da " + result.args.from +
+            " a " + result.args.to + ".");
+        console.log("I saldi ora sono:\n" +
+            "Mittente: " + Coin.balances.call(result.args.from) +
+            "Destinatario: " + Coin.balances.call(result.args.to));
+    }
+}
+**/
+
+// È prassi che un contratto dipenda da un altro (es. che dipenda
+// dai tassi di cambio forniti da un altro contratto)
+
 ```
-- 
cgit v1.2.3


From 107ff5cadf312703fadc7df0bb3c1da3a3de6fec Mon Sep 17 00:00:00 2001
From: Al <80943867+al-ias@users.noreply.github.com>
Date: Fri, 22 Jul 2022 22:27:23 +0200
Subject: Translate modifiers section (5.C)

---
 it-it/solidity.html.markdown | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index 5bf2c9e1..3ca814ac 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -547,4 +547,37 @@ Coin.LogSent().watch({}, '', function(error, result) {
 // È prassi che un contratto dipenda da un altro (es. che dipenda
 // dai tassi di cambio forniti da un altro contratto)
 
+// C. Modifier
+// I modifier validano gli input per conto dele funzioni verificando ad esempio
+// il saldo minimo o l'autenticazione dell'utente;
+// sono simili alle calusole di guardia di altri linguaggi
+
+// '_' (underscore) viene spesso posizionato nell'ultima riga del body, e indica
+// che la funzione chiamata dev'essere posizionata lì
+modifier onlyAfter(uint _time) { require (now >= _time); _; }
+modifier onlyOwner { require(msg.sender == owner) _; }
+// usate comunemente negli automi a stati finiti
+modifier onlyIfStateA (State currState) { require(currState == State.A) _; }
+
+// Si dichiarano appena dopo la definizione di una funzione
+function changeOwner(newOwner)
+onlyAfter(someTime)
+onlyOwner()
+onlyIfState(State.A)
+{
+    owner = newOwner;
+}
+
+// L'underscore può essere messo prima della fine del body,
+// ma un'istruzione di ritorno esplicita lo salterebbe,
+// quindi è da usare con cautela
+modifier checkValue(uint amount) {
+    _;
+    if (msg.value > amount) {
+        uint amountToRefund = amount - msg.value;
+        msg.sender.transfer(amountToRefund);
+    }
+}
+
+
 ```
-- 
cgit v1.2.3


From 4a60cef1899a23e4810ecdb42c7128a41cb6711d Mon Sep 17 00:00:00 2001
From: Al <80943867+al-ias@users.noreply.github.com>
Date: Sat, 23 Jul 2022 10:14:11 +0200
Subject: Transalte branching and loop section (6)

---
 it-it/solidity.html.markdown | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index 3ca814ac..e396eeb2 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -580,4 +580,32 @@ modifier checkValue(uint amount) {
 }
 
 
+// 6. ISTRUZIONI CONDIZIONALI E CICLI
+
+// Troviamo tutte le istruzioni condizionali di base - incluse if/else, for,
+// while, break, continue e return - ma non c'è lo switch
+
+// La sintassi è la stessa di javascript, ma non esiste la conversione di tipo
+// in booleano dai non booleani (bisogna usare gli operatori logici per
+// ottenere il valore boolean)
+
+// Bisogna stare attenti i loop che iterano in base al comportamento
+// dell'utente, dato che i contratti hanno un tetto massimo di gas
+// per blocco di codice e falliranno se lo superano
+// Ad esempio:
+for(uint x = 0; x < refundAddressList.length; x++) {
+    refundAddressList[x].transfer(SOME_AMOUNT);
+}
+
+// Ci sono due errori nel codice precedente:
+// 1. Un fallimento su una transfer impedisce al loop di completare tutti
+// i cicli, bloccando dei soldi;
+// 2. Questo loop potrebbe essere arbitrariamente lungo (si basa sul numero
+// degli utenti che hanno diritto al rimborso), quindi potrebbe fallire sempre
+// se supera il tetto massimo di gas per blocco;
+// Come soluzione, si potrebbe permettere agli utenti di prelevare
+// individualmente dal loro subaccount e segnare il rimborso come riscosso
+// Ad es. preferire pull payments ai push payment
+
+
 ```
-- 
cgit v1.2.3


From b7a2d1f164454e9d22a9aedc2d4ba3377ba639c8 Mon Sep 17 00:00:00 2001
From: Al <80943867+al-ias@users.noreply.github.com>
Date: Sat, 23 Jul 2022 12:54:08 +0200
Subject: Translate object/contracts section (7)

---
 it-it/solidity.html.markdown | 56 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index e396eeb2..eb46301e 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -608,4 +608,60 @@ for(uint x = 0; x < refundAddressList.length; x++) {
 // Ad es. preferire pull payments ai push payment
 
 
+// 7. OGGETTI/CONTRATTI
+
+// A. Invocare un contratto esterno
+contract InfoFeed {
+    function info() payable returns (uint ret)  { return 42; }
+}
+
+contract Consumer {
+    InfoFeed feed; // punta ad un contratto sulla blockchain
+
+    // Imposta il feed sull'istanza del contratto esistente
+    function setFeed(address addr) {
+        // fare attenzione alla conversione di tipo automatica;
+        // il costruttore non viene invocato
+        feed = InfoFeed(addr);
+    }
+
+    // Imposta il feed ad una nuova istanza del contratto
+    function createNewFeed() {
+        feed = new InfoFeed(); // viene creata una nuova istanza;
+        // viene invocato il costruttore
+    }
+
+    function callFeed() {
+        // le parentesi finali invocano il contratto, opzionalmente si può
+        // specificare un importo custom di ether o di gas
+        feed.info.value(10).gas(800)();
+    }
+}
+
+// B. ereditarietà
+
+// Conta l'ordine, l'ultimo contratto ereditato (es. 'def') può andare
+// in overriding su parti dei contratti precedentemente ereditati
+contract MyContract is abc, def("a custom argument to def") {
+
+// Funzione in overriding
+    function z() {
+        if (msg.sender == owner) {
+            def.z(); // invoca la funzione overridden da def
+            super.z(); // chiama la funzione overridden del padre
+        }
+    }
+}
+
+// Funzioni astratte
+function someAbstractFunction(uint x);
+// non possono essere compilate, vengono usate nei contratti base/astratti
+// e poi verranno implementate
+
+// C. Import
+
+import "filename";
+import "github.com/ethereum/dapp-bin/library/iterable_mapping.sol";
+
+
 ```
-- 
cgit v1.2.3


From 2a459d3a6666304d63a948bb456d75f0462ae454 Mon Sep 17 00:00:00 2001
From: Al <80943867+al-ias@users.noreply.github.com>
Date: Sat, 23 Jul 2022 13:09:49 +0200
Subject: Translate other keyword section (8)

---
 it-it/solidity.html.markdown | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index eb46301e..6fce1862 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -664,4 +664,28 @@ import "filename";
 import "github.com/ethereum/dapp-bin/library/iterable_mapping.sol";
 
 
+// 8. ALTRE KEYWORD
+
+// A. Selfdestruct
+// autodistrugge il contratto corrente, inviando i fondi ad un indirizzo
+// (di solito il creatore)
+selfdestruct(SOME_ADDRESS);
+
+// rimuove il codice e quanto in memoria dal blocco corrente e tutti i futuri blocchi
+// aiuta ad alleggerire i client, ma le informazioni precedenti continueranno
+// a persistere sulla blockchain
+
+// È un pattern comune, permette al proprietario di terminare il contratto
+// e ricevere i fondi rimasti
+function remove() {
+    if(msg.sender == creator) { // Solo il creatore del contratto può farlo
+        selfdestruct(creator); // Cessa l'attività del contratto, trasferisce i fondi
+    }
+}
+
+// Si potrebbe voler disattivare il contratto manualmente, anzichè usare una
+// selfdestruct (gli ether inviati ad un contratto dopo una selfdestruct
+// vengono persi)
+
+
 ```
-- 
cgit v1.2.3


From 0d2ba7e26fef9ce047adf9bcd2c9b3657547a095 Mon Sep 17 00:00:00 2001
From: Al <80943867+al-ias@users.noreply.github.com>
Date: Sat, 23 Jul 2022 13:34:07 +0200
Subject: Translate obfruscation section (9.A)

---
 it-it/solidity.html.markdown | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index 6fce1862..98a5da39 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -688,4 +688,18 @@ function remove() {
 // vengono persi)
 
 
+// 9. NOTE SUL DESIGN DEI CONTRATTI
+
+// A. Offruscamento
+// Tutte le variabili sono pubblicamente visibili sulla blockchain, quindi 
+// qualsiasi cosa privata ha bisogno di essere offruscata (es. hash con una
+// chiave segreta)
+
+// Passi: 1. Impegnarsi pagare una certa cifra, 2. Rivelare l'impegno preso
+keccak256("una_puntata_d_asta", "un segreto"); // impegno
+
+// in futuro, l'invocazione della funzione rivelatrice del contratto
+// mostrerà la puntata ed il segreto che produce lo SHA3
+reveal(100, "ilMioSegreto");
+
 ```
-- 
cgit v1.2.3


From 4a96407ff68f9dd46c0bbb39f59f41e16b492e0f Mon Sep 17 00:00:00 2001
From: Al <80943867+al-ias@users.noreply.github.com>
Date: Sat, 23 Jul 2022 13:54:02 +0200
Subject: Translate storage design notes section (9.B)

---
 it-it/solidity.html.markdown | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index 98a5da39..c8d97d76 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -702,4 +702,14 @@ keccak256("una_puntata_d_asta", "un segreto"); // impegno
 // mostrerà la puntata ed il segreto che produce lo SHA3
 reveal(100, "ilMioSegreto");
 
+// B. Ottimizzazione della memoria (storage)
+// Scrivere dati sulla blockchain può essere costoso visto che vengono 
+// conservati per sempre; siamo incoraggati ad usare la memoria in maniera
+// scaltra (un giorno la compilazione migliorerà, ma per ora è vantaggioso
+// pianificare le strutture dati da usare - e conservarne il minimo possibile
+// sulla blockchain)
+
+// I costi per conservare cose come array multidimensionali sono spesso alti
+// (costa conservare dati - non dichiarare variabili parzialmente vuote)
+
 ```
-- 
cgit v1.2.3


From a61887efd6d82fdf6c51b2cf8ba9d1c6c7c3b7f6 Mon Sep 17 00:00:00 2001
From: Al <80943867+al-ias@users.noreply.github.com>
Date: Sat, 23 Jul 2022 18:52:35 +0200
Subject: Translate data access in blockchain section (9.C)

---
 it-it/solidity.html.markdown | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index c8d97d76..063fbc44 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -712,4 +712,15 @@ reveal(100, "ilMioSegreto");
 // I costi per conservare cose come array multidimensionali sono spesso alti
 // (costa conservare dati - non dichiarare variabili parzialmente vuote)
 
+// C. Accesso ai dati sulla blockchain
+// Non si può impedire alle persone o ai computer di leggere il contenuto
+// o lo stato delle transazioni
+
+// Anche se 'private' non permette agli altri *contratti* di leggere alcune
+// informazioni direttamente, qualsiasi altro attore può leggere i dati
+// sulla blockchain
+
+// Tutti i dati, dall'inizio, vegono conservati sulla blockchain e
+// tutti possono accedere alle informazioni passate e ai cambiamenti futuri
+
 ```
-- 
cgit v1.2.3


From bd0a424a86c30a561709c83f17433204101c8ff8 Mon Sep 17 00:00:00 2001
From: Al <80943867+al-ias@users.noreply.github.com>
Date: Sat, 23 Jul 2022 19:51:17 +0200
Subject: Translate oracles and external data section (9.D)

---
 it-it/solidity.html.markdown | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index 063fbc44..fee7c7e0 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -723,4 +723,31 @@ reveal(100, "ilMioSegreto");
 // Tutti i dati, dall'inizio, vegono conservati sulla blockchain e
 // tutti possono accedere alle informazioni passate e ai cambiamenti futuri
 
+// D. Oracle e dati esterni
+// Gli oracle consentono di interagire con i tuoi smart contract
+// al di fuori della blockchain. 
+// Vengono usati per ricevere informazioni dal mondo reale, mandare
+// richieste post al mondo reale o vice versa.
+
+// Anche le implementazioni che sfruttano l'ora vengono fatte attraverso
+// gli oracle, visto che i contratti devono essere chiamati direttamente e
+// non possono fare una "subscribe" a un certo orario. 
+// Data la decentralizzazione degli smart contract, vorrai ricevere informazioni
+// in maniera decentralizzata, altrimenti rischi di ricreare l'accentramento
+// che la progettazione degli smart contract si prefigge di prevenire.
+
+// Il modo migliore di ottenere e usare dati decentralizzati già pronti
+// è attraverso i Chainlink Data Feeds
+// https://docs.chain.link/docs/get-the-latest-price
+// Possiamo fare riferimento a certe informazioni della blockchain
+// che sono già state aggregate da più fonti e ridistribuite on-chain,
+// usandole come "banche dati" di fonti di informazione. 
+
+// Puoi vedere altri esempi che effettuano chiamate alle API qui:
+// https://docs.chain.link/docs/make-a-http-get-request
+
+// E ovviamente puoi costruire la tua rete di orace, ma assicurati di sapere
+// quant'è accentrata o decentralizzata la tua applicazione. 
+
+// Mettere su una rete di oracle per conto tuo
 ```
-- 
cgit v1.2.3


From 118bda3ead4e3c3da913931f028d06a07eb3db19 Mon Sep 17 00:00:00 2001
From: Al <80943867+al-ias@users.noreply.github.com>
Date: Sat, 23 Jul 2022 19:59:50 +0200
Subject: Translate cron job section (9.E)

---
 it-it/solidity.html.markdown | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index fee7c7e0..55649eab 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -750,4 +750,10 @@ reveal(100, "ilMioSegreto");
 // quant'è accentrata o decentralizzata la tua applicazione. 
 
 // Mettere su una rete di oracle per conto tuo
+
+// E. Cron Job
+// I contratti devono essere chiamati manualmente per gestire la lo scheduling
+// in base all'orario; si può creare un codice esterno che li pinghi reglarmente
+//  oppure fornire degli incentivi (ether) a qualcun'altro che lo faccia
+
 ```
-- 
cgit v1.2.3


From dde96818dc33c2d49dd9ba30244244dadb38cd3b Mon Sep 17 00:00:00 2001
From: Al <80943867+al-ias@users.noreply.github.com>
Date: Sat, 23 Jul 2022 20:30:30 +0200
Subject: Translate pattern observer (9.F)

---
 it-it/solidity.html.markdown | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index 55649eab..94fb4803 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -756,4 +756,42 @@ reveal(100, "ilMioSegreto");
 // in base all'orario; si può creare un codice esterno che li pinghi reglarmente
 //  oppure fornire degli incentivi (ether) a qualcun'altro che lo faccia
 
+// F. Pattern Observer
+// Un pattern observer permette di iscriversi come osservatore e
+// registrare una funzione che verrà chiamata dall'oracle
+// (N.B. l'oracolo paga perchè sia eseguita quest'azione)
+// Ci sono alcune somoglianze nella registrazione con Pub/sub
+
+// Questo è un contratto astratto che importano sia il client che il server
+// Il client dovrebbe implementarlo
+contract SomeOracleCallback {
+    function oracleCallback(int _value, uint _time, bytes32 info) external;
+}
+
+contract SomeOracle {
+    SomeOracleCallback[] callbacks; // array di tutti gli osservatori iscritti
+
+    // Osservatori iscritti
+    function addSubscriber(SomeOracleCallback a) {
+        callbacks.push(a);
+    }
+
+    function notify(value, time, info) private {
+        for(uint i = 0;i < callbacks.length; i++) {
+            // tutti gli osservatori iscritti dovranno implementare la oracleCallback
+            callbacks[i].oracleCallback(value, time, info);
+        }
+    }
+
+    function doSomething() public {
+        // Codice che fa qualcosa
+
+        // Notifica a tutti gli iscritti
+        notify(_value, _time, _info);
+    }
+}
+
+// Il contratto client può aggiungersi agli iscritti (con addSubscriber) 
+// del contratto SomeOracle, importando SomeOracleCallback
+
 ```
-- 
cgit v1.2.3


From d0c0040f815736158d5b785ac53e6bdd6de16bc4 Mon Sep 17 00:00:00 2001
From: Al <80943867+al-ias@users.noreply.github.com>
Date: Sat, 23 Jul 2022 21:18:47 +0200
Subject: Translate state machines section (9.G)

---
 it-it/solidity.html.markdown | 147 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 147 insertions(+)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index 94fb4803..1f55546b 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -794,4 +794,151 @@ contract SomeOracle {
 // Il contratto client può aggiungersi agli iscritti (con addSubscriber) 
 // del contratto SomeOracle, importando SomeOracleCallback
 
+// G. Automi a stati finiti
+// vedi l'esempio sotto che usa enum per lo stato e il modifier inState
+```
+
+Prova l'esempio completo qui sotto [usando remix e la `Javascript VM`](https://remix.ethereum.org/#version=soljson-v0.6.6+commit.6c089d02.js&optimize=false&evmVersion=null&gist=3d12cd503dcedfcdd715ef61f786be0b&runs=200)
+
+```javascript
+// *** ESEMPIO: Un esempio di crowdfunding (molto simile a Kickstarter) ***
+// ** START EXAMPLE **
+
+// CrowdFunder.sol
+pragma solidity ^0.6.6;
+
+/// @title CrowdFunder
+/// @author nemild
+contract CrowdFunder {
+    // Variabili impostate alla creazione dal creatore
+    address public creator;
+    address payable public fundRecipient; // il creatore può essere diverso
+    // da chi riceve i fondi, che dev'essere payable
+    uint public minimumToRaise; // è richiesto per chiedere il finanziamento,
+    // altrimenti tutti ricevono un rimborso
+    string campaignUrl;
+    byte version = "1";
+
+    // Strutture dati
+    enum State {
+        Fundraising,
+        ExpiredRefund,
+        Successful
+    }
+    struct Contribution {
+        uint amount;
+        address payable contributor;
+    }
+
+    // Variabili di stato
+    State public state = State.Fundraising; // inizializzato alla creazione
+    uint public totalRaised;
+    uint public raiseBy;
+    uint public completeAt;
+    Contribution[] contributions;
+
+    event LogFundingReceived(address addr, uint amount, uint currentTotal);
+    event LogWinnerPaid(address winnerAddress);
+
+    modifier inState(State _state) {
+        require(state == _state);
+        _;
+    }
+
+    modifier isCreator() {
+        require(msg.sender == creator);
+        _;
+    }
+
+    // Aspetta 24 settimane dopo l'ultimo cambio di stato prima di consentire
+    // che in contratto venga distrutto
+    modifier atEndOfLifecycle() {
+    require(((state == State.ExpiredRefund || state == State.Successful) &&
+        completeAt + 24 weeks < now));
+        _;
+    }
+
+    function crowdFund(
+        uint timeInHoursForFundraising,
+        string memory _campaignUrl,
+        address payable _fundRecipient,
+        uint _minimumToRaise)
+        public
+    {
+        creator = msg.sender;
+        fundRecipient = _fundRecipient;
+        campaignUrl = _campaignUrl;
+        minimumToRaise = _minimumToRaise;
+        raiseBy = now + (timeInHoursForFundraising * 1 hours);
+    }
+
+    function contribute()
+    public
+    payable
+    inState(State.Fundraising)
+    returns(uint256 id)
+    {
+        contributions.push(
+            Contribution({
+                amount: msg.value,
+                contributor: msg.sender
+            }) // usiamo un array per iterare
+        );
+        totalRaised += msg.value;
+
+        emit LogFundingReceived(msg.sender, msg.value, totalRaised);
+
+        checkIfFundingCompleteOrExpired();
+        return contributions.length - 1; // restituisce l'id
+    }
+
+    function checkIfFundingCompleteOrExpired()
+    public
+    {
+        if (totalRaised > minimumToRaise) {
+            state = State.Successful;
+            payOut();
+
+            // qui si può incentivare chi ha provocato il cambiamento di stato
+        } else if ( now > raiseBy )  {
+            state = State.ExpiredRefund; // ora i finanziatori possono avere
+            // il rimborso chiamando getRefund(id)
+        }
+        completeAt = now;
+    }
+
+    function payOut()
+    public
+    inState(State.Successful)
+    {
+        fundRecipient.transfer(address(this).balance);
+        LogWinnerPaid(fundRecipient);
+    }
+
+    function getRefund(uint256 id)
+    inState(State.ExpiredRefund)
+    public
+    returns(bool)
+    {
+        require(contributions.length > id && id >= 0 && contributions[id].amount != 0 );
+
+        uint256 amountToRefund = contributions[id].amount;
+        contributions[id].amount = 0;
+
+        contributions[id].contributor.transfer(amountToRefund);
+
+        return true;
+    }
+
+    function removeContract()
+    public
+    isCreator()
+    atEndOfLifecycle()
+    {
+        selfdestruct(msg.sender);
+        // il creatore riceve tutti i fondi che non sono stati riscossi
+    }
+}
+// ** END EXAMPLE **
+
 ```
-- 
cgit v1.2.3


From 75f4c4c14393d2d800f1de129624cb31d2c55666 Mon Sep 17 00:00:00 2001
From: Al <80943867+al-ias@users.noreply.github.com>
Date: Sat, 23 Jul 2022 23:32:48 +0200
Subject: Translate other native functions (10)

---
 it-it/solidity.html.markdown | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index 1f55546b..55df471a 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -942,3 +942,35 @@ contract CrowdFunder {
 // ** END EXAMPLE **
 
 ```
+
+Qualche altra funzionalità.
+
+```javascript
+// 10. ATRE FUNZIONALITA' NATIVE
+
+// Unità di valuta
+// La valuta viene definita partendo dai wei, l'unità più piccola di Ether
+uint minAmount = 1 wei;
+uint a = 1 finney; // 1 ether == 1000 finney
+// Per altre unità, vedi: http://ether.fund/tool/converter
+
+// Unità temporali
+1 == 1 second
+1 minutes == 60 seconds
+
+// Le unità temporali si possono moltiplicare, visto che non vegono salvate
+// nelle variabili
+uint x = 5;
+(x * 1 days); // 5 giorni
+
+// Attenzione ad usare l'operatore di uguaglianza con i secondi/anni bisestili
+// (sono da preferire maggiore/minore di)
+
+// Crittografia
+// Tutte le stringhe che vengono passate vengono concatenate prima di
+// calcolare l'hash
+sha3("ab", "cd");
+ripemd160("abc");
+sha256("def");
+
+```
-- 
cgit v1.2.3


From af2ee86bcec23c3ed37a9dc3f607e34583c14b70 Mon Sep 17 00:00:00 2001
From: Al <80943867+al-ias@users.noreply.github.com>
Date: Sat, 23 Jul 2022 23:41:07 +0200
Subject: Translate security section (11)

---
 it-it/solidity.html.markdown | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index 55df471a..36e55f87 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -973,4 +973,12 @@ sha3("ab", "cd");
 ripemd160("abc");
 sha256("def");
 
+
+// 11.SICUREZZA
+
+// I bug possono essere disastrosi per i contratti Ethereum e anche 
+// i pattern comuni di Solidity potrebbero riverlarsi degli antipattern
+
+// Dai un'occhiata ai link sulla sicurezza alla fine di questo documento
+
 ```
-- 
cgit v1.2.3


From 16a8f0a12b9e0de5f8ca9c50b2fe2aa984ccd0e5 Mon Sep 17 00:00:00 2001
From: Al <80943867+al-ias@users.noreply.github.com>
Date: Sat, 23 Jul 2022 23:50:24 +0200
Subject: Translate low level functions section (12)

---
 it-it/solidity.html.markdown | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index 36e55f87..2425a40e 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -981,4 +981,15 @@ sha256("def");
 
 // Dai un'occhiata ai link sulla sicurezza alla fine di questo documento
 
+
+// 12. FUNZIONI DI BASSO LIVELLO
+// call - è di basso livello, non viene usata spesso, perchè non è type safe
+successBoolean = someContractAddress.call('function_name', 'arg1', 'arg2');
+
+// callcode - Il codice all'indirizzo target viene eseguito *contestualmente*
+// alla chiamata del contratto
+// fornisce le stesse funzionalità di una libreria
+someContractAddress.callcode('function_name');
+
+
 ```
-- 
cgit v1.2.3


From d6a94448f3341189f25184bcd4d17f74d9d0d49c Mon Sep 17 00:00:00 2001
From: Al <80943867+al-ias@users.noreply.github.com>
Date: Sat, 23 Jul 2022 23:58:34 +0200
Subject: Translate style notes section (13)

---
 it-it/solidity.html.markdown | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index 2425a40e..ee2cb807 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -992,4 +992,17 @@ successBoolean = someContractAddress.call('function_name', 'arg1', 'arg2');
 someContractAddress.callcode('function_name');
 
 
+// 13. NOTE SULLO STILE
+// Basate sulla guida allo stile PEP8 di Python
+// Guida completa allo stile: http://solidity.readthedocs.io/en/develop/style-guide.html
+
+// Riassunto veloce:
+// 4 spazi per l'indentazione
+// Due righe per separare la dichiarazione dei contratti
+// (e altre dichirazioni top level)
+// Evitare spazi ai lati interni delle parentesi tonde
+// Si possono omettere le parentesi graffe per statement monolinea (if, for, etc)
+// L'else dovrebbe essere posizionato su una riga a se
+
+
 ```
-- 
cgit v1.2.3


From 43f49745a996398237598cf993d9e0e36c59cc11 Mon Sep 17 00:00:00 2001
From: Al <80943867+al-ias@users.noreply.github.com>
Date: Sun, 24 Jul 2022 00:04:27 +0200
Subject: Translate natspec comments section (14)

---
 it-it/solidity.html.markdown | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index ee2cb807..8ec74af6 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -1004,5 +1004,18 @@ someContractAddress.callcode('function_name');
 // Si possono omettere le parentesi graffe per statement monolinea (if, for, etc)
 // L'else dovrebbe essere posizionato su una riga a se
 
+// 14. COMMENTI NATSPEC
+// usati per la documentazione, commenti e UI esterne
 
+// Natspec dei contratti - sempre sopra la definizione del contratto
+/// @title Titolo del contratto
+/// @author Nome dell'autore
+
+// Natspec delle funzioni
+/// @notice informazioni su quel che fa la funzione; mostrate quando la funzione viene eseguita
+/// @dev Documentazione della funzione per sviluppatori
+
+// Natspec dei parametri/valori di ritorno delle funzioni
+/// @param someParam Una descrizione di quel che fa il parametro
+/// @return Descrizione del valore di ritorno
 ```
-- 
cgit v1.2.3


From ff641c107ddf7a269dfa6c219b249fcb907fdf4a Mon Sep 17 00:00:00 2001
From: Al <80943867+al-ias@users.noreply.github.com>
Date: Sun, 24 Jul 2022 00:24:45 +0200
Subject: Translate links section (last one)

---
 it-it/solidity.html.markdown | 48 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index 8ec74af6..8c287727 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -1019,3 +1019,51 @@ someContractAddress.callcode('function_name');
 /// @param someParam Una descrizione di quel che fa il parametro
 /// @return Descrizione del valore di ritorno
 ```
+
+## Risorse Aggiuntive
+- [Documentazione di Solidity](https://solidity.readthedocs.org/en/latest/)
+- [Tutorial Chainlink per Principianti](https://docs.chain.link/docs/beginners-tutorial)
+- [Best Practice  per Smart Contract](https://github.com/ConsenSys/smart-contract-best-practices)
+- [Superblocks Lab - Ambiente di sviluppo su browser per Solidity](https://lab.superblocks.com/)
+- [EthFiddle - Il JsFiddle di Solidity](https://ethfiddle.com/)
+- [Solidity Editor su Browser](https://remix.ethereum.org/)
+- [Chat Room Gitter su Solidity](https://gitter.im/ethereum/solidity)
+- [Stategie di Progettazione Modulare per Contratti Ethereum](https://docs.erisindustries.com/tutorials/solidity/)
+- [Documentazione Chainlink](https://docs.chain.link/docs/getting-started)
+
+## Framework di Sviluppo per Smart Contract
+- [Hardhat](https://hardhat.org/)
+- [Brownie](https://github.com/eth-brownie/brownie)
+- [Truffle](https://www.trufflesuite.com/)
+
+## Librerie importanti
+- [Zeppelin](https://github.com/OpenZeppelin/openzeppelin-contracts): Librerie che offrono pattern comuni (crowdfuding, safemath, ecc)
+- [Chainlink](https://github.com/smartcontractkit/chainlink): Codice che permette di interagire con dati esterni
+
+## Contratti di esempio
+- [Dapp Bin](https://github.com/ethereum/dapp-bin)
+- [Esempi Defi](https://github.com/PatrickAlphaC/chainlink_defi)
+- [Solidity per Contratti a Piccoli Passi](https://github.com/fivedogit/solidity-baby-steps/tree/master/contracts)
+- [Contratti ConsenSys](https://github.com/ConsenSys/dapp-store-contracts)
+- [Lo stato delle Dapp](http://dapps.ethercasts.com/)
+
+## Sicurezza
+- [Pensando Alla Sicurezza Degli Smart Contract](https://blog.ethereum.org/2016/06/19/thinking-smart-contract-security/)
+- [Sicurezza Degli Smart Contract](https://blog.ethereum.org/2016/06/10/smart-contract-security/)
+- [Blog Distribuito di Hacking](http://hackingdistributed.com/)
+
+## Stile
+- [Guida allo Stile di Solidity](http://solidity.readthedocs.io/en/latest/style-guide.html): La guida allo stile di Ethereum deriva in gran parte dalla guida allo stile [PEP 8](https://www.python.org/dev/peps/pep-0008/) di Python.
+
+## Editor
+- [Remix](https://remix.ethereum.org/)
+- [Emacs Modalità Solidity](https://github.com/ethereum/emacs-solidity)
+- [Vim Solidity](https://github.com/tomlion/vim-solidity)
+- Snippet per gli Editor ([Ultisnips format](https://gist.github.com/nemild/98343ce6b16b747788bc))
+
+## Cose da fare in futuro
+- Nuove keyword: protected, inheritable
+- Lista dei design pattern comuni (throttling, RNG, upgrade di versione)
+-Anti patterns comuni sulla sicurezza
+
+Sentiti libero di mandare una pull request con qualsiasi modifica - o scrivi una mail a nemild -/at-/ gmail
-- 
cgit v1.2.3


From ae73cdf65d7bf151928556a990467db11167fdb9 Mon Sep 17 00:00:00 2001
From: Al <80943867+al-ias@users.noreply.github.com>
Date: Sun, 24 Jul 2022 12:19:16 +0200
Subject: Fix typos

---
 it-it/solidity.html.markdown | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index 8c287727..f397ec5f 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -78,7 +78,7 @@ trucchetto per iniziare ad usare Remix. Carica tutto il necessario [clickando su
 
 ![Solidity-deploy](../images/solidity/remix-interact.png)
 
-Hai distribuito il tuo primo contrattto! Congratulazioni!
+Hai distribuito il tuo primo contratto! Congratulazioni!
 
 Potrai testarlo e smanettare con le funzioni già definite. Dai un'occhiata ai
 commenti per scoprire cosa fanno.
@@ -156,7 +156,7 @@ contract SimpleBank { // CapWords
     // listener esterni
     event LogDepositMade(address accountAddress, uint amount);
 
-    // I 'constructor' possono ricevere una o più parametri; Si può
+    // I 'constructor' possono ricevere uno o più parametri; Si può
     // dichiarare un solo costruttore
     constructor() public {
         // 'msg' fornisce i dettagli sul messaggio che è stato mandato al contratto
@@ -271,7 +271,7 @@ address public owner;
 // Tipi di account:
 // Contract account: l'indirizzo viene impostato quando lo si crea (funzione con
 // l'indirzzo di chi lo crea, il numero della transazione inviata)
-// External Account: (persona/enitità esterna): l'indirizzo viene creato dala
+// External Account: (persona/enitità esterna): l'indirizzo viene creato dalla
 // chiave pubblica
 
 // Aggiungi il campo 'public' per indicare che è pubblico/accessibile dall'esterno
@@ -485,7 +485,7 @@ function increment(uint x) view returns (uint x) {
 // Possono essere messi vicino a 'view' e includono:
 // public - visibile esternamente e internamente (di default per function)
 // external - visible solo esternamente (comprese le chiamate fatte con this.)
-// private - visibile slo dal contratto attuale
+// private - visibile solo dal contratto attuale
 // internal - visibile solo dal contratto attuale, e da quelli che ne derivano
 
 // Di solito è una buona idea marcare esplicitamente ogni funzione
@@ -509,7 +509,7 @@ function depositEther() public payable {
 // I cicli sono da preferire alla ricorsione
 // (la profondità massima dello stack è 1024)
 // Inoltre, non impostare dei loop senza limiti,
-// perchè potresti reggiungere il limite per il gas
+// perchè potresti raggiungere il limite per il gas
 
 // B. Eventi
 // Gli eventi notificano a terze parti; è facile ispezionare e
@@ -752,7 +752,7 @@ reveal(100, "ilMioSegreto");
 // Mettere su una rete di oracle per conto tuo
 
 // E. Cron Job
-// I contratti devono essere chiamati manualmente per gestire la lo scheduling
+// I contratti devono essere chiamati manualmente per gestire lo scheduling
 // in base all'orario; si può creare un codice esterno che li pinghi reglarmente
 //  oppure fornire degli incentivi (ether) a qualcun'altro che lo faccia
 
-- 
cgit v1.2.3


From 39e0b12b1545b06c7359b544790e423550b5cf13 Mon Sep 17 00:00:00 2001
From: Al <80943867+al-ias@users.noreply.github.com>
Date: Sun, 24 Jul 2022 12:24:04 +0200
Subject: Improve translation and readability

---
 it-it/solidity.html.markdown | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index f397ec5f..eb72ec90 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -35,7 +35,7 @@ BLOG DI ETHEREUM PER TENERSI AGGIORNATI. TUTTO IL CODICE QUI PRESENTE E' FORNITO
 COSÌ COM'È, CON ANNESSI RISCHI SOSTANZIALI DI ERRORI O PATTERN DI PROGRAMMAZIONE
 DEPRECATI. 
 
-A differenza di altri tipi di codice, potresti aver bisogno di usare pattern di
+A differenza di altri linguaggi, potresti aver bisogno di usare pattern di
 pausing, deprecation e throttling usage per ridurre il rischio. Questo documento
 tratta principalmene la sintassi e quindi esclude molti design pattern in voga.
 
@@ -97,8 +97,8 @@ Sul tuo Metamask, dovrai cambiare la testnet in `Kovan`.
 
 ![Solidity-in-remix](../images/solidity/metamask-kovan.png)
 
-Riceverai degli Ethereum di test gratuiti. Per distribuire degli smart contract
-su una testnet abbiamo bisogno di Ethereum.
+Riceverai degli Ethereum di test gratuiti. Abbiamo bisogno di Ethereum per
+distribuire degli smart contract su una testnet.
 
 Nell'esempio precedente non avevamo usato una testnet, ma avevamo distribuito
 su un ambiente virtuale fittizio. Quando si lavora su una testnet, possiamo
@@ -244,7 +244,7 @@ uint8 b;
 int64 c;
 uint248 e;
 
-// Attenzione a non andare in overflow, e a proteggersi dagli attacchi che lo fanno
+// Attenzione a non andare in overflow e a proteggersi dagli attacchi che lo fanno
 // Ad esempio per quanto rigrada l'addizione, conviene fare:
 uint256 c = a + b;
 assert(c >= a); // 'assert' testa gli invarianti interni; require viene usato 
@@ -285,7 +285,7 @@ owner.transfer(SOME_BALANCE); // fallisce e, in tal caso, ripristina
 // false se fallisce
 if (owner.send) {} // RICORDA: metti la send in un 'if' dato che gli indirizzi
 // usati nei contratti hanno delle funzioni, che vengono eseguite quando viene
-// fatta una send, che possono fallire
+// fatta una send, che possono fallire.
 // Inoltre fai attenzione a scalare i saldi PRIMA di provare a fare una send,
 // dato il rischio di chiamate riscorsive che potrebbero prosciugare il contratto
 
@@ -387,7 +387,7 @@ delete b;
 // reimposta, imposta tutte le variabili della struttura a 0, tranne i mapping
 
 // Enumerazioni
-enum State { Created, Locked, Inactive }; // di solito si usano per le macchine di stato
+enum State { Created, Locked, Inactive }; // di solito si usano per gli automi a stati finiti
 State public state; // Dichiara una variabile da un enum
 state = State.Created;
 // Le enum possono essere convertite esplicitamente in int
@@ -414,7 +414,7 @@ uint createdState = uint(State.Created); //  0
 // 4. Variabili globali degne di nota
 // ** this **
 this; // indirizzo del contratto
-// di solito si usa per trasferire il aldo rimanente altrove 
+// di solito si usa per trasferire altrove il saldo rimanente 
 // al termine della vita del contratto 
 this.balance;
 this.someFunction(); // invoca una funzione esterna tramite chiamata,
@@ -490,7 +490,7 @@ function increment(uint x) view returns (uint x) {
 
 // Di solito è una buona idea marcare esplicitamente ogni funzione
 
-// Funzioni hoisted - e si può assegnare una funzione ad una variabile
+// Le funzioni sono hoisted e si può assegnare una funzione ad una variabile
 function a() {
     var z = b;
     b();
@@ -603,7 +603,7 @@ for(uint x = 0; x < refundAddressList.length; x++) {
 // 2. Questo loop potrebbe essere arbitrariamente lungo (si basa sul numero
 // degli utenti che hanno diritto al rimborso), quindi potrebbe fallire sempre
 // se supera il tetto massimo di gas per blocco;
-// Come soluzione, si potrebbe permettere agli utenti di prelevare
+// Come soluzione, si permette agli utenti di prelevare
 // individualmente dal loro subaccount e segnare il rimborso come riscosso
 // Ad es. preferire pull payments ai push payment
 
@@ -671,7 +671,7 @@ import "github.com/ethereum/dapp-bin/library/iterable_mapping.sol";
 // (di solito il creatore)
 selfdestruct(SOME_ADDRESS);
 
-// rimuove il codice e quanto in memoria dal blocco corrente e tutti i futuri blocchi
+// rimuove il codice e quanto in memoria dal blocco corrente e da tutti i blocchi futuri
 // aiuta ad alleggerire i client, ma le informazioni precedenti continueranno
 // a persistere sulla blockchain
 
@@ -692,14 +692,14 @@ function remove() {
 
 // A. Offruscamento
 // Tutte le variabili sono pubblicamente visibili sulla blockchain, quindi 
-// qualsiasi cosa privata ha bisogno di essere offruscata (es. hash con una
+// qualsiasi informazione privata ha bisogno di essere offruscata (es. hash con una
 // chiave segreta)
 
 // Passi: 1. Impegnarsi pagare una certa cifra, 2. Rivelare l'impegno preso
 keccak256("una_puntata_d_asta", "un segreto"); // impegno
 
 // in futuro, l'invocazione della funzione rivelatrice del contratto
-// mostrerà la puntata ed il segreto che produce lo SHA3
+// mostrerà la puntata con il segreto che produce lo SHA3
 reveal(100, "ilMioSegreto");
 
 // B. Ottimizzazione della memoria (storage)
@@ -717,7 +717,7 @@ reveal(100, "ilMioSegreto");
 // o lo stato delle transazioni
 
 // Anche se 'private' non permette agli altri *contratti* di leggere alcune
-// informazioni direttamente, qualsiasi altro attore può leggere i dati
+// informazioni direttamente, qualsiasi altro attore può leggerle
 // sulla blockchain
 
 // Tutti i dati, dall'inizio, vegono conservati sulla blockchain e
-- 
cgit v1.2.3


From d96db0f0e4057ee9a52c3713976bec6990f10bd2 Mon Sep 17 00:00:00 2001
From: Al <80943867+al-ias@users.noreply.github.com>
Date: Sun, 24 Jul 2022 18:53:07 +0200
Subject: Update filename

Co-authored-by: Marcel Ribeiro Dantas, Ph.D. <ribeirodantasdm@gmail.com>
---
 it-it/solidity.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
index eb72ec90..be747e68 100644
--- a/it-it/solidity.html.markdown
+++ b/it-it/solidity.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: Solidity
-filename: learnSolidity.sol
+filename: learnSolidity-it.sol
 contributors:
   - ["Nemil Dalal", "https://www.nemil.com"]
   - ["Joseph Chow", ""]
-- 
cgit v1.2.3