```
-
-Ora siamo pronti a configurare il nostro endpoint Alchemy Web3 nella nostra dapp! Torniamo al nostro `interact.js`, che è contenuto nella cartella `util` e aggiungiamo il seguente codice all'inizio del file:
-
-
+Ora siamo pronti a configurare il nostro endpoint Alchemy Web3 nella nostra dApp! Torniamo al nostro `interact.js`, che è annidato nella nostra cartella `util`, e aggiungiamo il seguente codice all'inizio del file:
```javascript
// interact.js
@@ -1023,33 +933,26 @@ const alchemyKey = process.env.REACT_APP_ALCHEMY_KEY
const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
const web3 = createAlchemyWeb3(alchemyKey)
-//export const helloWorldContract;
+//esporta const helloWorldContract;
```
-
-Sopra, abbiamo prima importato la chiave Alchemy dal nostro file `.env` e poi passato la nostra `alchemyKey` a `createAlchemyWeb3` per stabilire il nostro endpoint di Alchemy Web3.
+Sopra, abbiamo prima importato la chiave Alchemy dal nostro file `.env` e poi passato la nostra `alchemyKey` a `createAlchemyWeb3` per stabilire il nostro endpoint Alchemy Web3.
Con questo endpoint pronto, è il momento di caricare il nostro contratto intelligente!
+#### Caricamento del tuo contratto intelligente Hello World {#loading-your-hello-world-smart-contract}
-
-#### Caricare il proprio contratto intelligente Hello World {#loading-your-hello-world-smart-contract}
-
-Per caricare il tuo contratto intelligente Hello World, sono necessari l'indirizzo e l'ABI del contratto, entrambi reperibili su Etherscan se hai completato la [Parte 3 di questo tutorial.](/developers/tutorials/hello-world-smart-contract-fullstack/#part-3-publish-your-smart-contract-to-etherscan-part-3-publish-your-smart-contract-to-etherscan)
-
-
+Per caricare il tuo contratto intelligente Hello World, avrai bisogno del suo indirizzo e della sua ABI, entrambi reperibili su Etherscan se hai completato la [Parte 3 di questo tutorial](/developers/tutorials/hello-world-smart-contract-fullstack/#part-3-publish-your-smart-contract-to-etherscan-part-3-publish-your-smart-contract-to-etherscan).
#### Come ottenere l'ABI del tuo contratto da Etherscan {#how-to-get-your-contract-abi-from-etherscan}
-Se hai saltato la Parte 3 di questo tutorial, puoi usare il contratto HelloWorld con l'indirizzo [0x6f3f635A9762B47954229Ea479b4541eAF402A6A](https://goerli.etherscan.io/address/0x6f3f635a9762b47954229ea479b4541eaf402a6a#code). La sua ABI si trova [qui](https://goerli.etherscan.io/address/0x6f3f635a9762b47954229ea479b4541eaf402a6a#code).
+Se hai saltato la Parte 3 di questo tutorial, puoi usare il contratto HelloWorld con l'indirizzo [0x6f3f635A9762B47954229Ea479b4541eAF402A6A](https://goerli.etherscan.io/address/0x6f3f635a9762b47954229ea479b4541eaf402a6a#code). La sua ABI può essere trovata [qui](https://goerli.etherscan.io/address/0x6f3f635a9762b47954229ea479b4541eaf402a6a#code).
-L'ABI di un contratto serve per specificare quale funzione invocherà un contratto, oltre che per garantire che la funzione restituirà i dati nel formato previsto. Una volta copiata la ABI del nostro contratto, salviamola come file JSON chiamato `contract-abi.json` nella cartella `src`.
-
-Il file contract-abi.json deve essere memorizzato nella cartella src.
-
-Con l'indirizzo del contratto, l'ABI e l'endpoint di Alchemy Web3, possiamo usare il [metodo del contratto](https://docs.web3js.org/api/web3-eth-contract/class/Contract) per caricare un'istanza del nostro contratto intelligente. Importa la ABI del contratto nel file `interact.js` e aggiungi l'indirizzo del tuo contratto.
+L'ABI di un contratto è necessaria per specificare quale funzione un contratto invocherà, oltre a garantire che la funzione restituirà i dati nel formato previsto. Una volta copiata l'ABI del nostro contratto, salviamola come file JSON chiamato `contract-abi.json` nella tua directory `src`.
+Il tuo contract-abi.json dovrebbe essere salvato nella tua cartella src.
+Armati dell'indirizzo del nostro contratto, dell'ABI e dell'endpoint di Alchemy Web3, possiamo usare il [metodo `contract`](https://docs.web3js.org/api/web3-eth-contract/class/Contract) per caricare un'istanza del nostro contratto intelligente. Importa l'ABI del tuo contratto nel file `interact.js` e aggiungi l'indirizzo del tuo contratto.
```javascript
// interact.js
@@ -1058,10 +961,7 @@ const contractABI = require("../contract-abi.json")
const contractAddress = "0x6f3f635A9762B47954229Ea479b4541eAF402A6A"
```
-
-Ora possiamo finalmente eliminare il commento dalla nostra variabile `helloWorldContract` e caricare il contratto intelligente usando il nostro endpoint di AlchemyWeb3:
-
-
+Possiamo ora finalmente rimuovere il commento dalla nostra variabile `helloWorldContract` e caricare il contratto intelligente usando il nostro endpoint AlchemyWeb3:
```javascript
// interact.js
@@ -1071,10 +971,7 @@ export const helloWorldContract = new web3.eth.Contract(
)
```
-
-Ricapitolando, le prime 12 righe del file `interact.js` dovrebbero avere questo aspetto:
-
-
+Per ricapitolare, le prime 12 righe del tuo `interact.js` dovrebbero ora avere questo aspetto:
```javascript
// interact.js
@@ -1093,19 +990,14 @@ export const helloWorldContract = new web3.eth.Contract(
)
```
+Ora che il nostro contratto è caricato, possiamo implementare la nostra funzione `loadCurrentMessage`!
-Ora che il nostro contratto è stato caricato, possiamo implementare la nostra funzione `loadCurrentMessage`!
-
+#### Implementazione di `loadCurrentMessage` nel tuo file `interact.js` {#implementing-loadCurrentMessage-in-your-interact-js-file}
-
-#### Implementare `loadCurrentMessage` nel proprio file `interact.js` {#implementing-loadCurrentMessage-in-your-interact-js-file}
-
-Questa funzione è semplicissima. Faremo una semplice invocazione asincrona web3 per leggere dal nostro contratto. La nostra funzione restituirà il messaggio memorizzato nel contratto intelligente:
+Questa funzione è semplicissima. Faremo una semplice chiamata asincrona web3 per leggere dal nostro contratto. La nostra funzione restituirà il messaggio memorizzato nel contratto intelligente:
Aggiorna `loadCurrentMessage` nel tuo file `interact.js` come segue:
-
-
```javascript
// interact.js
@@ -1115,70 +1007,60 @@ export const loadCurrentMessage = async () => {
}
```
-
Poiché vogliamo visualizzare questo contratto intelligente nella nostra interfaccia utente, aggiorniamo la funzione `useEffect` nel nostro componente `HelloWorld.js` come segue:
-
-
```javascript
// HelloWorld.js
-//called only once
+//chiamato solo una volta
useEffect(async () => {
const message = await loadCurrentMessage()
setMessage(message)
}, [])
```
+Nota che vogliamo che il nostro `loadCurrentMessage` sia chiamato solo una volta durante il primo rendering del componente. Presto implementeremo `addSmartContractListener` per aggiornare automaticamente l'interfaccia utente dopo che il messaggio del contratto intelligente cambia.
-Si noti che vogliamo che il nostro `loadCurrentMessage` sia chiamato solo una volta durante il primo rendering del componente. Presto implementeremo `addSmartContractListener` per aggiornare automaticamente l'interfaccia utente dopo che il messaggio del contratto intelligente cambia.
-
-Prima di addentrarci nel nostro listener, diamo un'occhiata a ciò che abbiamo finora! Salva i file `HelloWorld.js` e `interact.js`, quindi vai su [http://localhost:3000/](http://localhost:3000/)
+Prima di addentrarci nel nostro listener, diamo un'occhiata a ciò che abbiamo finora! Salva i tuoi file `HelloWorld.js` e `interact.js`, e poi vai su [http://localhost:3000/](http://localhost:3000/)
Noterai che il messaggio corrente non dice più "Nessuna connessione alla rete". Riflette invece il messaggio memorizzato nel contratto intelligente. Pazzesco!
-
-
-#### L'interfaccia utente dovrebbe ora riflettere il messaggio memorizzato nel contratto intelligente {#your-UI-should-now-reflect-the-message-stored-in-the-smart-contract}
+#### La tua UI dovrebbe ora riflettere il messaggio memorizzato nel contratto intelligente {#your-UI-should-now-reflect-the-message-stored-in-the-smart-contract}
Ora, parlando di quel listener...
-
-
#### Implementa `addSmartContractListener` {#implement-addsmartcontractlistener}
-Se ripensi al file `HelloWorld.sol` che abbiamo scritto nella [Parte 1 di questa serie di tutorial](https://docs.alchemy.com/alchemy/tutorials/hello-world-smart-contract#step-10-write-our-contract), ricorderai che c'è un evento del contratto intelligente chiamato `UpdatedMessages` che viene emesso dopo aver invocato la funzione `update` del nostro contratto intelligente \(vedi righe 9 e 27\):
-
-
+Se ripensi al file `HelloWorld.sol` che abbiamo scritto nella [Parte 1 di questa serie di tutorial](https://docs.alchemy.com/alchemy/tutorials/hello-world-smart-contract#step-10-write-our-contract), ricorderai che c'è un evento del contratto intelligente chiamato `UpdatedMessages` che viene emesso dopo aver invocato la funzione `update` del nostro contratto intelligente (vedi righe 9 e 27):
```javascript
// HelloWorld.sol
-// Specifies the version of Solidity, using semantic versioning.
-// Learn more: https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma
+// Specifica la versione di Solidity, usando il versioning semantico.
+// Per saperne di più: https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma
pragma solidity ^0.7.3;
-// Defines a contract named `HelloWorld`.
-// Un contratto è una raccolta di funzioni e dati (il suo stato). Once deployed, a contract resides at a specific address on the Ethereum blockchain. Learn more: https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html
+// Definisce un contratto chiamato `HelloWorld`.
+// Un contratto è una raccolta di funzioni e dati (il suo stato). Una volta distribuito, un contratto risiede a un indirizzo specifico sulla blockchain di Ethereum. Per saperne di più: https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html
contract HelloWorld {
- //Emitted when update function is called
- //Smart contract events are a way for your contract to communicate that something happened on the blockchain to your app front-end, which can be 'listening' for certain events and take action when they happen.
+ //Emesso quando viene chiamata la funzione di aggiornamento
+ //Gli eventi dei contratti intelligenti sono un modo per il tuo contratto di comunicare che qualcosa è accaduto sulla blockchain alla tua app front-end, che può essere 'in ascolto' di determinati eventi e agire di conseguenza.
event UpdatedMessages(string oldStr, string newStr);
- // Declares a state variable `message` of type `string`.
- // Le variabili di stato sono variabili con valori memorizzati in modo permanente nello spazio di archiviazione (storage) del contratto. The keyword `public` makes variables accessible from outside a contract and creates a function that other contracts or clients can call to access the value.
+ // Dichiara una variabile di stato `message` di tipo `string`.
+ // Le variabili di stato sono variabili i cui valori sono memorizzati in modo permanente nella memoria del contratto. La parola chiave `public` rende le variabili accessibili dall'esterno di un contratto e crea una funzione che altri contratti o client possono chiamare per accedere al valore.
string public message;
- // Similar to many class-based object-oriented languages, a constructor is a special function that is only executed upon contract creation.
- // I costruttori sono utilizzati per inizializzare i dati del contratto. Learn more:https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors
+ // Simile a molti linguaggi orientati agli oggetti basati su classi, un costruttore è una funzione speciale che viene eseguita solo alla creazione del contratto.
+ // I costruttori sono usati per inizializzare i dati del contratto. Per saperne di più:https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors
constructor(string memory initMessage) {
- // Accepts a string argument `initMessage` and sets the value into the contract's `message` storage variable).
+ // Accetta un argomento stringa `initMessage` e imposta il valore nella variabile di archiviazione `message` del contratto).
message = initMessage;
}
- // A public function that accepts a string argument and updates the `message` storage variable.
+ // Una funzione pubblica che accetta un argomento stringa e aggiorna la variabile di archiviazione `message`.
function update(string memory newMessage) public {
string memory oldMsg = message;
message = newMessage;
@@ -1187,15 +1069,12 @@ contract HelloWorld {
}
```
+Gli eventi del contratto intelligente sono un modo per il contratto di comunicare che è successo qualcosa (cioè che c'è stato un _evento_) sulla blockchain alla tua applicazione front-end, che può essere 'in ascolto' di eventi specifici e agire quando si verificano.
-Gli eventi del contratto intelligente sono un modo per il contratto di comunicare che è successo qualcosa (cioè che c'è stato un _evento_) sulla blockchain alla tua applicazione front-end, che può essere "in ascolto" per eventi specifici e agire quando si verificano.
-
-La funzione `addSmartContractListener` sarà in ascolto specificamente per l'evento `UpdatedMessages` del nostro contratto intelligente Hello World e aggiornerà l'interfaccia utente per visualizzare il nuovo messaggio.
+La funzione `addSmartContractListener` sarà specificamente in ascolto dell'evento `UpdatedMessages` del nostro contratto intelligente Hello World, e aggiornerà la nostra interfaccia utente per visualizzare il nuovo messaggio.
Modifica `addSmartContractListener` come segue:
-
-
```javascript
// HelloWorld.js
@@ -1206,21 +1085,18 @@ function addSmartContractListener() {
} else {
setMessage(data.returnValues[1])
setNewMessage("")
- setStatus("🎉 Your message has been updated!")
+ setStatus("🎉 Il tuo messaggio è stato aggiornato!")
}
})
}
```
-
Analizziamo cosa succede quando il listener rileva un evento:
-- Se si verifica un errore quando viene emesso l'evento, questo si rifletterà nell'interfaccia utente tramite la variabile di stato `status`.
-- Altrimenti, si utilizzerà l'oggetto `data` restituito. `data.returnValues` è un array indicizzato a zero in cui il primo elemento dell'array memorizza il messaggio precedente e il secondo quello aggiornato. Complessivamente, in caso di evento concluso con successo, imposteremo la stringa `message` con il messaggio aggiornato, cancelleremo la stringa `newMessage` e aggiorneremo la variabile di stato `status` per rispecchiare il fatto che un nuovo messaggio è stato pubblicato sul nostro contratto intelligente.
-
-Infine, chiamiamo il nostro listener nella funzione `useEffect`, in modo che venga inizializzato al primo rendering del componente `HelloWorld.js`. Complessivamente, la funzione `useEffect` dovrebbe avere questo aspetto:
-
+- Se si verifica un errore quando viene emesso l'evento, questo si rifletterà nell'interfaccia utente tramite la nostra variabile di stato `status`.
+- Altrimenti, useremo l'oggetto `data` restituito. `data.returnValues` è un array indicizzato a zero in cui il primo elemento dell'array memorizza il messaggio precedente e il secondo elemento quello aggiornato. Complessivamente, in caso di evento concluso con successo, imposteremo la nostra stringa `message` con il messaggio aggiornato, cancelleremo la stringa `newMessage` e aggiorneremo la nostra variabile di stato `status` per riflettere il fatto che un nuovo messaggio è stato pubblicato sul nostro contratto intelligente.
+Infine, chiamiamo il nostro listener nella nostra funzione `useEffect` in modo che sia inizializzato al primo rendering del componente `HelloWorld.js`. Complessivamente, la tua funzione `useEffect` dovrebbe avere questo aspetto:
```javascript
// HelloWorld.js
@@ -1232,64 +1108,46 @@ useEffect(async () => {
}, [])
```
+Ora che siamo in grado di leggere dal nostro contratto intelligente, sarebbe bello capire anche come scrivergli! Tuttavia, per scrivere sulla nostra dApp, dobbiamo prima avere un portafoglio Ethereum collegato ad essa.
-Ora che siamo in grado di leggere dal nostro contratto intelligente, sarebbe bello anche capire come scrivergli! Tuttavia, per scrivere alla nostra dapp, dobbiamo prima avere un portafoglio di Ethereum collegato ad essa.
-
-Quindi, ora ci occuperemo di configurare il nostro portafoglio di Ethereum (MetaMask) e di collegarlo alla nostra dapp!
-
-
-
-### Fase 4: configura il tuo portafoglio di Ethereum {#step-4-set-up-your-ethereum-wallet}
+Quindi, ora ci occuperemo di configurare il nostro portafoglio Ethereum (MetaMask) e di collegarlo alla nostra dApp!
-Per scrivere qualsiasi cosa nella catena di Ethereum, gli utenti devono firmare le transazioni utilizzando le chiavi private del proprio portafoglio virtuale. Per questo tutorial, utilizzeremo [MetaMask](https://metamask.io/), un portafoglio virtuale nel browser utilizzato per gestire l'indirizzo del conto di Ethereum, in quanto rende la firma delle transazioni molto semplice per l'utente finale.
-
-Se vuoi capire di più su come funzionano le transazioni su Ethereum, dai un'occhiata a [questa pagina](/developers/docs/transactions/) della Ethereum Foundation.
+### Passaggio 4: Configura il tuo portafoglio Ethereum {#step-4-set-up-your-ethereum-wallet}
+Per scrivere qualsiasi cosa sulla chain di Ethereum, gli utenti devono firmare le transazioni utilizzando le chiavi private del proprio portafoglio virtuale. Per questo tutorial, utilizzeremo [MetaMask](https://metamask.io/), un portafoglio virtuale nel browser utilizzato per gestire l'indirizzo del tuo account Ethereum, poiché rende la firma delle transazioni estremamente semplice per l'utente finale.
+Se vuoi saperne di più su come funzionano le transazioni su Ethereum, consulta [questa pagina](/developers/docs/transactions/) della Ethereum Foundation.
#### Scarica MetaMask {#download-metamask}
-Puoi scaricare e creare gratuitamente un conto di MetaMask [qui](https://metamask.io/download). Quando crei un conto, o se ne possiedi già uno, assicurati di passare alla "rete di prova di Goerli" in alto a destra \(così da non avere a che fare con denaro reale\).
-
-
-
-#### Aggiungere ether da un Faucet {#add-ether-from-a-faucet}
-
-Per firmare una transazione sulla blockchain di Ethereum, abbiamo bisogno di un po' di Eth finti. Per ottenere Eth puoi andare su [FaucETH](https://fauceth.komputing.org) e inserire l'indirizzo del tuo conto di Goerli, cliccare su "Richiedi fondi", quindi selezionare "Rete di prova di Ethereum di Goerli" nel menu a discesa e infine fare clic di nuovo su "Richiedi fondi". Poco dopo, dovresti vedere gli Eth nel tuo conto di MetaMask!
-
+Puoi scaricare e creare un account MetaMask gratuitamente [qui](https://metamask.io/download). Quando crei un account, o se ne hai già uno, assicurati di passare alla “Rete di test Goerli” in alto a destra (in modo da non usare soldi veri).
+#### Aggiungi ether da un Faucet {#add-ether-from-a-faucet}
-#### Verifica il tuo saldo {#check-your-balance}
-
-Per ricontrollare che ci sia il saldo, facciamo una richiesta [eth_getBalance](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_getbalance) usando lo [strumento compositore di Alchemy](https://composer.alchemyapi.io/?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D). Questo restituirà l'importo di Eth nel tuo portafoglio. Dopo aver inserito l'indirizzo del tuo conto di MetaMask e aver cliccato “Invia richiesta”, dovresti vedere una risposta come questa:
+Per firmare una transazione sulla blockchain di Ethereum, avremo bisogno di Eth finti. Per ottenere Eth puoi andare su [FaucETH](https://fauceth.komputing.org) e inserire l'indirizzo del tuo account Goerli, fare clic su “Richiedi fondi”, quindi selezionare “Rete di test Goerli di Ethereum” nel menu a tendina e infine fare clic di nuovo sul pulsante “Richiedi fondi”. Poco dopo, dovresti vedere gli Eth nel tuo conto di MetaMask!
+#### Controlla il tuo saldo {#check-your-balance}
+Per verificare che il nostro saldo sia presente, effettuiamo una richiesta [eth_getBalance](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_getbalance) usando lo [strumento compositore di Alchemy](https://composer.alchemyapi.io/?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D). Questo restituirà l'importo di Eth nel tuo portafoglio. Dopo aver inserito l'indirizzo del tuo conto di MetaMask e aver cliccato "Invia Richiesta", dovresti visualizzare una risposta simile alla seguente:
```text
{"jsonrpc": "2.0", "id": 0, "result": "0xde0b6b3a7640000"}
```
-
-**NOTA:** Questo risultato è in wei non in eth. Wei è usato come taglio più piccolo dell'ether. La conversione da wei a eth è: 1 eth = 10¹⁸ wei. Quindi se convertiamo 0xde0b6b3a7640000 in decimali, otteniamo 1\*10¹⁸, pari a 1 eth.
+**NOTA:** questo risultato è in wei, non in eth. Wei è usato come taglio più piccolo dell'ether. La conversione da wei a eth è: 1 eth = 10¹⁸ wei. Quindi se convertiamo 0xde0b6b3a7640000 in decimali, otteniamo 1\*10¹⁸, pari a 1 eth.
Meno male! I nostri soldi finti ci sono tutti! 🤑
-
-
-### Fase 5: connetti MetaMask alla tua interfaccia utente {#step-5-connect-metamask-to-your-UI}
+### Passaggio 5: Collega MetaMask alla tua UI {#step-5-connect-metamask-to-your-UI}
Ora che il nostro portafoglio di MetaMask è configurato, connettiamo la nostra dapp!
-
-
#### La funzione `connectWallet` {#the-connectWallet-function}
-Nel nostro file `interact.js`, implementiamo la funzione `connectWallet`, che poi potremo chiamare nel nostro componente `HelloWorld.js`.
+Nel nostro file `interact.js`, implementiamo la funzione `connectWallet`, che potremo poi chiamare nel nostro componente `HelloWorld.js`.
Modifichiamo `connectWallet` come segue:
-
-
```javascript
// interact.js
@@ -1300,7 +1158,7 @@ export const connectWallet = async () => {
method: "eth_requestAccounts",
})
const obj = {
- status: "👆🏽 Write a message in the text-field above.",
+ status: "👆🏽 Scrivi un messaggio nel campo di testo qui sopra.",
address: addressArray[0],
}
return obj
@@ -1318,7 +1176,7 @@ export const connectWallet = async () => {
{" "}
🦊
- You must install MetaMask, a virtual Ethereum wallet, in your
+ Devi installare MetaMask, un portafoglio Ethereum virtuale, nel tuo
browser.
@@ -1329,66 +1187,56 @@ export const connectWallet = async () => {
}
```
+Quindi, cosa fa esattamente questo enorme blocco di codice?
-Cosa fa esattamente questo enorme blocco di codice?
-
-Innanzitutto, controlla se `window.ethereum` sia abilitato nel browser.
+Beh, per prima cosa, controlla se `window.ethereum` è abilitato nel tuo browser.
-`window.ethereum` è un'API globale, iniettata da MetaMask e altri fornitori di portafogli, che consente ai siti web di richiedere i conti di Ethereum degli utenti. Se approvato, può leggere i dati dalle blockchain a cui l'utente è connesso e suggerire all'utente di firmare messaggi e transazioni. Dai un'occhiata alla [documentazione di MetaMask](https://docs.metamask.io/guide/ethereum-provider.html#table-of-contents) per ulteriori informazioni!
+`window.ethereum` è un'API globale iniettata da MetaMask e da altri provider di portafogli che consente ai siti web di richiedere gli account Ethereum degli utenti. Se approvato, può leggere i dati dalle blockchain a cui l'utente è connesso e suggerire all'utente di firmare messaggi e transazioni. Consulta la [documentazione di MetaMask](https://docs.metamask.io/guide/ethereum-provider.html#table-of-contents) per maggiori informazioni!
-Se `window.ethereum` _non è_ presente, significa che MetaMask non è installato. Verrà quindi restituito un oggetto JSON in cui l'`address` restituito è una stringa vuota e l'oggetto JSX di `status` indica che l'utente deve installare MetaMask.
+Se `window.ethereum` _non è_ presente, significa che MetaMask non è installato. Questo restituisce un oggetto JSON, in cui l'`address` restituito è una stringa vuota e l'oggetto JSX `status` comunica che l'utente deve installare MetaMask.
-Ora, se `window.ethereum` _è_ presente, le cose cominciano a farsi interessanti.
+Ora, se `window.ethereum` _è_ presente, è qui che le cose si fanno interessanti.
-Usando una struttura try/catch, proveremo a connetterci a MetaMask chiamando [`window.ethereum.request({ method: "eth_requestAccounts" });`](https://docs.metamask.io/guide/rpc-api.html#eth-requestaccounts). Chiamare questa funzione aprirà MetaMask nel browser, dove sarà richiesto all'utente di connettere il proprio portafoglio alla tua dapp.
+Usando un ciclo try/catch, proveremo a connetterci a MetaMask chiamando [`window.ethereum.request({ method: "eth_requestAccounts" });`](https://docs.metamask.io/guide/rpc-api.html#eth-requestaccounts). Chiamare questa funzione aprirà MetaMask nel browser, dove sarà richiesto all'utente di connettere il proprio portafoglio alla tua dapp.
-- Se l'utente sceglie di connettersi, il `method: "eth_requestAccounts"` restituirà un array contenente gli indirizzi di tutti gli account dell'utente connessi alla dapp. Nel complesso, la nostra funzione `connectWallet` restituirà un oggetto JSON contenente il _primo_ `address` in questo array \(vedi la riga 9\) e un messaggio di `status` che richiede all'utente di scrivere un messaggio nello smart contract.
-- Se l'utente rifiuta la connessione, allora l'oggetto JSON conterrà una stringa vuota per l'`address` restituito e un messaggio di `status` che indica che l'utente ha rifiutato la connessione.
+- Se l'utente sceglie di connettersi, `method: "eth_requestAccounts"` restituirà un array contenente gli indirizzi di tutti gli account dell'utente connessi alla dApp. Complessivamente, la nostra funzione `connectWallet` restituirà un oggetto JSON che contiene il _primo_ `address` in questo array (vedi riga 9) e un messaggio di `status` che chiede all'utente di scrivere un messaggio allo smart contract.
+- Se l'utente rifiuta la connessione, l'oggetto JSON conterrà una stringa vuota per l'`address` restituito e un messaggio `status` che riflette il rifiuto della connessione da parte dell'utente.
Ora che abbiamo scritto questa funzione `connectWallet`, il passo successivo è chiamarla nel nostro componente `HelloWorld.js`.
-
-
-#### Aggiungi la funzione `connectWallet` al componente dell'interfaccia utente `HelloWorld.js` {#add-the-connectWallet-function-to-your-HelloWorld-js-ui-component}
+#### Aggiungi la funzione `connectWallet` al tuo componente UI `HelloWorld.js` {#add-the-connectWallet-function-to-your-HelloWorld-js-ui-component}
Vai alla funzione `connectWalletPressed` in `HelloWorld.js` e aggiornala come segue:
-
-
```javascript
-/ HelloWorld.js
+// HelloWorld.js
-const c= async () => {
+const connectWalletPressed = async () => {
const walletResponse = await connectWallet()
setStatus(walletResponse.status)
setWallet(walletResponse.address)
}
```
+Noti come la maggior parte della nostra funzionalità sia astratta dal nostro componente `HelloWorld.js` e si trovi nel file `interact.js`? Questo perché stiamo seguendo il modello M-V-C!
-Nota come gran parte della nostra funzionalità è esterna al nostro componente `HelloWorld.js` dal file `interact.js`? Questo perché stiamo seguendo il modello M-V-C!
+In `connectWalletPressed`, creiamo semplicemente una chiamata `await` alla nostra funzione `connectWallet` importata e, usando la sua risposta, aggiorniamo le nostre variabili `status` e `walletAddress` tramite i loro hook di stato.
-In `connectWalletPressed`, creiamo semplicemente una chiamata d'attesa alla nostra funzione `connectWallet` importata e, usando la sua risposta, aggiorniamo le nostre variabili `status` e `walletAddress` tramite i loro hook di stato.
-
-Ora salviamo entrambi i file \(`HelloWorld.js` e `interact.js`\) e testiamo la nostra interfaccia utente.
+Ora, salviamo entrambi i file (`HelloWorld.js` e `interact.js`) e testiamo la nostra interfaccia utente finora.
Apri il browser sulla pagina [http://localhost:3000/](http://localhost:3000/) e premi il pulsante "Connetti portafoglio" in alto a destra della pagina.
Se hai MetaMask installato, ti dovrebbe essere richiesto di connettere il tuo portafoglio alla tua dapp. Accetta l'invito a connetterti.
-Dovresti vedere che il pulsante del portafoglio ora mostra che il tuo indirizzo è connesso! Sììììì 🔥
-
-Prova quindi a ricaricare la pagina... questo è strano. Il nostro pulsante del portafoglio ci sta richiedendo di connetterci a MetaMask, anche se è già connesso...
-
-Tuttavia, non temere! Possiamo facilmente risolvere questo problema implementando `getCurrentWalletConnected`, che verificherà se un indirizzo è già connesso alla nostra dapp e aggiornerà l'interfaccia utente di conseguenza!
+Dovresti vedere che il pulsante del portafoglio ora riflette che il tuo indirizzo è connesso! Fantasticooo 🔥
+Prova quindi a ricaricare la pagina... strano. Il nostro pulsante del portafoglio ci sta richiedendo di connetterci a MetaMask, anche se è già connesso...
+Tuttavia, non temere! Possiamo facilmente risolvere questo problema! Implementando `getCurrentWalletConnected`, che verificherà se un indirizzo è già connesso alla nostra dApp e aggiornerà l'interfaccia utente di conseguenza!
#### La funzione `getCurrentWalletConnected` {#the-getcurrentwalletconnected-function}
-Aggiorna la funzione `getCurrentWalletConnected` nel file `interact.js` come segue:
-
-
+Aggiorna la tua funzione `getCurrentWalletConnected` nel file `interact.js` come segue:
```javascript
// interact.js
@@ -1402,12 +1250,12 @@ export const getCurrentWalletConnected = async () => {
if (addressArray.length > 0) {
return {
address: addressArray[0],
- status: "👆🏽 Write a message in the text-field above.",
+ status: "👆🏽 Scrivi un messaggio nel campo di testo qui sopra.",
}
} else {
return {
address: "",
- status: "🦊 Connect to MetaMask using the top right button.",
+ status: "🦊 Connettiti a MetaMask usando il pulsante in alto a destra.",
}
}
} catch (err) {
@@ -1424,7 +1272,7 @@ export const getCurrentWalletConnected = async () => {
{" "}
🦊
- You must install MetaMask, a virtual Ethereum wallet, in your
+ Devi installare MetaMask, un portafoglio Ethereum virtuale, nel tuo
browser.
@@ -1435,14 +1283,11 @@ export const getCurrentWalletConnected = async () => {
}
```
+Questo codice è _molto_ simile alla funzione `connectWallet` che abbiamo appena scritto nel passaggio precedente.
-Questo codice è _molto_ simile alla funzione `connectWallet` che abbiamo appena scritto nella fase precedente.
-
-La differenza principale è che, invece di chiamare il metodo `eth_requestAccounts`, che apre MetaMask perché l'utente connetta il proprio portafoglio, qui chiamiamo il metodo `eth_accounts` che, semplicemente, restituisce un insieme contenente gli indirizzi di MetaMask correntemente connessi alla nostra dapp.
-
-Per vedere questa funzione in azione, chiamiamola nella funzione `useEffect` del nostro componente `HelloWorld.js`:
-
+La differenza principale è che, invece di chiamare il metodo `eth_requestAccounts`, che apre MetaMask perché l'utente connetta il proprio portafoglio, qui chiamiamo il metodo `eth_accounts` che, semplicemente, restituisce un array contenente gli indirizzi di MetaMask correntemente connessi alla nostra dApp.
+Per vedere questa funzione in azione, chiamiamola nella nostra funzione `useEffect` del nostro componente `HelloWorld.js`:
```javascript
// HelloWorld.js
@@ -1458,14 +1303,11 @@ useEffect(async () => {
}, [])
```
-
Nota che stiamo usando la risposta alla nostra chiamata a `getCurrentWalletConnected` per aggiornare le nostre variabili di stato `walletAddress` e `status`.
-Ora che abbiamo aggiunto questo codice, proviamo ad aggiornare la finestra del browser.
-
-Bellooooo! Il pulsante dovrebbe dire che sei connesso e mostrare un'anteprima dell'indirizzo del tuo portafoglio connesso, anche dopo un refresh!
-
+Ora che hai aggiunto questo codice, proviamo ad aggiornare la finestra del browser.
+Benissimoooo! Il pulsante dovrebbe dire che sei connesso e mostrare un'anteprima dell'indirizzo del tuo portafoglio connesso, anche dopo un refresh!
#### Implementa `addWalletListener` {#implement-addwalletlistener}
@@ -1473,8 +1315,6 @@ Il passaggio finale della configurazione del portafoglio della nostra dapp è im
Nel tuo file `HelloWorld.js`, modifica la tua funzione `addWalletListener` come segue:
-
-
```javascript
// HelloWorld.js
@@ -1483,10 +1323,10 @@ function addWalletListener() {
window.ethereum.on("accountsChanged", (accounts) => {
if (accounts.length > 0) {
setWallet(accounts[0])
- setStatus("👆🏽 Write a message in the text-field above.")
+ setStatus("👆🏽 Scrivi un messaggio nel campo di testo qui sopra.")
} else {
setWallet("")
- setStatus("🦊 Connect to MetaMask using the top right button.")
+ setStatus("🦊 Connettiti a MetaMask usando il pulsante in alto a destra.")
}
})
} else {
@@ -1494,7 +1334,7 @@ function addWalletListener() {
{" "}
🦊
- You must install MetaMask, a virtual Ethereum wallet, in your browser.
+ Devi installare MetaMask, un portafoglio Ethereum virtuale, nel tuo browser.
)
@@ -1502,16 +1342,13 @@ function addWalletListener() {
}
```
+Scommetto che a questo punto non hai nemmeno bisogno del nostro aiuto per capire cosa sta succedendo, ma per completezza, analizziamolo rapidamente:
-Scommetto che a questo punto non hai bisogno del nostro aiuto per capire cosa succede qui, ma per completezza di informazioni, vediamo di analizzare velocemente la situazione:
-
-- Per prima cosa, la nostra funzione verifica se `window.ethereum` è abilitata \(cioè se MetaMask è installato\).
- - Se non lo è, impostiamo semplicemente la nostra variabile di stato `status`a una stringa JSX che richiede all'utente di installare MetaMask.
- - Se è abilitato, configuriamo l'ascoltatore `window.ethereum.on("accountsChanged")` alla riga 3, affinché ascolti i cambiamenti di stato nel portafoglio di MetaMask, tra cui, quando l'utente connette un ulteriore conto alla dapp, cambia conto, o ne disconnette uno. Se è connesso almeno un conto, la variabile di stato `walletAddress` è aggiornata come primo conto nell'insieme `accounts`, restituito dall'ascoltatore. Altrimenti, `walletAddress` è impostato come una stringa vuota.
-
-Infine ma non meno importante, dobbiamo chiamare la funzione `useEffect`:
-
+- Innanzitutto, la nostra funzione controlla se `window.ethereum` è abilitato (cioè se MetaMask è installato).
+ - In caso contrario, impostiamo semplicemente la nostra variabile di stato `status` su una stringa JSX che richiede all'utente di installare MetaMask.
+ - Se è abilitato, configuriamo l'ascoltatore `window.ethereum.on("accountsChanged")` alla riga 3, affinché ascolti i cambiamenti di stato nel portafoglio di MetaMask, tra cui, quando l'utente connette un ulteriore account alla dApp, cambia account, o ne disconnette uno. Se è connesso almeno un account, la variabile di stato `walletAddress` è aggiornata come primo account nell'array `accounts`, restituito dall'ascoltatore. Altrimenti, `walletAddress` è impostato come una stringa vuota.
+Infine, ma non meno importante, dobbiamo chiamarla nella nostra funzione `useEffect`:
```javascript
// HelloWorld.js
@@ -1529,30 +1366,23 @@ useEffect(async () => {
}, [])
```
-
E questo è tutto! Abbiamo completato con successo la programmazione di tutte le funzionalità del nostro portafoglio! Passiamo ora all'ultimo compito: aggiornare il messaggio memorizzato nel contratto intelligente!
+### Passaggio 6: Implementa la funzione `updateMessage` {#step-6-implement-the-updateMessage-function}
-
-### Fase 6: implementa la funzione `updateMessage` {#step-6-implement-the-updateMessage-function}
-
-Bene, siamo in dirittura d'arrivo! Nel `updateMessage` del tuo file `interact.js`, faremo quanto segue:
+Bene, siamo in dirittura d'arrivo! In `updateMessage` del tuo file `interact.js`, faremo quanto segue:
1. Assicurarci che il messaggio che vogliamo pubblicare nel nostro contratto intelligente sia valido
2. Firmare la transazione usando MetaMask
-3. Chiamare questa funzione dal componente del frontend `HelloWorld.js`
-
-Non ci vorrà molto; finiamo questa dapp!
-
+3. Chiamare questa funzione dal nostro componente frontend `HelloWorld.js`
+Non ci vorrà molto; finiamo questa dApp!
-#### Gestione degli errori d'input {#input-error-handling}
-
-Naturalmente, è utile avere una certa gestione degli errori di input all'inizio della funzione.
-
-Vorremo che la nostra funzione ci faccia sapere subito se non c'è un'estensione MetaMask installata, se non c'è un portafoglio connesso \(ossia `address` passato è una stringa vuota\) o se `message` è una stringa vuota. Aggiungiamo la seguente gestione degli errori a `updateMessage`:
+#### Gestione degli errori di input {#input-error-handling}
+Naturalmente, ha senso avere una qualche forma di gestione degli errori di input all'inizio della funzione.
+Vorremo che la nostra funzione termini presto se non è installata alcuna estensione MetaMask, non c'è un portafoglio connesso (cioè, l'`address` passato è una stringa vuota), o il `message` è una stringa vuota. Aggiungiamo la seguente gestione degli errori a `updateMessage`:
```javascript
// interact.js
@@ -1561,40 +1391,35 @@ export const updateMessage = async (address, message) => {
if (!window.ethereum || address === null) {
return {
status:
- "💡 Connect your MetaMask wallet to update the message on the blockchain.",
+ "💡 Connetti il tuo portafoglio MetaMask per aggiornare il messaggio sulla blockchain.",
}
}
if (message.trim() === "") {
return {
- status: "❌ Your message cannot be an empty string.",
+ status: "❌ Il tuo messaggio non può essere una stringa vuota.",
}
}
}
```
+Ora che abbiamo una corretta gestione degli errori di input, è il momento di firmare la transazione tramite MetaMask!
-Ora che la gestione degli errori d'input è gestita correttamente, è tempo di firmare la transazione con MetaMask!
-
-
-
-#### Firmare la transazione {#signing-our-transaction}
-
-Se ti senti già a tuo agio con le transazioni web3 di Ethereum tradizionali, il codice che scriveremo in seguito ti risulterà molto familiare. Sotto il tuo codice di gestione degli errori di input, aggiungi quanto segue a `updateMessage`:
-
+#### Firma della nostra transazione {#signing-our-transaction}
+Se hai già familiarità con le transazioni Ethereum web3 tradizionali, il codice che scriveremo di seguito ti sarà molto familiare. Sotto il codice di gestione degli errori di input, aggiungi quanto segue a `updateMessage`:
```javascript
// interact.js
-//set up transaction parameters
+//imposta i parametri della transazione
const transactionParameters = {
- to: contractAddress, // Required except during contract publications.
- from: address, // must match user's active address.
+ to: contractAddress, // Richiesto tranne durante le pubblicazioni di contratti.
+ from: address, // deve corrispondere all'indirizzo attivo dell'utente.
data: helloWorldContract.methods.update(message).encodeABI(),
}
-//sign the transaction
+//firma la transazione
try {
const txHash = await window.ethereum.request({
method: "eth_sendTransaction",
@@ -1605,11 +1430,11 @@ try {
✅{" "}
- View the status of your transaction on Etherscan!
+ Visualizza lo stato della tua transazione su Etherscan!
- ℹ️ Once the transaction is verified by the network, the message will be
- updated automatically.
+ ℹ️ Una volta che la transazione sarà verificata dalla rete, il messaggio verrà
+ aggiornato automaticamente.
),
}
@@ -1620,50 +1445,47 @@ try {
}
```
+Analizziamo cosa sta accadendo. Per prima cosa, impostiamo i parametri delle nostre transazioni, dove:
-Analizziamo cosa sta accadendo. Per prima cosa importiamo i parametri delle transazioni, dove:
-
-- `to` specifica l'indirizzo del destinatario \(il nostro smart contract\)
-- `from` specifica il firmatario della transazione, la variabile `address` che abbiamo passato nella nostra funzione
+- `to` specifica l'indirizzo del destinatario (il nostro smart contract)
+- `from` specifica il firmatario della transazione, la variabile `address` che abbiamo passato alla nostra funzione
- `data` contiene la chiamata al metodo `update` del nostro contratto intelligente Hello World, ricevendo la nostra variabile stringa `message` come input
-Creiamo quindi una chiamata d'attesa, `window.ethereum.request` in cui chiediamo a MetaMask di firmare la transazione. Nota che, alle righe 11 e 12, stiamo specificando il nostro metodo eth, `eth_sendTransaction`, e passando i nostri `transactionParameters`.
+Quindi, facciamo una chiamata `await`, `window.ethereum.request`, in cui chiediamo a MetaMask di firmare la transazione. Nota che, alle righe 11 e 12, stiamo specificando il nostro metodo eth, `eth_sendTransaction`, e passando i nostri `transactionParameters`.
A questo punto, MetaMask si aprirà nel browser e richiederà all'utente di firmare o rifiutare la transazione.
- Se la transazione va a buon fine, la funzione restituirà un oggetto JSON in cui la stringa JSX `status` richiede all'utente di controllare Etherscan per ulteriori informazioni sulla sua transazione.
-- Se la transazione non va a buon fine, la funzione restituirà un oggetto JSON in cui la stringa `status` trasmette il messaggio d'errore.
+- Se la transazione non va a buon fine, la funzione restituirà un oggetto JSON in cui la stringa `status` trasmette il messaggio di errore.
Complessivamente, la nostra funzione `updateMessage` dovrebbe avere questo aspetto:
-
-
```javascript
// interact.js
export const updateMessage = async (address, message) => {
- //input error handling
+ //gestione degli errori di input
if (!window.ethereum || address === null) {
return {
status:
- "💡 Connect your MetaMask wallet to update the message on the blockchain.",
+ "💡 Connetti il tuo portafoglio MetaMask per aggiornare il messaggio sulla blockchain.",
}
}
if (message.trim() === "") {
return {
- status: "❌ Your message cannot be an empty string.",
+ status: "❌ Il tuo messaggio non può essere una stringa vuota.",
}
}
- //set up transaction parameters
+ //imposta i parametri della transazione
const transactionParameters = {
- to: contractAddress, // Required except during contract publications.
- from: address, // must match user's active address.
+ to: contractAddress, // Richiesto tranne durante le pubblicazioni di contratti.
+ from: address, // deve corrispondere all'indirizzo attivo dell'utente.
data: helloWorldContract.methods.update(message).encodeABI(),
}
- //sign the transaction
+ //firma la transazione
try {
const txHash = await window.ethereum.request({
method: "eth_sendTransaction",
@@ -1674,11 +1496,11 @@ export const updateMessage = async (address, message) => {
✅{" "}
- View the status of your transaction on Etherscan!
+ Visualizza lo stato della tua transazione su Etherscan!
- ℹ️ Once the transaction is verified by the network, the message will
- be updated automatically.
+ ℹ️ Una volta che la transazione sarà verificata dalla rete, il messaggio
+ verrà aggiornato automaticamente.
),
}
@@ -1690,16 +1512,11 @@ export const updateMessage = async (address, message) => {
}
```
+Infine, ma non meno importante, dobbiamo connettere la nostra funzione `updateMessage` al nostro componente `HelloWorld.js`.
-Infine, ma non meno importante, dobbiamo connettere la nostra funzione`updateMessage` al nostro componente `HelloWorld.js`.
-
-
-
-#### Connetti `updateMessage`al frontend `HelloWorld.js` {#connect-updatemessage-to-the-helloworld-js-frontend}
-
-La nostra funzione `onUpdatePressed` dovrebbe effettuare una chiamata d'attesa alla funzione `updateMessage` importata e modificare la variabile di stato `status` per riflettere se la transazione è andata o meno a buon fine:
-
+#### Connetti `updateMessage` al frontend `HelloWorld.js` {#connect-updatemessage-to-the-helloworld-js-frontend}
+La nostra funzione `onUpdatePressed` dovrebbe effettuare una chiamata `await` alla funzione importata `updateMessage` e modificare la variabile di stato `status` per riflettere se la nostra transazione è andata a buon fine o meno:
```javascript
// HelloWorld.js
@@ -1710,21 +1527,18 @@ const onUpdatePressed = async () => {
}
```
+È super pulito e semplice. E indovina un po'... LA TUA DAPP È COMPLETA!!!
-È super chiaro e semplice. E indovina un po'... LA TUA DAPP È COMPLETA!!!
-
-Prosegui e pova il pulsante **Aggiorna**!
-
-
+Vai avanti e prova il pulsante **Aggiorna**!
-### Crea la tua dapp personalizzata {#make-your-own-custom-dapp}
+### Crea la tua dApp personalizzata {#make-your-own-custom-dapp}
Fantastico, sei arrivato alla fine del tutorial! Per ricapitolare, hai imparato a:
-- Collegare un portafoglio di MetaMask al tuo progetto dapp
-- Leggere dati da un contratto intelligente usando le API [Web3 di Alchemy](https://docs.alchemy.com/alchemy/documentation/alchemy-web3)
+- Collegare un portafoglio MetaMask al tuo progetto dApp
+- Leggere i dati dal tuo contratto intelligente usando l'API [Alchemy Web3](https://docs.alchemy.com/alchemy/documentation/alchemy-web3)
- Firmare le transazioni di Ethereum usando MetaMask
-Ora hai tutti gli strumenti applicare le competenze apprese in questo tutorial per costruire il tuo progetto dapp! Come sempre, se hai domande, non esitare a contattarci per chiedere aiuto sul [Discord di Alchemy](https://discord.gg/gWuC7zB). 🧙♂️
+Ora hai tutti gli strumenti per applicare le competenze apprese in questo tutorial per costruire il tuo progetto dApp personalizzato! Come sempre, se hai domande, non esitare a contattarci per chiedere aiuto sul [Discord di Alchemy](https://discord.gg/gWuC7zB). 🧙♂️
-Una volta completato questo tutorial, facci sapere come è stata la tua esperienza o se hai qualche feedback taggandoci su Twitter [@alchemyplatform](https://twitter.com/AlchemyPlatform)!
+Una volta completato questo tutorial, facci sapere com'è stata la tua esperienza o se hai qualche feedback taggandoci su Twitter [@alchemyplatform](https://twitter.com/AlchemyPlatform)!
diff --git a/public/content/translations/it/developers/tutorials/hello-world-smart-contract/index.md b/public/content/translations/it/developers/tutorials/hello-world-smart-contract/index.md
index 1c211718dd3..b80ffd1424b 100644
--- a/public/content/translations/it/developers/tutorials/hello-world-smart-contract/index.md
+++ b/public/content/translations/it/developers/tutorials/hello-world-smart-contract/index.md
@@ -3,73 +3,69 @@ title: Smart Contract "Hello World" per principianti
description: Tutorial introduttivo su come scrivere e distribuire un semplice smart contract su Ethereum.
author: "elanh"
tags:
- - "solidity"
- - "hardhat"
- - "alchemy"
- - "smart contract"
- - "distribuzione"
+ [
+ "Solidity",
+ "hardhat",
+ "alchemy",
+ "smart contract",
+ "distribuzione"
+ ]
skill: beginner
lang: it
published: 2021-03-31
---
-Se hai appena iniziato con lo sviluppo blockchain e non sai da dove cominciare, oppure se sei solo interessato a capire come distribuire e interagire con gli smart contract, questa è la guida che fa al caso tuo. Esamineremo la creazione e la distribuzione di un semplice contratto intelligente sulla rete di prova di Goerli, utilizzando un portafoglio virtuale di [MetaMask](https://metamask.io/), [Solidity](https://docs.soliditylang.org/en/v0.8.0/), [Hardhat](https://hardhat.org/) e [Alchemy](https://alchemyapi.io/eth) (non preoccuparti se non capisci cosa significhi, lo spiegheremo).
+Se hai appena iniziato con lo sviluppo blockchain e non sai da dove cominciare, oppure se sei solo interessato a capire come distribuire e interagire con gli smart contract, questa è la guida che fa al caso tuo. Esamineremo la creazione e la distribuzione di un semplice contratto intelligente sulla rete di test Sepolia, utilizzando un portafoglio virtuale [MetaMask](https://metamask.io/), [Solidity](https://docs.soliditylang.org/en/v0.8.0/), [Hardhat](https://hardhat.org/) e [Alchemy](https://www.alchemy.com/eth) (non preoccuparti se non capisci ancora cosa significhi, lo spiegheremo).
-> **Attenzione**
->
-> 🚧 Avviso di obsolescenza
->
-> Per l'intera guida, la rete di test Goerli viene utilizzata per creare e distribuire un contratto intelligente. Tuttavia, tieni presente che la Ethereum Foundation ha annunciato che [Goerli sarà presto abbandonata](https://www.alchemy.com/blog/goerli-faucet-deprecation).
->
-> Ti consigliamo di utilizzare [Sepolia](https://sepoliafaucet.com/) e il [faucet di Sepolia](https://www.alchemy.com/overviews/sepolia-testnet) per questo tutorial.
-
-Nella [parte 2](https://docs.alchemy.com/docs/interacting-with-a-smart-contract) di questo tutorial, esamineremo come possiamo interagire con il nostro contratto intelligente una volta distribuito e, nella [parte 3](https://docs.alchemy.com/docs/submitting-your-smart-contract-to-etherscan), copriremo come pubblicarlo su Etherscan.
+Nella [parte 2](https://docs.alchemy.com/docs/interacting-with-a-smart-contract) di questo tutorial vedremo come interagire con il nostro smart contract una volta distribuito, e nella [parte 3](https://www.alchemy.com/docs/submitting-your-smart-contract-to-etherscan) tratteremo come pubblicarlo su Etherscan.
Se in qualsiasi momento hai domande, non esitare a contattarci nel [Discord di Alchemy](https://discord.gg/gWuC7zB)!
-## Fase 1: connettersi alla rete di Ethereum {#step-1}
+## Fase 1: Connettersi alla rete di Ethereum {#step-1}
+
+Esistono molti modi per effettuare richieste alla catena di Ethereum. Per semplicità, ci serviremo di un conto gratuito su Alchemy, una piattaforma per sviluppatori di blockchain e API che ci consentirà di comunicare con la catena di Ethereum senza dover operare i nostri nodi. La piattaforma offre anche strumenti per sviluppatori per il monitoraggio e l'analisi di cui ci serviremo in questo tutorial per comprendere cosa succede dietro le quinte durante la distribuzione del nostro smart contract. Se non possiedi già un conto di Alchemy, [puoi iscriverti gratuitamente qui](https://dashboard.alchemy.com/signup).
-Esistono molti modi per effettuare richieste alla catena di Ethereum. Per semplicità, ci serviremo di un conto gratuito su Alchemy, una piattaforma per sviluppatori di blockchain e API che ci consentirà di comunicare con la catena di Ethereum senza dover operare i nostri nodi. La piattaforma offre anche strumenti di analisi e monitoraggio di cui ci serviremo in questo tutorial per comprendere al meglio l'andamento della distribuzione del nostro smart contract. Se non possiedi già un conto di Alchemy, [puoi iscriverti gratuitamente qui](https://dashboard.alchemyapi.io/signup).
+## Fase 2: Crea la tua app (e chiave API) {#step-2}
-## Fase 2: crea la tua app (e chiave API) {#step-2}
+Una volta creato un conto di Alchemy, puoi generare una chiave API creando un'app. Questo ci consentirà di effettuare richieste alla rete di prova di Sepolia. Se non hai familiarità con le reti di test, dai un'occhiata a [questa pagina](/developers/docs/networks/).
-Una volta creato un conto di Alchemy, puoi generare una chiave API creando un'app. Questo ci permetterà di effettuare delle richieste alla rete di prova di Goerli. Se non hai familiarità con le reti di prova, dai un'occhiata a [questa pagina](/developers/docs/networks/).
+1. Vai alla pagina "Crea nuova app" nella tua dashboard di Alchemy selezionando "Seleziona un'app" nella barra di navigazione e cliccando "Crea nuova app"
-1. Vai alla pagina “Crea App” nella tua dashboard di Alchemy passando su “App” nella barra di navigazione e cliccando “Crea App”
+
-
+2. Dai un nome alla tua app, "Hello World", fornisci una breve descrizione e scegli un caso d'uso, ad esempio, "Infrastruttura e strumenti." Successivamente, cerca "Ethereum" e seleziona la rete.
-2. Denomina la tua app "Ciao Mondo", offri una breve descrizione, seleziona "Staging" per l'Ambiente (utilizzato per la contabilità della tua app) e scegli "Goerli" per la tua rete.
+
-
+3. Fai clic su "Next" per procedere, quindi su "Create app" e il gioco è fatto! La tua app dovrebbe apparire nel menu a tendina della barra di navigazione, con una Chiave API disponibile per la copia.
-3. Clicca “Create app” ed è tutto! La tua app dovrebbe apparire nella tabella sottostante.
+## Fase 3: Crea un conto Ethereum (indirizzo) {#step-3}
-## Fase 3: Crea un conto di Ethereum (indirizzo) {#step-3}
+Per inviare e ricevere le transazioni, necessitiamo di un conto di Ethereum. Per questo tutorial, utilizzeremo MetaMask, un portafoglio virtuale nel browser, utilizzato per gestire l'indirizzo del tuo conto di Ethereum. Maggiori informazioni sulle [transazioni](/developers/docs/transactions/).
-Per inviare e ricevere le transazioni, necessitiamo di un conto di Ethereum. Per questo tutorial, useremo MetaMask, un portafoglio virtuale nel browser per gestire l'indirizzo del tuo conto di Ethereum. Maggiori informazioni sulle [transazioni](/developers/docs/transactions/).
+Puoi scaricare MetaMask e creare un conto Ethereum gratuito [qui](https://metamask.io/download). Quando crei un conto, o se ne hai già uno, assicurati di passare alla rete di test "Sepolia" utilizzando il menu a tendina della rete (in modo da non avere a che fare con denaro reale).
-Puoi scaricare e creare gratuitamente un conto di MetaMask [qui](https://metamask.io/download). Quando crei un account, o se ne possiedi già uno, assicurati di passare alla "rete di prova di Goerli" in alto a destra (così da non avere a che fare con denaro reale).
+Se non vedi Sepolia nell'elenco, vai nel menu, quindi su Avanzate e scorri verso il basso per attivare l'opzione "Mostra reti di test". Nel menu di selezione della rete, scegli la scheda "Personalizzata" per trovare un elenco di reti di test e seleziona "Sepolia."
-
+
-## Fase 4: aggiungi ether da un Faucet {#step-4}
+## Fase 4: Aggiungi ether da un faucet {#step-4}
-Per poter distribuire il nostro contratto intelligente alla rete di prova, avremo bisogno di degli ETH finti. Per ottenere degli ETH, puoi andare al [faucet di Goerli](https://goerlifaucet.com/), accedere al tuo conto di Alchemy e inserire l'indirizzo del tuo portafoglio, cliccando poi su "Inviami gli ETH". Potrebbe volerci del tempo per ricevere i tuoi ETH finti, a causa del traffico della rete. (Al momento della scrittura di questo tutorial, ci sono voluti circa 30 minuti.) Dovresti vedere i tuoi ETH nel tuo conto di Metamask dopo qualche minuto!
+Per distribuire il nostro smart contract sulla rete di test, avremo bisogno di Eth finti. Per ottenere ETH di Sepolia, puoi andare ai [dettagli della rete Sepolia](/developers/docs/networks/#sepolia) per visualizzare un elenco di vari faucet. Se uno non funziona, provane un altro perché a volte possono esaurirsi. Potrebbe essere necessario un po' di tempo per ricevere i tuoi ETH finti a causa del traffico di rete. Dovresti vedere gli ETH nel tuo conto MetaMask poco dopo!
-## Fase 5: controlla il saldo {#step-5}
+## Fase 5: Controlla il tuo saldo {#step-5}
-Per ricontrollare che ci sia il saldo, facciamo una richiesta [eth_getBalance](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_getbalance) usando lo [strumento compositore di Alchemy](https://composer.alchemyapi.io?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D). Questo restituirà l'importo di ETH nel nostro portafoglio. Dopo aver inserito l'indirizzo del tuo conto di MetaMask e aver cliccato su “Invia Richiesta”, dovresti vedere una risposta come questa:
+Per verificare che il nostro saldo sia presente, effettuiamo una richiesta [eth_getBalance](/developers/docs/apis/json-rpc/#eth_getbalance) utilizzando lo [strumento composer di Alchemy](https://sandbox.alchemy.com/?network=ETH_SEPOLIA&method=eth_getBalance&body.id=1&body.jsonrpc=2.0&body.method=eth_getBalance&body.params%5B0%5D=&body.params%5B1%5D=latest). Questo restituirà l'importo di ETH nel nostro portafoglio. Dopo aver inserito l'indirizzo del tuo conto di MetaMask e aver cliccato "Invia Richiesta", dovresti visualizzare una risposta simile alla seguente:
```json
{ "jsonrpc": "2.0", "id": 0, "result": "0x2B5E3AF16B1880000" }
```
-> **NOTA:** questo risultato è in wei non in ETH. Wei è usato come taglio più piccolo dell'ether. La conversione da wei a ETH è: 1 eth = 1018 wei. Quindi se convertiamo 0x2B5E3AF16B1880000 in decimali, otteniamo 5\*10¹⁸, pari a 5 ETH.
+> **NOTA:** questo risultato è in wei, non in ETH. Wei è usato come taglio più piccolo dell'ether. La conversione da wei a ETH è: 1 eth = 1018 wei. Quindi, se convertiamo 0x2B5E3AF16B1880000 in decimale, otteniamo 5\*10¹⁸, che equivale a 5 ETH.
>
> Meno male! I nostri soldi finti ci sono tutti .
-## Fase 6: inizializza il progetto {#step-6}
+## Fase 6: Inizializza il nostro progetto {#step-6}
Prima, dovremo creare una cartella per il nostro progetto. Vai alla riga di comando e digita:
@@ -78,18 +74,18 @@ mkdir hello-world
cd hello-world
```
-Ora che siamo nella cartella del nostro progetto, useremo `npm init` per inizializzare il progetto. Se non hai già installato npm, segui [queste istruzioni](https://docs.alchemyapi.io/alchemy/guides/alchemy-for-macs#1-install-nodejs-and-npm) (avremo bisogno anche di Node.js, quindi scarica anche questo!).
+Ora che siamo all'interno della nostra cartella del progetto, useremo `npm init` per inizializzare il progetto. Se non hai già installato npm, segui [queste istruzioni](https://docs.alchemyapi.io/alchemy/guides/alchemy-for-macs#1-install-nodejs-and-npm) (avremo bisogno anche di Node.js, quindi scarica anche quello!).
```
npm init
```
-Non è rilevante come rispondi alle domande d'installazione, ecco le nostre risposte come esempio:
+Non è molto importante come rispondi alle domande di installazione, ecco come abbiamo fatto noi come riferimento:
```
package name: (hello-world)
version: (1.0.0)
-description: hello world smart contract
+description: contratto intelligente hello world
entry point: (index.js)
test command:
git repository:
@@ -101,31 +97,31 @@ About to write to /Users/.../.../.../hello-world/package.json:
{
"name": "hello-world",
"version": "1.0.0",
- "description": "hello world smart contract",
+ "description": "contratto intelligente hello world",
"main": "index.js",
"scripts": {
- "test": "echo \\"Error: no test specified\\" && exit 1"
+ "test": "echo \"Errore: nessun test specificato\\" && exit 1"
},
"author": "",
"license": "ISC"
}
```
-Approva il package.json e siamo pronti!
+Approva il file package.json e siamo pronti a partire!
## Fase 7: Scarica [Hardhat](https://hardhat.org/getting-started/#overview) {#step-7}
Hardhat è un ambiente di sviluppo per compilare, distribuire, testare ed effettuare il debug del tuo software di Ethereum. Aiuta gli sviluppatori nella costruzione di contratti intelligenti e dapp localmente, prima di distribuirli alla catena.
-Nel nostro progetto `hello-world` esegui:
+All'interno del nostro progetto `hello-world`, esegui:
```
npm install --save-dev hardhat
```
-Dai un'occhiata a questa pagina per ulteriori dettagli sulle [istruzioni d'installazione](https://hardhat.org/getting-started/#overview).
+Consulta questa pagina per maggiori dettagli sulle [istruzioni di installazione](https://hardhat.org/getting-started/#overview).
-## Fase 8: crea un progetto Hardhat {#step-8}
+## Fase 8: Crea un progetto Hardhat {#step-8}
Nella cartella del nostro progetto esegui:
@@ -145,17 +141,17 @@ Dovresti poi vedere un messaggio di benvenuto e l'opzione per selezionare cosa d
888 888 888 888 888 Y88b 888 888 888 888 888 Y88b.
888 888 "Y888888 888 "Y88888 888 888 "Y888888 "Y888
-👷 Welcome to Hardhat v2.0.11 👷?
+👷 Benvenuto in Hardhat v2.0.11 👷?
-What do you want to do? …
-Create a sample project
-❯ Create an empty hardhat.config.js
-Quit
+Cosa vuoi fare? …
+Crea un progetto di esempio
+❯ Crea un hardhat.config.js vuoto
+Esci
```
-Questo genererà un file `hardhat.config.js`, in cui specificheremo tutta la configurazione per il nostro progetto (alla fase 13).
+Questo genererà per noi un file `hardhat.config.js`, in cui specificheremo tutta la configurazione del nostro progetto (nella fase 13).
-## Fase 9: aggiungi le cartelle del progetto {#step-9}
+## Fase 9: Aggiungi le cartelle del progetto {#step-9}
Per mantenere organizzato il nostro progetto creeremo due nuove cartelle. Vai alla cartella di root del tuo progetto nella tua riga di comando e digita:
@@ -164,55 +160,55 @@ mkdir contracts
mkdir scripts
```
-- `contracts/` è dove manterremo il file del codice del nostro smart contract hello world
-- `scripts/` è dove manterremo gli script per distribuire e interagire con il nostro contratto
+- `contracts/` è dove conserveremo il file del codice del nostro smart contract hello world
+- `scripts/` è dove conserveremo gli script per distribuire e interagire con il nostro contratto
-## Fase 10: compila il nostro contratto {#step-10}
+## Fase 10: Scrivi il nostro contratto {#step-10}
-Potresti chiederti, quando diavolo scriviamo il codice? Beh, eccoci qui, alla fase 10.
+Ti starai chiedendo, ma quando diavolo scriviamo il codice?? Beh, eccoci qui, alla fase 10.
-Apri il progetto hello-world nel tuo editor preferito (a noi piace [VSCode](https://code.visualstudio.com/)). Gli smart contract sono scritti in un linguaggio detto Solidity, che useremo per scrivere il nostro smart contract HelloWorld.sol.
+Apri il progetto hello-world nel tuo editor preferito (a noi piace [VSCode](https://code.visualstudio.com/)). Gli smart contract sono scritti in un linguaggio chiamato Solidity, che useremo per scrivere il nostro smart contract HelloWorld.sol.
-1. Vai alla cartella "contracts" e crea un nuovo file chiamato HelloWorld.sol
-2. Di seguito, un esempio dello smart contract Hello World dalla Ethereum Foundation che useremo per questo tutorial. Copia e incolla i contenuti seguenti nel tuo file HelloWorld.sol e assicurati di leggere i commenti per comprendere cosa fa il contratto:
+1. Vai alla cartella "contracts" e crea un nuovo file chiamato HelloWorld.sol
+2. Di seguito è riportato un esempio di smart contract Hello World della Ethereum Foundation che useremo per questo tutorial. Copia e incolla i contenuti sottostanti nel tuo file HelloWorld.sol e assicurati di leggere i commenti per capire cosa fa questo contratto:
```solidity
-// Specifica la versione di Solidity, utilizzando il controllo delle versioni semantico.
-// Learn more: https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma
+// Specifica la versione di Solidity, utilizzando il versioning semantico.
+// Per saperne di più: https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma
pragma solidity ^0.7.0;
-// Defines a contract named `HelloWorld`.
-// Un contratto è una raccolta di funzioni e dati (il suo stato). Once deployed, a contract resides at a specific address on the Ethereum blockchain. Learn more: https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html
+// Definisce un contratto chiamato `HelloWorld`.
+// Un contratto è una raccolta di funzioni e dati (il suo stato). Una volta distribuito, un contratto risiede a un indirizzo specifico sulla blockchain di Ethereum. Per saperne di più: https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html
contract HelloWorld {
- // Declares a state variable `message` of type `string`.
- // Le variabili di stato sono variabili con valori memorizzati in modo permanente nello spazio di archiviazione (storage) del contratto. The keyword `public` makes variables accessible from outside a contract and creates a function that other contracts or clients can call to access the value.
+ // Dichiara una variabile di stato `message` di tipo `string`.
+ // Le variabili di stato sono variabili i cui valori sono memorizzati in modo permanente nella memoria del contratto. La parola chiave `public` rende le variabili accessibili dall'esterno di un contratto e crea una funzione che altri contratti o client possono chiamare per accedere al valore.
string public message;
- // Similar to many class-based object-oriented languages, a constructor is a special function that is only executed upon contract creation.
- // I costruttori sono utilizzati per inizializzare i dati del contratto. Learn more:https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors
+ // Simile a molti linguaggi orientati agli oggetti basati su classi, un costruttore è una funzione speciale che viene eseguita solo alla creazione del contratto.
+ // I costruttori sono usati per inizializzare i dati del contratto. Per saperne di più:https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors
constructor(string memory initMessage) {
- // Accepts a string argument `initMessage` and sets the value into the contract's `message` storage variable).
+ // Accetta un argomento di tipo stringa `initMessage` e imposta il valore nella variabile di archiviazione `message` del contratto).
message = initMessage;
}
- // A public function that accepts a string argument and updates the `message` storage variable.
+ // Una funzione pubblica che accetta un argomento di tipo stringa e aggiorna la variabile di archiviazione `message`.
function update(string memory newMessage) public {
message = newMessage;
}
}
```
-Questo è uno smart contract semplicissimo che memorizza un messaggio alla creazione ed è aggiornabile chiamando la funzione `update`.
+Questo è uno smart contract molto semplice che memorizza un messaggio alla sua creazione e può essere aggiornato chiamando la funzione `update`.
-## Fase 11: connetti MetaMask e Alchemy al tuo progetto {#step-11}
+## Fase 11: Connetti MetaMask e Alchemy al tuo progetto {#step-11}
-Abbiamo creato un portafoglio di MetaMask, un conto di Alchemy e scritto il nostro contratto intelligente; è arrivato il momento di collegarli.
+Abbiamo creato un portafoglio MetaMask, un conto Alchemy e scritto il nostro smart contract, ora è il momento di collegare i tre.
Ogni transazione inviata dal tuo portafoglio virtuale richiede una firma tramite la tua chiave privata unica. Per fornire al nostro programma quest'autorizzazione, possiamo memorizzare in sicurezza la nostra chiave privata (e la chiave API di Alchemy) in un file ambientale.
-> Per saperne di più sull'invio delle transazioni, dai un'occhiata a [questo tutorial](/developers/tutorials/sending-transactions-using-web3-and-alchemy/) sull'invio di transazioni usando web3.
+> Per saperne di più sull'invio di transazioni, consulta [questa guida](/developers/tutorials/sending-transactions-using-web3-and-alchemy/) sull'invio di transazioni tramite web3.
Prima, installa il pacchetto dotenv nella cartella del tuo progetto:
@@ -220,37 +216,37 @@ Prima, installa il pacchetto dotenv nella cartella del tuo progetto:
npm install dotenv --save
```
-Poi, crea un file `.env` nella cartella di root del nostro progetto e aggiungi la tua chiave privata di MetaMask e l'URL API di Alchemy HTTP.
+Quindi, crea un file `.env` nella directory principale del nostro progetto e aggiungici la tua chiave privata di MetaMask e l'URL dell'API HTTP di Alchemy.
-- Segui [queste istruzioni](https://metamask.zendesk.com/hc/en-us/articles/360015289632-How-to-Export-an-Account-Private-Key) per esportare la tua chiave privata
-- Vedi sotto per ottenere l'URL dell'API di Alchemy HTTP
+- Segui [queste istruzioni](https://support.metamask.io/configure/accounts/how-to-export-an-accounts-private-key/) per esportare la tua chiave privata
+- Vedi di seguito per ottenere l'URL dell'API HTTP di Alchemy
-
+
Copia l'URL dell'API di Alchemy
-Il tuo `.env` dovrebbe somigliare a questo:
+Il tuo file `.env` dovrebbe avere questo aspetto:
```
-API_URL = "https://eth-goerli.alchemyapi.io/v2/your-api-key"
+API_URL = "https://eth-sepolia.g.alchemy.com/v2/your-api-key"
PRIVATE_KEY = "your-metamask-private-key"
```
-Per connetterli realmente al nostro codice, faremo riferimento a queste variabili nel nostro file `hardhat.config.js` nella fase 13.
+Per collegarli effettivamente al nostro codice, faremo riferimento a queste variabili nel nostro file `hardhat.config.js` nella fase 13.
-Non eseguire il commit di .env! Assicurati di non condividere o esporre mai il tuo file .env con nessuno, poiché così facendo comprometteresti i tuoi segreti. Se stai usando il controllo di versione, aggiungi il tuo .env a un file gitignore.
+Non eseguire il commit di .env! Assicurati di non condividere o esporre mai il tuo file .env a nessuno, poiché così facendo comprometteresti i tuoi segreti. Se stai usando un sistema di controllo di versione, aggiungi il tuo file .env a un file .gitignore.
-## Fase 12: installa Ethers.js {#step-12-install-ethersjs}
+## Fase 12: Installa Ethers.js {#step-12-install-ethersjs}
-Ethers.js è una libreria che rende più facile interagire ed effettuare richieste a Ethereum tramite wrapping dei [metodi JSON-RPC standard](/developers/docs/apis/json-rpc/) con altri metodi più facili da usare.
+Ethers.js è una libreria che semplifica l'interazione e l'invio di richieste a Ethereum, eseguendo il wrapping dei [metodi JSON-RPC standard](/developers/docs/apis/json-rpc/) con metodi più intuitivi.
-Hardhat rende davvero facile integrare [Plugin](https://hardhat.org/plugins/) per strumenti e funzionalità aggiuntive. Sfrutteremo il [plugin di Ethers](https://hardhat.org/docs/plugins/official-plugins#hardhat-ethers) per la distribuzione del contratto ([Ethers.js](https://github.com/ethers-io/ethers.js/) ha dei metodi di distribuzione del contratto molto puliti).
+Hardhat rende semplicissima l'integrazione di [Plugin](https://hardhat.org/plugins/) per strumenti aggiuntivi e funzionalità estese. Approfitteremo del [plugin Ethers](https://hardhat.org/docs/plugins/official-plugins#hardhat-ethers) per la distribuzione dei contratti ([Ethers.js](https://github.com/ethers-io/ethers.js/) ha dei metodi di distribuzione dei contratti molto puliti).
Nella cartella del tuo progetto digita:
@@ -258,13 +254,13 @@ Nella cartella del tuo progetto digita:
npm install --save-dev @nomiclabs/hardhat-ethers "ethers@^5.0.0"
```
-Avremo bisogno di ethers anche nel nostro `hardhat.config.js` nella prossima fase.
+Richiederemo anche ethers nel nostro `hardhat.config.js` nel prossimo passo.
-## Fase 13: aggiorna hardhat.config.js {#step-13-update-hardhatconfigjs}
+## Fase 13: Aggiorna hardhat.config.js {#step-13-update-hardhatconfigjs}
Finora abbiamo aggiunto diverse dipendenze e plugin, ora dobbiamo aggiornare `hardhat.config.js` in modo che il nostro progetto li riconosca tutti.
-Aggiorna il tuo `hardhat.config.js` affinché somigli a questo:
+Aggiorna il tuo `hardhat.config.js` perché abbia questo aspetto:
```
require('dotenv').config();
@@ -277,10 +273,10 @@ const { API_URL, PRIVATE_KEY } = process.env;
*/
module.exports = {
solidity: "0.7.3",
- defaultNetwork: "goerli",
+ defaultNetwork: "sepolia",
networks: {
hardhat: {},
- goerli: {
+ sepolia: {
url: API_URL,
accounts: [`0x${PRIVATE_KEY}`]
}
@@ -288,9 +284,9 @@ module.exports = {
}
```
-## Fase 14: compila il contratto {#step-14-compile-our-contracts}
+## Fase 14: Compila il nostro contratto {#step-14-compile-our-contracts}
-Per assicurarti che tutto funzioni fino a questo punto, compila il contratto. L'attività di `compilazione` è una delle attività integrate di hardhat.
+Per assicurarti che tutto funzioni fino a questo punto, compila il contratto. L'attività `compile` è una delle attività integrate di hardhat.
Dalla riga di comando esegui:
@@ -298,21 +294,21 @@ Dalla riga di comando esegui:
npx hardhat compile
```
-Potresti ottenere un avviso sull'assenza `nel file sorgente dell'identificativo della licenza SPDX`, ma non preoccupartene, si spera che tutto il resto funzioni! Altrimenti, puoi sempre inviare un messaggio nel [Discord di Alchemy](https://discord.gg/u72VCg3).
+Potresti ricevere un avviso `SPDX license identifier not provided in source file`, ma non c'è da preoccuparsi — si spera che tutto il resto vada bene! In caso contrario, puoi sempre inviare un messaggio nel [discord di Alchemy](https://discord.gg/u72VCg3).
-## Fase 15: scrivi lo script di distribuzione {#step-15-write-our-deploy-scripts}
+## Fase 15: Scrivi il nostro script di distribuzione {#step-15-write-our-deploy-scripts}
Ora che il nostro contratto è scritto e il nostro file di configurazione è pronto, è il momento di scrivere lo script di distribuzione del contratto.
-Vai alla cartella `script/` e crea un nuovo file chiamato `deploy.js`, aggiungendo i seguenti contenuti:
+Vai alla cartella `scripts/` e crea un nuovo file chiamato `deploy.js`, aggiungendovi i seguenti contenuti:
```
async function main() {
const HelloWorld = await ethers.getContractFactory("HelloWorld");
- // Start deployment, returning a promise that resolves to a contract object
+ // Inizia la distribuzione, restituendo una promessa che si risolve in un oggetto contratto
const hello_world = await HelloWorld.deploy("Hello World!");
- console.log("Contract deployed to address:", hello_world.address);}
+ console.log("Contratto distribuito all'indirizzo:", hello_world.address);}
main()
.then(() => process.exit(0))
@@ -322,48 +318,50 @@ main()
});
```
-Nel suo [tutorial sui Contratti](https://hardhat.org/tutorial/testing-contracts.html#writing-tests) hardhat spiega in modo eccellente cosa fa ognuna di queste righe di codice nel loro, quindi riportiamo qui le loro spiegazioni.
+Hardhat spiega molto bene cosa fa ciascuna di queste righe di codice nella sua [Guida ai contratti](https://hardhat.org/tutorial/testing-contracts.html#writing-tests), e qui abbiamo adottato le sue spiegazioni.
```
const HelloWorld = await ethers.getContractFactory("HelloWorld");
```
-Un `ContractFactory` su ethers.js è un'astrazione usata per distribuire nuovi smart contract, quindi `HelloWorld` qui è una fabbrica di istanze del nostro contratto hello world. Usando il plugin `hardhat-ethers`, le istanze `ContractFactory` e `Contract` sono connesse di default al primo firmatario.
+Una `ContractFactory` in ethers.js è un'astrazione usata per distribuire nuovi smart contract, quindi `HelloWorld` qui è una factory per le istanze del nostro contratto hello world. Quando si utilizza il plugin `hardhat-ethers`, le istanze di `ContractFactory` e `Contract` sono collegate di default al primo firmatario.
```
const hello_world = await HelloWorld.deploy();
```
-Chiamare `deploy()` su un `ContractFactory` avvierà la distribuzione e restituirà un `Promise` che si risolve in un `Contract`. Questo è l'oggetto che ha un metodo per ciascuna delle funzioni del nostro smart contract.
+Chiamare `deploy()` su una `ContractFactory` avvierà la distribuzione e restituirà una `Promise` che si risolve in un `Contract`. Questo è l'oggetto che ha un metodo per ciascuna delle funzioni del nostro smart contract.
-## Fase 16: distribuisci il contratto {#step-16-deploy-our-contract}
+## Fase 16: Distribuisci il nostro contratto {#step-16-deploy-our-contract}
Siamo finalmente pronti a distribuire il nostro smart contract! Vai alla riga di comando ed esegui:
```
-npx hardhat run scripts/deploy.js --network goerli
+npx hardhat run scripts/deploy.js --network sepolia
```
Vorrai poi vedere qualcosa del genere:
```
-Contract deployed to address: 0x6cd7d44516a20882cEa2DE9f205bF401c0d23570
+Contratto distribuito all'indirizzo: 0x6cd7d44516a20882cEa2DE9f205bF401c0d23570
```
-Se andiamo all'[Etherscan di Goerli](https://goerli.etherscan.io/) e cerchiamo l'indirizzo del nostro contratto, dovremmo poter vedere che è stato distribuito correttamente. La transazione somiglierà a questa:
+Se andiamo su [Etherscan di Sepolia](https://sepolia.etherscan.io/) e cerchiamo l'indirizzo del nostro contratto, dovremmo essere in grado di vedere che è stato distribuito con successo. La transazione somiglierà a questa:
-L'indirizzo `From` dovrebbe corrispondere all'indirizzo del tuo conto di MetaMask e, l'indirizzo To indicherà la "Creazione del Contratto"; ma cliccando sulla transazione, vedremo l'indirizzo del nostro contratto nel campo `To`:
+L'indirizzo `From` dovrebbe corrispondere all'indirizzo del tuo conto MetaMask e l'indirizzo To indicherà “Creazione del Contratto”, ma se facciamo clic sulla transazione vedremo l'indirizzo del nostro contratto nel campo `To`:
-Congratulazioni! Hai appena distribuito uno smart contract nella chain di Ethereum
+Congratulazioni! Hai appena distribuito uno smart contract sulla chain di Ethereum 🎉
-Per capire cosa sta succedendo, andiamo alla scheda Explorer nel nostro [dashboard di Alchemy](https://dashboard.alchemyapi.io/explorer). Se hai diverse app di Alchemy, assicurati di filtrare per app e selezionare "Hello World". 
+Per capire cosa sta succedendo dietro le quinte, vai alla scheda Explorer nella nostra [dashboard di Alchemy](https://dashboard.alchemyapi.io/explorer). Se hai più app di Alchemy, assicurati di filtrare per app e selezionare “Hello World”.
+
-Qui vedrai numerose chiamate a JSON-RPC che Hardhat/Ethers ha effettuato per noi quando abbiamo chiamato la funzione `.deploy()`. Due funzioni importanti da chiamare qui sono [`eth_sendRawTransaction`](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_sendrawtransaction), che è la richiesta per scrivere effettivamente il nostro contratto sulla catena di Goerli, e [`eth_getTransactionByHash`](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_gettransactionbyhash), che è una richiesta di leggere le informazioni sulla nostra transazione, dato l'hash (uno schema tipico nelle transazioni). Per saperne di più sull'invio delle transazioni, dai un'occhiata a questo tutorial [ sull'invio di transazioni usando web3](/developers/tutorials/sending-transactions-using-web3-and-alchemy/)
+Qui vedrai una manciata di chiamate JSON-RPC che Hardhat/Ethers hanno fatto per noi dietro le quinte quando abbiamo chiamato la funzione `.deploy()`. Due importanti da segnalare qui sono [`eth_sendRawTransaction`](https://www.alchemy.com/docs/node/abstract/abstract-api-endpoints/eth-send-raw-transaction), che è la richiesta per scrivere effettivamente il nostro contratto sulla catena di Sepolia, e [`eth_getTransactionByHash`](https://www.alchemy.com/docs/node/abstract/abstract-api-endpoints/eth-get-transaction-by-hash), che è una richiesta per leggere informazioni sulla nostra transazione dato l'hash (un modello tipico quando si effettuano
+transazioni). Per saperne di più sull'invio di transazioni, consulta questo tutorial su [come inviare transazioni usando Web3](/developers/tutorials/sending-transactions-using-web3-and-alchemy/)
-Questo è tutto per la parte 1 di questo tutorial, nella parte 2, [interagiremo realmente con il nostro smart contract](https://docs.alchemyapi.io/alchemy/tutorials/hello-world-smart-contract#part-2-interact-with-your-smart-contract) aggiornando il nostro messaggio iniziale e nella parte 3 [pubblicheremo il nostro smart contract su Etherscan](https://docs.alchemyapi.io/alchemy/tutorials/hello-world-smart-contract#optional-part-3-publish-your-smart-contract-to-etherscan), così che tutti sapranno come interagire con esso.
+Questo è tutto per la parte 1 di questo tutorial, nella [parte 2](https://www.alchemy.com/docs/interacting-with-a-smart-contract) interagiremo effettivamente con il nostro smart contract aggiornando il nostro messaggio iniziale, e nella [parte 3](https://www.alchemy.com/docs/submitting-your-smart-contract-to-etherscan) pubblicheremo il nostro smart contract su Etherscan in modo che tutti sappiano come interagire con esso.
-**Vuoi saperne di più su Alchemy? Dai un'occhiata al nostro [sito web](https://alchemyapi.io/eth). Non vuoi mai perderti un aggiornamento? Iscriviti alla nostra newsletter [qui](https://www.alchemyapi.io/newsletter)! Assicurati anche di seguire il nostro [Twitter](https://twitter.com/alchemyplatform) e di unirti al nostro [Discord](https://discord.com/invite/u72VCg3)**.
+**Vuoi saperne di più su Alchemy?** Visita il nostro [sito web](https://www.alchemy.com/eth). Non vuoi perderti nessun aggiornamento? Iscriviti alla nostra newsletter [qui](https://www.alchemy.com/newsletter)! Assicurati di unirti anche al nostro [Discord](https://discord.gg/u72VCg3).\*\*.
diff --git a/public/content/translations/it/developers/tutorials/how-to-implement-an-erc721-market/index.md b/public/content/translations/it/developers/tutorials/how-to-implement-an-erc721-market/index.md
index c0ab631254c..d282b5fa2ea 100644
--- a/public/content/translations/it/developers/tutorials/how-to-implement-an-erc721-market/index.md
+++ b/public/content/translations/it/developers/tutorials/how-to-implement-an-erc721-market/index.md
@@ -2,11 +2,7 @@
title: Come implementare un market ERC-721
description: Come mettere in vendita oggetti tokenizzati su bacheche di annunci decentralizzate
author: "Alberto Cuesta Cañada"
-tags:
- - "smart contract"
- - "erc-721"
- - "Solidity"
- - "token"
+tags: [ "Smart Contract", "erc-721", "solidity", "token" ]
skill: intermediate
lang: it
published: 2020-03-19
@@ -26,13 +22,13 @@ Con la blockchain questi mercati sono destinati a cambiare di nuovo, vediamo com
Il modello di business di una bacheca di annunci su blockchain pubblica sarà diverso da quello di Ebay e simili.
-Prima di tutto, c'è la [questione della decentralizzazione](/developers/docs/web2-vs-web3/). Le piattaforme esistenti devono mantenere i loro server. Una piattaforma decentralizzata è gestita dai suoi utenti, quindi il costo per tenere attiva la piattaforma base scende a zero per il proprietario della piattaforma.
+Innanzitutto, c'è [l'aspetto del decentramento](/developers/docs/web2-vs-web3/). Le piattaforme esistenti devono mantenere i loro server. Una piattaforma decentralizzata è gestita dai suoi utenti, quindi il costo per tenere attiva la piattaforma base scende a zero per il proprietario della piattaforma.
-Poi c'è il front end, ossia il sito Web o l'interfaccia che dà accesso alla piattaforma. Qua ci sono molte opzioni. Il proprietario della piattaforma può limitare l'accesso e costringere tutti a usare la propria interfaccia, imponendo un costo di utilizzo. I proprietari della piattaforma possono anche decidere di lasciare libero l'accesso (potere al popolo!) e di permettere che chiunque crei interfacce per la piattaforma. Oppure, potrebbero decidere qualsiasi altro tipo di approccio tra questi due estremi.
+Poi c'è il front end, ossia il sito Web o l'interfaccia che dà accesso alla piattaforma. Qua ci sono molte opzioni. Il proprietario della piattaforma può limitare l'accesso e costringere tutti a usare la propria interfaccia, imponendo un costo di utilizzo. I proprietari della piattaforma possono anche decidere di aprire l'accesso (Potere al popolo!) e permettere a chiunque di creare interfacce per la piattaforma. Oppure, potrebbero decidere qualsiasi altro tipo di approccio tra questi due estremi.
_Chi si occupa di affari e ha più visione di me saprà come monetizzare tutto questo. Tutto quello che io riesco a capire è che questo è diverso dallo status quo e probabilmente redditizio._
-In più, c'è la questione dell'automazione e dei pagamenti. Alcuni articoli si prestano molto ad essere [tokenizzati in modo efficace](https://hackernoon.com/tokenization-of-digital-assets-g0ffk3v8s?ref=hackernoon.com) e scambiati in una bacheca di annunci. Le risorse tokenizzate sono facilmente trasferibili su una blockchain. Metodi di pagamento altamente complessi possono essere facilmente implementati su una blockchain.
+In più, c'è la questione dell'automazione e dei pagamenti. Alcune cose possono essere [tokenizzate molto efficacemente](https://hackernoon.com/tokenization-of-digital-assets-g0ffk3v8s?ref=hackernoon.com) e scambiate in una bacheca di annunci. Le risorse tokenizzate sono facilmente trasferibili su una blockchain. Metodi di pagamento altamente complessi possono essere facilmente implementati su una blockchain.
Sento odore di business. Una bacheca di annunci senza costi di gestione può facilmente essere implementata con complessi percorsi di pagamento inclusi in ogni transazione. Sono sicuro che qualcuno verrà fuori con qualche idea su come utilizzare tutto questo.
@@ -40,9 +36,9 @@ Io sono felice di occuparmi della programmazione. Diamo un'occhiata al codice.
## Implementazione {#implementation}
-Un po' di tempo fa abbiamo iniziato un [repository open source](https://github.com/HQ20/contracts?ref=hackernoon.com) con implementazioni di esempio e altre cose interessanti, consiglio di dare una sbirciata.
+Qualche tempo fa abbiamo avviato un [repository open source](https://github.com/HQ20/contracts?ref=hackernoon.com) con implementazioni di esempi di casi aziendali e altre cose interessanti, dai un'occhiata.
-Il codice di questa [bacheca di annunci Ethereum](https://github.com/HQ20/contracts/tree/master/contracts/classifieds?ref=hackernoon.com) è qui, potete usarlo e anche abusarne. Occhio solo che non è stato verificato e quindi fate molta attenzione prima di metterci dei soldi.
+Il codice per questa [Bacheca di Annunci di Ethereum](https://github.com/HQ20/contracts/tree/master/contracts/classifieds?ref=hackernoon.com) è lì, per favore usalo e sfruttalo al massimo. Occhio solo che non è stato verificato e quindi fate molta attenzione prima di metterci dei soldi.
Le basi della bacheca non sono difficili. Tutti gli annunci della bacheca saranno semplicemente uno struct con pochi campi:
@@ -67,9 +63,9 @@ Usare un mapping significa solo che dobbiamo trovare un ID per ogni annuncio pri
La seconda questione è capire quali sono gli elementi con cui lavoriamo e qual è la valuta che deve essere usata per pagare la transazione.
-Per gli elementi, chiederemo solo che implementino l'interfaccia [ERC-721](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/IERC721.sol?ref=hackernoon.com), che è semplicemente un modo per rappresentare gli oggetti del mondo reale su una blockchain, anche se [funziona meglio con le risorse digitali](https://hackernoon.com/tokenization-of-digital-assets-g0ffk3v8s?ref=hackernoon.com). Specificheremo il nostro contratto ERC271 nel costruttore, dicendo che ogni risorsa della nostra bacheca di annunci deve prima essere tokenizzata.
+Per gli articoli, chiederemo solo che implementino l'interfaccia [ERC-721](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/IERC721.sol?ref=hackernoon.com), che in realtà è solo un modo per rappresentare oggetti del mondo reale in una blockchain, anche se [funziona meglio con gli asset digitali](https://hackernoon.com/tokenization-of-digital-assets-g0ffk3v8s?ref=hackernoon.com). Specificheremo il nostro contratto ERC271 nel costruttore, dicendo che ogni risorsa della nostra bacheca di annunci deve prima essere tokenizzata.
-Per i pagamenti, faremo qualcosa di simile. La maggior parte dei progetti di blockchain definisce la propria criptovaluta [ERC-20](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol?ref=hackernoon.com). Altri preferiscono usarne una popolare come DAI. In questa bacheca di annunci, dovrai solo decidere al momento della creazione quale sarà la tua valuta. Facile.
+Per i pagamenti, faremo qualcosa di simile. La maggior parte dei progetti blockchain definisce la propria criptovaluta [ERC-20](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol?ref=hackernoon.com). Altri preferiscono usarne una popolare come DAI. In questa bacheca di annunci, dovrai solo decidere al momento della creazione quale sarà la tua valuta. Facile.
```solidity
constructor (
@@ -127,16 +123,16 @@ function cancelTrade(uint256 _trade)
Trade memory trade = trades[_trade];
require(
msg.sender == trade.poster,
- "Trade can be cancelled only by poster."
+ "Lo scambio può essere annullato solo da chi lo ha pubblicato."
);
- require(trade.status == "Open", "Trade is not Open.");
+ require(trade.status == "Open", "Lo scambio non è Aperto.");
itemToken.transferFrom(address(this), trade.poster, trade.item);
trades[_trade].status = "Cancelled";
emit TradeStatusChange(_trade, "Cancelled");
}
```
-Ecco qua. Siamo giunti alla fine dell'implementazione. È sorprendente come alcuni concetti di business siano compatti quando vengono espressi con codice, e questo è uno di questi esempi. Guarda il contratto completo [nel nostro repo](https://github.com/HQ20/contracts/blob/master/contracts/classifieds/Classifieds.sol).
+Ecco qua. Siamo giunti alla fine dell'implementazione. È sorprendente come alcuni concetti di business siano compatti quando vengono espressi con codice, e questo è uno di questi esempi. Consulta il contratto completo [nel nostro repository](https://github.com/HQ20/contracts/blob/master/contracts/classifieds/Classifieds.sol).
## Conclusione {#conclusion}
@@ -146,4 +142,4 @@ Sono anche uno strumento facile da replicare in un ambiente blockchain, con cara
In questo articolo ho fatto un tentativo di collegare la realtà delle bacheche di annunci con l'implementazione tecnologica. Queste conoscenze, con le giuste capacità, dovrebbero aiutare a creare una vision e una roadmap per l'implementazione.
-Come sempre, se vuoi creare qualcosa di interessante e vorresti qualche consiglio, [scrivimi](https://albertocuesta.es/)! Sono sempre felice di dare una mano.
+Come sempre, se vuoi creare qualcosa di interessante e vorresti qualche consiglio, [scrivimi pure](https://albertocuesta.es/)! Sono sempre felice di dare una mano.
diff --git a/public/content/translations/it/developers/tutorials/how-to-mint-an-nft/index.md b/public/content/translations/it/developers/tutorials/how-to-mint-an-nft/index.md
index bacc5b8b167..369926d711c 100644
--- a/public/content/translations/it/developers/tutorials/how-to-mint-an-nft/index.md
+++ b/public/content/translations/it/developers/tutorials/how-to-mint-an-nft/index.md
@@ -1,38 +1,36 @@
---
-title: Come coniare un NFT (Parte 2/3 della Serie di tutorial sugli NFT)
-description: Questo tutorial descrive come coniare un NFT sulla Blockchain di Ethereum usando il nostro contratto intelligente e Web3.
+title: Come coniare un NFT (Parte 2/3 della serie di tutorial sugli NFT)
+description: Questo tutorial descrive come coniare un NFT sulla blockchain di Ethereum usando il nostro contratto intelligente e Web3.
author: "Sumi Mudgil"
-tags:
- - "ERC-721"
- - "alchemy"
- - "solidity"
- - "contratti intelligenti"
+tags: [ "ERC-721", "alchemy", "Solidity", "smart contract" ]
skill: beginner
lang: it
published: 2021-04-22
---
-[Beeple](https://www.nytimes.com/2021/03/11/arts/design/nft-auction-christies-beeple.html): $69 milioni [3LAU](https://www.forbes.com/sites/abrambrown/2021/03/03/3lau-nft-nonfungible-tokens-justin-blau/?sh=5f72ef64643b): $11 milioni [Grimes](https://www.theguardian.com/music/2021/mar/02/grimes-sells-digital-art-collection-non-fungible-tokens): $6 milioni
+[Beeple](https://www.nytimes.com/2021/03/11/arts/design/nft-auction-christies-beeple.html): 69 milioni di dollari
+[3LAU](https://www.forbes.com/sites/abrambrown/2021/03/03/3lau-nft-nonfungible-tokens-justin-blau/?sh=5f72ef64643b): 11 milioni di dollari
+[Grimes](https://www.theguardian.com/music/2021/mar/02/grimes-sells-digital-art-collection-non-fungible-tokens): 6 milioni di dollari
-Tutti loro hanno coniato i propri NFT utilizzando la potente API di Alchemy. In questo tutorial ti insegneremo come fare lo stesso in meno di 10 minuti.
+Tutti loro hanno coniato i propri NFT utilizzando la potente API di Alchemy. In questo tutorial ti insegneremo come fare lo stesso in \<10 minuti.
-"Coniare un NFT" è l'atto di pubblicare un'istanza unica del tuo token ERC-721 sulla blockchain. Usando il nostro contratto intelligente dalla [Parte 1 di questa serie di tutorial sugli NFT](/developers/tutorials/how-to-write-and-deploy-an-nft/), dimostriamo le nostre abilità di Web3 e coniamo un NFT. Alla fine di questo tutorial, potrai coniare tutti gli NFT che desideri (e che può permettersi il tuo portafoglio)!
+"Coniare un NFT" è l'atto di pubblicare un'istanza unica del tuo token ERC-721 sulla blockchain. Usando il nostro contratto intelligente dalla [Parte 1 di questa serie di tutorial sugli NFT](/developers/tutorials/how-to-write-and-deploy-an-nft/), dimostriamo le nostre abilità con Web3 e coniamo un NFT. Alla fine di questo tutorial, potrai coniare tutti gli NFT che desideri (e che può permettersi il tuo portafoglio)!
Iniziamo!
-## Fase 1: installa Web3 {#install-web3}
+## Fase 1: Installare Web3 {#install-web3}
-Se hai seguito il primo tutorial sulla creazione del tuo contratto intelligente di NFT, hai già esperienza usando Ethers.js. Web3 è simile a Ethers, trattandosi di una libreria usata per effettuare più facilmente richieste di creazione alla Blockchain di Ethereum. In questo tutorial, useremo [Alchemy Web3](https://docs.alchemyapi.io/alchemy/documentation/alchemy-web3), una libreria Web3 migliorata che offre tentativi automatici e robusto supporto a WebSocket.
+Se hai seguito il primo tutorial sulla creazione del tuo contratto intelligente di NFT, hai già esperienza con Ethers.js. Web3 è simile a Ethers, trattandosi di una libreria usata per effettuare più facilmente richieste alla blockchain di Ethereum. In questo tutorial useremo [Alchemy Web3](https://docs.alchemyapi.io/alchemy/documentation/alchemy-web3), una libreria Web3 migliorata che offre tentativi automatici e un solido supporto a WebSocket.
-Nella cartella home del tuo progetto, esegui:
+Nella cartella principale del tuo progetto, esegui:
```
npm install @alch/alchemy-web3
```
-## Fase 2: crea un file `mint-nft.js` {#create-mintnftjs}
+## Fase 2: Crea un file `mint-nft.js` {#create-mintnftjs}
-Nella tua cartella di script, crea un `mint-nft.js` e aggiungi le seguenti righe di codice:
+Nella tua cartella degli script, crea un file `mint-nft.js` e aggiungi le seguenti righe di codice:
```js
require("dotenv").config()
@@ -41,9 +39,9 @@ const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
const web3 = createAlchemyWeb3(API_URL)
```
-## Fase 3: prendi l'ABI del tuo contratto {#contract-abi}
+## Fase 3: Prendi l'ABI del tuo contratto {#contract-abi}
-L'ABI (Interfaccia Binaria dell'Applicazione) del nostro contratto è l'interfaccia per interagire con il nostro contratto intelligente. Puoi saperne di più sull'ABI dei contratti leggi [qui](https://docs.alchemyapi.io/alchemy/guides/eth_getlogs#what-are-ab-is). Hardhat genera automaticamente un'ABI e la salva nel file `MyNFT.json`. Per poterla usare, dovremo analizzare i contenuti aggiungendo le seguenti righe di codice al nostro `mint-nft.js`:
+L'ABI (Application Binary Interface) del nostro contratto è l'interfaccia per interagire con il nostro contratto intelligente. Puoi saperne di più sugli ABI dei contratti [qui](https://docs.alchemyapi.io/alchemy/guides/eth_getlogs#what-are-ab-is). Hardhat genera automaticamente un'ABI per noi e la salva nel file `MyNFT.json`. Per poterla usare, dovremo analizzarne i contenuti aggiungendo le seguenti righe di codice al nostro file `mint-nft.js`:
```js
const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json")
@@ -55,69 +53,69 @@ Se vuoi vedere l'ABI, puoi stamparla nella tua console:
console.log(JSON.stringify(contract.abi))
```
-Per eseguire `mint-nft.js` e vedere l'ABI stampata alla console, vai alla console ed esegui:
+Per eseguire `mint-nft.js` e vedere la tua ABI stampata sulla console, vai al tuo terminale ed esegui:
```js
node scripts/mint-nft.js
```
-## Fase 4: configura i metadati del tuo NFT usando IPFS {#config-meta}
+## Fase 4: Configura i metadati del tuo NFT usando IPFS {#config-meta}
-Se ti ricordi dal nostro tutorial nella Parte 1, la funzione del nostro contratto intelligente `mintNFT` prende un parametro tokenURl che dovrebbe risolversi a un documento JSON che descrive i metadati del NFT; che è ciò che porta realmente in vita lo NFT, consentendogli di avere proprietà configurabili, come un nome, una descrizione, un'immagine e altri attributi.
+Se ricordi dal nostro tutorial nella Parte 1, la funzione del nostro contratto intelligente `mintNFT` riceve un parametro tokenURI, che dovrebbe risolversi in un documento JSON che descrive i metadati dell'NFT, ed è questo che porta realmente in vita l'NFT, consentendogli di avere proprietà configurabili, quali nome, descrizione, immagine e altri attributi.
-> _Il Planetary File System (IPFS) è un protocollo decentralizzato e una rete peer-to-peer per memorizzare e condividere i dati in un file di sistema distribuito._
+> _L'Interplanetary File System (IPFS) è un protocollo decentralizzato e una rete peer-to-peer per l'archiviazione e la condivisione di dati in un file system distribuito._
-Useremo Pinata, una comoda API di IPFS e strumento per memorizzare la nostra risorsa NFT e i metadati, per essere sicuri che il nostro NFT sia realmente decentralizzato. Se non hai un conto di Pinata, registrane uno gratuito [qui](https://app.pinata.cloud) e completa i passaggi per verificare la tua email.
+Useremo Pinata, una comoda API e un pratico toolkit di IPFS per archiviare le risorse e i metadati del nostro NFT e per garantire che il nostro NFT sia veramente decentralizzato. Se non hai un account Pinata, creane uno gratuito [qui](https://app.pinata.cloud) e completa i passaggi per verificare la tua e-mail.
-Una volta creato un conto:
+Una volta creato un account:
-- Vai alla pagina "File" e clicca il pulsante "Carica" blu in alto a sinistra alla pagina.
+- Vai alla pagina "File" e fai clic sul pulsante blu "Carica" in alto a sinistra nella pagina.
-- Carica un'immagine su Pinata, sarà la risorsa immagine del tuo NFT. Assegna alla risorsa il nome desideri
+- Carica un'immagine su Pinata: sarà la risorsa immagine del tuo NFT. Puoi dare alla risorsa il nome che desideri
-- Dopo il caricamento, vedrai le informazioni del file nella tabella sulla pagina "File". Vedrai anche una colonna CID. Puoi copiare il CID cliccando il pulsante di copia accanto. Puoi visualizzare il tuo caricamento su: `https://gateway.pinata.cloud/ipfs/`. Puoi trovare l'immagine che abbiamo usato su IPFS [qui](https://gateway.pinata.cloud/ipfs/QmZdd5KYdCFApWn7eTZJ1qgJu18urJrP9Yh1TZcZrZxxB5), ad esempio.
+- Dopo il caricamento, vedrai le informazioni del file nella tabella sulla pagina "File". Vedrai anche una colonna CID. Puoi copiare il CID facendo clic sul pulsante di copia accanto. Puoi visualizzare il file caricato su: `https://gateway.pinata.cloud/ipfs/`. Ad esempio, puoi trovare l'immagine che abbiamo usato su IPFS [qui](https://gateway.pinata.cloud/ipfs/QmZdd5KYdCFApWn7eTZJ1qgJu18urJrP9Yh1TZcZrZxxB5).
-Per chi preferisce un apprendimento "visivo", i passaggi sopra sono riassunti qui:
+Per chi impara più facilmente con supporti visivi, i passaggi precedenti sono riassunti qui:
-
+
-Vogliamo caricare ora un altro documento su Pinata. Ma prima, dobbiamo crearlo!
+Ora caricheremo un altro documento su Pinata. Ma prima, dobbiamo crearlo!
-Nella tua cartella di root, crea un nuovo file chiamato `nft-metadata.json` e aggiungi il seguente codice json:
+Nella tua cartella radice, crea un nuovo file chiamato `nft-metadata.json` e aggiungi il seguente codice json:
```json
{
"attributes": [
{
- "trait_type": "Breed",
+ "trait_type": "Razza",
"value": "Maltipoo"
},
{
- "trait_type": "Eye color",
- "value": "Mocha"
+ "trait_type": "Colore occhi",
+ "value": "Moka"
}
],
- "description": "The world's most adorable and sensitive pup.",
+ "description": "Il cucciolo più adorabile e sensibile del mondo.",
"image": "ipfs://QmWmvTJmJU3pozR9ZHFmQC2DNDwi2XJtf3QGyYiiagFSWb",
"name": "Ramses"
}
```
-Puoi modificare liberamente i dati nel json. Puoi rimuoverli o aggiungerli alla sezione degli attributi. Soprattutto, assicurati che il campo immagine punti alla posizione della tua immagine IPFS; altrimenti, il tuo NFT includerà la foto di un cane (molto carino!).
+Puoi modificare liberamente i dati nel file json. Puoi rimuovere attributi o aggiungerne di nuovi. Soprattutto, assicurati che il campo dell'immagine punti alla posizione della tua immagine IPFS, altrimenti il tuo NFT includerà una foto di un ( carinissimo!) cane.
Una volta finito di modificare il file JSON, salvalo e caricalo su Pinata, seguendo gli stessi passaggi di caricamento dell'immagine.
-
+
-## Fase 5: crea un'istanza del tuo contratto {#instance-contract}
+## Fase 5: Crea un'istanza del tuo contratto {#instance-contract}
-Ora, per interagire con il nostro contratto, dobbiamo crearne un'istanza nel nostro codice. Per farlo, avremo bisogno dell'indirizzo del nostro contratto, che possiamo ottenere dalla distribuzione o da [Etherscan](https://sepolia.etherscan.io/), cercando l'indirizzo usato per distribuire il contratto.
+Ora, per interagire con il nostro contratto, dobbiamo crearne un'istanza nel nostro codice. Per farlo, avremo bisogno dell'indirizzo del nostro contratto, che possiamo ottenere dalla distribuzione o da [Blockscout](https://eth-sepolia.blockscout.com/) cercando l'indirizzo che hai usato per distribuire il contratto.
Nell'esempio precedente, l'indirizzo del nostro contratto è 0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778.
-Poi useremo il [metodo di contratto](https://docs.web3js.org/api/web3-eth-contract/class/Contract) di Web3 per creare il nostro contratto usando l'ABI e l'indirizzo. Nel tuo file `mint-nft.js`, aggiungi quanto segue:
+Successivamente, useremo il [metodo contract](https://docs.web3js.org/api/web3-eth-contract/class/Contract) di Web3 per creare il nostro contratto usando l'ABI e l'indirizzo. Nel tuo file `mint-nft.js`, aggiungi quanto segue:
```js
const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
@@ -125,11 +123,11 @@ const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
const nftContract = new web3.eth.Contract(contract.abi, contractAddress)
```
-## Fase 6: aggiorna il file `.env` {#update-env}
+## Fase 6: Aggiorna il file `.env` {#update-env}
-Ora, per poter creare e inviare le transazioni alla catena di Ethereum, useremo l'indirizzo pubblico del tuo conto di Ethereum per ottenerne il nonce (spiegheremo in seguito).
+Ora, per creare e inviare transazioni alla catena di Ethereum, useremo l'indirizzo pubblico del tuo account Ethereum per ottenere il nonce dell'account (lo spiegheremo più avanti).
-Aggiungi la tua chiave pubblica al tuo file `.env`; se hai completato la parte 1 del tutorial, il nostro file `.env` dovrebbe somigliare a questo:
+Aggiungi la tua chiave pubblica al tuo file `.env`; se hai completato la parte 1 del tutorial, il nostro file `.env` dovrebbe ora avere questo aspetto:
```js
API_URL = "https://eth-sepolia.g.alchemy.com/v2/your-api-key"
@@ -137,27 +135,27 @@ PRIVATE_KEY = "your-private-account-address"
PUBLIC_KEY = "your-public-account-address"
```
-## Fase 7: crea la tua transazione {#create-txn}
+## Fase 7: Crea la tua transazione {#create-txn}
-Prima di tutto, definiamo una funzione denominata `mintNFT(tokenData)` e creiamo la nostra transazione facendo quanto segue:
+Prima di tutto, definiamo una funzione denominata `mintNFT(tokenData)` e creiamo la nostra transazione nel modo seguente:
-1. Prendi la tua _PRIVATE_KEY_ e _PUBLIC_KEY_ dal file `.env`.
+1. Prendi i tuoi _PRIVATE_KEY_ e _PUBLIC_KEY_ dal file `.env`.
-1. Poi, dobbiamo trovare il nonce del conto. La specifica di nonce è usata per tracciare il numero di transazioni inviate dal tuo indirizzo, di cui necessitiamo per motivi di sicurezza e per impedire gli [attacchi di riproduzione](https://docs.alchemyapi.io/resources/blockchain-glossary#account-nonce). Per ottenere il numero di transazioni inviate dal tuo indirizzo, usiamo [getTransactionCount](https://docs.alchemyapi.io/documentation/alchemy-api-reference/json-rpc#eth_gettransactioncount).
+2. Successivamente, dovremo ricavare il nonce dell'account. La specifica del nonce è usata per tracciare il numero di transazioni inviate dal tuo indirizzo, di cui necessitiamo per motivi di sicurezza e per impedire gli [attacchi di riproduzione](https://docs.alchemyapi.io/resources/blockchain-glossary#account-nonce). Per ottenere il numero di transazioni inviate dal tuo indirizzo, usiamo [getTransactionCount](https://docs.alchemyapi.io/documentation/alchemy-api-reference/json-rpc#eth_gettransactioncount).
-1. Infine, configureremo la nostra transazione con le seguenti informazioni:
+3. Infine, configureremo la nostra transazione con le seguenti informazioni:
- `'from': PUBLIC_KEY` — L'origine della nostra transazione è il nostro indirizzo pubblico
- `'to': contractAddress` — Il contratto con cui vogliamo interagire e a cui vogliamo inviare la transazione
-- `'nonce': nonce`: l'account nonce con il numero di transazioni inviate dal nostro indirizzo
+- `'nonce': nonce` — Il nonce dell'account con il numero di transazioni inviate dal nostro indirizzo
-- `'gas': estimatedGas`: Il gas stimato necessario per completare la transazione
+- `'gas': estimatedGas` — Il gas stimato necessario per completare la transazione
- `'data': nftContract.methods.mintNFT(PUBLIC_KEY, md).encodeABI()` — Il calcolo che vogliamo eseguire in questa transazione, che in questo caso è il conio di un NFT
-Il tuo file `mint-nft.js` dovrebbe somigliare a questo ora:
+Il tuo file `mint-nft.js` dovrebbe ora avere questo aspetto:
```js
require('dotenv').config();
@@ -173,9 +171,9 @@ Il tuo file `mint-nft.js` dovrebbe somigliare a questo ora:
const nftContract = new web3.eth.Contract(contract.abi, contractAddress);
async function mintNFT(tokenURI) {
- const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, 'latest'); //get latest nonce
+ const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, 'latest'); // ottieni l'ultimo nonce
- //the transaction
+ // la transazione
const tx = {
'from': PUBLIC_KEY,
'to': contractAddress,
@@ -186,11 +184,11 @@ Il tuo file `mint-nft.js` dovrebbe somigliare a questo ora:
}
```
-## Fase 8: firma la transazione {#sign-txn}
+## Fase 8: Firma la transazione {#sign-txn}
-Ora che abbiamo creato la nostra transazione, dobbiamo firmarla per inviarla. Ecco dove useremo la nostra chiave privata.
+Ora che abbiamo creato la nostra transazione, dobbiamo firmarla per poterla inviare. Qui è dove useremo la nostra chiave privata.
-`web3.eth. endSignedTransaction` ci darà l'hash della transazione, che possiamo usare per assicurarci che la nostra transazione sia stata minata e non sia stata eliminata dalla rete. Noterai nella sezione di firma della transazione che abbiamo aggiunto dei controlli degli errori, per poter sapere se la nostra transazione è passata correttamente.
+`web3.eth.sendSignedTransaction` ci darà l'hash della transazione, che possiamo usare per assicurarci che la nostra transazione sia stata minata e non sia stata scartata dalla rete. Noterai che nella sezione di firma della transazione abbiamo aggiunto dei controlli degli errori, per poter sapere se la nostra transazione è andata a buon fine.
```js
require("dotenv").config()
@@ -206,9 +204,9 @@ const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
const nftContract = new web3.eth.Contract(contract.abi, contractAddress)
async function mintNFT(tokenURI) {
- const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") //get latest nonce
+ const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") // ottieni l'ultimo nonce
- //the transaction
+ // la transazione
const tx = {
from: PUBLIC_KEY,
to: contractAddress,
@@ -225,13 +223,13 @@ async function mintNFT(tokenURI) {
function (err, hash) {
if (!err) {
console.log(
- "The hash of your transaction is: ",
+ "L'hash della tua transazione è: ",
hash,
- "\nCheck Alchemy's Mempool to view the status of your transaction!"
+ "\nControlla il Mempool di Alchemy per visualizzare lo stato della tua transazione!"
)
} else {
console.log(
- "Something went wrong when submitting your transaction:",
+ "Qualcosa è andato storto durante l'invio della transazione:",
err
)
}
@@ -239,24 +237,24 @@ async function mintNFT(tokenURI) {
)
})
.catch((err) => {
- console.log(" Promise failed:", err)
+ console.log(" Promise non riuscita:", err)
})
}
```
-## Fase 9: chiama `mintNFT` ed esegui il nodo `mint-nft.js` {#call-mintnft-fn}
+## Fase 9: Chiama `mintNFT` ed esegui `node mint-nft.js` {#call-mintnft-fn}
-Ricordi il `metadata.json` che hai caricato su Pinata? Ottieni il suo hashcode da Pinata e passa il seguente come un parametro alla funzione `mintNFT` `https://gateway.pinata.cloud/ipfs/`
+Ricordi il file `metadata.json` che hai caricato su Pinata? Ottieni il suo codice hash da Pinata e passalo come parametro alla funzione `mintNFT` `https://gateway.pinata.cloud/ipfs/`
-Ecco come ottenere l'hashcode:
+Ecco come ottenere il codice hash:
-_Come ottenere l'hashcode dei metadati del tuo NFT su Pinata_
+_Come ottenere il codice hash dei metadati del tuo NFT su Pinata_
-> Ricontrolla che l'hashcode che hai copiato si colleghi al tuo **metadata.json**, caricando `https://gateway.pinata.cloud/ipfs/` in una finestra separata. La pagina dovrebbe somigliare al seguente screenshot:
+> Verifica che il codice hash che hai copiato rimandi al tuo file **metadata.json** caricando `https://gateway.pinata.cloud/ipfs/` in una finestra separata. La pagina dovrebbe avere un aspetto simile allo screenshot qui sotto:
-_La tua pagina deve mostrare i metadati in json_
+_La tua pagina dovrebbe visualizzare i metadati json_
-Nel complesso, il tuo codice dovrebbe somigliare a questo:
+Nel complesso, il tuo codice dovrebbe avere questo aspetto:
```js
require("dotenv").config()
@@ -272,9 +270,9 @@ const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
const nftContract = new web3.eth.Contract(contract.abi, contractAddress)
async function mintNFT(tokenURI) {
- const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") //get latest nonce
+ const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") // ottieni l'ultimo nonce
- //the transaction
+ // la transazione
const tx = {
from: PUBLIC_KEY,
to: contractAddress,
@@ -291,13 +289,13 @@ async function mintNFT(tokenURI) {
function (err, hash) {
if (!err) {
console.log(
- "The hash of your transaction is: ",
+ "L'hash della tua transazione è: ",
hash,
- "\nCheck Alchemy's Mempool to view the status of your transaction!"
+ "\nControlla il Mempool di Alchemy per visualizzare lo stato della tua transazione!"
)
} else {
console.log(
- "Something went wrong when submitting your transaction:",
+ "Qualcosa è andato storto durante l'invio della transazione:",
err
)
}
@@ -305,26 +303,27 @@ async function mintNFT(tokenURI) {
)
})
.catch((err) => {
- console.log("Promise failed:", err)
+ console.log("Promise non riuscita:", err)
})
}
mintNFT("ipfs://QmYueiuRNmL4MiA2GwtVMm6ZagknXnSpQnB3z2gWbz36hP")
```
-Ora, esegui `scripts/mint-nft.js` per distribuire il tuo NFT. Dopo qualche secondo, dovresti vedere una risposta come questa nel tuo terminale:
+Ora, esegui `node scripts/mint-nft.js` per distribuire il tuo NFT. Dopo qualche secondo, dovresti vedere una risposta come questa nel tuo terminale:
- L'hash della tua transazione è:
- 0x301791fdf492001fcd9d5e5b12f3aa1bbbea9a88ed24993a8ab2cdae2d06e1e8
+ ```
+ L'hash della tua transazione è: 0x301791fdf492001fcd9d5e5b12f3aa1bbbea9a88ed24993a8ab2cdae2d06e1e8
- Consulta il Mempool di Alchemy per visualizzare lo stato della tua transazione!
+ Controlla il Mempool di Alchemy per visualizzare lo stato della tua transazione!
+ ```
-Vai quindi alla tua [mempool di Alchemy](https://dashboard.alchemyapi.io/mempool) per vedere lo stato della transazione (se è sospesa, minata o eliminata dalla rete). Se la tua transazione è stata eliminata, è utile dare un'occhiata anche su [Sepolia Etherscan](https://sepolia.etherscan.io/) e cercare l'hash della tua transazione.
+Successivamente, visita il [mempool di Alchemy](https://dashboard.alchemyapi.io/mempool) per vedere lo stato della tua transazione (se è in sospeso, minata o è stata scartata dalla rete). Se la transazione è stata scartata, è utile anche controllare su [Blockscout](https://eth-sepolia.blockscout.com/) e cercare l'hash della transazione.
-_Visualizza l'hash della tua transazione NFT su Etherscan_
+_Visualizza l'hash della transazione del tuo NFT su Etherscan_
-Ecco fatto! Hai ora distribuito E coniato con un NFT sulla Blockchain di Ethereum
+Ecco fatto! Hai distribuito E coniato un NFT sulla blockchain di Ethereum
-Utilizzando `mint-nft.js`, puoi coniare quanti NFT il tuo cuore, e portafoglio, desiderino! Basta che ti accerti di passare un nuovo tokenURI che descriva i metadati dell'NFT (altrimenti, finirai per crearne tanti identici con ID differenti).
+Utilizzando `mint-nft.js`, puoi coniare quanti NFT il tuo cuore (e portafoglio) desidera! Basta che ti accerti di passare un nuovo tokenURI che descriva i metadati dell'NFT (altrimenti, finirai per crearne tanti identici con ID differenti).
-Molto probabilmente vorrai visualizzare il tuo NFT nel tuo portafoglio, quindi assicurati di leggere la [Parte 3: come visualizzare il tuo NFT nel portafoglio](/developers/tutorials/how-to-view-nft-in-metamask/)!
+Probabilmente vorrai poter mostrare il tuo NFT nel portafoglio, quindi assicurati di consultare la [Parte 3: Come visualizzare il tuo NFT nel tuo portafoglio](/developers/tutorials/how-to-view-nft-in-metamask/)!
diff --git a/public/content/translations/it/developers/tutorials/how-to-mock-solidity-contracts-for-testing/index.md b/public/content/translations/it/developers/tutorials/how-to-mock-solidity-contracts-for-testing/index.md
index cec6a7b6dab..fca229e8088 100644
--- a/public/content/translations/it/developers/tutorials/how-to-mock-solidity-contracts-for-testing/index.md
+++ b/public/content/translations/it/developers/tutorials/how-to-mock-solidity-contracts-for-testing/index.md
@@ -1,30 +1,26 @@
---
title: Come simulare i contratti intelligenti in Solidity per testarli
-description: Perché è importante prendersi gioco dei propri contratti in fase di test
+description: "Perché è importante prendersi gioco dei propri contratti in fase di test"
author: Markus Waas
lang: it
-tags:
- - "solidity"
- - "contratti intelligenti"
- - "test"
- - "simulazione"
+tags: [ "Solidity", "smart contract", "test", "simulazione" ]
skill: intermediate
published: 2020-05-02
source: soliditydeveloper.com
sourceUrl: https://soliditydeveloper.com/mocking-contracts
---
-[Gli oggetti Mock](https://wikipedia.org/wiki/Mock_object) sono un modello di progettazione comune nella programmazione orientata agli oggetti. Il termine inglese per "simulare" è "to mock", dal francese antico "mocquer" col significato di "prendersi gioco di". Questo significato si è poi evoluto in "imitare qualcosa di reale", che è ciò che in effetti facciamo nella programmazione. Prenditi gioco dei tuoi contratti intelligenti quanto vuoi, ma simulali ogni volta che puoi. Ti semplificherà la vita.
+[Oggetti mock](https://wikipedia.org/wiki/Mock_object) sono un modello di progettazione comune nella programmazione orientata agli oggetti. Il termine inglese per "simulare" è "to mock", dal francese antico "mocquer" col significato di "prendersi gioco di". Questo significato si è poi evoluto in "imitare qualcosa di reale", che è ciò che in effetti facciamo nella programmazione. Prenditi gioco dei tuoi contratti intelligenti quanto vuoi, ma simulali ogni volta che puoi. Ti semplificherà la vita.
-## Condurre unit test dei contratti con le simulazioni {#unit-testing-contracts-with-mocks}
+## Unit test di contratti con mock {#unit-testing-contracts-with-mocks}
-Simulare un contratto significa essenzialmente creare una seconda versione di quel contratto che si comporta in modo simile a quello originale, ma in modo che possa essere facilmente controllato dallo sviluppatore. Ci si ritrova spesso con contratti complessi in cui si desidera solo [eseguire unit test di piccole parti del contratto](/developers/docs/smart-contracts/testing/). Ma cosa succede se il test di questa piccola parte richiede uno condizione molto specifica del contratto, difficile da ottenere?
+Simulare un contratto significa essenzialmente creare una seconda versione di quel contratto che si comporta in modo simile a quello originale, ma in modo che possa essere facilmente controllato dallo sviluppatore. Spesso ci si ritrova con contratti complessi in cui si desidera solo [eseguire unit test di piccole parti del contratto](/developers/docs/smart-contracts/testing/). Ma cosa succede se il test di questa piccola parte richiede uno condizione molto specifica del contratto, difficile da ottenere?
Potresti scrivere una complessa logica di configurazione del test ogni volta che porta il contratto nello stato richiesto o scrivi una simulazione. Simulare un contratto tramite ereditarietà è semplice. Basta creare un secondo contratto simulato che erediti da quello originale. Ora puoi sovrascrivere le funzioni nella tua simulazione. Vediamolo con un esempio.
-## Esempio: ERC20 Privato {#example-private-erc20}
+## Esempio: ERC20 privato {#example-private-erc20}
-Usiamo un contratto ERC-20 di esempio dotato di un tempo privato iniziale. Il proprietario può gestire utenti privati, che saranno gli unici autorizzati a ricevere token all'inizio. Una volta trascorso un certo intervallo di tempo, a tutti sarà consentito utilizzare i token. Se sei curioso, stiamo usando l'hook [`_beforeTokenTransfer`](https://docs.openzeppelin.com/contracts/5.x/extending-contracts#using-hooks) dalla nuova libreria di contratti OpenZeppelin v3.
+Usiamo un contratto ERC-20 di esempio dotato di un tempo privato iniziale. Il proprietario può gestire utenti privati, che saranno gli unici autorizzati a ricevere token all'inizio. Una volta trascorso un certo intervallo di tempo, a tutti sarà consentito utilizzare i token. Se sei curioso, stiamo usando l'hook [`_beforeTokenTransfer`](https://docs.openzeppelin.com/contracts/5.x/extending-contracts#using-hooks) dei nuovi contratti v3 di OpenZeppelin.
```solidity
pragma solidity ^0.6.0;
@@ -51,7 +47,7 @@ contract PrivateERC20 is ERC20, Ownable {
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
super._beforeTokenTransfer(from, to, amount);
- require(_validRecipient(to), "PrivateERC20: invalid recipient");
+ require(_validRecipient(to), "PrivateERC20: destinatario non valido");
}
function _validRecipient(address to) private view returns (bool) {
@@ -87,20 +83,20 @@ contract PrivateERC20Mock is PrivateERC20 {
Otterrai uno dei seguenti messaggi d'errore:
-- `PrivateERC20Mock.sol: TypeError: Overriding function is missing "override" specifier.`
-- `PrivateERC20.sol: TypeError: Trying to override non-virtual function. Did you forget to add "virtual"?.`
+- `PrivateERC20Mock.sol: TypeError: La funzione di sovrascrizione manca dello specificatore "override".`
+- `PrivateERC20.sol: TypeError: Tentativo di sovrascrivere una funzione non virtuale.` `Hai dimenticato di aggiungere "virtual"?`
-Poiché stiamo usando la nuova versione di Solidity 0.6, dobbiamo aggiungere la parola chiave `virtual` per le funzioni sovrascrivibili e `override` per la funzione di sovrascrizione. Quindi, aggiungiamoli a entrambe le funzioni `isPublic`.
+Poiché stiamo usando la nuova versione 0.6 di Solidity, dobbiamo aggiungere la parola chiave `virtual` per le funzioni che possono essere sovrascritte e override per la funzione di sovrascrizione. Quindi, aggiungiamoli a entrambe le funzioni `isPublic`.
-Ora, nei tuoi unit test, puoi invece usare `PrivateERC20Mock`. Quando desideri testare il comportamento durante il tempo di utilizzo privato, usa `setIsPublic(false` e, allo stesso modo, `setIsPublic(true)` per testare il tempo di utilizzo pubblico. Ovviamente, nel nostro esempio, abbiamo potuto usare soltanto i [time helper](https://docs.openzeppelin.com/test-helpers/0.5/api#increase) per modificare anche i tempi di conseguenza. Ma l'idea della simulazione dovrebbe ora esserti chiara e puoi immaginarti scenari in cui non sia facile come far procedere semplicemente il tempo.
+Ora, nei tuoi unit test, puoi invece usare `PrivateERC20Mock`. Quando vuoi testare il comportamento durante il periodo di utilizzo privato, usa `setIsPublic(false)` e, allo stesso modo, `setIsPublic(true)` per testare il periodo di utilizzo pubblico. Ovviamente, nel nostro esempio, potremmo anche usare semplicemente gli [helper di tempo](https://docs.openzeppelin.com/test-helpers/0.5/api#increase) per modificare i tempi di conseguenza. Ma l'idea della simulazione dovrebbe ora esserti chiara e puoi immaginarti scenari in cui non sia facile come far procedere semplicemente il tempo.
-## Simulare molti contratti {#mocking-many-contracts}
+## Mocking di molti contratti {#mocking-many-contracts}
-Può diventare caotico creare un altro contratto per ogni singola simulazione. Se ciò ti preoccupa, puoi dare un'occhiata alla libreria [MockContract](https://github.com/gnosis/mock-contract). Ti consente di sovrascrivere e modificare i comportamenti dei contratti al volo. Tuttavia, funziona solo per le chiamate di simulazione a un altro contratto, quindi non funzionerebbe per il nostro esempio.
+Può diventare caotico creare un altro contratto per ogni singola simulazione. Se questo ti dà fastidio, puoi dare un'occhiata alla libreria [MockContract](https://github.com/gnosis/mock-contract). Ti consente di sovrascrivere e modificare i comportamenti dei contratti al volo. Tuttavia, funziona solo per le chiamate di simulazione a un altro contratto, quindi non funzionerebbe per il nostro esempio.
-## La simulazione può essere ancora più potente {#mocking-can-be-even-more-powerful}
+## Il mocking può essere ancora più potente {#mocking-can-be-even-more-powerful}
I poteri della simulazione non finiscono qui.
-- Aggiungere funzioni: è utile non solo sovrascrivere una funzione specifica, ma anche aggiungere funzioni aggiuntive. Un buon esempio per i token è proprio avere una funzione `mint` aggiuntiva per consentire a qualsiasi utente di ottenere nuovi token gratuitamente.
+- Aggiungere funzioni: è utile non solo sovrascrivere una funzione specifica, ma anche aggiungere funzioni aggiuntive. Un buon esempio per i token è avere una funzione `mint` aggiuntiva per consentire a qualsiasi utente di ottenere nuovi token gratuitamente.
- Uso nelle testnet: quando distribuisci e testi i tuoi contratti sulle reti di prova insieme alla tua dApp, prendi in considerazione l'uso di una versione simulata. Evita di sovrascrivere le funzioni, a meno che non sia davvero necessario. Dopotutto, vuoi testare la logica reale. Ma può essere utile aggiungere una funzione di ripristino che ripristini semplicemente lo stato del contratto all'inizio, senza necessità di alcuna nuova distribuzione. Ovviamente, non vorresti farlo in un contratto sulla Rete mainnet.
diff --git a/public/content/translations/it/developers/tutorials/how-to-use-echidna-to-test-smart-contracts/index.md b/public/content/translations/it/developers/tutorials/how-to-use-echidna-to-test-smart-contracts/index.md
index bc374533d9a..f0f8495a5ba 100644
--- a/public/content/translations/it/developers/tutorials/how-to-use-echidna-to-test-smart-contracts/index.md
+++ b/public/content/translations/it/developers/tutorials/how-to-use-echidna-to-test-smart-contracts/index.md
@@ -1,23 +1,25 @@
---
-title: Come usare Echidna per testare gli smart contract
-description: Come usare Echidna per testare automaticamente gli smart contract
+title: Come usare Echidna per testare i contratti intelligenti
+description: Come usare Echidna per testare automaticamente i contratti intelligenti
author: "Trailofbits"
lang: it
tags:
- - "solidity"
- - "contratti intelligenti"
- - "sicurezza"
- - "test"
- - "fuzzing"
+ [
+ "Solidity",
+ "smart contract",
+ "sicurezza",
+ "test",
+ "fuzzing"
+ ]
skill: advanced
published: 2020-04-10
-source: Creare contratti sicuri
+source: Building secure contracts
sourceUrl: https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/echidna
---
## Installazione {#installation}
-Echidna è installabile tramite docker o usando il binario pre-compilato.
+Echidna può essere installato tramite docker o usando il binario pre-compilato.
### Echidna tramite docker {#echidna-through-docker}
@@ -26,9 +28,9 @@ docker pull trailofbits/eth-security-toolbox
docker run -it -v "$PWD":/home/training trailofbits/eth-security-toolbox
```
-_L'ultimo comando esegue eth-security-toolbox in un docker che ha accesso alla tua cartella corrente. Puoi modificare i file dal tuo host ed eseguire gli strumenti sui file dal docker_
+_L'ultimo comando esegue eth-security-toolbox in un docker che ha accesso alla tua directory corrente. Puoi modificare i file dal tuo host ed eseguire gli strumenti sui file dal docker_
-Nel docker, esegui:
+All'interno di docker, esegui:
```bash
solc-select 0.5.11
@@ -39,33 +41,33 @@ cd /home/training
[https://github.com/crytic/echidna/releases/tag/v1.4.0.0](https://github.com/crytic/echidna/releases/tag/v1.4.0.0)
-## Introduzione al fuzzing basato sulla proprietà {#introduction-to-property-based-fuzzing}
+## Introduzione al fuzzing basato sulle proprietà {#introduction-to-property-based-fuzzing}
-Echidna è un fuzzer basato sulla proprietà, che abbiamo descritto nei nostri post del blog precedenti ([1](https://blog.trailofbits.com/2018/03/09/echidna-a-smart-fuzzer-for-ethereum/), [2](https://blog.trailofbits.com/2018/05/03/state-machine-testing-with-echidna/), [3](https://blog.trailofbits.com/2020/03/30/an-echidna-for-all-seasons/)).
+Echidna è un fuzzer basato sulle proprietà, come descritto nei nostri precedenti post del blog ([1](https://blog.trailofbits.com/2018/03/09/echidna-a-smart-fuzzer-for-ethereum/), [2](https://blog.trailofbits.com/2018/05/03/state-machine-testing-with-echidna/), [3](https://blog.trailofbits.com/2020/03/30/an-echidna-for-all-seasons/)).
### Fuzzing {#fuzzing}
-Il [fuzzing](https://wikipedia.org/wiki/Fuzzing) è una ben nota tecnica nella community della sicurezza. Consiste nella generazione di input più o meno randomici, per trovare i bug nel programma. I fuzzer per il software tradizionale (come [AFL](http://lcamtuf.coredump.cx/afl/) o [LibFuzzer](https://llvm.org/docs/LibFuzzer.html)) sono noti per essere strumenti efficienti per trovare i bug.
+[Il fuzzing](https://wikipedia.org/wiki/Fuzzing) è una tecnica ben nota nella comunità della sicurezza. Consiste nel generare input più o meno casuali per trovare bug nel programma. I fuzzer per il software tradizionale (come [AFL](http://lcamtuf.coredump.cx/afl/) o [LibFuzzer](https://llvm.org/docs/LibFuzzer.html)) sono noti per essere strumenti efficienti per la ricerca di bug.
-Oltre alla generazione di input puramente casuale, esistono molte tecniche e strategie per generare input validi, tra cui:
+Oltre alla generazione di input puramente casuali, esistono molte tecniche e strategie per generare input validi, tra cui:
-- Ottenere feedback da ogni esecuzione e generazione della guida durante l'utilizzo. Ad esempio, se un input appena generato conduce alla scoperta di un nuovo percorso, può avere senso generare nuovi input vicini a esso.
-- Generare l'input rispettando un vincolo strutturale. Ad esempio, se il tuo input contiene un'intestazione con un checksum, avrà senso lasciare che il fuzzer generi input a convalida del checksum.
-- Usare input noti per generarne di nuovi: se hai accesso a un grande dataset di input validi, il tuo fuzzer può generarne di nuovi, anziché iniziare da zero la generazione. In genere sono detti _seed_.
+- Ottenere un feedback da ogni esecuzione e usarlo per guidare la generazione. Ad esempio, se un input appena generato porta alla scoperta di un nuovo percorso, può avere senso generare nuovi input vicini ad esso.
+- Generare l'input rispettando un vincolo strutturale. Ad esempio, se il tuo input contiene un'intestazione con un checksum, avrà senso lasciare che il fuzzer generi un input che convalidi il checksum.
+- Usare input noti per generarne di nuovi: se hai accesso a un grande dataset di input validi, il tuo fuzzer può generare nuovi input da essi, anziché iniziare la generazione da zero. Questi sono solitamente chiamati _seed_.
-### Fuzzing basato sulla proprietà {#property-based-fuzzing}
+### Fuzzing basato sulle proprietà {#property-based-fuzzing}
-Echidna appartiene a una famiglia specifica di fuzzer: il fuzzing basato sulla proprietà, ampiamente ispirato da [QuickCheck](https://wikipedia.org/wiki/QuickCheck). In contrasto al fuzzer classico che prova a trovare i crash, Echidna prova a rompere le invarianti definite dall'utente.
+Echidna appartiene a una famiglia specifica di fuzzer: il fuzzing basato sulle proprietà, fortemente ispirato da [QuickCheck](https://wikipedia.org/wiki/QuickCheck). A differenza del fuzzer classico, che tenta di trovare i crash, Echidna tenta di violare le invarianti definite dall'utente.
-Negli smart contract, le invarianti sono funzioni di Solidity, che possono rappresentare ogni stato non corretto o non valido raggiungibile dal contratto, tra cui:
+Nei contratti intelligenti, le invarianti sono funzioni di Solidity, che possono rappresentare qualsiasi stato errato o non valido che il contratto può raggiungere, tra cui:
-- Controllo d'accesso errato: il malintenzionato diventa il proprietario del contratto.
-- Macchina di stato errata: i token sono trasferibili mentre il contratto è in pausa.
-- Aritmetica errata: l'utente può sottovalutare il proprio saldo e ottenere token gratuiti illimitati.
+- Controllo degli accessi errato: l'autore dell'attacco è diventato il proprietario del contratto.
+- Macchina a stati errata: i token possono essere trasferiti mentre il contratto è in pausa.
+- Aritmetica errata: l'utente può causare un underflow del suo saldo e ottenere token gratuiti illimitati.
### Testare una proprietà con Echidna {#testing-a-property-with-echidna}
-Vedremo come testare un contratto intelligente con Echidna. L'obiettivo è il seguente smart contract [`token.sol`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/echidna/example/token.sol):
+Vedremo come testare un contratto intelligente con Echidna. L'obiettivo è il seguente contratto intelligente [`token.sol`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/echidna/example/token.sol):
```solidity
contract Token{
@@ -83,26 +85,26 @@ contract Token{
}
```
-Presumeremo che questo token debba avere le seguenti proprietà:
+Partiremo dal presupposto che questo token debba avere le seguenti proprietà:
-- Chiunque può avere al massimo 1.000 token
-- Il token non è trasferibile (non è un token ERC20)
+- Chiunque può avere al massimo 1000 token
+- Il token non può essere trasferito (non è un token ERC20)
-### Scrivi una proprietà {#write-a-property}
+### Scrivere una proprietà {#write-a-property}
-Le proprietà di Echidna sono funzioni di Solidity. Una proprietà deve:
+Le proprietà di Echidna sono funzioni Solidity. Una proprietà deve:
-- Non avere alcun argomento
-- Restituire `true` se va a buon fine
-- Avere un nome che inizia per `echidna`
+- Non avere argomenti
+- Restituire `true` se ha successo
+- Avere un nome che inizia con `echidna`
Echidna:
-- Genererà automaticamente transazioni arbitrarie per testare la proprietà.
-- Segnalare ogni transazione che fa sì che una proprietà restituisca `false` o generi un errore.
-- Scartare l'effetto collaterale quando si chiama una proprietà (ad es. se la proprietà cambia una variabile di stato, viene scartata dopo il test)
+- Generare automaticamente transazioni arbitrarie per testare la proprietà.
+- Segnalare qualsiasi transazione che porti una proprietà a restituire `false` o a sollevare un errore.
+- Annullare gli effetti collaterali quando si chiama una proprietà (cioè, se la proprietà modifica una variabile di stato, la modifica viene annullata dopo il test)
-La seguente proprietà controlla che il chiamante non abbia più di 1.000 token:
+La seguente proprietà controlla che il chiamante non abbia più di 1000 token:
```solidity
function echidna_balance_under_1000() public view returns(bool){
@@ -110,7 +112,7 @@ function echidna_balance_under_1000() public view returns(bool){
}
```
-Usa l'eredità per separare il contratto dalle proprietà:
+Usa l'ereditarietà per separare il tuo contratto dalle tue proprietà:
```solidity
contract TestToken is Token{
@@ -122,34 +124,34 @@ contract TestToken is Token{
[`token.sol`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/echidna/example/token.sol) implementa la proprietà ed eredita dal token.
-### Avviare un contratto {#initiate-a-contract}
+### Inizializzare un contratto {#initiate-a-contract}
-Echidna necessita di un [costruttore](/developers/docs/smart-contracts/anatomy/#constructor-functions) senza argomento. Se il tuo contratto necessita di un'inizializzazione specifica, devi farlo nel costruttore.
+Echidna necessita di un [costruttore](/developers/docs/smart-contracts/anatomy/#constructor-functions) senza argomenti. Se il tuo contratto necessita di un'inizializzazione specifica, devi effettuarla nel costruttore.
-Esistono degli indirizzi specifici in Echidna:
+In Echidna ci sono alcuni indirizzi specifici:
-- `0x00a329c0648769A73afAc7F9381E08FB43dBEA72` per chiamare il costruttore.
-- `0x10000`, `0x20000`, e `0x00a329C0648769a73afAC7F9381e08fb43DBEA70` per chiamare casualmente le altre funzioni.
+- `0x00a329c0648769A73afAc7F9381E08FB43dBEA72` che chiama il costruttore.
+- `0x10000`, `0x20000` e `0x00a329C0648769a73afAC7F9381e08fb43DBEA70` che chiamano casualmente le altre funzioni.
-Non necessitiamo di alcuna inizializzazione particolare nel nostro esempio corrente, di conseguenza il nostro costruttore è vuoto.
+Non abbiamo bisogno di alcuna inizializzazione particolare nel nostro esempio attuale, di conseguenza il nostro costruttore è vuoto.
### Eseguire Echidna {#run-echidna}
-Echidna è avviato con:
+Echidna si avvia con:
```bash
echidna-test contract.sol
```
-Se contract.sol contiene più contratti, puoi specificare l'obiettivo:
+Se contract.sol contiene più contratti, puoi specificare la destinazione:
```bash
echidna-test contract.sol --contract MyContract
```
-### Riepilogo: Testare una proprietà {#summary-testing-a-property}
+### Riepilogo: testare una proprietà {#summary-testing-a-property}
-Di seguito è riepilogata l'esecuzione di Echidna nel nostro esempio:
+Quanto segue riassume l'esecuzione di echidna sul nostro esempio:
```solidity
contract TestToken is Token{
@@ -164,19 +166,20 @@ contract TestToken is Token{
echidna-test testtoken.sol --contract TestToken
...
-echidna_balance_under_1000: failed!💥
- Call sequence, shrinking (1205/5000):
+echidna_balance_under_1000: fallito!💥
+ Sequenza di chiamate, riduzione in corso (1205/5000):
airdrop()
backdoor()
...
```
-Echidna ha individuato che la proprietà è violata se `backdoor` viene chiamata.
+Echidna ha rilevato che la proprietà viene violata se si chiama `backdoor`.
## Filtrare le funzioni da chiamare durante una campagna di fuzzing {#filtering-functions-to-call-during-a-fuzzing-campaign}
-Vedremo come filtrare le funzioni da sottoporre a fuzzing. L'obiettivo è il seguente smart contract:
+Vedremo come filtrare le funzioni da sottoporre a fuzzing.
+L'obiettivo è il seguente contratto intelligente:
```solidity
contract C {
@@ -227,35 +230,39 @@ contract C {
}
```
-Questo piccolo esempio forza Echidna a trovare una certa sequenza di transazioni per modificare una variabile di stato. Ciò è difficile per un fuzzer (si consiglia di usare uno strumento di esecuzione simbolica come [Manticore](https://github.com/trailofbits/manticore)). Possiamo eseguire Echidna per verificarlo:
+Questo piccolo esempio costringe Echidna a trovare una determinata sequenza di transazioni per modificare una variabile di stato.
+Questo è difficile per un fuzzer (si consiglia di usare uno strumento di esecuzione simbolica come [Manticore](https://github.com/trailofbits/manticore)).
+Possiamo eseguire Echidna per verificarlo:
```bash
echidna-test multi.sol
...
-echidna_state4: passed! 🎉
+echidna_state4: superato! 🎉
Seed: -3684648582249875403
```
### Funzioni di filtraggio {#filtering-functions}
-Echidna fa fatica a trovare la sequenza corretta per testare questo contratto perché le due funzioni di reset (`reset1` e `reset2`) imposteranno tutte le variabili di stato su `false`. Tuttavia, possiamo usare una funzionalità speciale di Echidna per inserire nella blacklist la funzione di reset o nella whitelist solo le funzioni `f`, `g`, `h` e `i`.
+Echidna ha difficoltà a trovare la sequenza corretta per testare questo contratto perché le due funzioni di ripristino (`reset1` e `reset2`) imposteranno tutte le variabili di stato su `false`.
+Tuttavia, possiamo usare una funzionalità speciale di Echidna per inserire nella blacklist la funzione di ripristino o per inserire nella whitelist solo le funzioni `f`, `g`,
+`h` e `i`.
-Per inserire le funzioni nella blacklist, possiamo usare questo file di configurazione:
+Per inserire funzioni nella blacklist, possiamo usare questo file di configurazione:
```yaml
filterBlacklist: true
filterFunctions: ["reset1", "reset2"]
```
-Un altro approccio per filtrare le funzioni è elencare quelle nella whitelist. Per farlo, possiamo usare questo file di configurazione:
+Un altro approccio per filtrare le funzioni è elencare quelle inserite nella whitelist. A tal fine, possiamo usare questo file di configurazione:
```yaml
filterBlacklist: false
filterFunctions: ["f", "g", "h", "i"]
```
-- `filterBlacklist` è `true` di default.
-- Il filtraggio sarà eseguito solo per nome (senza parametri). Se hai `f()` e `f(uint256)`, il filtro `"f"` abbinerà entrambe le funzioni.
+- `filterBlacklist` è `true` per impostazione predefinita.
+- Il filtraggio sarà eseguito solo per nome (senza parametri). Se si dispone di `f()` e `f(uint256)`, il filtro `"f"` corrisponderà a entrambe le funzioni.
### Eseguire Echidna {#run-echidna-1}
@@ -264,19 +271,19 @@ Per eseguire Echidna con un file di configurazione `blacklist.yaml`:
```bash
echidna-test multi.sol --config blacklist.yaml
...
-echidna_state4: failed!
- Call sequence:
+echidna_state4: fallito!💥
+ Sequenza di chiamate:
f(12)
g(8)
h(42)
i()
```
-Echidna troverà la sequenza di transazioni per falsificare la proprietà quasi immediatamente.
+Echidna troverà quasi subito la sequenza di transazioni per falsificare la proprietà.
-### Riepilogo: Filtrare le funzioni {#summary-filtering-functions}
+### Riepilogo: funzioni di filtraggio {#summary-filtering-functions}
-Echidna può inserire le funzioni di blacklist o whitelist da chiamare durante una campagna di fuzzing usando:
+Echidna può inserire nella blacklist o nella whitelist le funzioni da chiamare durante una campagna di fuzzing usando:
```yaml
filterBlacklist: true
@@ -288,11 +295,12 @@ echidna-test contract.sol --config config.yaml
...
```
-Echidna avvia una campagna di fuzzing inserendo `f1`, `f2` e `f3` nella blacklist o solo chiamandole, in base al valore del booleano `filterBlacklist`.
+Echidna avvia una campagna di fuzzing inserendo `f1`, `f2` e `f3` nella blacklist o chiamando solo queste, a seconda
+del valore del booleano `filterBlacklist`.
-## Come testare l'affermazione di Solidity con Echidna {#how-to-test-soliditys-assert-with-echidna}
+## Come testare l'assert di Solidity con Echidna {#how-to-test-soliditys-assert-with-echidna}
-In questo breve tutorial, mostreremo come usare Echidna per testare il controllo dell'affermazione nei contratti. Supponiamo di avere un contratto come questo:
+In questo breve tutorial, mostreremo come usare Echidna per testare il controllo delle asserzioni nei contratti. Supponiamo di avere un contratto come questo:
```solidity
contract Incrementor {
@@ -309,7 +317,8 @@ contract Incrementor {
### Scrivere un'asserzione {#write-an-assertion}
-Vogliamo assicurarci che `tmp` sia minore o uguale al `counter` dopo averne restituita la differenza. Potremmo scrivere una proprietà di Echidna, ma dovremmo memorizzare da qualche parte il valore `tmp`. Invece, potremmo usare un'asserzione come questa:
+Vogliamo assicurarci che `tmp` sia minore o uguale a `counter` dopo aver restituito la loro differenza. Potremmo scrivere una
+proprietà di Echidna, ma dovremmo memorizzare il valore di `tmp` da qualche parte. Invece, potremmo usare un'asserzione come questa:
```solidity
contract Incrementor {
@@ -326,19 +335,19 @@ contract Incrementor {
### Eseguire Echidna {#run-echidna-2}
-Per abilitare il test di insuccesso dell'asserzione, crea un [file di configurazione di Echidna](https://github.com/crytic/echidna/wiki/Config) `config.yaml`:
+Per abilitare il test di fallimento dell'asserzione, crea un [file di configurazione di Echidna](https://github.com/crytic/echidna/wiki/Config) `config.yaml`:
```yaml
checkAsserts: true
```
-Quando eseguiamo questo contratto in Echidna, otteniamo i risultati previsti:
+Quando eseguiamo questo contratto in Echidna, otteniamo i risultati attesi:
```bash
echidna-test assert.sol --config config.yaml
Analyzing contract: assert.sol:Incrementor
-assertion in inc: failed!💥
- Call sequence, shrinking (2596/5000):
+assertion in inc: fallita!💥
+ Sequenza di chiamate, riduzione in corso (2596/5000):
inc(21711016731996786641919559689128982722488122124807605757398297001483711807488)
inc(7237005577332262213973186563042994240829374041602535252466099000494570602496)
inc(86844066927987146567678238756515930889952488499230423029593188005934847229952)
@@ -346,15 +355,15 @@ assertion in inc: failed!💥
Seed: 1806480648350826486
```
-Come puoi vedere, Echidna segnala alcuni insuccessi dell'asserzione nella funzione `inc`. Aggiungere più di un'asserzione per funzione è possibile, ma Echidna non può dire quale sia fallita.
+Come puoi vedere, Echidna segnala un fallimento dell'asserzione nella funzione `inc`. È possibile aggiungere più di un'asserzione per funzione, ma Echidna non è in grado di dire quale asserzione sia fallita.
### Quando e come usare le asserzioni {#when-and-how-use-assertions}
-Le asserzioni sono utilizzabili come alternative a proprietà esplicite, specialmente se le condizioni per il controllo sono direttamente correlate all'uso corretto della stessa operazione `f`. Aggiungere le asserzioni dopo il codice farà sì che il controllo abbia luogo immediatamente dopo la sua esecuzione:
+Le asserzioni possono essere usate come alternative a proprietà esplicite, specialmente se le condizioni da verificare sono direttamente correlate all'uso corretto di un'operazione `f`. L'aggiunta di asserzioni dopo una porzione di codice garantirà che il controllo avvenga immediatamente dopo la sua esecuzione:
```solidity
function f(..) public {
- // some complex code
+ // un po' di codice complesso
...
assert (condition);
...
@@ -362,7 +371,7 @@ function f(..) public {
```
-Al contrario, l'utilizzo di una proprietà esplicita di Echidna eseguirà casualmente le transazioni e non esiste alcun metodo semplice per imporre esattamente quando verrà controllata. È comunque possibile sfruttare questa scappatoia:
+Al contrario, usando una proprietà esplicita di echidna si eseguiranno transazioni in modo casuale e non c'è un modo semplice per imporre esattamente quando verrà controllata. È comunque possibile sfruttare questa scappatoia:
```solidity
function echidna_assert_after_f() public returns (bool) {
@@ -373,20 +382,20 @@ function echidna_assert_after_f() public returns (bool) {
Tuttavia, esistono dei problemi:
-- Fallisce se `f` è dichiarata come `internal` o `external`.
+- Fallisce se `f` è dichiarato come `internal` o `external`.
- Non è chiaro quali argomenti dovrebbero essere usati per chiamare `f`.
-- Se `f` si ripristina, la proprietà fallirà.
+- Se `f` esegue il revert, la proprietà fallirà.
-In generale, consigliamo di seguire i [consigli di John Regehr](https://blog.regehr.org/archives/1091) su come usare le affermazioni:
+In generale, raccomandiamo di seguire la [raccomandazione di John Regehr](https://blog.regehr.org/archives/1091) su come usare le asserzioni:
-- Non forzare alcun effetto collaterale durante il controllo dell'affermazione. Ad esempio: `assert(ChangeStateAndReturn() == 1)`
-- Non affermare dichiarazioni ovvie. Ad esempio `assert(var >= 0)` dove `var` è dichiarata come `uint`.
+- Non forzare alcun effetto collaterale durante il controllo dell'asserzione. Ad esempio: `assert(ChangeStateAndReturn() == 1)`
+- Non asserire dichiarazioni ovvie. Ad esempio `assert(var >= 0)` dove `var` è dichiarato come `uint`.
-Infine, consigliamo di **non usare** `require` al posto di `assert`, poiché Echidna non potrà rilevarlo (ma il contratto si ripristinerà ugualmente).
+Infine, **non usare** `require` invece di `assert`, poiché Echidna non sarà in grado di rilevarlo (ma il contratto eseguirà comunque un revert).
-### Riepilogo: Controllo dell'asserzione {#summary-assertion-checking}
+### Riepilogo: controllo delle asserzioni {#summary-assertion-checking}
-Quanto segue riepiloga l'esecuzione di Echidna nel nostro esempio:
+Quanto segue riassume l'esecuzione di echidna sul nostro esempio:
```solidity
contract Incrementor {
@@ -404,8 +413,8 @@ contract Incrementor {
```bash
echidna-test assert.sol --config config.yaml
Analyzing contract: assert.sol:Incrementor
-assertion in inc: failed!💥
- Call sequence, shrinking (2596/5000):
+assertion in inc: fallita!💥
+ Sequenza di chiamate, riduzione in corso (2596/5000):
inc(21711016731996786641919559689128982722488122124807605757398297001483711807488)
inc(7237005577332262213973186563042994240829374041602535252466099000494570602496)
inc(86844066927987146567678238756515930889952488499230423029593188005934847229952)
@@ -413,11 +422,11 @@ assertion in inc: failed!💥
Seed: 1806480648350826486
```
-Echidna ha trovato che l'asserzione in `inc` può fallire se questa funzione è chiamata diverse volte con grandi argomenti.
+Echidna ha rilevato che l'asserzione in `inc` può fallire se questa funzione viene chiamata più volte con argomenti di grandi dimensioni.
## Raccogliere e modificare un corpus di Echidna {#collecting-and-modifying-an-echidna-corpus}
-Vedremo come raccogliere e usare un corpus di transazioni con Echidna. L'obiettivo è il seguente smart contract [`magic.sol`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/echidna/example/magic.sol):
+Vedremo come raccogliere e usare un corpus di transazioni con Echidna. L'obiettivo è il seguente contratto intelligente [`magic.sol`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/echidna/example/magic.sol):
```solidity
contract C {
@@ -437,20 +446,22 @@ contract C {
}
```
-Questo piccolo esempio forza Echidna a trovare una certi valori per modificare una variabile di stato, il che è difficile per un fuzzer (si consiglia di usare uno strumento d'esecuzione simbolica come [Manticore](https://github.com/trailofbits/manticore)). Possiamo eseguire Echidna per verificarlo:
+Questo piccolo esempio costringe Echidna a trovare determinati valori per modificare una variabile di stato. Questo è difficile per un fuzzer
+(si consiglia di usare uno strumento di esecuzione simbolica come [Manticore](https://github.com/trailofbits/manticore)).
+Possiamo eseguire Echidna per verificarlo:
```bash
echidna-test magic.sol
...
-echidna_magic_values: passed! 🎉
+echidna_magic_values: superato! 🎉
Seed: 2221503356319272685
```
Tuttavia, possiamo comunque usare Echidna per raccogliere il corpus mentre si esegue questa campagna di fuzzing.
-### Raccogliere un corpus {#collecting-a-corpus}
+### Raccolta di un corpus {#collecting-a-corpus}
Per abilitare la raccolta, crea la cartella di un corpus:
@@ -471,7 +482,8 @@ Ora possiamo eseguire il nostro strumento e controllare il corpus raccolto:
echidna-test magic.sol --config config.yaml
```
-Echidna non è ancora in grado di trovare i valori magici corretti, ma possiamo dare un'occhiata al corpus raccolto. Ad esempio, uno di questi file era:
+Echidna non è ancora in grado di trovare i valori magici corretti, ma possiamo dare un'occhiata al corpus raccolto.
+Ad esempio, uno di questi file era:
```json
[
@@ -518,21 +530,22 @@ Echidna non è ancora in grado di trovare i valori magici corretti, ma possiamo
Chiaramente, questo input non innescherà il fallimento nella nostra proprietà. Tuttavia, nel prossimo passaggio, vedremo come modificarlo a tale scopo.
-### Seeding di un corpus {#seeding-a-corpus}
+### Fornire un corpus come seed {#seeding-a-corpus}
-Echidna necessita di un po' di aiuto per poter affrontare la funzione `magic`. Copieremo e modificheremo l'input per usare parametri idonei a tale scopo:
+Echidna necessita di un po' di aiuto per poter affrontare la funzione magic. Copieremo e modificheremo l'input per usare parametri idonei
+a tale scopo:
```bash
cp corpus/2712688662897926208.txt corpus/new.txt
```
-Modificheremo `new.txt` per chiamare `magic(42,129,333,0)`. Ora possiamo ri-eseguire Echidna:
+Modificheremo `new.txt` per chiamare `magic(42,129,333,0)`. Ora possiamo rieseguire Echidna:
```bash
echidna-test magic.sol --config config.yaml
...
-echidna_magic_values: failed!💥
- Call sequence:
+echidna_magic_values: fallito!💥
+ Sequenza di chiamate:
magic(42,129,333,0)
@@ -544,9 +557,9 @@ Seed: -7293830866560616537
Questa volta, ha scoperto che la proprietà è immediatamente violata.
-## Individuare le transazioni ad alto consumo di gas {#finding-transactions-with-high-gas-consumption}
+## Trovare transazioni con un elevato consumo di gas {#finding-transactions-with-high-gas-consumption}
-Vedremo come individuare le transazioni con un alto consumo di gas con Echidna. L'obiettivo è il seguente smart contract:
+Vedremo come individuare le transazioni con un alto consumo di gas con Echidna. L'obiettivo è il seguente contratto intelligente:
```solidity
contract C {
@@ -573,17 +586,18 @@ contract C {
Qui `expensive` può avere un gran consumo di gas.
-Attualmente, Echidna necessità sempre di una proprietà da testare: qui `echidna_test` restituisce sempre `true`. Possiamo eseguire Echidna per verificarlo:
+Attualmente, Echidna necessità sempre di una proprietà da testare: qui `echidna_test` restituisce sempre `true`.
+Possiamo eseguire Echidna per verificarlo:
```
echidna-test gas.sol
...
-echidna_test: passed! 🎉
+echidna_test: superato! 🎉
Seed: 2320549945714142710
```
-### Misurare il Consumo di Gas {#measuring-gas-consumption}
+### Misurare il consumo di gas {#measuring-gas-consumption}
Per abilitare il consumo di gas con Echidna, crea un file di configurazione `config.yaml`:
@@ -594,92 +608,85 @@ estimateGas: true
In questo esempio, ridurremo anche le dimensioni della sequenza di transazione per facilitare la comprensione dei risultati:
```yaml
-seqLen: 2
-estimateGas: true
+In questo esempio, ridurremo anche le dimensioni della sequenza di transazione per facilitare la comprensione dei risultati:
```
-### Eseguire Echidna {#run-echidna-3}
+### seqLen: 2
estimateGas: true
-Una volta creato il file di configurazione, possiamo eseguire Echidna come segue:
+Eseguire Echidna {#run-echidna-3}
```bash
-echidna-test gas.sol --config config.yaml
-...
-echidna_test: passed! 🎉
-
-f used a maximum of 1333608 gas
- Call sequence:
- f(42,123,249) Gas price: 0x10d5733f0a Time delay: 0x495e5 Block delay: 0x88b2
-
-Unique instructions: 157
-Unique codehashes: 1
-Seed: -325611019680165325
-
+Una volta creato il file di configurazione, possiamo eseguire Echidna come segue:
```
-- Il gas mostrato è una stima fornita da [HEVM](https://github.com/dapphub/dapptools/tree/master/src/hevm#hevm-).
+- echidna-test gas.sol --config config.yaml
+ ...
+ echidna_test: superato! 🎉f ha usato un massimo di 1333608 di gas
+ Sequenza di chiamate:
+ f(42,123,249) Prezzo del gas: 0x10d5733f0a Ritardo: 0x495e5 Ritardo blocco: 0x88b2Unique instructions: 157
+ Unique codehashes: 1
+ Seed: -325611019680165325
-### Filtrare le Chiamate di Riduzione del Gas {#filtering-out-gas-reducing-calls}
+### Il gas mostrato è una stima fornita da [HEVM](https://github.com/dapphub/dapptools/tree/master/src/hevm#hevm-).
-Il tutorial precedente sulle **funzioni di filtraggio da chiamare durante una campagna di fuzzing**, mostra come rimuovere alcune funzioni dal tuo test.
-Questo può esser critico per ottenere una stima accurata del gas. Considera l'esempio seguente:
+Filtrare le chiamate che riducono il gas {#filtering-out-gas-reducing-calls}
+Il tutorial precedente su come **filtrare le funzioni da chiamare durante una campagna di fuzzing** mostra come
+rimuovere alcune funzioni dal tuo test.
+Si consideri l'esempio seguente:
```solidity
+Questo può essere fondamentale per ottenere una stima accurata del gas.
+```
+
contract C {
- address [] addrs;
- function push(address a) public {
- addrs.push(a);
- }
- function pop() public {
- addrs.pop();
- }
- function clear() public{
- addrs.length = 0;
- }
- function check() public{
- for(uint256 i = 0; i < addrs.length; i++)
- for(uint256 j = i+1; j < addrs.length; j++)
- if (addrs[i] == addrs[j])
- addrs[j] = address(0x0);
- }
- function echidna_test() public returns (bool) {
- return true;
- }
+address [] addrs;
+function push(address a) public {
+addrs.push(a);
+}
+function pop() public {
+addrs.pop();
+}
+function clear() public{
+addrs.length = 0;
+}
+function check() public{
+for(uint256 i = 0; i < addrs.length; i++)
+for(uint256 j = i+1; j < addrs.length; j++)
+if (addrs[i] == addrs[j])
+addrs[j] = address(0x0);
+}
+function echidna_test() public returns (bool) {
+return true;
+}
}
-```
+```
Se Echidna può chiamare tutte le funzioni, non troverà facilmente le transazioni a costo elevato di gas:
-
```
+
echidna-test pushpop.sol --config config.yaml
...
-pop used a maximum of 10746 gas
+pop ha usato un massimo di 10746 di gas
...
-check used a maximum of 23730 gas
+check ha usato un massimo di 23730 di gas
...
-clear used a maximum of 35916 gas
+clear ha usato un massimo di 35916 di gas
...
-push used a maximum of 40839 gas
-```
-
-Questo perché il costo dipende dalla dimensione di `addrs` e le chiamate casuali tendono a lasciare l'array quasi vuoto. L'inserimento in blacklist di `pop` e `clear`, tuttavia, fornisce risultati molto più efficaci:
+push ha usato un massimo di 40839 di gas
+Questo perché il costo dipende dalla dimensione di `addrs` e le chiamate casuali tendono a lasciare l'array quasi vuoto.
```yaml
-filterBlacklist: true
-filterFunctions: ["pop", "clear"]
+Tuttavia, inserire `pop` e `clear` in una blacklist, ci fornisce risultati molto migliori:
```
```
-echidna-test pushpop.sol --config config.yaml
-...
-push used a maximum of 40839 gas
-...
-check used a maximum of 1484472 gas
+filterBlacklist: true
+filterFunctions: ["pop", "clear"]
```
-### Sommario: Individuare le transazioni ad alto consumo di gas {#summary-finding-transactions-with-high-gas-consumption}
+### echidna-test pushpop.sol --config config.yaml
...
push ha usato un massimo di 40839 di gas
...
check ha usato un massimo di 1484472 di gas
-Echidna può trovare le transazioni ad alto consumo di gas usando l'opzione di configurazione `estimateGas`:
+Riepilogo: trovare transazioni con un elevato consumo di gas {#summary-finding-transactions-with-high-gas-consumption}
```yaml
estimateGas: true
@@ -690,4 +697,4 @@ echidna-test contract.sol --config config.yaml
...
```
-Echidna segnalerà una sequenza con il consumo massimo di gas per ogni funzione, una volta terminata la campagna di fuzzing.
+Echidna può trovare le transazioni ad alto consumo di gas usando l'opzione di configurazione `estimateGas`:
diff --git a/public/content/translations/it/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/index.md b/public/content/translations/it/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/index.md
index 7d97bd4a966..5772b59ff98 100644
--- a/public/content/translations/it/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/index.md
+++ b/public/content/translations/it/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/index.md
@@ -4,40 +4,42 @@ description: Come usare Manticore per trovare automaticamente bug negli Smart Co
author: Trailofbits
lang: it
tags:
- - "solidity"
- - "contratti intelligenti"
- - "sicurezza"
- - "test"
- - "verifica formale"
+ [
+ "Solidity",
+ "smart contract",
+ "sicurezza",
+ "test",
+ "verifica formale"
+ ]
skill: advanced
published: 2020-01-13
-source: Creare contratti sicuri
+source: Building secure contracts
sourceUrl: https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/manticore
---
-L'obiettivo di questo tutorial è mostrare come usare Manticore per trovare automaticamente bug negli Smart Contract.
+L'obiettivo di questa guida è mostrare come usare Manticore per trovare automaticamente bug negli Smart Contract.
## Installazione {#installation}
-Manticore richiede >= Python 3.6. Può essere installato tramite pip o usando docker.
+Manticore richiede python >= 3.6. Può essere installato tramite pip o usando docker.
-### Manticore con docker {#manticore-through-docker}
+### Manticore tramite docker {#manticore-through-docker}
```bash
docker pull trailofbits/eth-security-toolbox
docker run -it -v "$PWD":/home/training trailofbits/eth-security-toolbox
```
-_L'ultimo comando esegue eth-security-toolbox in un docker avente accesso alla tua directory corrente. Puoi cambiare i file dal tuo host ed eseguire gli strumenti sui file dal docker_
+_L'ultimo comando esegue eth-security-toolbox in un docker che ha accesso alla tua directory corrente. Puoi modificare i file dal tuo host ed eseguire gli strumenti sui file dal docker_
-In docker, esegui:
+All'interno del docker, esegui:
```bash
solc-select 0.5.11
cd /home/trufflecon/
```
-### Manticore con pip {#manticore-through-pip}
+### Manticore tramite pip {#manticore-through-pip}
```bash
pip3 install --user manticore
@@ -45,7 +47,7 @@ pip3 install --user manticore
È consigliato solc 0.5.11.
-### Esecuzione di uno script {#running-a-script}
+### Eseguire uno script {#running-a-script}
Per eseguire uno script Python con Python 3:
@@ -55,18 +57,18 @@ python3 script.py
## Introduzione all'esecuzione simbolica dinamica {#introduction-to-dynamic-symbolic-execution}
-### Esecuzione simbolica dinamica in pillole {#dynamic-symbolic-execution-in-a-nutshell}
+### Esecuzione Simbolica Dinamica in poche parole {#dynamic-symbolic-execution-in-a-nutshell}
-L'esecuzione simbolica dinamica (DSE) è una tecnica di analisi di un programma che esplora uno spazio di stati con un alto grado di consapevolezza semantica. Questa tecnica si basa sulla scoperta dei "percorsi del programma", rappresentati da formule matematiche dette `predicati di percorso`. Concettualmente, opera su predicati di percorso in due passaggi:
+L'esecuzione simbolica dinamica (DSE) è una tecnica di analisi di un programma che esplora uno spazio degli stati con un alto grado di consapevolezza semantica. Questa tecnica si basa sulla scoperta dei "percorsi del programma", rappresentati da formule matematiche chiamate `predicati di percorso`. Concettualmente, questa tecnica opera sui predicati di percorso in due passaggi:
-1. Vengono costruiti usando vincoli nell'input del programma.
-2. Vengono usati per generare input del programma che causeranno l'esecuzione dei percorsi associati.
+1. Sono costruiti usando vincoli sull'input del programma.
+2. Sono usati per generare input del programma che causeranno l'esecuzione dei percorsi associati.
-Questo approccio non produce falsi positivi nel senso che tutti gli stati del programma identificati possono essere attivati durante l'esecuzione concreta. Per esempio, se le analisi trova un overflow di valori interi, è garantito che sia riproducibile.
+Questo approccio non produce falsi positivi, nel senso che tutti gli stati del programma identificati possono essere attivati durante l'esecuzione concreta. Ad esempio, se l'analisi rileva un overflow di valori interi, è garantito che sia riproducibile.
-### Esempio di predicato di percorso {#path-predicate-example}
+### Esempio di Predicato di Percorso {#path-predicate-example}
-Per avere un'idea di funziona la DSE, considera il seguente esempio:
+Per avere un'idea di come funziona la DSE, si consideri il seguente esempio:
```solidity
function f(uint a){
@@ -83,17 +85,17 @@ Poiché `f()` contiene due percorsi, una DSE costruirà due diversi predicati di
- Percorso 1: `a == 65`
- Percorso 2: `Not (a == 65)`
-Ogni predicato di percorso è una formula matematica che può essere passata a un cosiddetto [risolutore SMT](https://wikipedia.org/wiki/Satisfiability_modulo_theories), che proverà a risolvere l'equazione. Per il `Percorso 1`, il risolutore dirà che il percorso può essere esplorato con `a = 65`. Per il `Percorso 2`, il risolutore può assegnare ad `a` tutti i valori diversi da 65, per esempio `a = 0`.
+Ogni predicato di percorso è una formula matematica che può essere data a un cosiddetto [risolutore SMT](https://wikipedia.org/wiki/Satisfiability_modulo_theories), che proverà a risolvere l'equazione. Per `Percorso 1`, il risolutore dirà che il percorso può essere esplorato con `a = 65`. Per `Percorso 2`, il risolutore può dare ad `a` qualsiasi valore diverso da 65, ad esempio `a = 0`.
### Verifica delle proprietà {#verifying-properties}
-Manticore permette un controllo completo su tutta l'esecuzione di ogni percorso. Di conseguenza, consente di aggiungere vincoli arbitrari quasi a tutto. Questo controllo permette di creare proprietà sul contratto.
+Manticore permette un controllo completo su tutta l'esecuzione di ogni percorso. Di conseguenza, consente di aggiungere vincoli arbitrari a quasi tutto. Questo controllo permette la creazione di proprietà sul contratto.
-Considera l'esempio seguente:
+Si consideri l'esempio seguente:
```solidity
function unsafe_add(uint a, uint b) returns(uint c){
- c = a + b; // no overflow protection
+ c = a + b; // nessuna protezione da overflow
return c;
}
```
@@ -102,13 +104,13 @@ Qui c'è un solo percorso da esplorare nella funzione:
- Percorso 1: `c = a + b`
-Usando Manticore, si può controllare l'overflow e aggiungere vincoli al predicato di percorso:
+Usando Manticore, si può verificare la presenza di overflow e aggiungere vincoli al predicato di percorso:
- `c = a + b AND (c < a OR c < b)`
-Se è possibile trovare una valutazione di `a` e `b` per cui il predicato di percorso qui sopra sia fattibile, significa che è stato trovato un overflow. Ad esempio, il risolutore può generare l'input `a = 10 , b = MAXUINT256`.
+Se è possibile trovare una valutazione di `a` e `b` per cui il predicato di percorso di cui sopra è fattibile, significa che si è trovato un overflow. Ad esempio, il risolutore può generare l'input `a = 10, b = MAXUINT256`.
-Se consideri una versione fissa:
+Se si considera una versione corretta:
```solidity
function safe_add(uint a, uint b) returns(uint c){
@@ -119,17 +121,17 @@ function safe_add(uint a, uint b) returns(uint c){
}
```
-La formula associata al controllo dell'overflow sarebbe:
+La formula associata con il controllo dell'overflow sarebbe:
- `c = a + b AND (c >= a) AND (c=>b) AND (c < a OR c < b)`
-Questa formula non è risolvibile; in altri mondi questa è una **prova** che in `safe_add`, `c` aumenterà sempre.
+Questa formula non può essere risolta; in altre parole, questa è una **prova** che in `safe_add`, `c` aumenterà sempre.
-La DSE è quindi uno strumento potente, che può verificare i vincoli arbitrari nel codice.
+La DSE è quindi uno strumento potente, in grado di verificare vincoli arbitrari sul codice.
-## Esecuzione in Manticore {#running-under-manticore}
+## Esecuzione con Manticore {#running-under-manticore}
-Vedremo come esplorare uno Smart Contract con l'API Manticore. La destinazione è il seguente Smart Contract [`example.sol`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/manticore/examples/example.sol):
+Vedremo come esplorare uno Smart Contract con l'API Manticore. L'obiettivo è il seguente Smart Contract [`example.sol`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/manticore/examples/example.sol):
```solidity
pragma solidity >=0.4.24 <0.6.0;
@@ -143,15 +145,15 @@ contract Simple {
}
```
-### Esplorazione indipendente {#run-a-standalone-exploration}
+### Eseguire un'esplorazione autonoma {#run-a-standalone-exploration}
-Manticore può essere eseguito direttamente sullo Smart Contract con il comando seguente (`project` può essere un file Solidity o una directory del progetto):
+È possibile eseguire Manticore direttamente sullo Smart Contract tramite il seguente comando (`project` può essere un file Solidity o una directory di progetto):
```bash
$ manticore project
```
-Otterrai l'output dei casi di prova, come il seguente (l'ordine potrebbe variare):
+Si otterrà l'output dei casi di test come questo (l'ordine potrebbe cambiare):
```
...
@@ -162,43 +164,43 @@ Otterrai l'output dei casi di prova, come il seguente (l'ordine potrebbe variare
... m.c.manticore:INFO: Generated testcase No. 4 - STOP
... m.c.manticore:INFO: Generated testcase No. 5 - REVERT
... m.c.manticore:INFO: Generated testcase No. 6 - REVERT
-... m.c.manticore:INFO: Results in /home/ethsec/workshops/Automated Smart Contract Audit - TruffleCon 2018/manticore/examples/mcore_t6vi6ij3
+... m.c.manticore:INFO: Results in /home/ethsec/workshops/Automated Smart Contracts Audit - TruffleCon 2018/manticore/examples/mcore_t6vi6ij3
...
```
-Senza altre informazioni, Manticore esplorerà il contratto con nuove transazioni simboliche, finché non esplorerà nuovi percorsi sul contratto. Manticore non esegue nuove transazioni se una non riesce (ad esempio dopo un ripristino).
+Senza informazioni aggiuntive, Manticore esplorerà il contratto con nuove transazioni simboliche finché non esplorerà nuovi percorsi sul contratto. Manticore non esegue nuove transazioni dopo una non riuscita (ad es. dopo un revert).
-Manticore restituirà le informazioni un una directory `mcore_*`. In questa directory troverai, tra altre cose:
+Manticore genererà l'output delle informazioni in una directory `mcore_*`. Tra le altre cose, in questa directory si troverà:
- `global.summary`: copertura e avvisi del compilatore
-- `test_XXXXX.summary`: copertura, ultima istruzione, saldi del conto per casi di prova
-- `test_XXXXX.tx`: elenco dettagliato delle transazioni per test case
+- `test_XXXXX.summary`: copertura, ultima istruzione, saldi dei conti per caso di test
+- `test_XXXXX.tx`: elenco dettagliato delle transazioni per caso di test
-Qui Manticore trova 7 test case che corrispondono a (l'ordine dei nomi dei file potrebbe variare):
+Qui Manticore trova 7 casi di test, che corrispondono a (l'ordine dei nomi dei file potrebbe cambiare):
-| | Transazione 0 | Transazione 1 | Transazione 2 | Risultato |
-|:--------------------:|:-----------------------:|:--------------------:| -------------------- |:---------:|
-| **test_00000000.tx** | Creazione del contratto | f(!=65) | f(!=65) | STOP |
-| **test_00000001.tx** | Creazione del contratto | funzione di fallback | | REVERT |
-| **test_00000002.tx** | Creazione del contratto | | | RETURN |
-| **test_00000003.tx** | Creazione del contratto | f(65) | | REVERT |
-| **test_00000004.tx** | Creazione del contratto | f(!=65) | | STOP |
-| **test_00000005.tx** | Creazione del contratto | f(!=65) | f(65) | REVERT |
-| **test_00000006.tx** | Creazione del contratto | f(!=65) | funzione di fallback | REVERT |
+| | Transazione 0 | Transazione 1 | Transazione 2 | Risultato |
+| :-------------------------------------------------------: | :---------------------: | :------------------------: | -------------------------- | :-------: |
+| **test_00000000.tx** | Creazione del contratto | f(!=65) | f(!=65) | STOP |
+| **test_00000001.tx** | Creazione del contratto | funzione di fallback | | REVERT |
+| **test_00000002.tx** | Creazione del contratto | | | RETURN |
+| **test_00000003.tx** | Creazione del contratto | f(65) | | REVERT |
+| **test_00000004.tx** | Creazione del contratto | f(!=65) | | STOP |
+| **test_00000005.tx** | Creazione del contratto | f(!=65) | f(65) | REVERT |
+| **test_00000006.tx** | Creazione del contratto | f(!=65) | funzione di fallback | REVERT |
-_Il riepilogo dell'esplorazione f(!=65) denota f chiamata con ogni valore diverso da 65._
+_Riepilogo dell'esplorazione: f(!=65) denota f chiamata con qualsiasi valore diverso da 65._
-Come puoi notare, Manticore genera un test case univoco per ogni transazione riuscita o ripristinata.
+Come si può notare, Manticore genera un caso di test univoco per ogni transazione riuscita o ripristinata.
-Usa il flag `--quick-mode` se desideri un'esplorazione veloce del codice (disabilita rilevatori di bug, calcolo del carburante, etc.)
+Usare il flag `--quick-mode` per un'esplorazione rapida del codice (disabilita i rilevatori di bug, il calcolo del gas, ...).
-### Manipolazione di uno Smart Contract tramite l'API {#manipulate-a-smart-contract-through-the-api}
+### Manipolare uno Smart Contract tramite l'API {#manipulate-a-smart-contract-through-the-api}
-Questa sezione contiene informazioni su come manipolare uno Smart Contract tramite l'API Python di Manticore. Puoi creare un nuovo file con l'estensione di Python `*.py` e scrivere il codice necessario aggiungendo i comandi dell'API (le basi saranno descritte di seguito) in questo file e poi eseguirlo con il comando `$ python3 *.py`. Puoi anche eseguire i comandi qui sotto direttamente nella console Python. Per eseguirla usa il comando `$ python3`.
+Questa sezione descrive in dettaglio come manipolare uno Smart Contract tramite l'API Python di Manticore. È possibile creare un nuovo file con l'estensione python `*.py` e scrivere il codice necessario aggiungendo i comandi dell'API (le cui basi saranno descritte di seguito) in questo file e quindi eseguirlo con il comando `$ python3 *.py`. Inoltre è possibile eseguire i comandi seguenti direttamente nella console di python; per avviare la console, usare il comando `$ python3`.
-### Creare i Conti {#creating-accounts}
+### Creazione di Conti {#creating-accounts}
-La prima da fare è inizializzare una nuova blockchain con i comandi seguenti:
+La prima cosa da fare è avviare una nuova blockchain con i seguenti comandi:
```python
from manticore.ethereum import ManticoreEVM
@@ -206,7 +208,7 @@ from manticore.ethereum import ManticoreEVM
m = ManticoreEVM()
```
-Un conto privo di contratto è creato usando [m.create_account](https://manticore.readthedocs.io/en/latest/evm.html?highlight=create_account#manticore.ethereum.ManticoreEVM.create_account):
+Un conto non di contratto viene creato usando [m.create_account](https://manticore.readthedocs.io/en/latest/evm.html?highlight=create_account#manticore.ethereum.ManticoreEVM.create_account):
```python
user_account = m.create_account(balance=1000)
@@ -231,9 +233,9 @@ contract_account = m.solidity_create_contract(source_code, owner=user_account)
#### Riepilogo {#summary}
-- Puoi creare conti dell'utente e del contratto con [m.create_account](https://manticore.readthedocs.io/en/latest/evm.html?highlight=create_account#manticore.ethereum.ManticoreEVM.create_account) e [m.solidity_create_contract](https://manticore.readthedocs.io/en/latest/evm.html?highlight=solidity_create#manticore.ethereum.ManticoreEVM.create_contract).
+- È possibile creare conti utente e conti di contratto con [m.create_account](https://manticore.readthedocs.io/en/latest/evm.html?highlight=create_account#manticore.ethereum.ManticoreEVM.create_account) e [m.solidity_create_contract](https://manticore.readthedocs.io/en/latest/evm.html?highlight=solidity_create#manticore.ethereum.ManticoreEVM.create_contract).
-### Esecuzione di transazioni {#executing-transactions}
+### Esecuzione delle transazioni {#executing-transactions}
Manticore supporta due tipi di transazione:
@@ -254,9 +256,9 @@ m.transaction(caller=user_account,
Il chiamante, l'indirizzo, i dati o il valore della transazione possono essere concreti o simbolici:
- [m.make_symbolic_value](https://manticore.readthedocs.io/en/latest/evm.html?highlight=make_symbolic_value#manticore.ethereum.ManticoreEVM.make_symbolic_value) crea un valore simbolico.
-- [m.make_symbolic_buffer(size)](https://manticore.readthedocs.io/en/latest/evm.html?highlight=make_symbolic_buffer#manticore.ethereum.ManticoreEVM.make_symbolic_buffer) crea un array di byte simbolici.
+- [m.make_symbolic_buffer(size)](https://manticore.readthedocs.io/en/latest/evm.html?highlight=make_symbolic_buffer#manticore.ethereum.ManticoreEVM.make_symbolic_buffer) crea un array di byte simbolico.
-Ad esempio:
+Per esempio:
```python
symbolic_value = m.make_symbolic_value()
@@ -267,40 +269,41 @@ m.transaction(caller=user_account,
value=symbolic_value)
```
-Se i dati sono simbolici, Manticore esplorerà tutte le funzioni del contratto durante l'esecuzione della transazione. È utile consultare la spiegazione della funzione di fallback nell'articolo [Hands on the Ethernaut CTF](https://blog.trailofbits.com/2017/11/06/hands-on-the-ethernaut-ctf/) per comprendere come funziona la selezione delle funzioni.
+Se i dati sono simbolici, Manticore esplorerà tutte le funzioni del contratto durante l'esecuzione della transazione. Sarà utile consultare la spiegazione della Funzione di Fallback nell'articolo [Hands on the Ethernaut CTF](https://blog.trailofbits.com/2017/11/06/hands-on-the-ethernaut-ctf/) per capire come funziona la selezione della funzione.
#### Transazione con nome {#named-transaction}
-Le funzioni sono eseguibili tramite il loro nome. Per eseguire `f(uint var)` con un valore simbolico, da user_account e con 0 ether, usa:
+Le funzioni possono essere eseguite tramite il loro nome.
+Per eseguire `f(uint var)` con un valore simbolico, da user_account, e con 0 ether, usare:
```python
symbolic_var = m.make_symbolic_value()
contract_account.f(symbolic_var, caller=user_account, value=0)
```
-Se `value` della transazione non è specificato, è 0 di default.
+Se il `value` della transazione non è specificato, è 0 per impostazione predefinita.
#### Riepilogo {#summary-1}
- Gli argomenti di una transazione possono essere concreti o simbolici
- Una transazione grezza esplorerà tutte le funzioni
-- La funzione può essere chiamata con il suo nome
+- Le funzioni possono essere chiamate per nome
### Area di lavoro {#workspace}
-`m.workspace` è la directory usata come output per tutti i file generati:
+`m.workspace` è la directory utilizzata come directory di output per tutti i file generati:
```python
print("Results are in {}".format(m.workspace))
```
-### Chiusura dell'esplorazione {#terminate-the-exploration}
+### Terminare l'esplorazione {#terminate-the-exploration}
-Per interrompere l'esplorazione usa [m.finalize()](https://manticore.readthedocs.io/en/latest/evm.html?highlight=finalize#manticore.ethereum.ManticoreEVM.finalize). Nessun'altra transazione dovrebbe essere inviata una volta chiamato questo metodo e dopo che Manticore ha generato test case per ognuno dei percorsi esplorati.
+Per interrompere l'esplorazione, usare [m.finalize()](https://manticore.readthedocs.io/en/latest/evm.html?highlight=finalize#manticore.ethereum.ManticoreEVM.finalize). Nessuna ulteriore transazione deve essere inviata una volta chiamato questo metodo e Manticore genererà i casi di test per ciascun percorso esplorato.
-### Riepilogo: esecuzione in Manticore {#summary-running-under-manticore}
+### Riepilogo: Esecuzione con Manticore {#summary-running-under-manticore}
-Mettendo insieme tutti i passaggi precedenti, otteniamo:
+Mettendo insieme tutti i passaggi precedenti, si ottiene:
```python
from manticore.ethereum import ManticoreEVM
@@ -317,14 +320,14 @@ symbolic_var = m.make_symbolic_value()
contract_account.f(symbolic_var)
print("Results are in {}".format(m.workspace))
-m.finalize() # stop the exploration
+m.finalize() # interrompe l'esplorazione
```
-Tutto il codice sopra lo puoi trovare in [`example_run.py`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/manticore/examples/example_run.py)
+Tutto il codice di cui sopra si trova in [`example_run.py`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/manticore/examples/example_run.py)
## Ottenere i percorsi che generano eccezioni {#getting-throwing-paths}
-Ora creeremo input specifici per i percorsi che generano un'eccezione in `f()`. La destinazione è ancora il seguente Smart Contract [`example.sol`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/manticore/examples/example.sol):
+Ora genereremo input specifici per i percorsi che sollevano un'eccezione in `f()`. L'obiettivo è ancora il seguente Smart Contract [`example.sol`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/manticore/examples/example.sol):
```solidity
pragma solidity >=0.4.24 <0.6.0;
@@ -337,35 +340,35 @@ contract Simple {
}
```
-### Uso delle informazioni di stato {#using-state-information}
+### Utilizzo delle informazioni sullo stato {#using-state-information}
-Ogni percorso eseguito ha il proprio stato della blockchain. Uno stato è pronto o terminato, a significare che ha raggiunto un'istruzione THROW o REVERT:
+Ogni percorso eseguito ha il suo stato della blockchain. Uno stato è pronto o terminato, il che significa che raggiunge un'istruzione THROW o REVERT:
-- [m.ready_states](https://manticore.readthedocs.io/en/latest/states.html#accessing): l'elenco degli stati pronti (cioè che non hanno eseguito un REVERT/INVALID)
+- [m.ready_states](https://manticore.readthedocs.io/en/latest/states.html#accessing): l'elenco degli stati pronti (che non hanno eseguito un REVERT/INVALID)
- [m.killed_states](https://manticore.readthedocs.io/en/latest/states.html#accessings): l'elenco degli stati terminati
- [m.all_states](https://manticore.readthedocs.io/en/latest/states.html#accessings): tutti gli stati
```python
for state in m.all_states:
- # esegue un'operazione con lo stato
+ # fai qualcosa con lo stato
```
-Puoi accedere alle informazioni sullo stato. Per esempio:
+È possibile accedere alle informazioni sullo stato. Per esempio:
- `state.platform.get_balance(account.address)`: il saldo del conto
- `state.platform.transactions`: l'elenco delle transazioni
- `state.platform.transactions[-1].return_data`: i dati restituiti dall'ultima transazione
-I dati restituiti dall'ultima transazione sono un array, convertibile in un valore con ABI.deserialize, per esempio:
+I dati restituiti dall'ultima transazione sono un array, che può essere convertito in un valore con ABI.deserialize, ad esempio:
```python
data = state.platform.transactions[0].return_data
data = ABI.deserialize("uint", data)
```
-### Come generare test case {#how-to-generate-testcase}
+### Come generare un caso di test {#how-to-generate-testcase}
-Usa [m.generate_testcase(state, name)](https://manticore.readthedocs.io/en/latest/evm.html?highlight=generate_testcase#manticore.ethereum.ManticoreEVM.generate_testcase) per generare test case:
+Usare [m.generate_testcase(state, name)](https://manticore.readthedocs.io/en/latest/evm.html?highlight=generate_testcase#manticore.ethereum.ManticoreEVM.generate_testcase) per generare un caso di test:
```python
m.generate_testcase(state, 'BugFound')
@@ -373,13 +376,13 @@ m.generate_testcase(state, 'BugFound')
### Riepilogo {#summary-2}
-- Puoi eseguire iterazioni sullo stato con m.all_states
+- È possibile iterare sullo stato con m.all_states
- `state.platform.get_balance(account.address)` restituisce il saldo del conto
- `state.platform.transactions` restituisce l'elenco delle transazioni
- `transaction.return_data` sono i dati restituiti
- `m.generate_testcase(state, name)` genera input per lo stato
-### Riepilogo: ottenere il percorso che genera eccezioni {#summary-getting-throwing-path}
+### Riepilogo: Ottenere percorsi che generano eccezioni {#summary-getting-throwing-path}
```python
from manticore.ethereum import ManticoreEVM
@@ -395,7 +398,8 @@ contract_account = m.solidity_create_contract(source_code, owner=user_account)
symbolic_var = m.make_symbolic_value()
contract_account.f(symbolic_var)
-## Controlla se l'esecuzione termina con REVERT o INVALID
+## Controlla se un'esecuzione termina con un REVERT o INVALID
+
for state in m.terminated_states:
last_tx = state.platform.transactions[-1]
if last_tx.result in ['REVERT', 'INVALID']:
@@ -403,13 +407,13 @@ for state in m.terminated_states:
m.generate_testcase(state, 'ThrowFound')
```
-Tutto il codice qui sopra si trova in [`example_run.py`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/manticore/examples/example_run.py)
+Tutto il codice di cui sopra si trova in [`example_run.py`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/manticore/examples/example_run.py)
-_Nota: avremmo potuto generare uno script molto più semplice poiché tutti gli stati restituiti da terminated_state hanno REVERT o INVALID nel risultato. Questo esempio era inteso solo per dimostrare come manipolare l'API._
+_Nota: avremmo potuto generare uno script molto più semplice, poiché tutti gli stati restituiti da terminated_state hanno REVERT o INVALID nel loro risultato: questo esempio aveva solo lo scopo di dimostrare come manipolare l'API._
## Aggiunta di vincoli {#adding-constraints}
-Vediamo ora come vincolare l'esplorazione. Presumiamo che la documentazione di `f()` indichi che la funzione non viene mai chiamata con `a == 65`, quindi ogni bug con `a == 65` non è un vero bug. La destinazione è ancora il seguente Smart Contract [`example.sol`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/manticore/examples/example.sol):
+Vedremo come vincolare l'esplorazione. Assumeremo che la documentazione di `f()` dichiari che la funzione non viene mai chiamata con `a == 65`, quindi qualsiasi bug con `a == 65` non è un bug reale. L'obiettivo è ancora il seguente Smart Contract [`example.sol`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/manticore/examples/example.sol):
```solidity
pragma solidity >=0.4.24 <0.6.0;
@@ -424,7 +428,7 @@ contract Simple {
### Operatori {#operators}
-Il modulo [Operators](https://github.com/trailofbits/manticore/blob/master/manticore/core/smtlib/operators.py) facilita la manipolazione dei vincoli, fornendo tra l'altro:
+Il modulo [Operators](https://github.com/trailofbits/manticore/blob/master/manticore/core/smtlib/operators.py) facilita la manipolazione dei vincoli e, tra le altre cose, fornisce:
- Operators.AND,
- Operators.OR,
@@ -433,13 +437,13 @@ Il modulo [Operators](https://github.com/trailofbits/manticore/blob/master/manti
- Operators.ULT (minore di senza segno),
- Operators.ULE (minore o uguale a senza segno).
-Per importare il modulo usa:
+Per importare il modulo, usare quanto segue:
```python
from manticore.core.smtlib import Operators
```
-`Operators.CONCAT` è usato per concatenare un array a un valore. Per esempio, return_data di una transazione deve essere modificato in valore per poter essere verificato a fronte di un altro valore:
+`Operators.CONCAT` viene usato per concatenare un array a un valore. Ad esempio, il return_data di una transazione deve essere modificato in un valore per essere confrontato con un altro valore:
```python
last_return = Operators.CONCAT(256, *last_return)
@@ -447,11 +451,12 @@ last_return = Operators.CONCAT(256, *last_return)
### Vincoli {#state-constraint}
-Puoi usare vincoli globalmente o per uno stato specifico.
+È possibile usare vincoli a livello globale o per uno stato specifico.
#### Vincolo globale {#state-constraint}
-Usa `m.constrain(constraint)` per aggiungere un vincolo globale. Per esempio, puoi chiamare un contratto da un indirizzo simbolico e limitare quest'indirizzo a valori specifici:
+Usare `m.constrain(constraint)` per aggiungere un vincolo globale.
+Ad esempio, è possibile chiamare un contratto da un indirizzo simbolico e vincolare questo indirizzo a valori specifici:
```python
symbolic_address = m.make_symbolic_value()
@@ -464,11 +469,13 @@ m.transaction(caller=user_account,
#### Vincolo di stato {#state-constraint}
-Usa [state.constrain(constraint)](https://manticore.readthedocs.io/en/latest/states.html?highlight=StateBase#manticore.core.state.StateBase.constrain) per aggiungere un vincolo a uno stato specifico Può essere usato per vincolare lo stato dopo la sua esplorazione per verificarvi della proprietà.
+Usare [state.constrain(constraint)](https://manticore.readthedocs.io/en/latest/states.html?highlight=StateBase#manticore.core.state.StateBase.constrain) per aggiungere un vincolo a uno stato specifico.
+Può essere usato per vincolare lo stato dopo la sua esplorazione per verificare una proprietà su di esso.
-### Controllo di un vincolo {#checking-constraint}
+### Verifica del vincolo {#checking-constraint}
-Usa `solver.check(state.constraints)` per sapere se un vincolo è ancora fattibile. Per esempio, il codice seguente vincola symbolic_value ad essere diverso da 65 e controlla se lo stato è ancora fattibile:
+Usare `solver.check(state.constraints)` per sapere se un vincolo è ancora fattibile.
+Ad esempio, quanto segue vincolerà symbolic_value a essere diverso da 65 e verificherà se lo stato è ancora fattibile:
```python
state.constrain(symbolic_var != 65)
@@ -476,9 +483,9 @@ if solver.check(state.constraints):
# lo stato è fattibile
```
-### Riepilogo: aggiunta di vincoli {#summary-adding-constraints}
+### Riepilogo: Aggiunta di vincoli {#summary-adding-constraints}
-Aggiungendo il vincolo al codice precedente, otteniamo:
+Aggiungendo un vincolo al codice precedente, si ottiene:
```python
from manticore.ethereum import ManticoreEVM
@@ -499,18 +506,19 @@ contract_account.f(symbolic_var)
no_bug_found = True
-## Controlla se l'esecuzione termina con REVERT o INVALID
+## Controlla se un'esecuzione termina con un REVERT o INVALID
+
for state in m.terminated_states:
last_tx = state.platform.transactions[-1]
if last_tx.result in ['REVERT', 'INVALID']:
- # we do not consider the path were a == 65
+ # non consideriamo il percorso in cui a == 65
condition = symbolic_var != 65
if m.generate_testcase(state, name="BugFound", only_if=condition):
- print(f'Bug found, results are in {m.workspace}')
+ print(f'Trovato bug, i risultati sono in {m.workspace}')
no_bug_found = False
if no_bug_found:
- print(f'No bug found')
+ print(f'Nessun bug trovato')
```
-Tutto il codice sopra si può trovare in [`example_run.py`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/manticore/examples/example_run.py)
+Tutto il codice di cui sopra si trova in [`example_run.py`](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/manticore/examples/example_run.py)
diff --git a/public/content/translations/it/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/index.md b/public/content/translations/it/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/index.md
index 28111da448b..2d63a281cb6 100644
--- a/public/content/translations/it/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/index.md
+++ b/public/content/translations/it/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/index.md
@@ -1,49 +1,44 @@
---
-title: Come usare Slither per trovare i bug dello Smart Contract
-description: Come usare Slither per trovare automaticamente bug negli Smart Contract
+title: Come usare Slither per trovare bug nei contratti intelligenti
+description: Come usare Slither per trovare automaticamente bug nei contratti intelligenti
author: Trailofbits
lang: it
-tags:
- - "solidity"
- - "contratti intelligenti"
- - "sicurezza"
- - "test"
- - "analisi statica"
+tags: [ "Solidity", "smart contract", "sicurezza", "test" ]
skill: advanced
published: 2020-06-09
-source: Creare contratti sicuri
+source: Building secure contracts
sourceUrl: https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/slither
---
## Come usare Slither {#how-to-use-slither}
-L'obiettivo di questo tutorial è mostrare come usare Slither per trovare automaticamente bug negli Smart Contract.
+L'obiettivo di questo tutorial è mostrare come usare Slither per trovare automaticamente bug nei contratti intelligenti.
- [Installazione](#installation)
-- [Uso dalla riga di comando](#command-line)
-- [Introduzione all'analisi statica](#static-analysis): breve introduzione all'analisi statica
-- [API](#api-basics): descrizione dell'API Python
+- [Uso della riga di comando](#command-line)
+- [Introduzione all'analisi statica](#static-analysis): Breve introduzione all'analisi statica
+- [API](#api-basics): Descrizione dell'API Python
## Installazione {#installation}
-Slither richiede Python >=3.6. Può essere installato tramite pip o usando docker.
+Slither richiede Python >= 3.6. Può essere installato tramite pip o usando docker.
-Slither con pip:
+Slither tramite pip:
```bash
pip3 install --user slither-analyzer
```
-Slither con docker:
+Slither tramite docker:
```bash
docker pull trailofbits/eth-security-toolbox
docker run -it -v "$PWD":/home/trufflecon trailofbits/eth-security-toolbox
```
-_L'ultimo comando esegue eth-security-toolbox in un docker che ha accesso alla directory corrente. Puoi cambiare i file dall'host ed eseguire gli strumenti sui file dal docker_
+_L'ultimo comando esegue eth-security-toolbox in un docker che ha accesso alla tua directory corrente. Puoi modificare i file dal tuo host ed eseguire gli strumenti sui file dal docker_
-In docker, esegui:
+All'interno del docker, esegui:
```bash
solc-select 0.5.11
@@ -60,23 +55,23 @@ python3 script.py
### Riga di comando {#command-line}
-**Riga di comando e script definiti dall'utente.** Slither comprende una serie di rilevatori predefiniti che trovano molti bug comuni. Chiamare Slither dalla riga di comando eseguirà tutti i rilevatori, non è necessaria alcuna conoscenza dettagliata dell'analisi statica:
+**Riga di comando e script definiti dall'utente.** Slither è dotato di una serie di rilevatori predefiniti che trovano molti bug comuni. Chiamare Slither dalla riga di comando eseguirà tutti i rilevatori; non è necessaria alcuna conoscenza dettagliata dell'analisi statica:
```bash
slither project_paths
```
-Oltre ai rilevatori, Slither ha capacità di revisione del codice tramite le sue [stampanti](https://github.com/crytic/slither#printers) e i suoi [strumenti](https://github.com/crytic/slither#tools).
+Oltre ai rilevatori, Slither ha funzionalità di revisione del codice tramite i suoi [printer](https://github.com/crytic/slither#printers) e [strumenti](https://github.com/crytic/slither#tools).
-Usa [crytic.io](https://github.com/crytic) per ottenere accesso ai rilevatori privati e integrazione con GitHub.
+Usa [crytic.io](https://github.com/crytic) per ottenere l'accesso ai rilevatori privati e all'integrazione con GitHub.
## Analisi statica {#static-analysis}
-Le capacità e il design del framework di analisi statica di Slither sono stati descritti in post di blog ([1](https://blog.trailofbits.com/2018/10/19/slither-a-solidity-static-analysis-framework/), [2](https://blog.trailofbits.com/2019/05/27/slither-the-leading-static-analyzer-for-smart-contracts/)) e in un [paper accademico](https://github.com/trailofbits/publications/blob/master/papers/wetseb19.pdf).
+Le funzionalità e il design del framework di analisi statica di Slither sono stati descritti in post del blog ([1](https://blog.trailofbits.com/2018/10/19/slither-a-solidity-static-analysis-framework/), [2](https://blog.trailofbits.com/2019/05/27/slither-the-leading-static-analyzer-for-smart-contracts/)) e in un [articolo accademico](https://github.com/trailofbits/publications/blob/master/papers/wetseb19.pdf).
-L'analisi statica esiste in diversi tipi. Molto probabilmente ti renderai conto che compilatori come [clang](https://clang-analyzer.llvm.org/) e [gcc](https://lwn.net/Articles/806099/) dipendono da queste tecniche di ricerca, che sono anche alla base di [Infer](https://fbinfer.com/), [CodeClimate](https://codeclimate.com/), [FindBugs](http://findbugs.sourceforge.net/) e strumenti basati sui metodi formali come [Frama-C](https://frama-c.com/) e [Polyspace](https://www.mathworks.com/products/polyspace.html).
+L'analisi statica esiste in diverse varianti. Molto probabilmente ti rendi conto che i compilatori come [clang](https://clang-analyzer.llvm.org/) e [gcc](https://lwn.net/Articles/806099/) dipendono da queste tecniche di ricerca, ma essa è anche alla base di ([Infer](https://fbinfer.com/), [CodeClimate](https://codeclimate.com/), [FindBugs](http://findbugs.sourceforge.net/) e strumenti basati su metodi formali come [Frama-C](https://frama-c.com/) e [Polyspace](https://www.mathworks.com/products/polyspace.html)).
-Qui non esamineremo in modo esaustivo le tecniche di analisi statica e il ricercatore. Ci concentreremo invece su ciò che serve per capire come funziona Slither così da poterlo usare più efficacemente per trovare bug e comprendere il codice.
+Qui non esamineremo in modo esaustivo le tecniche di analisi statica e la ricerca in materia. Ci concentreremo invece su ciò che serve per capire come funziona Slither, in modo da poterlo usare più efficacemente per trovare bug e comprendere il codice.
- [Rappresentazione del codice](#code-representation)
- [Analisi del codice](#analysis)
@@ -84,13 +79,13 @@ Qui non esamineremo in modo esaustivo le tecniche di analisi statica e il ricerc
### Rappresentazione del codice {#code-representation}
-A differenza dell'analisi dinamica, che ragiona su un percorso di esecuzione singolo, l'analisi statica ragiona su tutti i percorsi contemporaneamente. Per farlo, si basa su una diversa rappresentazione del codice. Le due tipologie più comuni sono l'albero di sintassi astratta (AST) e il grafico del flusso di controllo (CFG).
+A differenza di un'analisi dinamica, che ragiona su un singolo percorso di esecuzione, l'analisi statica ragiona su tutti i percorsi contemporaneamente. Per farlo, si basa su una diversa rappresentazione del codice. Le due più comuni sono l'albero di sintassi astratta (AST) e il grafico del flusso di controllo (CFG).
### Alberi di sintassi astratta (AST) {#abstract-syntax-trees-ast}
-Gli AST sono usati ogni volta che il compilatore analizza il codice. Sono probabilmente la struttura più basilare su cui è eseguibile l'analisi statica.
+Gli AST sono usati ogni volta che il compilatore analizza sintatticamente il codice. Sono probabilmente la struttura più basilare su cui è possibile eseguire un'analisi statica.
-In pillole, un AST è un albero strutturato dove, di solito, ogni foglia contiene una variabile o una costante e i nodi interni sono operandi o controllano le operazioni del flusso. Considera il codice seguente:
+In breve, un AST è un albero strutturato in cui, di solito, ogni foglia contiene una variabile o una costante e i nodi interni sono operandi o operazioni di controllo del flusso. Considera il codice seguente:
```solidity
function safeAdd(uint a, uint b) pure internal returns(uint){
@@ -107,9 +102,9 @@ L'AST corrispondente è mostrato in:
Slither usa l'AST esportato da solc.
-Sebbene semplice da costruire, l'AST è una struttura nidificata. A volte, non è la più semplice da analizzare. Per esempio, per identificare le operazioni usate dall'espressione `a + b <= a`, devi prima analizzare `<=` e poi `+`. Un approccio comune è usare il cosiddetto schema dei visitatori, che naviga l'albero in modo ricorsivo. Slither contiene un visitatore generico in [`ExpressionVisitor`](https://github.com/crytic/slither/blob/master/slither/visitors/expression/expression.py).
+Sebbene sia semplice da costruire, l'AST è una struttura nidificata. A volte, non è la più semplice da analizzare. Ad esempio, per identificare le operazioni usate dall'espressione `a + b <= a`, devi prima analizzare `<=` e poi `+`. Un approccio comune è usare il cosiddetto pattern visitor, che naviga ricorsivamente l'albero. Slither contiene un visitor generico in [`ExpressionVisitor`](https://github.com/crytic/slither/blob/master/slither/visitors/expression/expression.py).
-Il codice seguente usa `ExpressionVisitor` per rilevare se l'espressione contiene una somma:
+Il codice seguente usa `ExpressionVisitor` per rilevare se l'espressione contiene un'addizione:
```python
from slither.visitors.expression.expression import ExpressionVisitor
@@ -124,43 +119,43 @@ class HasAddition(ExpressionVisitor):
if expression.type == BinaryOperationType.ADDITION:
self._result = True
-visitor = HasAddition(expression) # expression is the expression to be tested
+visitor = HasAddition(expression) # expression è l'espressione da testare
print(f'The expression {expression} has a addition: {visitor.result()}')
```
### Grafico del flusso di controllo (CFG) {#control-flow-graph-cfg}
-La seconda rappresentazione più comune del codice è il grafico del flusso di controllo (CFG). Come suggerisce il nome, è una rappresentazione basata su un grafico, che espone tutti i percorsi d'esecuzione. Ogni nodo contiene una o più istruzioni. I bordi nel grafico rappresentano le operazioni del flusso di controllo (if/then/else, loop, ecc). Il CFG del nostro esempio precedente è:
+La seconda rappresentazione più comune del codice è il grafico del flusso di controllo (CFG). Come suggerisce il nome, è una rappresentazione basata su grafico che espone tutti i percorsi di esecuzione. Ogni nodo contiene una o più istruzioni. Gli archi nel grafico rappresentano le operazioni di controllo del flusso (if/then/else, loop, ecc.). Il CFG del nostro esempio precedente è:
-Il CFG è la rappresentazione su cui gran parte delle analisi sono costruite.
+Il CFG è la rappresentazione su cui si basa la maggior parte delle analisi.
Esistono molte altre rappresentazioni del codice. Ogni rappresentazione ha vantaggi e svantaggi a seconda dell'analisi che si desidera eseguire.
### Analisi {#analysis}
-Il tipo più semplice di analisi eseguibile con Slither è l'analisi sintattica.
+Il tipo di analisi più semplice che puoi eseguire con Slither è l'analisi sintattica.
### Analisi della sintassi {#syntax-analysis}
-Slither può navigare attraverso diversi componenti del codice e la loro rappresentazione per trovare incoerenze e difetti usando un approccio simile all'abbinamento a schemi.
+Slither può navigare attraverso i diversi componenti del codice e la loro rappresentazione per trovare incoerenze e difetti usando un approccio simile al pattern matching.
-Per esempio i seguenti rilevatori cercano problemi correlati alla sintassi:
+Ad esempio, i seguenti rilevatori cercano problemi relativi alla sintassi:
-- [Shadowing della variabile di stato](https://github.com/crytic/slither/wiki/Detector-Documentation#state-variable-shadowing): esegue iterazioni su tutte le variabili di stato e controlla se qualcuna esegue lo shadowing di una variabile da un contratto ereditato ([state.py#L51-L62](https://github.com/crytic/slither/blob/0441338e055ab7151b30ca69258561a5a793f8ba/slither/detectors/shadowing/state.py#L51-L62))
+- [Shadowing di variabile di stato](https://github.com/crytic/slither/wiki/Detector-Documentation#state-variable-shadowing): itera su tutte le variabili di stato e controlla se qualcuna di esse nasconde una variabile di un contratto ereditato ([state.py#L51-L62](https://github.com/crytic/slither/blob/0441338e055ab7151b30ca69258561a5a793f8ba/slither/detectors/shadowing/state.py#L51-L62))
-- [Interfaccia errata di ERC20](https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-erc20-interface): cerca firme della funzione ERC20 errate ([incorrect_erc20_interface.py#L34-L55](https://github.com/crytic/slither/blob/0441338e055ab7151b30ca69258561a5a793f8ba/slither/detectors/erc/incorrect_erc20_interface.py#L34-L55))
+- [Interfaccia ERC20 non corretta](https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-erc20-interface): cerca le firme di funzione ERC20 non corrette ([incorrect_erc20_interface.py#L34-L55](https://github.com/crytic/slither/blob/0441338e055ab7151b30ca69258561a5a793f8ba/slither/detectors/erc/incorrect_erc20_interface.py#L34-L55))
### Analisi semantica {#semantic-analysis}
-A differenza dell'analisi di sintassi, un'analisi semantica va più in profondità e analizza il "significato" del codice. Questa famiglia include alcuni tipi generici di analisi. Conducono a risultati più potenti e utili, ma anche più complessi da scrivere.
+A differenza dell'analisi della sintassi, un'analisi semantica va più in profondità e analizza il "significato" del codice. Questa famiglia include alcuni tipi ampi di analisi. Portano a risultati più potenti e utili, ma sono anche più complessi da scrivere.
-Le analisi semantiche sono usate per i rilevamenti più avanzati delle vulnerabilità.
+Le analisi semantiche sono usate per i rilevamenti di vulnerabilità più avanzati.
#### Analisi della dipendenza dei dati {#fixed-point-computation}
-Una variabile `variable_a` si dice dipendente dai dati di `variable_b` se esiste un percorso per cui il valore di `variable_a` è influenzato da `variable_b`.
+Una variabile `variable_a` si dice dipendente dai dati di `variable_b` se esiste un percorso per il quale il valore di `variable_a` è influenzato da `variable_b`.
Nel codice seguente, `variable_a` dipende da `variable_b`:
@@ -169,13 +164,13 @@ Nel codice seguente, `variable_a` dipende da `variable_b`:
variable_a = variable_b + 1;
```
-Slither è dotato di capacità integrate di [dipendenza dai dati](https://github.com/crytic/slither/wiki/data-dependency), grazie alla sua rappresentazione intermedia (discussa in una sezione successiva).
+Slither è dotato di funzionalità integrate di [dipendenza dei dati](https://github.com/crytic/slither/wiki/data-dependency), grazie alla sua rappresentazione intermedia (discussa in una sezione successiva).
-Un esempio di uso della dipendenza dei dati si può trovare nel [rilevatore di uguaglianze rigorose pericolose](https://github.com/crytic/slither/wiki/Detector-Documentation#dangerous-strict-equalities). In questo caso Slither cercherà confronti tra uguaglianze rigorose a un valore pericoloso ([incorrect_strict_equality.py#L86-L87](https://github.com/crytic/slither/blob/6d86220a53603476f9567c3358524ea4db07fb25/slither/detectors/statements/incorrect_strict_equality.py#L86-L87)), e informerà l'utente che dovrebbe usare `>=` o `<=` anziché `==`, per impedire a un malintenzionato di bloccare il contratto. Tra gli altri, il rilevatore considererà come pericoloso il valore restituito da una chiamata di `balanceOf(address)` ([incorrect_strict_equality.py#L63-L64](https://github.com/crytic/slither/blob/6d86220a53603476f9567c3358524ea4db07fb25/slither/detectors/statements/incorrect_strict_equality.py#L63-L64)), e userà il motore delle dipendenze dei dati per monitorarne l'uso.
+Un esempio di utilizzo della dipendenza dei dati si trova nel [rilevatore di uguaglianze strette pericolose](https://github.com/crytic/slither/wiki/Detector-Documentation#dangerous-strict-equalities). Qui Slither cercherà un confronto di uguaglianza stretta con un valore pericoloso ([incorrect_strict_equality.py#L86-L87](https://github.com/crytic/slither/blob/6d86220a53603476f9567c3358524ea4db07fb25/slither/detectors/statements/incorrect_strict_equality.py#L86-L87)) e informerà l'utente che dovrebbe usare `>=` o `<=` invece di `==`, per impedire a un utente malintenzionato di intrappolare il contratto. Tra le altre cose, il rilevatore considererà pericoloso il valore restituito di una chiamata a `balanceOf(indirizzo)` ([incorrect_strict_equality.py#L63-L64](https://github.com/crytic/slither/blob/6d86220a53603476f9567c3358524ea4db07fb25/slither/detectors/statements/incorrect_strict_equality.py#L63-L64)) e utilizzerà il motore di dipendenza dei dati per tracciarne l'uso.
#### Calcolo del punto fisso {#fixed-point-computation}
-Se l'analisi naviga attraverso il CFG e segue i bordi, potresti vedere nodi già visitati. Per esempio, se un ciclo viene presentato come mostrato sotto:
+Se la tua analisi naviga attraverso il CFG e ne segue gli archi, è probabile che tu veda nodi già visitati. Ad esempio, se un loop è presentato come mostrato di seguito:
```solidity
for(uint i; i < range; ++){
@@ -183,37 +178,37 @@ for(uint i; i < range; ++){
}
```
-L'analisi dovrà sapere quando interrompersi. Qui esistono due strategie principali: (1) itera su ogni nodo un numero finito di volte, (2) calcola un cosiddetto _fixpoint_ (punto fisso). Un punto fisso indica fondamentalmente che analizzare il nodo non fornisce alcuna informazione utile.
+La tua analisi dovrà sapere quando fermarsi. Ci sono due strategie principali: (1) iterare su ogni nodo un numero finito di volte, (2) calcolare un cosiddetto _punto fisso_. Un punto fisso significa fondamentalmente che l'analisi di questo nodo non fornisce più alcuna informazione significativa.
-Un esempio di punto fisso usato si può trovare nei rilevatori di rientranza: Slither esplora i nodi e cerca chiamate esterne, scrive e legge lo storage. Una volta raggiunto un punto fisso ([reentrancy.py#L125-L131](https://github.com/crytic/slither/blob/master/slither/detectors/reentrancy/reentrancy.py#L125-L131)), interrompe l'esplorazione e analizza i risultati per vedere se è presente una rientranza, tramite diversi schemi di rientranza ([reentrancy_benign.py](https://github.com/crytic/slither/blob/b275bcc824b1b932310cf03b6bfb1a1fef0ebae1/slither/detectors/reentrancy/reentrancy_benign.py), [reentrancy_read_before_write.py](https://github.com/crytic/slither/blob/b275bcc824b1b932310cf03b6bfb1a1fef0ebae1/slither/detectors/reentrancy/reentrancy_read_before_write.py), [reentrancy_eth.py](https://github.com/crytic/slither/blob/b275bcc824b1b932310cf03b6bfb1a1fef0ebae1/slither/detectors/reentrancy/reentrancy_eth.py)).
+Un esempio di utilizzo del punto fisso si può trovare nei rilevatori di rientranza: Slither esplora i nodi e cerca chiamate esterne, operazioni di scrittura e lettura dello storage. Una volta raggiunto un punto fisso ([reentrancy.py#L125-L131](https://github.com/crytic/slither/blob/master/slither/detectors/reentrancy/reentrancy.py#L125-L131)), interrompe l'esplorazione e analizza i risultati per vedere se è presente una rientranza, attraverso diversi pattern di rientranza ([reentrancy_benign.py](https://github.com/crytic/slither/blob/b275bcc824b1b932310cf03b6bfb1a1fef0ebae1/slither/detectors/reentrancy/reentrancy_benign.py), [reentrancy_read_before_write.py](https://github.com/crytic/slither/blob/b275bcc824b1b932310cf03b6bfb1a1fef0ebae1/slither/detectors/reentrancy/reentrancy_read_before_write.py), [reentrancy_eth.py](https://github.com/crytic/slither/blob/b275bcc824b1b932310cf03b6bfb1a1fef0ebae1/slither/detectors/reentrancy/reentrancy_eth.py)).
-La scrittura dell'analisi tramite un calcolo efficiente dei punti fissi richiede una buona comprensione di come l'analisi propaga le informazioni.
+Scrivere analisi utilizzando un calcolo efficiente del punto fisso richiede una buona comprensione di come l'analisi propaga le sue informazioni.
### Rappresentazione intermedia {#intermediate-representation}
-Una rappresentazione intermedia (IR) è un linguaggio pensato per essere più adatto all'analisi statica che a quella originale. Slither traduce Solidity nella propria rappresentazione intermedia: [SlithIR](https://github.com/crytic/slither/wiki/SlithIR).
+Una rappresentazione intermedia (IR) è un linguaggio inteso per essere più adatto all'analisi statica rispetto a quello originale. Slither traduce Solidity nella sua IR: [SlithIR](https://github.com/crytic/slither/wiki/SlithIR).
-Comprendere SlithIR non è necessario per scrivere controlli di base. È invece utile se pensi di scrivere analisi semantiche avanzate. Le stampanti [SlithIR](https://github.com/crytic/slither/wiki/Printer-documentation#slithir) e [SSA](https://github.com/crytic/slither/wiki/Printer-documentation#slithir-ssa) aiuteranno a comprendere come è tradotto il codice.
+Comprendere SlithIR non è necessario se si vogliono scrivere solo controlli di base. Tuttavia, sarà utile se hai intenzione di scrivere analisi semantiche avanzate. I printer [SlithIR](https://github.com/crytic/slither/wiki/Printer-documentation#slithir) e [SSA](https://github.com/crytic/slither/wiki/Printer-documentation#slithir-ssa) ti aiuteranno a capire come viene tradotto il codice.
-## Fondamenti delle API {#api-basics}
+## Nozioni di base sull'API {#api-basics}
-Slither ha un'API che consente di esplorare gli attributi di base del contratto e le sue funzioni.
+Slither ha un'API che ti permette di esplorare gli attributi di base del contratto e le sue funzioni.
-Per caricare una base di codice:
+Per caricare una codebase:
```python
from slither import Slither
-slither = Slither('/path/to/project')
+slither = Slither('/percorso/del/progetto')
```
-### Esplorare contratti e funzioni {#exploring-contracts-and-functions}
+### Esplorazione di contratti e funzioni {#exploring-contracts-and-functions}
Un oggetto `Slither` ha:
- `contracts (list(Contract)`: elenco di contratti
-- `contracts_derived (list(Contract)`: elenco dei contratti che non vengono ereditati da un altro contratto (sottoinsieme di contratti)
-- `get_contract_from_name (str)`: restituisce un contratto dal nome
+- `contracts_derived (list(Contract)`: elenco di contratti non ereditati da un altro contratto (sottoinsieme di contratti)
+- `get_contract_from_name (str)`: restituisce un contratto dal suo nome
Un oggetto `Contract` ha:
@@ -222,17 +217,17 @@ Un oggetto `Contract` ha:
- `modifiers (list(Modifier))`: elenco di funzioni
- `all_functions_called (list(Function/Modifier))`: elenco di tutte le funzioni interne raggiungibili dal contratto
- `inheritance (list(Contract))`: elenco di contratti ereditati
-- `get_function_from_signature (str)`: restituisce una funzione dalla firma
-- `get_modifier_from_signature (str)`: restituisce un modificatore dalla firma
-- `get_state_variable_from_name (str)`: restituisce una variabile di stato dal nome
+- `get_function_from_signature (str)`: restituisce una funzione dalla sua firma
+- `get_modifier_from_signature (str)`: restituisce un modificatore dalla sua firma
+- `get_state_variable_from_name (str)`: restituisce una StateVariable dal suo nome
Un oggetto `Function` o `Modifier` ha:
- `name (str)`: nome della funzione
-- `contract (contract)`: il contratto in cui è dichiarata la funzione
-- `nodes (list(Node))`: elenco dei nodi che compongono il CFG della funzione o del modificatore
+- `contract (contract)`: il contratto in cui la funzione è dichiarata
+- `nodes (list(Node))`: elenco dei nodi che compongono il CFG della funzione/modificatore
- `entry_point (Node)`: punto di ingresso del CFG
-- `variables_read (list(Variable))`: elenco delle variabili lette
-- `variables_written (list(Variable))`: elenco delle variabili scritte
-- `state_variables_read (list(StateVariable))`: elenco delle variabili di stato lette (sottoinsieme di variables`read)
-- `state_variables_written (list(StateVariable))`: elenco delle variabili di stato scritte (sottoinsieme di variables`written)
+- `variables_read (list(Variable))`: elenco di variabili lette
+- `variables_written (list(Variable))`: elenco di variabili scritte
+- `state_variables_read (list(StateVariable))`: elenco di variabili di stato lette (sottoinsieme di `variables_read`)
+- `state_variables_written (list(StateVariable))`: elenco di variabili di stato scritte (sottoinsieme di `variables_written`)
diff --git a/public/content/translations/it/developers/tutorials/how-to-use-tellor-as-your-oracle/index.md b/public/content/translations/it/developers/tutorials/how-to-use-tellor-as-your-oracle/index.md
index 8a4d38bb867..e53056c8f23 100644
--- a/public/content/translations/it/developers/tutorials/how-to-use-tellor-as-your-oracle/index.md
+++ b/public/content/translations/it/developers/tutorials/how-to-use-tellor-as-your-oracle/index.md
@@ -1,51 +1,48 @@
---
-title: Come Configurare Tellor come tuo Oracolo
+title: Come configurare Tellor come proprio oracolo
description: Una guida per iniziare a integrare l'oracolo di Tellor nel tuo protocollo
author: "Tellor"
lang: it
-tags:
- - "solidity"
- - "contratti intelligenti"
- - "oracoli"
+tags: [ "Solidity", "smart contract", "oracoli" ]
skill: beginner
published: 2021-06-29
-source: Documentazione di Tellor
+source: Tellor Docs
sourceUrl: https://docs.tellor.io/tellor/
---
-Quiz: il tuo protocollo è appena terminato, ma ti serve un oracolo per avere accesso ai dati esterni alla catena... Cosa fai?
+Quiz: il tuo protocollo è quasi finito, ma ha bisogno di un oracolo per accedere a dati fuori dalla catena... Cosa fai?
-## (Soft) Prerequisiti {#soft-prerequisites}
+## (Prerequisiti consigliati) {#soft-prerequisites}
Questo post intende rendere l'accesso al feed dell'oracolo il più semplice e diretto possibile. Detto ciò, per concentrarci sull'aspetto dell'oracolo, presumiamo da parte tua le seguenti abilità di programmazione.
-Premesse:
+Presupposti:
-- se capage di muoverti nella console
+- sai muoverti in un terminale
- hai installato npm
- sai come usare npm per gestire le dipendenze
-Tellor è un oracolo in diretta e open source pronto all'implementazione. Questa guida per principianti serve a mostrare la facilità con cui puoi metterti al lavoro con Tellor, fornendo il tuo progetto con un oracolo completamente decentralizzato e resistente alla censura.
+Tellor è un oracolo open-source attivo e pronto per l'implementazione. Questa guida per principianti serve a mostrare la facilità con cui è possibile iniziare a usare Tellor, fornendo al tuo progetto un oracolo completamente decentralizzato e resistente alla censura.
## Panoramica {#overview}
-Tellor è un sistema di oracolo in cui le parti possono richiedere il valore di un punto di dati esterno alla catena (es. BTC/USD) e i segnalatori competono ad aggiungere tale valore a una banca dati sulla catena, accessibile da tutti i contratti intelligenti di Ethereum. Gli input a questa banca dati sono protetti da una rete di reporter di staking. Tellor utilizza dei meccanismi d'incentivazione cripto-economica, ricompensando gli invii di dati onesti dai segnalatori e punendo gli utenti malevoli tramite l'emissione del token di Tellor, Tributes (TRB) e un meccanismo di disputa.
+Tellor è un sistema di oracolo in cui le parti possono richiedere il valore di un dato fuori dalla catena (ad es., BTC/USD) e i reporter competono per aggiungere questo valore a una banca dati sulla catena, accessibile da tutti gli smart contract di Ethereum. Gli input di questa banca dati sono protetti da una rete di reporter con staking. Tellor utilizza meccanismi di incentivazione cripto-economica, premiando l'invio di dati onesti da parte dei reporter e punendo gli attori malintenzionati tramite l'emissione del token di Tellor, Tributes (TRB), e un meccanismo di disputa.
-In questo tutorial, esamineremo:
+In questa guida vedremo:
-- Configurazione del toolkit iniziale di cui ha bisogno per metterti al lavoro.
-- Guida a un semplice esempio.
-- Elenco degli indirizzi testnet delle reti su cui puoi testare Tellor in questo momento.
+- Configurazione del toolkit iniziale di cui avrai bisogno per iniziare.
+- Analisi di un semplice esempio.
+- Elenco degli indirizzi delle reti di test su cui puoi attualmente provare Tellor.
-## Usare Tellor {#usingtellor}
+## UsingTellor {#usingtellor}
-La prima cosa che dovrai fare è installare gli strumenti di base necessari per usare Tellor come oracolo. Usa [questo pacchetto](https://github.com/tellor-io/usingtellor) per installare i Contratti Utente di Tellor:
+La prima cosa che dovrai fare è installare gli strumenti di base necessari per usare Tellor come tuo oracolo. Usa [questo pacchetto](https://github.com/tellor-io/usingtellor) per installare i Tellor User Contracts:
`npm install usingtellor`
Una volta installato, i tuoi contratti potranno ereditare le funzioni dal contratto 'UsingTellor'.
-Ottimo! Ora che hai preparato gli strumenti, guardiamo un semplice esercizio in cui recuperiamo il prezzo Bitcoin:
+Ottimo! Ora che hai gli strumenti pronti, esaminiamo un semplice esercizio in cui recuperiamo il prezzo di bitcoin:
### Esempio BTC/USD {#btcusd-example}
@@ -59,7 +56,7 @@ import "usingtellor/contracts/UsingTellor.sol";
contract PriceContract is UsingTellor {
uint256 public btcPrice;
- //This Contract now has access to all functions in UsingTellor
+ //Questo Contratto ora ha accesso a tutte le funzioni in UsingTellor
constructor(address payable _tellorAddress) UsingTellor(_tellorAddress) public {}
@@ -77,8 +74,8 @@ function setBtcPrice() public {
}
```
-Per un elenco completo degli indirizzi dei contratti, fai riferimento a [questa guida](https://docs.tellor.io/tellor/the-basics/contracts-reference).
+Per un elenco completo degli indirizzi dei contratti, consulta [qui](https://docs.tellor.io/tellor/the-basics/contracts-reference).
-Per semplicità d'uso, la repository UsingTellort è dotata di una versione del contratto [Tellor Playground](https://github.com/tellor-io/TellorPlayground), per una più facile integrazione. Visualizza [questa pagina](https://github.com/tellor-io/sampleUsingTellor#tellor-playground) per un elenco delle funzioni utili.
+Per facilità d'uso, il repo UsingTellor include una versione del contratto [Tellor Playground](https://github.com/tellor-io/TellorPlayground) per un'integrazione più semplice. Consulta [qui](https://github.com/tellor-io/sampleUsingTellor#tellor-playground) per un elenco di funzioni utili.
-Per un'implementazione più robusta dell'oracolo di Tellor, consulta [qui](https://github.com/tellor-io/usingtellor/blob/master/README.md) l'elenco completo delle funzioni disponibili.
+Per un'implementazione più robusta dell'oracolo Tellor, consulta l'elenco completo delle funzioni disponibili [qui](https://github.com/tellor-io/usingtellor/blob/master/README.md).
diff --git a/public/content/translations/it/developers/tutorials/how-to-view-nft-in-metamask/index.md b/public/content/translations/it/developers/tutorials/how-to-view-nft-in-metamask/index.md
index c9b3a494aea..bfe832a3e93 100644
--- a/public/content/translations/it/developers/tutorials/how-to-view-nft-in-metamask/index.md
+++ b/public/content/translations/it/developers/tutorials/how-to-view-nft-in-metamask/index.md
@@ -1,35 +1,32 @@
---
title: Come visualizzare il tuo NFT nel portafoglio (Parte 3/3 della Serie di tutorial sugli NFT)
-description: Questo tutorial descrive come visualizzare un NFT esistente su Metamask!
+description: Questo tutorial descrive come visualizzare un NFT esistente su MetaMask!
author: "Sumi Mudgil"
-tags:
- - "ERC-721"
- - "Alchemy"
- - "Solidity"
+tags: [ "ERC-721", "Alchemy", "Solidity" ]
skill: beginner
lang: it
published: 2021-04-22
---
-Questo tutorial è la Parte 3/3 della serie di Tutorial sugli NFT, dove visualizziamo il nostro NFT appena coniato. Tuttavia, puoi usare il tutorial generico per qualsiasi token ERC-721 usando MetaMask, anche sulla rete principale o su qualsiasi testnet. Se vorresti imparare come coniare il tuo NFT su Ethereum, dovresti dare un'occhiata alla [Parte 1 su Come Scrivere e Distribuire un contratto intelligente NFT](/developers/tutorials/how-to-write-and-deploy-an-nft)!
+Questo tutorial è la Parte 3/3 della serie di Tutorial sugli NFT, dove visualizziamo il nostro NFT appena coniato. Tuttavia, puoi usare il tutorial generico per qualsiasi token ERC-721 usando MetaMask, anche sulla Mainnet o su qualsiasi rete di test. Se desideri imparare a coniare il tuo NFT su Ethereum, dai un'occhiata alla [Parte 1 su come scrivere e distribuire uno smart contract NFT](/developers/tutorials/how-to-write-and-deploy-an-nft)!
Congratulazioni! Sei arrivato alla parte più breve e semplice della nostra serie di tutorial sugli NFT: come visualizzare il tuo NFT appena coniato in un portafoglio virtuale. Useremo MetaMask per questo esempio poiché lo abbiamo usato nelle due parti precedenti.
-Come prerequisito, dovresti già aver installato MetaMask sullo smartphone e dovrebbe includere il conto in cui hai coniato il tuo NFT, puoi ottenere l'app gratuitamente su [iOS](https://apps.apple.com/us/app/metamask-blockchain-wallet/id1438144202) o su [Android](https://play.google.com/store/apps/details?id=io.metamask&hl=en_US&gl=US).
+Come prerequisito, dovresti avere già installato MetaMask sul cellulare e dovrebbe includere il conto su cui hai coniato il tuo NFT — puoi scaricare l'app gratuitamente su [iOS](https://apps.apple.com/us/app/metamask-blockchain-wallet/id1438144202) o [Android](https://play.google.com/store/apps/details?id=io.metamask&hl=en_US&gl=US).
-## Fase 1: imposta la tua rete su Sepolia {#set-network-to-sepolia}
+## Passaggio 1: Imposta la tua rete su Sepolia {#set-network-to-sepolia}
-Nella parte superiore dell'app, premi il pulsante “Portafoglio”, dopodiché ti sarà richiesto di selezionare una rete. Dato che il nostro NFT è stato coniato sulla rete di Sepolia, ti consigliamo di selezionare Sepolia come tua rete.
+Nella parte superiore dell'app, premi il pulsante "Portafoglio", dopodiché ti sarà richiesto di selezionare una rete. Dato che il nostro NFT è stato coniato sulla rete di Sepolia, ti consigliamo di selezionare Sepolia come tua rete.
-## Fase 2: aggiungi il tuo oggetto collezionabile a MetaMask {#add-nft-to-metamask}
+## Passaggio 2: Aggiungi il tuo oggetto collezionabile a MetaMask {#add-nft-to-metamask}
-Una volta sulla rete di Sepolia, seleziona la scheda "Collezionabili" sulla destra e aggiungi l'indirizzo del contratto intelligente NFT e l'ID del token ERC-721 del tuo NFT (dovrebbe essere reperibile su Etherscan a seconda dell'hash della transazione del tuo NFT, distribuito nella parte II del nostro tutorial).
+Una volta sulla rete di Sepolia, seleziona la scheda "Collezionabili" sulla destra e aggiungi l'indirizzo dello smart contract NFT e l'ID del token ERC-721 del tuo NFT — che dovrebbe essere reperibile su Etherscan in base all'hash della transazione del tuo NFT, distribuito nella parte II del nostro tutorial.
-È possibile che tu debba ricaricare un paio di volte per vedere il tuo NFT — ma ci sarà !
+Potresti dover aggiornare un paio di volte per visualizzare il tuo NFT — ma sarà lì !
diff --git a/public/content/translations/it/developers/tutorials/how-to-write-and-deploy-an-nft/index.md b/public/content/translations/it/developers/tutorials/how-to-write-and-deploy-an-nft/index.md
index c7995522e44..3609c5c24fd 100644
--- a/public/content/translations/it/developers/tutorials/how-to-write-and-deploy-an-nft/index.md
+++ b/public/content/translations/it/developers/tutorials/how-to-write-and-deploy-an-nft/index.md
@@ -1,12 +1,8 @@
---
-title: Come Scrivere e Distribuire un NFT (Parte 1/3 della Serie di tutorial sugli NFT)
-description: Questo tutorial è la Parte 1 di una serie sui NFT che ti guiderà passo dopo passo alla scrittura e distribuzione del contratto intelligente di un Token Non Fungibile (token ERC-721) usando Ethereum e l'InterPlanetary File System (IPFS).
+title: Come scrivere e distribuire un NFT (Parte 1/3 della serie di guide sugli NFT)
+description: "Questo tutorial è la Parte 1 di una serie sui NFT che ti guiderà passo dopo passo alla scrittura e distribuzione del contratto intelligente di un Token Non Fungibile (token ERC-721) usando Ethereum e l'InterPlanetary File System (IPFS)."
author: "Sumi Mudgil"
-tags:
- - "ERC-721"
- - "Alchemy"
- - "Solidity"
- - "contratti intelligenti"
+tags: [ "ERC-721", "Alchemy", "Solidity", "Smart Contract" ]
skill: beginner
lang: it
published: 2021-04-22
@@ -14,23 +10,23 @@ published: 2021-04-22
Ora che gli NFT rendono nota la blockchain al grande pubblico, si presenta un'eccellente opportunità per comprendere questo interesse, pubblicando il tuo NFT (Token ERC-721) sulla blockchain di Ethereum!
-Alchemy è estremamente orgogliosa di supportare i più grandi nomi nello spazio degli NFT, tra cui Makersplace (ha recentemente toccato un record nella vendita di opere d'arte digitali a Christie, per $69 milioni), Dapper Labs (creatori di NBA Top Shot e Crypto Kitties), OpenSea (il più grande mercato di NFT al mondo), Zora, Super Rare, NFTfi, Foundation, Enjin, Origin Protocol, Immutable e altri.
+Alchemy è estremamente orgogliosa di supportare i più grandi nomi nello spazio degli NFT, tra cui Makersplace (ha recentemente toccato un record nella vendita di opere d'arte digitali a Christie, per 69 milioni di dollari), Dapper Labs (creatori di NBA Top Shot e Crypto Kitties), OpenSea (il più grande mercato di NFT al mondo), Zora, Super Rare, NFTfi, Foundation, Enjin, Origin Protocol, Immutable e altri.
-In questo tutorial, ti guideremo alla creazione e distribuzione di un contratto intelligente ERC-721 sulla rete di prova di Sepolia, utilizzando [MetaMask](https://metamask.io/), [Solidity](https://docs.soliditylang.org/en/v0.8.0/), [Hardhat](https://hardhat.org/), [Pinata](https://pinata.cloud/) e [Alchemy](https://alchemy.com/signup/eth) (non preoccuparti se ancora non capisci che significa; te lo spiegheremo!).
+In questa guida, illustreremo la creazione e la distribuzione di un contratto intelligente ERC-721 sulla rete di test di Sepolia usando [MetaMask](https://metamask.io/), [Solidity](https://docs.soliditylang.org/en/v0.8.0/), [Hardhat](https://hardhat.org/), [Pinata](https://pinata.cloud/) e [Alchemy](https://alchemy.com/signup/eth) (non preoccuparti se non hai ancora capito cosa significa, te lo spiegheremo!).
Nella Parte 2 di questo tutorial affronteremo come possiamo usare il nostro contratto intelligente per coniare un NFT e nella Parte 3 spiegheremo come visualizzare il tuo NFT su MetaMask.
-E, ovviamente, se in qualsiasi momento hai domande, non esitare a contattarci nel [Discord di Alchemy](https://discord.gg/gWuC7zB) o consulta [la documentazione sulle NFT API di Alchemy](https://docs.alchemy.com/alchemy/enhanced-apis/nft-api)!!
+E, naturalmente, se hai domande in qualsiasi momento, non esitare a contattarci sul [Discord di Alchemy](https://discord.gg/gWuC7zB) o a visitare la [documentazione dell'API NFT di Alchemy](https://docs.alchemy.com/alchemy/enhanced-apis/nft-api)!
-## Fase 1: connettersi alla rete di Ethereum {#connect-to-ethereum}
+## Fase 1: Connettiti alla rete Ethereum {#connect-to-ethereum}
-Esistono molti modi per effettuare richieste alla blockchain di Ethereum, ma per semplificare le cose, utilizzeremo un conto gratuito su [Alchemy](https://alchemy.com/signup/eth), una piattaforma per sviluppatori della blockchain e API, che ci consente di comunicare con la catena di Ethereum senza dover operare i nostri nodi.
+Ci sono molti modi per effettuare richieste alla blockchain di Ethereum, ma per semplificare le cose, useremo un account gratuito su [Alchemy](https://alchemy.com/signup/eth), una piattaforma di sviluppo blockchain e API che ci permette di comunicare con la chain di Ethereum senza dover gestire i nostri nodi.
-In questo tutorial, approfitteremo anche degli strumenti per monitoraggio e analisi per sviluppatori messi a disposizione da Alchemy per comprendere cosa succede dietro le quinte quando distribuiamo il nostro contratto intelligente. Se non hai già un conto di Alchemy, puoi iscriverti gratuitamente [qui](https://alchemy.com/signup/eth).
+In questo tutorial, approfitteremo anche degli strumenti per monitoraggio e analisi per sviluppatori messi a disposizione da Alchemy per comprendere cosa succede dietro le quinte quando distribuiamo il nostro contratto intelligente. Se non hai già un account Alchemy, puoi iscriverti gratuitamente [qui](https://alchemy.com/signup/eth).
-## Fase 2: crea la tua app (e chiave API) {#make-api-key}
+## Fase 2: Crea la tua app (e la chiave API) {#make-api-key}
-Una volta creato un profilo di Alchemy, puoi generare una chiave API creando un'app. Questo ci consentirà di effettuare richieste alla rete di prova di Sepolia. Dai un'occhiata a [questa guida](https://docs.alchemyapi.io/guides/choosing-a-network) se vuoi maggiori informazioni sulle reti di prova.
+Una volta creato un conto di Alchemy, puoi generare una chiave API creando un'app. Questo ci consentirà di effettuare richieste alla rete di prova di Sepolia. Consulta [questa guida](https://docs.alchemyapi.io/guides/choosing-a-network) se sei curioso di saperne di più sulle reti di test.
1. Naviga fino alla pagina "Create App" nella tua Dashboard di Alchemy passando il puntatore del mouse su "Apps" nella barra di navigazione e cliccando su "Create App"
@@ -40,46 +36,53 @@ Una volta creato un profilo di Alchemy, puoi generare una chiave API creando un'
-3. Clicca su “Create app” e il gioco è fatto! La tua app dovrebbe apparire nella tabella seguente.
+3. Clicca “Crea app” ed è tutto! La tua app dovrebbe apparire nella tabella seguente.
-## Fase 3: crea un conto di Ethereum (indirizzo) {#create-eth-address}
+## Fase 3: Crea un account Ethereum (indirizzo) {#create-eth-address}
-Per inviare e ricevere le transazioni, necessitiamo di un conto di Ethereum. Per questo tutorial, useremo MetaMask, un portafoglio virtuale nel browser per gestire l'indirizzo del tuo conto di Ethereum. Se vuoi capire di più su come funzionano le transazioni su Ethereum, dai un'occhiata a [questa pagina](/developers/docs/transactions/) della Ethereum Foundation.
+Per inviare e ricevere le transazioni, necessitiamo di un conto di Ethereum. Per questo tutorial, utilizzeremo MetaMask, un portafoglio virtuale nel browser, utilizzato per gestire l'indirizzo del tuo conto di Ethereum. Se vuoi saperne di più su come funzionano le transazioni su Ethereum, consulta [questa pagina](/developers/docs/transactions/) della Ethereum Foundation.
-Puoi scaricare e creare gratuitamente un conto di MetaMask [qui](https://metamask.io/download). Quando crei un account, o se ne possiedi già uno, assicurati di passare alla "Rete di prova di Sepolia" in alto a destra (così da non avere a che fare con denaro reale).
+Puoi scaricare e creare un account MetaMask gratuitamente [qui](https://metamask.io/download). Quando crei un account, o se ne possiedi già uno, assicurati di passare alla "Rete di prova di Sepolia" in alto a destra (così da non avere a che fare con denaro reale).
-## Fase 4: aggiungi ether da un Faucet {#step-4-add-ether-from-a-faucet}
+## Fase 4: Aggiungi ether da un Faucet {#step-4-add-ether-from-a-faucet}
-Per poter distribuire il nostro contratto intelligente alla rete di prova, avremo prima bisogno di degli ETH finti. Per ottenere ETH puoi andare al [Faucet di Sepolia](https://sepoliafaucet.com/) ospitato da Alchemy, accedi e inserisci l'indirizzo del tuo account, fai clic su “Inviami ETH”. Subito dopo, dovresti vedere gli ETH nel tuo conto di MetaMask!
+Per poter distribuire il nostro contratto intelligente alla rete di prova, avremo bisogno di degli ETH finti. Per ottenere ETH, vai al [Sepolia Faucet](https://sepoliafaucet.com/) ospitato da Alchemy, accedi, inserisci l'indirizzo del tuo account e fai clic su “Inviami ETH”. Subito dopo, dovresti vedere gli ETH nel tuo conto di MetaMask!
-## Fase 5: controlla il saldo {#check-balance}
+## Fase 5: Controlla il tuo saldo {#check-balance}
-Per ricontrollare che ci sia il saldo, facciamo una richiesta [eth_getBalance](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_getbalance) usando lo [strumento compositore di Alchemy](https://composer.alchemyapi.io?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D). Questo restituirà l'importo di ETH nel nostro portafoglio. Dopo aver inserito l'indirizzo del tuo conto di MetaMask e aver cliccato “Invia richiesta”, dovresti vedere una risposta come questa:
+Per verificare che il nostro saldo sia presente, effettuiamo una richiesta [eth_getBalance](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_getbalance) utilizzando lo [strumento composer di Alchemy](https://composer.alchemyapi.io?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D). Questo restituirà l'importo di ETH nel nostro portafoglio. Dopo aver inserito l'indirizzo del tuo conto di MetaMask e aver cliccato "Invia Richiesta", dovresti visualizzare una risposta simile alla seguente:
+ ```
`{"jsonrpc": "2.0", "id": 0, "result": "0xde0b6b3a7640000"}`
+ ```
-> **NOTA:** Questo risultato è in wei, non in ETH. Wei è usato come taglio più piccolo dell'ether. La conversione da wei a ETH è: 1 eth = 1018 wei. Quindi se convertiamo 0xde0b6b3a7640000 in decimali, otteniamo 1\*1018 wei, pari a 1 ETH.
+> **Nota**: questo risultato è in wei, non in ETH. Wei è usato come taglio più piccolo dell'ether. La conversione da wei a ETH è: 1 eth = 1018 wei. Quindi se convertiamo 0xde0b6b3a7640000 in decimali, otteniamo 1\*1018 wei, pari a 1 ETH.
Meno male! I nostri soldi finti ci sono tutti.
-## Fase 6: inizializza il progetto {#initialize-project}
+## Fase 6: Inizializza il nostro progetto {#initialize-project}
Prima, dovremo creare una cartella per il nostro progetto. Vai alla riga di comando e digita:
+ ```
mkdir my-nft
cd my-nft
+ ```
-Ora che siamo nella cartella del nostro progetto, useremo npm init per inizializzare il progetto. Se non hai già installato npm, segui [queste istruzioni](https://docs.alchemyapi.io/alchemy/guides/alchemy-for-macs#1-install-nodejs-and-npm) (avremo anche bisogno di [Node.js](https://nodejs.org/en/download/), quindi scarica anche questo!).
+Ora che siamo nella cartella del nostro progetto, useremo npm init per inizializzare il progetto. Se non hai ancora installato npm, segui [queste istruzioni](https://docs.alchemyapi.io/alchemy/guides/alchemy-for-macs#1-install-nodejs-and-npm) (avremo bisogno anche di [Node.js](https://nodejs.org/en/download/), quindi scarica anche quello!).
+ ```
npm init
+ ```
Non è importante come rispondi alle domande d'installazione; a titolo di esempio, ecco le nostre risposte:
+
```json
package name: (my-nft)
version: (1.0.0)
- description: My first NFT!
+ description: Il mio primo NFT!
entry point: (index.js)
test command:
git repository:
@@ -91,7 +94,7 @@ Non è importante come rispondi alle domande d'installazione; a titolo di esempi
{
"name": "my-nft",
"version": "1.0.0",
- "description": "My first NFT!",
+ "description": "Il mio primo NFT!",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
@@ -100,26 +103,32 @@ Non è importante come rispondi alle domande d'installazione; a titolo di esempi
"license": "ISC"
}
```
+
Approva il package.json, e siamo pronti!
-## Fase 7: installa [Hardhat](https://hardhat.org/getting-started/#overview) {#install-hardhat}
+## Fase 7: Installa [Hardhat](https://hardhat.org/getting-started/#overview) {#install-hardhat}
Hardhat è un ambiente di sviluppo per compilare, distribuire, testare ed effettuare il debug del tuo software di Ethereum. Aiuta gli sviluppatori nella costruzione di contratti intelligenti e dapp localmente, prima di distribuirli alla catena.
Nel nostro progetto my-nft esegui:
+ ```
npm install --save-dev hardhat
+ ```
-Dai un'occhiata a questa pagina per ulteriori dettagli sulle [istruzioni d'installazione](https://hardhat.org/getting-started/#overview).
+Consulta questa pagina per maggiori dettagli sulle [istruzioni di installazione](https://hardhat.org/getting-started/#overview).
-## Fase 8: crea un progetto Hardhat {#create-hardhat-project}
+## Fase 8: Crea un progetto Hardhat {#create-hardhat-project}
Nella cartella del nostro progetto esegui:
+ ```
npx hardhat
+ ```
Dovresti poi vedere un messaggio di benvenuto e l'opzione per selezionare cosa desideri fare. Seleziona “crea un hardhat.config.js vuoto”:
+ ```
888 888 888 888 888
888 888 888 888 888
888 888 888 888 888
@@ -128,37 +137,40 @@ Dovresti poi vedere un messaggio di benvenuto e l'opzione per selezionare cosa d
888 888 .d888888 888 888 888 888 888 .d888888 888
888 888 888 888 888 Y88b 888 888 888 888 888 Y88b.
888 888 "Y888888 888 "Y88888 888 888 "Y888888 "Y888
- 👷 Welcome to Hardhat v2.0.11 👷
+ 👷 Benvenuto in Hardhat v2.0.11 👷
? Cosa vuoi fare? …
- Create a sample project
- ❯ Create an empty hardhat.config.js
- Quit
+ Crea un progetto di esempio
+ ❯ Crea un hardhat.config.js vuoto
+ Esci
+ ```
Questo genererà un file hardhat.config.js, in cui specificheremo tutta la configurazione per il nostro progetto (alla fase 13).
-## Fase 9: aggiungi le cartelle del progetto {#add-project-folders}
+## Fase 9: Aggiungi le cartelle di progetto {#add-project-folders}
Per mantenere organizzato il nostro progetto, creeremo due nuove cartelle. Vai alla cartella di root del tuo progetto nella tua riga di comando e digita:
+ ```
mkdir contracts
mkdir scripts
+ ```
- contracts/ è dove manterremo il codice del contratto intelligente del nostro NFT
- scripts/ è dove manterremo gli script per distribuire e interagire con il nostro contratto intelligente
-## Fase 10: compila il nostro contratto {#write-contract}
+## Fase 10: Scrivi il nostro contratto {#write-contract}
-Ora che il nostro ambiente è configurato, passiamo alle cose più entusiasmanti: _scrivere il codice del nostro contratto intelligente!_
+Ora che il nostro ambiente è configurato, passiamo a cose più entusiasmanti: _scrivere il codice del nostro contratto intelligente!_
Apri il progetto my-nft nel tuo editor preferito (a noi piace [VSCode](https://code.visualstudio.com/)). I contratti intelligenti sono scritti in un linguaggio detto Solidity, che useremo per scrivere il nostro contratto intelligente MyNFT.sol.
1. Vai alla cartella `contracts` e crea un nuovo file chiamato MyNFT.sol
-2. Segue il codice del contratto intelligente del nostro NFT, che abbiamo basato sull'implementazione ERC-721 della libreria di [OpenZeppelin](https://docs.openzeppelin.com/contracts/3.x/erc721). Copia e incolla i seguenti contenuti nel tuo file MyNFT.sol.
+2. Di seguito è riportato il codice del nostro contratto intelligente NFT, che si basa sull'implementazione ERC-721 della libreria di [OpenZeppelin](https://docs.openzeppelin.com/contracts/3.x/erc721). Copia e incolla i seguenti contenuti nel tuo file MyNFT.sol.
```solidity
- //Contract based on [https://docs.openzeppelin.com/contracts/3.x/erc721](https://docs.openzeppelin.com/contracts/3.x/erc721)
+ //Contratto basato su [https://docs.openzeppelin.com/contracts/3.x/erc721](https://docs.openzeppelin.com/contracts/3.x/erc721)
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
@@ -188,72 +200,78 @@ Apri il progetto my-nft nel tuo editor preferito (a noi piace [VSCode](https://c
}
```
-3. Poiché stiamo ereditando classi dalla libreria di contratti di OpenZeppelin, nella riga di comando esegui `npm install @openzeppelin/contracts` per installare la libreria nella nostra cartella.
+3. Poiché stiamo ereditando le classi dalla libreria di contratti OpenZeppelin, nella riga di comando esegui `npm install @openzeppelin/contracts^4.0.0` per installare la libreria nella nostra cartella.
Quindi, cosa _fa_ esattamente questo codice? Analizziamolo, riga dopo riga.
-In cima al nostro contratto intelligente, importiamo tre classi del contratto intelligente di [OpenZeppelin](https://openzeppelin.com/):
+Nella parte superiore del nostro contratto intelligente, importiamo tre classi di contratto intelligente di [OpenZeppelin](https://openzeppelin.com/):
-- @openzeppelin/contracts/token/ERC721/ERC721.sol contiene l'implementazione dello standard ERC-721, che il contratto intelligente del nostro NFT erediterà. (Per essere un NFT valido, il tuo contratto intelligente deve implementare tutti i metodi dello standard ERC-721.) Per saperne di più sulle funzioni ERC-721 ereditate, dai un'occhiata alla definizione dell'interfaccia [qui](https://eips.ethereum.org/EIPS/eip-721).
+- @openzeppelin/contracts/token/ERC721/ERC721.sol contiene l'implementazione dello standard ERC-721, che il contratto intelligente del nostro NFT erediterà. (Per essere un NFT valido, il tuo contratto intelligente deve implementare tutti i metodi dello standard ERC-721.) Per saperne di più sulle funzioni ERC-721 ereditate, consulta la definizione dell'interfaccia [qui](https://eips.ethereum.org/EIPS/eip-721).
- @openzeppelin/contracts/utils/Counters.sol fornisce contatori che possono esser solo incrementati o diminuiti di unità alla volta. Il nostro contratto intelligente usa un contatore per tener traccia del numero totale di NFT coniati e impostare l'ID univoco sul nostro nuovo NFT. (A ogni NFT coniato usando un contratto intelligente, dev'esser assegnato un ID univoco, qui il nostro ID univoco è determinato solo dal numero totale di NFT esistenti. Ad esempio, il primo NFT che coniamo con il nostro contratto intelligente ha un ID di "1," il nostro secondo NFT ha un ID di "2," ecc.)
-- @openzeppelin/contracts/access/Ownable.sol imposta [il controllo d'accesso](https://docs.openzeppelin.com/contracts/3.x/access-control) sul nostro contratto intelligente, così solo il proprietario del contratto intelligente (tu) può coniare NFT. (Nota, prevedere il controllo dell'accesso è totalmente facoltativo. Se volessi che tutti potessero coniare un NFT usando il tuo contratto intelligente, dovresti rimuovere la parola Ownable alla riga 10 e onlyOwner alla riga 17.)
+- `@openzeppelin/contracts/access/Ownable.sol` imposta il [controllo degli accessi](https://docs.openzeppelin.com/contracts/3.x/access-control) sul nostro contratto intelligente, in modo che solo il proprietario del contratto intelligente (tu) possa coniare NFT. (Nota, prevedere il controllo dell'accesso è totalmente facoltativo. Se volessi che tutti potessero coniare un NFT usando il tuo contratto intelligente, dovresti rimuovere la parola Ownable alla riga 10 e onlyOwner alla riga 17.)
-Dopo le nostre dichiarazioni d'importazione, abbiamo il contratto intelligente del nostro NFT personalizzato, che è sorprendentemente corto: contiene solo un contatore, un costruttore e una funzione singola! Questo grazie ai nostri contratti ereditati da OpenZeppelin, che implementa gran parte dei metodi che necessitiamo per creare un NFT, come `ownerOf`, che restituisce il proprietario del NFT e `transferFrom`, che trasferisce la proprietà del NFT da un conto a un altro.
+Dopo le nostre dichiarazioni d'importazione, abbiamo il contratto intelligente del nostro NFT personalizzato, che è sorprendentemente corto: contiene solo un contatore, un costruttore e una funzione singola! Questo è possibile grazie ai nostri contratti OpenZeppelin ereditati, che implementano la maggior parte dei metodi necessari per creare un NFT, come `ownerOf`, che restituisce il proprietario dell'NFT, e `transferFrom`, che trasferisce la proprietà dell'NFT da un account a un altro.
Nel nostro costruttore ERC-721, noterai che passiamo 2 stringhe, “MyNFT” e “NFT.” La prima variabile è il nome del contratto intelligente e la seconda è il suo simbolo. Puoi assegnare a ciascuna di queste variabili il nome che desideri!
-Infine, abbiamo la nostra funzione `mintNFT(address recipient, string tokenURI)` che ci consente di coniare un NFT! Noterai che questa funzione usa due variabili:
+Infine, abbiamo la nostra funzione `mintNFT(address recipient, string memory tokenURI)` che ci permette di coniare un NFT! Noterai che questa funzione usa due variabili:
-- `address recipient` specifica l'indirizzo che riceverà il tuo NFT appena coniato
+- `address recipient` specifica l'indirizzo che riceverà il tuo NFT appena coniato.
- `string memory tokenURI` è una stringa che dovrebbe risolversi in un documento JSON che descrive i metadati dell'NFT. I metadati di un NFT sono davvero ciò che lo porta in vita, consentendogli di avere proprietà configurabili, quali nome, descrizione, immagine e altri attributi. Nella parte 2 di questo tutorial, descriveremo come configurare questi metadati.
`mintNFT` chiama alcuni metodi dalla libreria ERC-721 ereditata e, infine, restituisce un numero che rappresenta l'ID dell'NFT appena coniato.
-## Fase 11: connetti MetaMask e Alchemy al tuo progetto {#connect-metamask-and-alchemy}
+## Fase 11: Collega MetaMask e Alchemy al tuo progetto {#connect-metamask-and-alchemy}
Ora che abbiamo creato un portafoglio di MetaMask, un conto di Alchemy e scritto il nostro contratto intelligente, è il momento di collegarli.
Ogni transazione inviata dal tuo portafoglio virtuale richiede una firma tramite la tua chiave privata unica. Per fornire al nostro programma quest'autorizzazione, possiamo memorizzare in sicurezza la nostra chiave privata (e la chiave API di Alchemy) in un file ambientale.
-Per saperne di più sull'invio delle transazioni, dai un'occhiata a [questo tutorial](/developers/tutorials/sending-transactions-using-web3-and-alchemy/) sull'invio di transazioni usando web3.
+Per saperne di più sull'invio di transazioni, consulta [questa guida](/developers/tutorials/sending-transactions-using-web3-and-alchemy/) sull'invio di transazioni tramite web3.
Prima, installa il pacchetto dotenv nella cartella del tuo progetto:
+ ```
npm install dotenv --save
+ ```
-Poi, crea un file `.env` nella cartella di root del nostro progetto e aggiungi la tua chiave privata di MetaMask e l'URL API di Alchemy HTTP.
+Quindi, crea un file `.env` nella directory principale del nostro progetto e aggiungici la tua chiave privata di MetaMask e l'URL dell'API HTTP di Alchemy.
-- Segui [queste istruzioni](https://metamask.zendesk.com/hc/en-us/articles/360015289632-How-to-Export-an-Account-Private-Key) per esportare la tua chiave privata da MetaMask
+- Segui [queste istruzioni](https://metamask.zendesk.com/hc/en-us/articles/360015289632-How-to-Export-an-Account-Private-Key) per esportare la tua chiave privata da MetaMask.
- Vedi di seguito come ottenere l'URL dell'API di Alchemy HTTP e copialo negli appunti
-
+
-Il tuo `.env` dovrebbe somigliare a questo:
+Il tuo file `.env` dovrebbe ora apparire così:
+ ```
API_URL="https://eth-sepolia.g.alchemy.com/v2/your-api-key"
PRIVATE_KEY="your-metamask-private-key"
+ ```
Per connetterli realmente al nostro codice, faremo riferimento a queste variabili nel nostro file hardhat.config.js nella fase 13.
-## Fase 12: installa Ethers.js {#install-ethers}
+## Fase 12: Installa Ethers.js {#install-ethers}
-Ethers.js è una libreria che rende più facile interagire ed effettuare richieste a Ethereum tramite wrapping dei [metodi JSON-RPC standard](/developers/docs/apis/json-rpc/) con altri metodi più facili da usare.
+Ethers.js è una libreria che semplifica l'interazione e l'invio di richieste a Ethereum, eseguendo il wrapping dei [metodi JSON-RPC standard](/developers/docs/apis/json-rpc/) con metodi più intuitivi.
-Hardhat rende davvero facile integrare [Plugin](https://hardhat.org/plugins/) per strumenti e funzionalità aggiuntive. Sfrutteremo il [plugin di Ethers](https://hardhat.org/docs/plugins/official-plugins#hardhat-ethers) per la distribuzione del contratto ([Ethers.js](https://github.com/ethers-io/ethers.js/) ha dei metodi di distribuzione del contratto molto puliti).
+Hardhat rende semplicissima l'integrazione di [Plugin](https://hardhat.org/plugins/) per strumenti aggiuntivi e funzionalità estese. Approfitteremo del [plugin Ethers](https://hardhat.org/docs/plugins/official-plugins#hardhat-ethers) per la distribuzione dei contratti ([Ethers.js](https://github.com/ethers-io/ethers.js/) ha dei metodi di distribuzione dei contratti molto puliti).
Nella cartella del tuo progetto digita:
+ ```
npm install --save-dev @nomiclabs/hardhat-ethers ethers@^5.0.0
+ ```
Avremo bisogno di ethers anche nel nostro hardhat.config.js nella prossima fase.
-## Fase 13: aggiorna hardhat.config.js {#update-hardhat-config}
+## Fase 13: Aggiorna hardhat.config.js {#update-hardhat-config}
Finora abbiamo aggiunto diverse dipendenze e plugin, ora dobbiamo aggiornare hardhat.config.js in modo che il nostro progetto li riconosca tutti.
@@ -279,30 +297,32 @@ Aggiorna il tuo hardhat.config.js affinché appaia così:
}
```
-## Fase 14: compila il contratto {#compile-contract}
+## Fase 14: Compila il nostro contratto {#compile-contract}
Per assicurarti che tutto funzioni fino a questo punto, compila il contratto. L'attività di compilazione è una delle attività integrate di hardhat.
Dalla riga di comando esegui:
+ ```
npx hardhat compile
+ ```
-Potresti ottenere un avviso sull'assenza nel file sorgente dell'identificativo della licenza SPDX, ma non preoccupartene, tutto il resto dovrebbe funzionare! Altrimenti, puoi sempre inviare un messaggio nel [Discord di Alchemy](https://discord.gg/u72VCg3).
+Potresti ottenere un avviso sull'assenza nel file sorgente dell'identificativo della licenza SPDX, ma non preoccupartene, tutto il resto dovrebbe funzionare! In caso contrario, puoi sempre inviare un messaggio nel [discord di Alchemy](https://discord.gg/u72VCg3).
-## Fase 15: scrivi lo script di distribuzione {#write-deploy}
+## Fase 15: Scrivi il nostro script di distribuzione {#write-deploy}
Ora che il nostro contratto è scritto e il nostro file di configurazione è pronto, è il momento di scrivere lo script di distribuzione del contratto.
-Vai alla cartella `script/` e crea un nuovo file chiamato `deploy.js`, aggiungendo i seguenti contenuti:
+Vai alla cartella `scripts/` e crea un nuovo file chiamato `deploy.js`, aggiungendovi i seguenti contenuti:
```js
async function main() {
const MyNFT = await ethers.getContractFactory("MyNFT")
- // Start deployment, returning a promise that resolves to a contract object
+ // Avvia la distribuzione, restituendo una promise che si risolve in un oggetto contratto
const myNFT = await MyNFT.deploy()
await myNFT.deployed()
- console.log("Contract deployed to address:", myNFT.address)
+ console.log("Contratto distribuito all'indirizzo:", myNFT.address)
}
main()
@@ -313,40 +333,48 @@ main()
})
```
-Nel suo [tutorial sui Contratti](https://hardhat.org/tutorial/testing-contracts.html#writing-tests) hardhat spiega in modo eccellente cosa fa ognuna di queste righe di codice nel loro, quindi riportiamo qui le loro spiegazioni.
+Hardhat spiega molto bene cosa fa ciascuna di queste righe di codice nella sua [Guida ai contratti](https://hardhat.org/tutorial/testing-contracts.html#writing-tests), e qui abbiamo adottato le sue spiegazioni.
+ ```
const MyNFT = await ethers.getContractFactory("MyNFT");
+ ```
Un ContractFactory su ethers.js è un'astrazione usata per distribuire nuovi contratti intelligenti, quindi MyNFT qui è una fabbrica di istanze del nostro contratto NFT. Usando il plugin hardhat-ethers, le istanze ContractFactory e Contract sono connesse di default al primo firmatario.
+ ```
const myNFT = await MyNFT.deploy();
+ ```
Chiamare deploy() su un ContractFactory avvierà la distribuzione e restituirà una promessa che si risolverà in un contratto. Questo è l'oggetto che ha un metodo per ciascuna delle funzioni del nostro smart contract.
-## Fase 16: distribuisci il contratto {#deploy-contract}
+## Fase 16: Distribuisci il nostro contratto {#deploy-contract}
Siamo finalmente pronti a distribuire il nostro smart contract! Torna alla root della cartella del tuo progetto e nella riga di comando esegui:
+ ```
npx hardhat --network sepolia run scripts/deploy.js
+ ```
Vorrai poi vedere qualcosa del genere:
+ ```
Contratto distribuito all'indirizzo: 0x4C5266cCc4b3F426965d2f51b6D910325a0E7650
+ ```
-Se andiamo su [Sepolia etherscan](https://sepolia.etherscan.io/) e cerchiamo l'indirizzo del nostro contratto, dovremmo poter vedere che è stato distribuito correttamente. Se non riesci a vederlo immediatamente, attendi alcuni istanti poiché potrebbe essere necessario un po' di tempo. La transazione somiglierà a questa:
+Se andiamo su [Sepolia Etherscan](https://sepolia.etherscan.io/) e cerchiamo l'indirizzo del nostro contratto, dovremmo essere in grado di vedere che è stato distribuito con successo. Se non riesci a vederlo immediatamente, attendi alcuni istanti poiché potrebbe essere necessario un po' di tempo. La transazione somiglierà a questa:
-L'indirizzo "Da" dovrebbe corrispondere all'indirizzo del tuo account di MetaMask mentre l'indirizzo "A" sarà: “Creazione del contratto.” Se facciamo clic sulla transazione, vediamo l'indirizzo del nostro contratto nel campo "A":
+L'indirizzo "Da" dovrebbe corrispondere all'indirizzo del tuo account di MetaMask mentre l'indirizzo "A" sarà: “Creazione del contratto”. Se facciamo clic sulla transazione, vediamo l'indirizzo del nostro contratto nel campo "A":
Sììììììììììì! Hai appena distribuito il tuo contratto intelligente NFT alla catena (testnet) di Ethereum!
-Per capire cosa sta succedendo, andiamo alla scheda Explorer nel nostro [dashboard di Alchemy](https://dashboard.alchemyapi.io/explorer). Se hai diverse app di Alchemy, assicurati di filtrare per app e selezionare "MyNFT".
+Per capire cosa sta succedendo dietro le quinte, vai alla scheda Explorer nella nostra [dashboard di Alchemy](https://dashboard.alchemyapi.io/explorer). Se hai diverse app di Alchemy, assicurati di filtrare per app e selezionare "MyNFT".
-
+
-Qui vedrai numerose chiamate a JSON-RPC che Hardhat/Ethers ha effettuato per noi quando abbiamo chiamato la funzione .deploy(). Due funzioni importanti da chiamare qui sono [eth_sendRawTransaction](/developers/docs/apis/json-rpc/#eth_sendrawtransaction), che è la richiesta di scrivere realmente il nostro contratto intelligente sulla catena di Sepolia e [eth_getTransactionByHash](/developers/docs/apis/json-rpc/#eth_gettransactionbyhash), che è una richiesta di leggere le informazioni sulla nostra transazione dato l'hash (uno schema tipico quando si inviano le transazioni). Per saperne di più sull'invio delle transazioni, dai un'occhiata a questo tutorial [ sull'invio di transazioni usando web3](/developers/tutorials/sending-transactions-using-web3-and-alchemy/).
+Qui vedrai numerose chiamate a JSON-RPC che Hardhat/Ethers ha effettuato per noi quando abbiamo chiamato la funzione .deploy(). Due funzioni importanti da menzionare sono [`eth_sendRawTransaction`](/developers/docs/apis/json-rpc/#eth_sendrawtransaction), che è la richiesta di scrivere effettivamente il nostro contratto intelligente sulla chain di Sepolia, e [`eth_getTransactionByHash`](/developers/docs/apis/json-rpc/#eth_gettransactionbyhash), che è una richiesta di leggere le informazioni sulla nostra transazione dato l'hash (un modello tipico quando si inviano transazioni). Per saperne di più sull'invio di transazioni, consulta questa guida su come [inviare transazioni usando Web3](/developers/tutorials/sending-transactions-using-web3-and-alchemy/).
-È tutto per la parte 1 di questo tutorial. Nella [parte 2 interagiremo realmente con il nostro contratto intelligente, coniando un NFT](/developers/tutorials/how-to-mint-an-nft/) e nella [parte 3 ti mostreremo come visualizzare il tuo NFT nel tuo portafoglio di Ethereum](/developers/tutorials/how-to-view-nft-in-metamask/)!
+È tutto per la parte 1 di questo tutorial. Nella [parte 2, interagiremo con il nostro contratto intelligente coniando un NFT](/developers/tutorials/how-to-mint-an-nft/) e, nella [parte 3, ti mostreremo come visualizzare il tuo NFT nel tuo portafoglio Ethereum](/developers/tutorials/how-to-view-nft-in-metamask/)!
diff --git a/public/content/translations/it/developers/tutorials/interact-with-other-contracts-from-solidity/index.md b/public/content/translations/it/developers/tutorials/interact-with-other-contracts-from-solidity/index.md
index 63c082a5be6..14da62d03a3 100644
--- a/public/content/translations/it/developers/tutorials/interact-with-other-contracts-from-solidity/index.md
+++ b/public/content/translations/it/developers/tutorials/interact-with-other-contracts-from-solidity/index.md
@@ -1,13 +1,15 @@
---
title: Interazione con altri contratti da Solidity
-description: Come distribuire uno Smart Contract da uno esistente e interagirvi
+description: Come distribuire un contratto intelligente da un contratto esistente e interagire con esso
author: "jdourlens"
tags:
- - "smart contract"
- - "Solidity"
- - "remix"
- - "distribuzione"
- - "componibilità"
+ [
+ "smart contract",
+ "Solidity",
+ "remix",
+ "distribuzione",
+ "componibilità"
+ ]
skill: advanced
lang: it
published: 2020-04-05
@@ -16,9 +18,9 @@ sourceUrl: https://ethereumdev.io/interact-with-other-contracts-from-solidity/
address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
---
-Nei tutorial precedenti abbiamo imparato molto su [come distribuire il primo Smart Contract](/developers/tutorials/deploying-your-first-smart-contract/) e aggiungervi alcune funzionalità come il [controllo degli accessi con modificatori](https://ethereumdev.io/organize-your-code-and-control-access-to-your-smart-contract-with-modifiers/) o la [gestione degli errori in Solidity](https://ethereumdev.io/handle-errors-in-solidity-with-require-and-revert/). In questo tutorial impareremo come distribuire uno Smart Contract da uno esistente e interagirvi.
+Nelle guide precedenti abbiamo imparato molto, ad esempio [come distribuire il tuo primo contratto intelligente](/developers/tutorials/deploying-your-first-smart-contract/) e ad aggiungervi alcune funzionalità come [il controllo degli accessi con i modificatori](https://ethereumdev.io/organize-your-code-and-control-access-to-your-smart-contract-with-modifiers/) o [la gestione degli errori in Solidity](https://ethereumdev.io/handle-errors-in-solidity-with-require-and-revert/). In questa guida impareremo come distribuire un contratto intelligente da un contratto esistente e interagire con esso.
-Creeremo un contratto che permetta a chiunque ad avere uno Smart Contract `Counter` creando una factory associata, il cui nome sarà `CounterFactory`. Prima di tutto, ecco il codice del nostro Smart Contract iniziale `Counter`:
+Creeremo un contratto che consenta a chiunque di avere il proprio contratto intelligente `Counter`, creando una factory per esso, il cui nome sarà `CounterFactory`. Prima di tutto, ecco il codice del nostro contratto intelligente `Counter` iniziale:
```solidity
pragma solidity 0.5.17;
@@ -56,19 +58,19 @@ contract Counter {
}
```
-Nota: abbiamo leggermente modificato il codice del contratto per tenere traccia dell'indirizzo della factory e dell'indirizzo del proprietario del contratto. Quando si chiama il codice di un contratto da un altro contratto, msg.sender fa riferimento all'indirizzo della factory del contratto. È **molto importante comprendere questo concetto**, perché usare un contratto per interagire con altri contratti è una prassi comune. Dovresti quindi saper gestire il mittente nei casi complessi.
+Nota: abbiamo leggermente modificato il codice del contratto per tenere traccia dell'indirizzo della factory e dell'indirizzo del proprietario del contratto. Quando si chiama il codice di un contratto da un altro contratto, `msg.sender` si riferisce all'indirizzo della nostra factory del contratto. È molto importante comprendere questo concetto, perché usare un contratto per interagire con altri contratti è una prassi comune. Dovresti quindi prestare attenzione a chi è il mittente nei casi complessi.
-Per questo motivo abbiamo aggiunto anche un modificatore `onlyFactory` che fa in modo che la funzione di cambiamento dello stato sia chiamabile solo dalla factory che passerà il chiamante originale come parametro.
+Per questo motivo abbiamo aggiunto anche un modificatore `onlyFactory` che fa in modo che la funzione di cambiamento dello stato possa essere chiamata solo dalla factory, che passerà il chiamante originale come parametro.
-Nella nostra nuova `CounterFactory` che gestirà tutti gli altri Counter aggiungeremo un mapping che assocerà un proprietario all'indirizzo del relativo contratto Counter:
+All'interno della nostra nuova `CounterFactory` che gestirà tutti gli altri `Counter`, aggiungeremo un `mapping` che assocerà un proprietario all'indirizzo del suo contratto `Counter`:
```solidity
mapping(address => Counter) _counters;
```
-In Ethereum, i mapping equivalgono agli oggetti di Javascript, che permettono di mappare una chiave di tipo A a un valore di tipo B. In questo caso mappiamo l'indirizzo di un proprietario all'istanza del suo Counter.
+In Ethereum, i `mapping` sono l'equivalente degli oggetti in JavaScript: permettono di mappare una chiave di tipo A a un valore di tipo B. In questo caso, mappiamo l'indirizzo di un proprietario con l'istanza del suo `Counter`.
-Istanziare un nuovo Counter per un utente sarà più o meno:
+Istanziare un nuovo `Counter` per qualcuno sarà così:
```solidity
function createCounter() public {
@@ -77,9 +79,9 @@ Istanziare un nuovo Counter per un utente sarà più o meno:
}
```
-Prima controlliamo se la persona possiede già un Counter. Se non lo possiede, istanziamo un nuovo Counter passandone l'indirizzo al costruttore del `Counter` e assegniamo l'istanza appena creata al mapping.
+Per prima cosa, verifichiamo se la persona possiede già un `Counter`. Se non ne possiede uno, istanziamo un nuovo `Counter` passando il suo indirizzo al costruttore di `Counter` e assegniamo l'istanza appena creata al `mapping`.
-Ottenere il conteggio di un Counter specifico significa:
+Per ottenere il conteggio di un `Counter` specifico, il codice sarà simile a questo:
```solidity
function getCount(address account) public view returns (uint256) {
@@ -92,9 +94,9 @@ function getMyCount() public view returns (uint256) {
}
```
-La prima funzione controlla se il contratto Counter esiste per un determinato indirizzo e poi chiama il metodo `getCount` dall'istanza. La seconda funzione: `getMyCount` è passa direttamente msg.sender alla funzione `getCount`.
+La prima funzione controlla se il contratto `Counter` esiste per un dato indirizzo e poi chiama il metodo `getCount` dall'istanza. La seconda funzione, `getMyCount`, è solo una scorciatoia per passare `msg.sender` direttamente alla funzione `getCount`.
-La funzione `increment` è abbastanza simile ma passa il mittente della transazione originale al contratto `Counter`:
+La funzione `increment` è abbastanza simile, ma passa il mittente della transazione originale al contratto `Counter`:
```solidity
function increment() public {
@@ -103,9 +105,9 @@ function increment() public {
}
```
-Nota: se chiamato troppe volte, il Counter potrebbe rimanere vittima di overflow. È consigliabile usare la [libreria di SafeMath](https://ethereumdev.io/using-safe-math-library-to-prevent-from-overflows/) il più possibile per evitare questa eventualità.
+Nota che, se chiamato troppe volte, il nostro `Counter` potrebbe essere vittima di un sovraflusso. Dovresti usare il più possibile la [libreria SafeMath](https://ethereumdev.io/using-safe-math-library-to-prevent-from-overflows/) per proteggerti da questo possibile caso.
-Per distribuire il contratto, dovrai fornire sia il codice della `CounterFactory` che il `Counter`. Quando si esegue la distribuzione ad esempio in Remix, è necessario selezionare CounterFactory.
+Per distribuire il nostro contratto, dovrai fornire sia il codice di `CounterFactory` sia quello di `Counter`. Quando si esegue la distribuzione, ad esempio in Remix, è necessario selezionare `CounterFactory`.
Ecco il codice completo:
@@ -170,8 +172,8 @@ contract CounterFactory {
}
```
-Dopo la compilazione, nella sezione di distribuzione di Remix si selezionerà la factory da distribuire:
+Dopo la compilazione, nella sezione di distribuzione di Remix, selezionerai la factory da distribuire:
-A questo punto puoi fare esperimenti la factory del contratto e controllare il valore che cambia. Se vorresti chiamare il contratto intelligente da un indirizzo differente, dovrai cambiare l'indirizzo nella selezione Conto di Remix.
+A questo punto puoi fare esperimenti con la factory del tuo contratto e controllare il cambiamento del valore. Se desideri chiamare il contratto intelligente da un indirizzo diverso, dovrai modificare l'indirizzo nella selezione 'Conto' di Remix.
diff --git a/public/content/translations/it/developers/tutorials/ipfs-decentralized-ui/index.md b/public/content/translations/it/developers/tutorials/ipfs-decentralized-ui/index.md
new file mode 100644
index 00000000000..64ea9520cdc
--- /dev/null
+++ b/public/content/translations/it/developers/tutorials/ipfs-decentralized-ui/index.md
@@ -0,0 +1,73 @@
+---
+title: IPFS per interfacce utente decentralizzate
+description: Questa guida insegna al lettore come usare IPFS per archiviare l'interfaccia utente per una dApp. Sebbene i dati e la logica di business dell'applicazione siano decentralizzati, senza un'interfaccia utente resistente alla censura gli utenti potrebbero comunque perdere l'accesso ad essa.
+author: Ori Pomerantz
+tags: [ "ipfs" ]
+skill: beginner
+lang: it
+published: 2024-06-29
+---
+
+Hai scritto una nuova dApp incredibile. Hai persino scritto un'[interfaccia utente](/developers/tutorials/creating-a-wagmi-ui-for-your-contract/) per essa. Ma ora temi che qualcuno tenterà di censurarla disattivando la tua interfaccia utente, che è solo un server nel cloud. In questa guida imparerai come evitare la censura caricando la tua interfaccia utente su **[interplanetary file system (IPFS)](https://ipfs.tech/developers/)**, così chiunque sia interessato potrà fissarla su un server per potervi accedere in futuro.
+
+Potresti usare un servizio di terze parti come [Fleek](https://resources.fleek.xyz/docs/) per fare tutto il lavoro. Questa guida è per le persone che vogliono fare abbastanza per capire cosa stanno facendo, anche se comporta più lavoro.
+
+## Introduzione in locale {#getting-started-locally}
+
+Esistono diversi [provider IPFS di terze parti](https://docs.ipfs.tech/how-to/work-with-pinning-services/#use-a-third-party-pinning-service), ma è meglio iniziare eseguendo IPFS in locale per i test.
+
+1. Installa l'[interfaccia utente IPFS](https://docs.ipfs.tech/install/ipfs-desktop/#install-instructions).
+
+2. Crea una directory con il tuo sito web. Se stai usando [Vite](https://vite.dev/), usa questo comando:
+
+ ```sh
+ pnpm vite build
+ ```
+
+3. In IPFS Desktop, fai clic su **Importa > Cartella** e seleziona la directory che hai creato nel passaggio precedente.
+
+4. Seleziona la cartella che hai appena caricato e fai clic su **Rinomina**. Dagli un nome più significativo.
+
+5. Selezionala di nuovo e fai clic su **Condividi link**. Copia l'URL negli appunti. Il link sarà simile a `https://ipfs.io/ipfs/QmaCuQ7yN6iyBjLmLGe8YiFuCwnePoKfVu6ue8vLBsLJQJ`.
+
+6. Fai clic su **Stato**. Espandi la scheda **Avanzate** per visualizzare l'indirizzo del gateway. Ad esempio, sul mio sistema l'indirizzo è `http://127.0.0.1:8080`.
+
+7. Combina il percorso del passaggio del link con l'indirizzo del gateway per trovare il tuo indirizzo. Ad esempio, per l'esempio precedente, l'URL è `http://127.0.0.1:8080/ipfs/QmaCuQ7yN6iyBjLmLGe8YiFuCwnePoKfVu6ue8vLBsLJQJ`. Apri l'URL in un browser per visualizzare il tuo sito.
+
+## Caricamento {#uploading}
+
+Ora puoi usare IPFS per servire file in locale, il che non è molto entusiasmante. Il passo successivo è renderli disponibili a tutto il mondo quando sei offline.
+
+Ci sono diversi noti [servizi di pinning](https://docs.ipfs.tech/concepts/persistence/#pinning-services). Scegline uno. Qualunque servizio tu usi, dovrai creare un account e fornirgli l'**identificatore di contenuto (CID)** nel tuo desktop IPFS.
+
+Personalmente, ho trovato [4EVERLAND](https://docs.4everland.org/storage/4ever-pin/guides) il più facile da usare. Ecco le istruzioni:
+
+1. Vai alla [dashboard](https://dashboard.4everland.org/overview) e accedi con il tuo portafoglio.
+
+2. Nella barra laterale sinistra fai clic su **Archiviazione > 4EVER Pin**.
+
+3. Fai clic su **Carica > CID Selezionato**. Dai un nome al tuo contenuto e fornisci il CID dal desktop IPFS. Attualmente un CID è una stringa che inizia con `Qm` seguita da 44 lettere e cifre che rappresentano un [hash codificato in base-58](https://medium.com/bootdotdev/base64-vs-base58-encoding-c25553ff4524), come `QmaCuQ7yN6iyBjLmLGe8YiFuCwnePoKfVu6ue8vLBsLJQJ`, ma [è probabile che questo cambi](https://docs.ipfs.tech/concepts/content-addressing/#version-1-v1).
+
+4. Lo stato iniziale è **In coda**. Ricarica finché non cambia in **Fissato**.
+
+5. Fai clic sul tuo CID per ottenere il link. Puoi vedere la mia applicazione [qui](https://bafybeifqka2odrne5b6l5guthqvbxu4pujko2i6rx2zslvr3qxs6u5o7im/).
+
+6. Potrebbe essere necessario attivare il tuo account per averlo fissato per più di un mese. L'attivazione dell'account costa circa 1 $. Se l'hai chiuso, disconnettiti e riaccedi per ricevere di nuovo la richiesta di attivazione.
+
+## Utilizzo da IPFS {#using-from-ipfs}
+
+A questo punto hai un link a un gateway centralizzato che serve i tuoi contenuti IPFS. In breve, la tua interfaccia utente potrebbe essere un po' più sicura ma non è ancora resistente alla censura. Per una vera resistenza alla censura, gli utenti devono usare IPFS [direttamente da un browser](https://docs.ipfs.tech/install/ipfs-companion/#prerequisites).
+
+Una volta installato (e con il desktop IPFS funzionante), puoi andare su [/ipfs/``](https://any.site/ipfs/bafybeifqka2odrne5b6l5guthqvbxu4pujko2i6rx2zslvr3qxs6u5o7im) su qualsiasi sito e otterrai quel contenuto, servito in modo decentralizzato.
+
+## Svantaggi {#drawbacks}
+
+Non puoi eliminare in modo affidabile i file IPFS, quindi finché stai modificando la tua interfaccia utente, è probabilmente meglio lasciarla centralizzata, o usare l'[interplanetary name system (IPNS)](https://docs.ipfs.tech/concepts/ipns/#mutability-in-ipfs), un sistema che fornisce mutabilità su IPFS. Naturalmente, tutto ciò che è mutabile può essere censurato, nel caso di IPNS facendo pressione sulla persona con la chiave privata a cui corrisponde.
+
+Inoltre, alcuni pacchetti hanno un problema con IPFS, quindi se il tuo sito web è molto complicato potrebbe non essere una buona soluzione. E ovviamente, tutto ciò che si basa sull'integrazione del server non può essere decentralizzato semplicemente avendo il lato client su IPFS.
+
+## Conclusione {#conclusion}
+
+Proprio come Ethereum ti permette di decentralizzare gli aspetti del database e della logica di business della tua dApp, IPFS ti permette di decentralizzare l'interfaccia utente. Ciò ti consente di eliminare un altro vettore di attacco contro la tua dApp.
+
+[Vedi qui per altri miei lavori](https://cryptodocguy.pro/).
diff --git a/public/content/translations/it/developers/tutorials/kickstart-your-dapp-frontend-development-with-create-eth-app/index.md b/public/content/translations/it/developers/tutorials/kickstart-your-dapp-frontend-development-with-create-eth-app/index.md
index 8d093e6360e..5aa0ea06b7a 100644
--- a/public/content/translations/it/developers/tutorials/kickstart-your-dapp-frontend-development-with-create-eth-app/index.md
+++ b/public/content/translations/it/developers/tutorials/kickstart-your-dapp-frontend-development-with-create-eth-app/index.md
@@ -1,14 +1,15 @@
---
-title: Avvia lo sviluppo del frontend della tua dapp con create-eth-app
-description: Una panoramica su come usare create-eth-app e le sue funzionalità
+title: Avvia lo sviluppo del frontend della tua dApp con create-eth-app
+description: "Una panoramica su come usare create-eth-app e le sue funzionalità"
author: "Markus Waas"
tags:
- - "create-eth-app"
- - "frontend"
- - "javascript"
- - "ethers.js"
- - "the graph"
- - "defi"
+ [
+ "frontend",
+ "javascript",
+ "ethers.js",
+ "the graph",
+ "defi"
+ ]
skill: beginner
lang: it
published: 2020-04-27
@@ -16,11 +17,11 @@ source: soliditydeveloper.com
sourceUrl: https://soliditydeveloper.com/create-eth-app
---
-L'ultima volta abbiamo dato un'occhiata al [quadro generale di Solidity](https://soliditydeveloper.com/solidity-overview-2020) e abbiamo già accennato a [create-eth-app](https://github.com/PaulRBerg/create-eth-app). Ora scoprirai come usarlo, quali funzionalità sono integrate e alcune idee aggiuntive su come approfondilo. Creata da Paul Razvan Berg, fondatore di [Sablier](http://sablier.com/), quest'app avvierà lo sviluppo del tuo frontend, offrendo diverse integrazioni facoltative tra cui scegliere.
+L'ultima volta abbiamo dato uno sguardo [alla panoramica di Solidity](https://soliditydeveloper.com/solidity-overview-2020) e abbiamo già menzionato [create-eth-app](https://github.com/PaulRBerg/create-eth-app). Ora scoprirai come usarlo, quali funzionalità sono integrate e idee aggiuntive su come espanderlo. Creata da Paul Razvan Berg, il fondatore di [Sablier](http://sablier.com/), questa app darà il via allo sviluppo del tuo frontend e offre diverse integrazioni opzionali tra cui scegliere.
## Installazione {#installation}
-L'installazione richiede Yarn 0.25 o superiore (`npm install yarn -- global`). L'esecuzione è semplicissima:
+L'installazione richiede Yarn 0.25 o superiore (`npm install yarn --global`). È semplice come eseguire:
```bash
yarn create eth-app my-eth-app
@@ -28,44 +29,44 @@ cd my-eth-app
yarn react-app:start
```
-Come sistema sottostante utilizza [create-react-app](https://github.com/facebook/create-react-app). Per vedere la tua app, apri `http://localhost:3000/`. Quando sei pronto a distribuire in produzione, crea un pacchetto minimizzato con yarn build. Un modo facile per ospitarlo sarebbe [Netlify](https://www.netlify.com/). Puoi creare una repo di GitHub, aggiungerla a Netlify, configurare il comando build e hai finito! La tua app sarà ospitata e utilizzabile da tutti. E tutto gratuitamente.
+Utilizza [create-react-app](https://github.com/facebook/create-react-app) sotto il cofano. Per vedere la tua app, apri `http://localhost:3000/`. Quando sei pronto a eseguire il deploy in produzione, crea un bundle minimizzato con yarn build. Un modo semplice per ospitarlo sarebbe [Netlify](https://www.netlify.com/). Puoi creare un repository GitHub, aggiungerlo a Netlify, configurare il comando di build e il gioco è fatto! La tua app sarà ospitata e utilizzabile da tutti. E tutto gratuitamente.
-## Caratteristiche {#features}
+## Funzionalità {#features}
### React e create-react-app {#react--create-react-app}
-Prima di tutto, il cuore dell'app: React e tutte le funzionalità aggiuntive fornite con _create-react-app_. Usare solo questo strumento è un'ottima opzione se non vuoi integrare Ethereum. [React](https://reactjs.org/) stesso rende semplicissima la costruzione di UI interattive. Potrebbe non esser facile per i principianti come [Vue](https://vuejs.org/), ma è comunque molto usato, ha più funzionalità e, soprattutto, ha migliaia di librerie aggiuntive tra cui scegliere. _create-react-app_ è facilissimo per iniziare e include:
+Prima di tutto il cuore dell'app: React e tutte le funzionalità aggiuntive che derivano da _create-react-app_. Usare solo questo è un'ottima opzione se non vuoi integrare Ethereum. [React](https://react.dev/) stesso rende la creazione di interfacce utente (UI) interattive molto semplice. Potrebbe non essere così facile per i principianti come [Vue](https://vuejs.org/), ma è comunque il più utilizzato, ha più funzionalità e, soprattutto, migliaia di librerie aggiuntive tra cui scegliere. L'_create-react-app_ rende anche molto facile iniziare e include:
-- Supporto alla sintassi di React, JSX, ES6, TypeScript, Flow.
-- Extra linguistici oltre ES6 come l'operatore di diffusione dell'oggetto.
-- CSS auto-prefissato, così da non necessitare -webkit- o altri prefissi.
-- Un veloce esecutore di test unitari interattivi con supporto integrato per la segnalazione della copertura.
-- Un server di sviluppo live che avverte degli errori comuni.
-- Uno script di costruzione per riunire JS, CSS e immagini per la produzione, con hash e mappe sorgente.
+- Supporto della sintassi di React, JSX, ES6, TypeScript e Flow.
+- Funzionalità extra del linguaggio oltre a ES6 come l'operatore spread dell'oggetto.
+- CSS con prefisso automatico, quindi non sono necessari `-webkit-` o altri prefissi.
+- Un veloce esecutore di unit test interattivo con supporto integrato per la segnalazione della copertura.
+- Un server di sviluppo in tempo reale che avverte degli errori comuni.
+- Uno script di build per creare un bundle di JS, CSS e immagini per la produzione, con hash e sourcemap.
-_create-eth-app_ in particolare, fa uso dei nuovi [effetti hook](https://reactjs.org/docs/hooks-effect.html). Un metodo per scrivere componenti funzionali potenti ma molto piccoli. Vedi di seguito la sezione su Apollo per capire come vengono usati in _create-eth-app_.
+In particolare, _create-eth-app_ fa uso dei nuovi [effetti degli hook](https://legacy.reactjs.org/docs/hooks-effect.html). Un metodo per scrivere i cosiddetti componenti funzionali, potenti ma molto piccoli. Vedi la sezione sottostante su Apollo per scoprire come vengono utilizzati in _create-eth-app_.
### Yarn Workspaces {#yarn-workspaces}
-[Yarn Workspaces](https://classic.yarnpkg.com/en/docs/workspaces/) ti consente di utilizzare più pacchetti e di gestirli tutti dalla cartella di root e installare le dipendenze per tutti in una volta, usando `yarn install`. Ciò è utile soprattutto per i pacchetti aggiuntivi più piccoli, come la gestione di indirizzi/ABI degli smart contract (le informazioni su dove hai distribuito quali smart contract e come comunicare con essi) o l'integrazione di Graph, entrambi parte di `create-eth-app`.
+[Yarn Workspaces](https://classic.yarnpkg.com/en/docs/workspaces/) permette di avere più pacchetti, gestendoli tutti dalla cartella radice e installando le dipendenze per tutti in una volta sola usando `yarn install`. Ciò ha senso soprattutto per pacchetti aggiuntivi più piccoli come la gestione di indirizzi/ABI dei contratti intelligenti (le informazioni su dove hai distribuito quali contratti intelligenti e come comunicare con essi) o l'integrazione di The Graph, entrambi parte di `create-eth-app`.
### ethers.js {#ethersjs}
-Mentre [Web3](https://docs.web3js.org/) è ancora molto usato, nell'ultimo anno [ethers.js](https://docs.ethers.io/) ha riscosso molto successo come strumento alternativo ed è integrato in _create-eth-app_. Puoi lavorare con questo strumento, passare a Web3 o considerare di aggiornare a [ethers.js v5](https://docs.ethers.org/v5/), che ha quasi terminato la fase beta.
+Anche se [Web3](https://docs.web3js.org/) è ancora il più utilizzato, [ethers.js](https://docs.ethers.io/) ha guadagnato molta più popolarità come alternativa nell'ultimo anno ed è quello integrato in _create-eth-app_. Puoi lavorare con questo, passare a Web3 o considerare l'aggiornamento a [ethers.js v5](https://docs.ethers.org/v5/) che è quasi uscito dalla beta.
-### Graph {#the-graph}
+### The Graph {#the-graph}
-[GraphQL](https://graphql.org/) è un metodo alternativo per gestire i dati rispetto a un'[API di Restful](https://restfulapi.net/). Ha diversi vantaggi rispetto alle Api di Restful, specialmente per i dati della blockchain decentralizzata. Se sei interessato al ragionamento dietro questo metodo, dai un'occhiata a [GraphQL Will Power the Decentralized Web](https://medium.com/graphprotocol/graphql-will-power-the-decentralized-web-d7443a69c69a).
+[GraphQL](https://graphql.org/) è un modo alternativo per gestire i dati rispetto a una [API RESTful](https://restfulapi.net/). Presenta diversi vantaggi rispetto alle API RESTful, specialmente per i dati decentralizzati della blockchain. Se sei interessato al ragionamento che c'è dietro, dai un'occhiata a [GraphQL Will Power the Decentralized Web](https://medium.com/graphprotocol/graphql-will-power-the-decentralized-web-d7443a69c69a).
-Solitamente recupereresti i dati direttamente dal tuo smart contract. Vuoi leggere l'ora dell'ultima operazione? Basta chiamare `MyContract.methods.latestTradeTime().call()`, che recupera i dati da un nodo di Ethereum nella tua dapp. E se ci fossero centinaia di punti di dati diversi? Ciò risulterebbe in centinaia di recuperi di dati al nodo, richiedendo ogni volta un [RTT](https://wikipedia.org/wiki/Round-trip_delay_time) e rendendo la tua dapp lenta e inefficace. Una scappatoia potrebbe essere una funzione di chiamata del recuperatore nel tuo contratto, in modo da restituire più dati in una volta. Questa soluzione però non è sempre ideale.
+Di solito, recupereresti i dati direttamente dal tuo contratto intelligente. Vuoi leggere l'ora dell'ultima operazione? Basta chiamare `MyContract.methods.latestTradeTime().call()`, che recupera i dati da un nodo di Ethereum nella tua dApp. Ma cosa succede se hai bisogno di centinaia di punti dati diversi? Ciò comporterebbe centinaia di recuperi di dati al nodo, ognuno dei quali richiederebbe un [RTT](https://wikipedia.org/wiki/Round-trip_delay_time), rendendo la tua dApp lenta e inefficiente. Una soluzione alternativa potrebbe essere una funzione di chiamata fetcher all'interno del tuo contratto che restituisce più dati contemporaneamente. Questa soluzione però non è sempre ideale.
-E poi potresti essere interessato anche ai dati storici. Vuoi sapere non solo l'orario dell'ultima operazione, ma gli orari per tutte le operazioni che tu stesso hai mai eseguito? Usa il pacchetto subgraph _create-eth-app_, leggi la [documentazione](https://thegraph.com/docs/en/subgraphs/developing/creating/starting-your-subgraph) e adattalo ai tuoi contratti. Se stai cercando degli smart contract popolari, potrebbe anche esistere già un subgraph. Dai un'occhiata al [subgraph explorer](https://thegraph.com/explorer/).
+E poi potresti essere interessato anche ai dati storici. Vuoi conoscere non solo l'ora dell'ultima operazione, ma anche gli orari di tutte le operazioni che hai eseguito. Usa il pacchetto subgraph di _create-eth-app_, leggi la [documentazione](https://thegraph.com/docs/en/subgraphs/developing/creating/starting-your-subgraph) e adattalo ai tuoi contratti. Se stai cercando contratti intelligenti popolari, potrebbe già esistere un subgraph. Dai un'occhiata all'[esploratore di subgraph](https://thegraph.com/explorer/).
-Una volta che hai un grafico secondario, ti consente di scrivere una semplice richiesta nella tua dapp che recuperi tutti i dati importanti della blockchain, inclusi quelli storici che necessiti, tramite un solo recupero necessario.
+Una volta che hai un subgraph, questo ti permette di scrivere una semplice query nella tua dApp che recupera tutti i dati importanti della blockchain di cui hai bisogno, inclusi quelli storici, con un solo recupero richiesto.
### Apollo {#apollo}
-Grazie all'integrazione di [Apollo Boost](https://www.apollographql.com/docs/react/get-started/), puoi integrare facilmente il grafico nella tua dapp di React. Specialmente quando si utilizzano gli [hook di React e Apollo](https://www.apollographql.com/blog/apollo-client-now-with-react-hooks), recuperare i dati è tanto facile quanto scrivere una singola query di GraphQL nel tuo componente:
+Grazie all'integrazione di [Apollo Boost](https://www.apollographql.com/docs/react/get-started/), puoi facilmente integrare The Graph nella tua dApp React. Soprattutto quando si usano gli [hook di React e Apollo](https://www.apollographql.com/blog/apollo-client-now-with-react-hooks), recuperare i dati è semplice come scrivere una singola query GraphQL nel tuo componente:
```js
const { loading, error, data } = useQuery(myGraphQlQuery)
@@ -79,32 +80,32 @@ React.useEffect(() => {
## Modelli {#templates}
-Inoltre, puoi scegliere tra diversi modelli. Finora puoi usare un'integrazione di Aave, Compound, Uniswap o Sablier. Aggiungono tutti importanti indirizzi di servizi degli smart contract con integrazioni di subgraph pre-realizzate. Basta aggiungere il modello al comando di creazione come in `yarn create eth-app my-eth-app --with-template aave`.
+Inoltre, puoi scegliere tra diversi modelli. Finora puoi usare un'integrazione Aave, Compound, UniSwap o sablier. Tutti aggiungono importanti indirizzi di contratti intelligenti di servizio insieme a integrazioni subgraph pre-realizzate. Basta aggiungere il modello al comando di creazione, ad esempio `yarn create eth-app my-eth-app --with-template aave`.
### Aave {#aave}
-[Aave](https://aave.com/) è un mercato per il prestito di denaro decentralizzato. I depositanti forniscono liquidità al mercato per guadagnare un reddito passivo, mentre i debitori possono prendere in prestito usando garanzie. Una funzionalità unica di Aave sono quei [prestiti flash](https://docs.aave.com/developers/guides/flash-loans) che ti consentono di prendere in prestito denaro senza alcuna garanzia, finché restituisci il prestito entro una transazione. Questo può essere utile, ad esempio, per fornirti denaro extra sul trading d'arbitraggio.
+[Aave](https://aave.com/) è un mercato decentralizzato di prestiti monetari. I depositanti forniscono liquidità al mercato per guadagnare un reddito passivo, mentre i mutuatari sono in grado di prendere in prestito usando garanzie. Una caratteristica unica di Aave sono i [prestiti flash](https://aave.com/docs/developers/flash-loans) che ti consentono di prendere in prestito denaro senza alcuna garanzia, a condizione che il prestito venga restituito all'interno di una singola transazione. Questo può essere utile, ad esempio, per darti liquidità extra nel trading di arbitraggio.
-I token scambiati che ti fanno guadagnare interessi si chiamano _aTokens_.
+I token scambiati che ti fruttano interessi sono chiamati _aTokens_.
-Quando scegli di integrare Aave con _create-eth-app_, otterrai un'[integrazione del subgraph](https://docs.aave.com/developers/getting-started/using-graphql). Aave usa The Graph e ti fornisce già diversi subgraph pronti all'uso su [Ropsten](https://thegraph.com/explorer/subgraph/aave/protocol-ropsten) e sulla [rete principale](https://thegraph.com/explorer/subgraph/aave/protocol) in forma [grezza](https://thegraph.com/explorer/subgraph/aave/protocol-raw) o [formattata](https://thegraph.com/explorer/subgraph/aave/protocol).
+Quando scegli di integrare Aave con _create-eth-app_, otterrai un'[integrazione subgraph](https://docs.aave.com/developers/getting-started/using-graphql). Aave usa The Graph e ti fornisce già diversi subgraph pronti per l'uso su [Ropsten](https://thegraph.com/explorer/subgraph/aave/protocol-ropsten) e [Rete Principale](https://thegraph.com/explorer/subgraph/aave/protocol) in forma [grezza](https://thegraph.com/explorer/subgraph/aave/protocol-raw) o [formattata](https://thegraph.com/explorer/subgraph/aave/protocol).
-
+
### Compound {#compound}
-[Compound](https://compound.finance/) è simile ad Aave. L'integrazione include già il nuovo [Compound v2 Subgraph](https://medium.com/graphprotocol/https-medium-com-graphprotocol-compound-v2-subgraph-highlight-a5f38f094195). A gran sorpresa, qui i token che guadagnano interessi sono chiamati _cToken_.
+[Compound](https://compound.finance/) è simile ad Aave. L'integrazione include già il nuovo [Subgraph di Compound v2](https://medium.com/graphprotocol/https-medium-com-graphprotocol-compound-v2-subgraph-highlight-a5f38f094195). I token che generano interessi qui sono sorprendentemente chiamati _cTokens_.
### Uniswap {#uniswap}
-[Uniswap](https://uniswap.exchange/) è uno scambio decentralizzato (DEX). I fornitori di liquidità possono guadagnare commissioni fornendo i token richiesti o ether per ambe le parti di uno scambio. È ampiamente usato e dunque ha una delle liquidità più elevate per una gamma davvero ampia di token. Puoi integrarla facilmente nella tua dapp, ad esempio, per consentire agli utenti di scambiare i propri ETH per DAI.
+[Uniswap](https://uniswap.exchange/) è una borsa decentralizzata (DEX). I fornitori di liquidità possono guadagnare commissioni fornendo i token o l'ether necessari per entrambe le parti di uno scambio. È ampiamente utilizzato e quindi ha una delle più alte liquidità per una vasta gamma di token. Puoi integrarlo facilmente nella tua dApp per, ad esempio, consentire agli utenti di scambiare i loro ETH con DAI.
-Sfortunatamente, al momento della redazione del del presente articolo, l'integrazione è solo per Uniswap v1 e non per [la recente v2](https://uniswap.org/blog/uniswap-v2/).
+Sfortunatamente, al momento della stesura di questo articolo, l'integrazione è solo per Uniswap v1 e non per la [v2 appena rilasciata](https://uniswap.org/blog/uniswap-v2/).
### Sablier {#sablier}
-[Sablier](https://sablier.com/) consente agli utenti di trasmettere pagamenti in denaro. Invece di un singolo giorno di pagamento, in realtà puoi ricevere denaro costantemente senza ulteriore amministrazione dopo la configurazione iniziale. L'integrazione include i [propri subgraph](https://thegraph.com/explorer/subgraph/sablierhq/sablier).
+[Sablier](https://sablier.com/) consente agli utenti lo streaming di pagamenti in denaro. Invece di un singolo giorno di paga, ricevi il tuo denaro costantemente senza ulteriore amministrazione dopo la configurazione iniziale. L'integrazione include il suo [subgraph personale](https://thegraph.com/explorer/subgraph/sablierhq/sablier).
-## E poi? {#whats-next}
+## Quali sono i prossimi passi? {#whats-next}
-Se hai domande su _create-eth-app_, vai al [server della community di Sablier](https://discord.gg/bsS8T47), dove puoi contattare gli autori di _create-eth-app_. Come passaggi iniziali, potrebbe essere utile integrare un framework dell'UI come [Material UI](https://material-ui.com/), scrivere query di GraphQL per i dati che ti servono realmente e configurare la distribuzione.
+Se hai domande su _create-eth-app_, vai al [server della community di Sablier](https://discord.gg/bsS8T47), dove puoi metterti in contatto con gli autori di _create-eth-app_. Come primi passi successivi, potresti voler integrare un framework UI come [Material UI](https://mui.com/material-ui/), scrivere query GraphQL per i dati di cui hai effettivamente bisogno e impostare il deploy.
diff --git a/public/content/translations/it/developers/tutorials/kickstart-your-dapp-frontend-development-wth-create-eth-app/index.md b/public/content/translations/it/developers/tutorials/kickstart-your-dapp-frontend-development-wth-create-eth-app/index.md
index 8d093e6360e..20ef58025ce 100644
--- a/public/content/translations/it/developers/tutorials/kickstart-your-dapp-frontend-development-wth-create-eth-app/index.md
+++ b/public/content/translations/it/developers/tutorials/kickstart-your-dapp-frontend-development-wth-create-eth-app/index.md
@@ -1,6 +1,6 @@
---
title: Avvia lo sviluppo del frontend della tua dapp con create-eth-app
-description: Una panoramica su come usare create-eth-app e le sue funzionalità
+description: "Una panoramica su come usare create-eth-app e le sue funzionalità"
author: "Markus Waas"
tags:
- "create-eth-app"
diff --git a/public/content/translations/it/developers/tutorials/merkle-proofs-for-offline-data-integrity/index.md b/public/content/translations/it/developers/tutorials/merkle-proofs-for-offline-data-integrity/index.md
index eb020f647c1..ac53cd738cf 100644
--- a/public/content/translations/it/developers/tutorials/merkle-proofs-for-offline-data-integrity/index.md
+++ b/public/content/translations/it/developers/tutorials/merkle-proofs-for-offline-data-integrity/index.md
@@ -1,6 +1,6 @@
---
-title: Prove di Merkle per l'integrità dei dati offline
-description: Garantire l'integrità dei dati sulla catena per i dati memorizzati principalmente al di fuori di essa
+title: "Prove di Merkle per l'integrità dei dati offline"
+description: "Garantire l'integrità dei dati sulla catena per i dati memorizzati principalmente al di fuori di essa"
author: Ori Pomerantz
tags:
- "archiviazione"
@@ -33,7 +33,7 @@ L'hash principale è l'unica parte che deve essere memorizzata sulla catena. Per
[Il campione di codice è disponibile qui](https://github.com/qbzzt/merkle-proofs-for-offline-data-integrity).
-### Codice esterno alla catena {#off-chain-code}
+### Codice esterno alla catena {#offchain-code}
In questo articolo usiamo JavaScript per i calcoli al di fuori della catena. Gran parte delle app decentralizzate hanno i propri componenti esterni alla catena su JavaScript.
@@ -163,7 +163,7 @@ Eseguiamo l'hashing di `(v[0],v[1])`, `(v[2],v[3])`, ecc. Quindi per i valori pa
} // getMerkleProof
```
-### Codice on-chain {#on-chain-code}
+### Codice on-chain {#onchain-code}
Finalmente abbiamo il codice che verifica la prova. Il codice on-chain è scritto in [Solidity](https://docs.soliditylang.org/en/v0.8.11/). L'ottimizzazione è molto più importante qui, perché il gas è relativamente costoso.
diff --git a/public/content/translations/it/developers/tutorials/nft-minter/index.md b/public/content/translations/it/developers/tutorials/nft-minter/index.md
index 5029f29175f..6f777a22037 100644
--- a/public/content/translations/it/developers/tutorials/nft-minter/index.md
+++ b/public/content/translations/it/developers/tutorials/nft-minter/index.md
@@ -183,7 +183,7 @@ return (
Mint NFT
{status}
-
+
)
```
diff --git a/public/content/translations/it/developers/tutorials/optimism-std-bridge-annotated-code/index.md b/public/content/translations/it/developers/tutorials/optimism-std-bridge-annotated-code/index.md
index 623a368b33e..20ffd103981 100644
--- a/public/content/translations/it/developers/tutorials/optimism-std-bridge-annotated-code/index.md
+++ b/public/content/translations/it/developers/tutorials/optimism-std-bridge-annotated-code/index.md
@@ -1,6 +1,6 @@
---
title: "Guida del ponte standard di Optimism per contratti"
-description: Come funziona il ponte standard per Optimism? Perché funziona così?
+description: "Come funziona il ponte standard per Optimism? Perché funziona così?"
author: Ori Pomerantz
tags:
- "solidity"
diff --git a/public/content/translations/it/developers/tutorials/run-node-raspberry-pi/index.md b/public/content/translations/it/developers/tutorials/run-node-raspberry-pi/index.md
index 0b7f03a7701..a5d4e6b6795 100644
--- a/public/content/translations/it/developers/tutorials/run-node-raspberry-pi/index.md
+++ b/public/content/translations/it/developers/tutorials/run-node-raspberry-pi/index.md
@@ -10,7 +10,7 @@ tags:
lang: it
skill: intermediate
published: 2022-06-10
-source: Ethereum su ARM
+source: Ethereum on ARM
sourceUrl: https://ethereum-on-arm-documentation.readthedocs.io/en/latest/
---
diff --git a/public/content/translations/it/developers/tutorials/secure-development-workflow/index.md b/public/content/translations/it/developers/tutorials/secure-development-workflow/index.md
index 124522bb671..4d961ea14a3 100644
--- a/public/content/translations/it/developers/tutorials/secure-development-workflow/index.md
+++ b/public/content/translations/it/developers/tutorials/secure-development-workflow/index.md
@@ -9,7 +9,7 @@ tags:
skill: intermediate
lang: it
published: 2020-09-07
-source: Creare contratti sicuri
+source: Building secure contracts
sourceUrl: https://github.com/crytic/building-secure-contracts/blob/master/development-guidelines/workflow.md
---
diff --git a/public/content/translations/it/developers/tutorials/sending-transactions-using-web3-and-alchemy/index.md b/public/content/translations/it/developers/tutorials/sending-transactions-using-web3-and-alchemy/index.md
index ac548d8aaa8..4db85d9821c 100644
--- a/public/content/translations/it/developers/tutorials/sending-transactions-using-web3-and-alchemy/index.md
+++ b/public/content/translations/it/developers/tutorials/sending-transactions-using-web3-and-alchemy/index.md
@@ -9,7 +9,7 @@ tags:
skill: beginner
lang: it
published: 2020-11-04
-source: documentazione Alchemy
+source: Alchemy docs
sourceUrl: https://www.alchemy.com/docs/how-to-send-transactions-on-ethereum
---
diff --git a/public/content/translations/it/developers/tutorials/short-abi/index.md b/public/content/translations/it/developers/tutorials/short-abi/index.md
index 15b2ff853f5..0ebe8f089b4 100644
--- a/public/content/translations/it/developers/tutorials/short-abi/index.md
+++ b/public/content/translations/it/developers/tutorials/short-abi/index.md
@@ -327,7 +327,7 @@ Crea una transazione di trasferimento. Il primo byte è "0x02", seguito dall'ind
}) // describe
```
-### Esempio {#example}
+### Esempio {#reducing-the-cost-when-you-do-control-the-destination-contract}
Se desideri vedere questi file in azione senza eseguirli tu stesso, segui questi link:
@@ -337,13 +337,13 @@ Se desideri vedere questi file in azione senza eseguirli tu stesso, segui questi
4. [Chiamata a `OrisUselessToken.approve()`](https://kovan-optimistic.etherscan.io/tx/1410747). Questa chiamata deve andare direttamente al contratto del token, poiché l'elaborazione si affida al `msg.sender`.
5. [Chiamata a `transfer()`](https://kovan-optimistic.etherscan.io/tx/1410748).
-## Ridurre il costo quando hai il controllo del contratto di destinazione {#reducing-the-cost-when-you-do-control-the-destination-contract}
+## Ridurre il costo quando hai il controllo del contratto di destinazione {#token-sol-2}
Se hai il controllo sul contratto di destinazione, puoi creare funzioni che bypassano i controlli `msg.sender` poiché si fidano dell'interprete dei calldata. [Puoi vedere un esempio di come funziona qui, nel ramo `control-contract`](https://github.com/qbzzt/ethereum.org-20220330-shortABI/tree/control-contract).
Se il contratto rispondesse solo alle transazioni esterne, potremmo riuscirsi con un solo contratto. Tuttavia, questo spezzerebbe la [componibilità](/developers/docs/smart-contracts/composability/). È molto meglio avere un contratto che risponda alle normali chiamate ERC-20 e un altro che risponda alle transazioni con dati della chiamata brevi.
-### Token.sol {#token-sol-2}
+### Token.sol {#calldatainterpreter-sol-2}
In questo esempio, possiamo modificare `Token.sol`. Questo ci permette di avere un numero di funzioni che solo il proxy può chiamare. Ecco le nuove parti:
@@ -441,7 +441,7 @@ Queste sono tre operazioni che normalmente richiedono che il messaggio provenga
1. È modificata da `onlyProxy()`, così che nessun altro possa controllarla.
2. Ottiene l'indirizzo che sarebbe normalmente `msg.sender` come un parametro aggiuntivo.
-### CalldataInterpreter.sol {#calldatainterpreter-sol-2}
+### CalldataInterpreter.sol {#test-js-2}
L'interprete dei dati della chiamata è praticamente identico a quello precedente, tranne che le funzioni in proxy ricevono un parametro `msg.sender` e non è necessaria un'indennità per `transfer`.
@@ -475,7 +475,7 @@ L'interprete dei dati della chiamata è praticamente identico a quello precedent
}
```
-### Test.js {#test-js-2}
+### Test.js {#conclusion}
Ci sono alcune modifiche tra il codice di test precedente e questo.
diff --git a/public/content/translations/it/developers/tutorials/smart-contract-security-guidelines/index.md b/public/content/translations/it/developers/tutorials/smart-contract-security-guidelines/index.md
index d58a2b840ee..72c04d2ac1e 100644
--- a/public/content/translations/it/developers/tutorials/smart-contract-security-guidelines/index.md
+++ b/public/content/translations/it/developers/tutorials/smart-contract-security-guidelines/index.md
@@ -9,7 +9,7 @@ tags:
skill: intermediate
lang: it
published: 2020-09-06
-source: Creare contratti sicuri
+source: Building secure contracts
sourceUrl: https://github.com/crytic/building-secure-contracts/blob/master/development-guidelines/guidelines.md
---
@@ -27,7 +27,7 @@ La documentazione può essere scritta su diversi livelli e deve essere aggiornat
- **Schema e diagrammi architettonici**, incluse le interazioni del contratto e la macchina a stati del sistema. Le [stampanti Slither](https://github.com/crytic/slither/wiki/Printer-documentation) possono aiutare a generare questi schemi.
- **Documentazione approfondita sul codice**, il [formato Natspec](https://solidity.readthedocs.io/en/develop/natspec-format.html) si può usare per Solidity.
-### Calcolo sulla catena ed esterno alla catena {#on-chain-vs-off-chain-computation}
+### Calcolo sulla catena ed esterno alla catena {#onchain-vs-offchain-computation}
- **Mantieni quanto più codice possibile al di fuori della catena.** Il livello sulla catena deve essere il più ridotto possibile. Elabora anticipatamente i dati con il codice esternamente alla catena così che la verifica su di essa sia semplice. Ti serve un elenco ordinato? Ordina l'elenco esternamente alla catena, poi controlla solo l'ordine sulla catena.
diff --git a/public/content/translations/it/developers/tutorials/the-graph-fixing-web3-data-querying/index.md b/public/content/translations/it/developers/tutorials/the-graph-fixing-web3-data-querying/index.md
index 1adc5485c36..74a030740b1 100644
--- a/public/content/translations/it/developers/tutorials/the-graph-fixing-web3-data-querying/index.md
+++ b/public/content/translations/it/developers/tutorials/the-graph-fixing-web3-data-querying/index.md
@@ -1,6 +1,6 @@
---
title: "The Graph: query di dati in Web3"
-description: La blockchain è come un database ma senza SQL. Contiene tutti i dati, ma non c'è modo di accedervi. Vediamo come risolvere la situazione con The Graph e GraphQL.
+description: "La blockchain è come un database ma senza SQL. Contiene tutti i dati, ma non c'è modo di accedervi. Vediamo come risolvere la situazione con The Graph e GraphQL."
author: Markus Waas
lang: it
tags:
diff --git a/public/content/translations/it/developers/tutorials/token-integration-checklist/index.md b/public/content/translations/it/developers/tutorials/token-integration-checklist/index.md
index 50630419398..d6579c04b63 100644
--- a/public/content/translations/it/developers/tutorials/token-integration-checklist/index.md
+++ b/public/content/translations/it/developers/tutorials/token-integration-checklist/index.md
@@ -10,7 +10,7 @@ tags:
- "token"
skill: intermediate
published: 2020-08-13
-source: Creare contratti sicuri
+source: Building secure contracts
sourceUrl: https://github.com/crytic/building-secure-contracts/blob/master/development-guidelines/token_integration.md
---
diff --git a/public/content/translations/it/developers/tutorials/uniswap-v2-annotated-code/index.md b/public/content/translations/it/developers/tutorials/uniswap-v2-annotated-code/index.md
index 23ed18a2053..82e24f12a55 100644
--- a/public/content/translations/it/developers/tutorials/uniswap-v2-annotated-code/index.md
+++ b/public/content/translations/it/developers/tutorials/uniswap-v2-annotated-code/index.md
@@ -1,6 +1,6 @@
---
title: "Guida dettagliata al contratto Uniswap-v2"
-description: Come funziona il contratto Uniswap-v2? Perché è scritto così?
+description: "Come funziona il contratto Uniswap-v2? Perché è scritto così?"
author: Ori Pomerantz
tags:
- "solidity"
@@ -55,9 +55,8 @@ Questo è il flusso più comune, usato dai trader:
3. Identifica l'importo necessario da scambiare su ogni scambio lungo il percorso.
4. Itera sul percorso. Per ogni scambio lungo il percorso, invia il token di input e poi chiama la funzione di `swap` dello scambio. In gran parte dei casi, l'indirizzo di destinazione per i token è lo scambio in pari successivo nel percorso. Nello scambio finale è presente l'indirizzo fornito dal trader.
-#### Nel contratto principale (UniswapV2Pair.sol) {#in-the-core-contract-uniswapv2pairsol-2}
+#### Nel contratto principale (UniswapV2Pair.sol) {#in-the-core-contract-uniswapv2pairsol-2}5. Verifica che il contratto principale non raggiri il sistema e possa mantenere liquidità sufficiente dopo lo scambio.
-5. Verifica che il contratto principale non raggiri il sistema e possa mantenere liquidità sufficiente dopo lo scambio.
6. Vede quanti token aggiuntivi abbiamo, in aggiunta alle riserve note. Quell'importo è il numero di token di input ricevuti da scambiare.
7. Invia i token d'output alla destinazione.
8. Chiama `_update` per aggiornare gli importi della riserva
@@ -743,7 +742,7 @@ Questa è la funzione principale della factory, per creare uno scambio in pari t
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
```
-Vogliamo che l'indirizzo del nuovo scambio sia deterministico, quindi calcolabile in anticipo al di fuori della catena (questo può essere utile per le [transazioni di livello 2](/developers/docs/layer-2-scaling/)). Per farlo, dobbiamo avere un ordine coerente degli indirizzi del token, indipendentemente dall'ordine in cui li abbiamo ricevuti, quindi li ordiniamo qui.
+Vogliamo che l'indirizzo del nuovo scambio sia deterministico, quindi calcolabile in anticipo al di fuori della catena (questo può essere utile per le [transazioni di livello 2](/developers/docs/scaling/)). Per farlo, dobbiamo avere un ordine coerente degli indirizzi del token, indipendentemente dall'ordine in cui li abbiamo ricevuti, quindi li ordiniamo qui.
```solidity
require(token0 != address(0), 'UniswapV2: ZERO_ADDRESS');
diff --git a/public/content/translations/it/developers/tutorials/using-websockets/index.md b/public/content/translations/it/developers/tutorials/using-websockets/index.md
index 892853e0405..f96fc83dfca 100644
--- a/public/content/translations/it/developers/tutorials/using-websockets/index.md
+++ b/public/content/translations/it/developers/tutorials/using-websockets/index.md
@@ -9,8 +9,8 @@ tags:
- "query"
- "javascript"
skill: beginner
-source: documentazione Alchemy
-sourceUrl: https://docs.alchemyapi.io/guides/using-websockets
+source: Alchemy docs
+sourceUrl: https://www.alchemy.com/docs/reference/best-practices-for-using-websockets-in-web3
published: 2020-12-01
---
diff --git a/public/content/translations/it/developers/tutorials/waffle-dynamic-mocking-and-testing-calls/index.md b/public/content/translations/it/developers/tutorials/waffle-dynamic-mocking-and-testing-calls/index.md
index bec9d55112b..676f647e349 100644
--- a/public/content/translations/it/developers/tutorials/waffle-dynamic-mocking-and-testing-calls/index.md
+++ b/public/content/translations/it/developers/tutorials/waffle-dynamic-mocking-and-testing-calls/index.md
@@ -295,4 +295,4 @@ Il codice sorgente di questo tutorial si può trovare [qui](https://github.com/E
Altri tutorial che potrebbero interessarti:
-- [Test di Smart Contract con Waffle](/developers/tutorials/testing-smart-contract-with-waffle/)
+- [Test di Smart Contract con Waffle](/developers/tutorials/waffle-test-simple-smart-contract/)
diff --git a/public/content/translations/it/developers/tutorials/waffle-test-simple-smart-contract/index.md b/public/content/translations/it/developers/tutorials/waffle-test-simple-smart-contract/index.md
index d440693878a..6b30dec8150 100644
--- a/public/content/translations/it/developers/tutorials/waffle-test-simple-smart-contract/index.md
+++ b/public/content/translations/it/developers/tutorials/waffle-test-simple-smart-contract/index.md
@@ -30,7 +30,6 @@ published: 2021-02-26
Il tutorial dimostra la configurazione di prova e opera utilizzando yarn, ma non ci sono problemi se preferisci npm: fornirò gli adeguati riferimenti alla [documentazione](https://ethereum-waffle.readthedocs.io/en/latest/index.html) ufficiale di Waffle.
### Installa dipendenze {#install-dependencies}
-
[Aggiungi](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#installation) ethereum-waffle e le dipendenze di TypeScript alle dipendenze di sviluppo del tuo progetto.
```bash
@@ -38,7 +37,6 @@ yarn add --dev ethereum-waffle ts-node typescript @types/jest
```
### Esempio di contratto intelligente {#example-smart-contract}
-
Durante il tutorial lavoreremo a un esempio di contratto intelligente semplice: EtherSplitter. Non fa molto, tranne che consentire a chiunque di inviare wei e dividerli uniformemente tra due destinatari predefiniti. La funzione di divisione richiede che il numero di wei sia pari, altrimenti si ripristinerà. Per entrambi i destinatari esegue un trasferimento di wei, seguito dall'emissione dell'evento Trasferimento.
Posiziona il frammento del codice di EtherSplitter in `src/EtherSplitter.sol`.
@@ -68,7 +66,6 @@ contract EtherSplitter {
```
### Compila il contratto {#compile-the-contract}
-
Per [compilare](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#compiling-the-contract) il contratto, aggiungi il seguente elemento al file package.json:
```json
@@ -91,7 +88,6 @@ Poi, crea un file di configurazione di Waffle nella cartella di root del progett
Esegui `yarn build`. Di conseguenza, la cartella `build` apparirà con il contratto compilato di EtherSplitter nel formato JSON.
### Testare la configurazione {#test-setup}
-
Testare con Waffle richiede l'utilizzo di abbinatori Chai e Mocha, quindi, devi [aggiungerli](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#writing-tests) al tuo progetto. Aggiorna il tuo file package.json e aggiungi l'elemento `test` nella parte degli script:
```json
@@ -135,7 +131,6 @@ Solo due parole prima di iniziare. `MockProvider` offre una versione fittizia de
Quindi, dichiariamo una variabile detta "splitter" (divisore), che è il nostro contratto fittizio EtherSplitter. È creato prima di ogni esecuzione di un singolo test dal metodo `deployContract`. Questo metodo simula la distribuzione di un contratto dal portafoglio passato come primo parametro (nel nostro caso, il portafoglio del mittente). Il secondo parametro è l'ABI e il bytecode del contratto testato; qui, passiamo il file json del contratto compilato EtherSplitter dalla cartella `build`. Il terzo parametro è un insieme con gli argomenti del costruttore del contratto che, nel nostro caso, sono gli indirizzi dei due destinatari.
### changeBalances {#changebalances}
-
Prima controlleremo se il metodo di divisione modifica effettivamente i saldi dei portafogli dei destinatari. Se dividiamo 50 wei dall'account del mittente, i saldi di entrambi i destinatari dovrebbero aumentare di 25 wei. Utilizzeremo l'abbinatore di Waffle "`changeBalances`:
```ts
@@ -163,7 +158,6 @@ Nota che in entrambi i casi di `changeBalance` e `changeBalances`, passiamo la f
Poi, testeremo se l'evento Trasferimento è stato emesso dopo ogni trasferimento di wei. Ci rivolgeremo a un altro abbinatore da Waffle:
### Emetti {#emit}
-
```ts
it("Emits event on the transfer to the first receiver", async () => {
await expect(splitter.split({ value: 50 }))
@@ -181,7 +175,6 @@ it("Emits event on the transfer to the second receiver", async () => {
L'abbinatore `emit` ci consente di verificare se un contratto ha emesso un evento alla chiamata di un metodo. Come parametri all'abbinatore `emit`, forniamo il contratto fittizio che prevediamo emetterà l'evento, insieme al nome di tale evento. Nel nostro caso, il contratto fittizio è `splitter` e il nome dell'evento è `Trasferimento`. Inoltre, possiamo verificare i valori precisi degli argomenti con cui è stato emesso l'evento; passiamo altrettanti argomenti all'abbinatore `withArgs`, come previsto dalla dichiarazione del nostro evento. Nel caso del contratto EtherSplitter, passiamo gli indirizzi del mittente e del destinatario insieme all'importo trasferito di wei.
### revertedWith {#revertedwith}
-
Come ultimo esempio verificheremo se la transazione è stata ripristinata, nel caso di un numero dispari di wei. Utilizzeremo l'abbinatore `revertedWith`:
```ts
diff --git a/public/content/translations/it/ethereum-forks/index.md b/public/content/translations/it/ethereum-forks/index.md
index d5f6252e37c..b3a41fd3001 100644
--- a/public/content/translations/it/ethereum-forks/index.md
+++ b/public/content/translations/it/ethereum-forks/index.md
@@ -16,7 +16,6 @@ Le diramazioni si verificano quando è necessario apportare importanti aggiornam
Quando sono necessari aggiornamenti in software tradizionali controllati centralmente, l'azienda pubblica una nuova versione per l'utente finale. Le blockchain funzionano diversamente perché non esiste una proprietà centrale. I [client di Ethereum](/developers/docs/nodes-and-clients/) devono aggiornare il proprio software e implementare le regole della nuova diramazione. Inoltre i creatori dei blocchi (miner in contesto Proof of Work e validatori in contesto Proof of Stake) e i nodi devono creare blocchi e convalidarli in base alle nuove regole. [Maggiori informazioni sui meccanismi di consenso](/developers/docs/consensus-mechanisms/)
Queste modifiche alle regole potrebbero creare una divisione temporanea nella rete. I nuovi blocchi potrebbero essere creati in base alle nuove regole o a quelle vecchie. Le diramazioni di solito sono concordate in anticipo in modo che i client adottino le modifiche all'unisono e la diramazione legata agli upgrade diventi la catena principale. Tuttavia, in rari casi, disaccordi sulle diramazioni possono causare una divisione permanente della rete, come è successo con la creazione di Ethereum Classic con la diramazione DAO.
-
@@ -59,7 +58,6 @@ Gli aggiornamenti dei livelli di esecuzione e di consenso erano inizialmente dis
| ----------------- | ----------------- | ---------- |
| Shanghai | Capella | "Shapella" |
| Cancun | Deneb | "Dencun" |
-
Salta direttamente alle informazioni su alcuni degli ultimi aggiornamenti particolarmente importanti: [La Beacon Chain](/roadmap/beacon-chain/); [La Fusione](/roadmap/merge/) ed [EIP-1559](#london)
@@ -68,13 +66,13 @@ Stai cercando i prossimi aggiornamenti di protocollo? [Scopri di più sui prossi
-## 2024 {#2024}
+## 2024 {#2025}
-### Cancun-Deneb ("Dencun") {#dencun}
+### Cancun-Deneb ("Dencun") {#fusaka}
-#### Riepilogo di Cancun {#cancun-summary}
+#### Riepilogo di Cancun {#pectra}
L'aggiornamento di Cancun contiene una serie di miglioramenti all'_esecuzione_ di Ethereum, mirati a migliorarne la scalabilità, in tandem con gli aggiornamenti al consenso di Deneb.
@@ -90,7 +88,6 @@ Notevolmente, include l'EIP-4844, nota come **Proto-Danksharding**, che riduce s
EIP-6780: SELFDESTRUCT soltanto nella stessa transazione
EIP-7516: Codice operativo BLOBBASEFEE
-
- [Rollup del Livello 2](/layer-2/)
@@ -98,7 +95,7 @@ Notevolmente, include l'EIP-4844, nota come **Proto-Danksharding**, che riduce s
- [Danksharding](/roadmap/danksharding/)
- [Leggi le specifiche dell'aggiornamento di Cancun](https://github.com/ethereum/execution-specs/blob/master/network-upgrades/mainnet-upgrades/cancun.md)
-#### Riepilogo di Deneb {#deneb-summary}
+#### Riepilogo di Deneb {#2024}
L'aggiornamento di Deneb contiene una serie di miglioramenti al _consenso_ di Ethereum, mirati a migliorarne la scalabilità. Questo aggiornamento è in tandem con gli aggiornamenti del livello di esecuzione Cancun per consentire il Proto-Danksharding (EIP-4844), insieme ad altri miglioramenti alla Beacon Chain.
@@ -115,7 +112,6 @@ EIP-7514 comporta un rafforzamento dell'emissione di ETH, limitando il tasso di
EIP-7045: Aumento degli slot massimi di inclusione dell'attestazione
EIP-7514: Aggiunta del limite massimo di churn per epoca
-
- [Leggi le specifiche dell'aggiornamento di Deneb](https://github.com/ethereum/consensus-specs/blob/dev/specs/deneb/)
@@ -123,13 +119,13 @@ EIP-7514 comporta un rafforzamento dell'emissione di ETH, limitando il tasso di
-## 2023 {#2023}
+## 2023 {#dencun}
-### Shanghai-Capella ("Shapella") {#shapella}
+### Shanghai-Capella ("Shapella") {#cancun-summary}
-#### Riepilogo di Shanghai {#shanghai-summary}
+#### Riepilogo di Shanghai {#deneb-summary}
L'aggiornamento di Shanghai ha portato i prelievi di staking al livello d'esecuzione. Insieme all'aggiornamento Capella, questo abiliterà i blocchi ad accettare le operazioni di prelievo, che consentono agli staker di prelevare i propri ETH dalla Beacon Chain al livello d'esecuzione.
@@ -142,12 +138,11 @@ L'aggiornamento di Shanghai ha portato i prelievi di staking al livello d'esecuz
EIP-4895 – La Beacon Chain lancia i prelievi come operazioni
EIP-6049 - Depreca SELFDESTRUCT
-
- [Leggi le specifiche dell'aggiornamento Shanghai](https://github.com/ethereum/execution-specs/blob/master/network-upgrades/mainnet-upgrades/shanghai.md)
-#### Riepilogo di Capella {#capella-summary}
+#### Riepilogo di Capella {#2023}
L'aggiornamento di Capella è il terzo aggiornamento principale al livello del consenso (Beacon Chain) e ha abilitato i prelievi di staking. Capella è avvenuto contemporaneamente all'aggiornamento del livello di esecuzione di Shanghai, e ha reso disponibili le funzioni di prelievo da staking.
@@ -160,13 +155,13 @@ L'aggiornamento, inoltre, ha fornito la funzionalità di pulizia automatica dei
-## 2022 {#2022}
+## 2022 {#shapella}
-### Paris (la Fusione) {#paris}
+### Paris (la Fusione) {#shanghai-summary}
-#### Riepilogo {#paris-summary}
+#### Riepilogo {#capella-summary}
L'aggiornamento Paris è stato attivato dal passaggio da una blockchain proof-of-work di una [difficoltà totale terminale](/glossary/#terminal-total-difficulty) di 58750000000000000000000. Questo è avvenuto al blocco 15537393 il 15 settembre 2022, innescando l'aggiornamento Paris dal blocco successivo. Paris è stata la transizione [alla Fusione](/roadmap/merge/): la sua caratteristica principale è lo spegnimento dell'algoritmo di mining [proof-of-work](/developers/docs/consensus-mechanisms/pow) e della relativa logica di consenso, e l'attivazione della [proof-of-stake](/developers/docs/consensus-mechanisms/pos). Paris è stata un aggiornamento ai [client di esecuzione](/developers/docs/nodes-and-clients/#execution-clients) (equivalente a Bellatrix a livello di consenso) che ha permesso loro di ricevere istruzioni dai loro [client di consenso](/developers/docs/nodes-and-clients/#consensus-clients) collegati. Questo ha richiesto l'attivazione di una nuova serie di metodi API interni, collettivamente noti come l'[API Engine](https://github.com/ethereum/execution-apis/blob/main/src/engine/common.md). Questo è stato probabilmente l'aggiornamento più significativo nella storia di Ethereum dopo [Homestead](#homestead)!
@@ -178,16 +173,15 @@ L'aggiornamento Paris è stato attivato dal passaggio da una blockchain proof-of
EIP-3675 – Aggiorna il consenso al Proof-of-Stake
EIP-4399 – Sostituisce l'opcode DIFFICULTY con PREVRANDAO
-
---
-### Bellatrix {#bellatrix}
+### Bellatrix {#2022}
-#### Riepilogo {#bellatrix-summary}
+#### Riepilogo {#paris}
L'aggiornamento Bellatrix è stato il secondo aggiornamento programmato per la [Beacon Chain](/roadmap/beacon-chain), preparando la catena per [la Fusione](/roadmap/merge/). Porta le penalità dei validatori al valore pieno per inattività e azioni sanzionabili (slashing). Bellatrix include anche un aggiornamento alle regole di scelta della diramazione per preparare la catena per la Fusione e la transizione dall'ultimo blocco di proof-of-work al primo blocco proof-of-stake. A tale scopo occorre far sì che i client di consenso siano consapevoli della [difficoltà terminale totale](/glossary/#terminal-total-difficulty) di 58750000000000000000000.
@@ -195,11 +189,11 @@ L'aggiornamento Bellatrix è stato il secondo aggiornamento programmato per la [
---
-### Gray Glacier {#gray-glacier}
+### Gray Glacier {#paris-summary}
-#### Riepilogo {#gray-glacier-summary}
+#### Riepilogo {#bellatrix}
L'aggiornamento della rete di Gray Glacier ha rimandato di tre mesi la [bomba di difficoltà](/glossary/#difficulty-bomb). Questa è l'unica modifica introdotta in questo aggiornamento ed è simile per natura agli aggiornamenti di [Arrow Glacier](#arrow-glacier) e [Muir Glacier](#muir-glacier). Modifiche simili sono state effettuate sugli aggiornamenti di rete [Byzantium](#byzantium), [Constantinople](#constantinople) e [London](#london).
@@ -210,18 +204,17 @@ L'aggiornamento della rete di Gray Glacier ha rimandato di tre mesi la [bomba di
- EIP-5133 – ritarda la bomba di difficoltà fino a settembre 2022
-
-## 2021 {#2021}
+## 2021 {#bellatrix-summary}
-### Arrow Glacier {#arrow-glacier}
+### Arrow Glacier {#gray-glacier}
-#### Riepilogo {#arrow-glacier-summary}
+#### Riepilogo {#gray-glacier-summary}
L'aggiornamento di rete Arrow Glacier ha rimandato la [bomba di difficoltà](/glossary/#difficulty-bomb) di diversi mesi. Questo è l'unico cambiamento introdotto in questo aggiornamento, ed è simile nella sostanza all'aggiornamento [Muir Glacier](#muir-glacier). Modifiche simili sono state effettuate sugli aggiornamenti di rete [Byzantium](#byzantium), [Constantinople](#constantinople) e [London](#london).
@@ -233,22 +226,21 @@ L'aggiornamento di rete Arrow Glacier ha rimandato la [bomba di difficoltà](/gl
- EIP-4345 – ritarda la bomba di difficoltà fino a giugno 2022
-
---
-### Altair {#altair}
+### Altair {#2021}
-#### Riepilogo {#altair-summary}
+#### Riepilogo {#arrow-glacier}
L'aggiornamento Altair è stato il primo aggiornamento pianificato per la [Beacon Chain](/roadmap/beacon-chain). Ha aggiunto il supporto per le "commissioni di sincronizzazione", abilitando i "client leggeri", aumentando le penalità per inattività e slashing per i validatori man mano che lo sviluppo procedeva verso la Fusione.
- [Leggi le specifiche dell'aggiornamento di Altair](https://github.com/ethereum/consensus-specs/tree/dev/specs/altair)
-#### Curiosità! {#altair-fun-fact}
+#### Curiosità! {#arrow-glacier-summary}
Altair è stato il primo importante aggiornamento di rete che ha avuto un tempo di rollout esatto. Tutti gli aggiornamenti precedenti erano basati su un numero di blocco dichiarato su una catena proof-of-work, dove i tempi del blocco variavano. La Beacon Chain non richiede la risoluzione del proof-of-work e funziona invece su un sistema di epoche basato sul tempo che consiste in 32 "slot" di dodici secondi in cui i validatori possono proporre dei blocchi. Questo è il motivo per cui sapevamo esattamente quando avremmo raggiunto l'epoca 74.240 e Altair sarebbe diventato operativo!
@@ -256,15 +248,15 @@ Altair è stato il primo importante aggiornamento di rete che ha avuto un tempo
---
-### London {#london}
+### London {#altair}
-#### Riepilogo {#london-summary}
+#### Riepilogo {#altair-summary}
L'aggiornamento London ha introdotto l'[EIP-1559](https://eips.ethereum.org/EIPS/eip-1559), che ha riformato il mercato delle commissioni sulle transazioni, oltre a modificare come sono gestiti i rimborsi di carburante e la pianificazione di [Ice Age](/glossary/#ice-age).
-#### Cos'è l'Aggiornamento di Londra / EIP-1559? {#eip-1559}
+#### Cos'è l'Aggiornamento di Londra / EIP-1559? {#altair-fun-fact}
Prima dell'Aggiornamento di Londra, Ethereum disponeva di blocchi di dimensioni fisse. Nei momenti di elevata domanda di rete, questi blocchi operavano a piena capacità. Di conseguenza, gli utenti devono spesso attendere che la domanda si riduca per essere inclusi in un blocco, il che ha portato a una scadente esperienza degli utenti. L'Aggiornamento di Londra ha introdotto blocchi di dimensioni variabili a Ethereum.
@@ -291,16 +283,15 @@ Questo video spiega l'EIP-1559 e i benefici che comporta: [EIP-1559 Explained](h
EIP-3541 - impedisce la distribuzione dei contratti che iniziano con 0xEF
EIP-3554 – ritarda l'Era Glaciale fino a dicembre 2021
-
---
-### Berlin {#berlin}
+### Berlin {#london}
-#### Riepilogo {#berlin-summary}
+#### Riepilogo {#london-summary}
L'aggiornamento Berlin ha ottimizzato i costi del carburante per certe azioni dell'EVM e ha aumentato il supporto per vari tipi di transazioni.
@@ -315,18 +306,17 @@ L'aggiornamento Berlin ha ottimizzato i costi del carburante per certe azioni de
EIP-2929 – il costo del carburante aumenta per gli opcode d'accesso allo stato
EIP-2930 – aggiunge elenchi d'accesso facoltativi
-
-## 2020 {#2020}
+## 2020 {#eip-1559}
-### Genesi della Beacon Chain {#beacon-chain-genesis}
+### Genesi della Beacon Chain {#berlin}
-#### Riepilogo {#beacon-chain-genesis-summary}
+#### Riepilogo {#berlin-summary}
La [Beacon Chain](/roadmap/beacon-chain/) necessita di 16384 depositi da 32 ETH di staking per poter funzionare in sicurezza. Questo è successo il 27 novembre, quindi la Beacon Chain ha iniziato a produrre blocchi il 1° dicembre 2020. Questa è una prima fase importante nel percorso per raggiungere la [visione di Ethereum](/roadmap/vision/).
@@ -338,11 +328,11 @@ La [Beacon Chain](/roadmap/beacon-chain/) necessita di 16384 depositi da 32 ETH
---
-### Distribuzione del contratto di deposito in staking {#staking-deposit-contract}
+### Distribuzione del contratto di deposito in staking {#2020}
-#### Riepilogo {#deposit-contract-summary}
+#### Riepilogo {#beacon-chain-genesis}
Il contratto di deposito in staking ha introdotto lo [staking](/glossary/#staking) all'ecosistema di Ethereum. Nonostante fosse un contratto della [Rete principale](/glossary/#mainnet), ha avuto un impatto diretto sulla linea temporale per il lancio della [Beacon Chain](/roadmap/beacon-chain/), un importante [aggiornamento di Ethereum](/roadmap/).
@@ -354,11 +344,11 @@ Il contratto di deposito in staking ha introdotto lo [staking](/glossary/#stakin
---
-### Muir Glacier {#muir-glacier}
+### Muir Glacier {#beacon-chain-genesis-summary}
-#### Riepilogo {#muir-glacier-summary}
+#### Riepilogo {#staking-deposit-contract}
La diramazione Muir Glacier ha introdotto un ritardo nella [bomba di difficoltà](/glossary/#difficulty-bomb). Aumenta la difficoltà del blocco del meccanismo di consenso [Proof-of-Work](/developers/docs/consensus-mechanisms/pow/), che rischiava di peggiorare l'utilizzabilità di Ethereum, aumentando i tempi d'attesa per l'invio delle transazioni e l'uso delle dapp.
@@ -370,18 +360,17 @@ La diramazione Muir Glacier ha introdotto un ritardo nella [bomba di difficoltà
- EIP-2384 – ritarda la bomba di difficoltà per altri 4.000.000 blocchi, o circa 611 giorni.
-
-## 2019 {#2019}
+## 2019 {#deposit-contract-summary}
-### Istanbul {#istanbul}
+### Istanbul {#muir-glacier}
-#### Riepilogo {#istanbul-summary}
+#### Riepilogo {#muir-glacier-summary}
La diramazione Instanbul:
@@ -403,16 +392,15 @@ La diramazione Instanbul:
EIP-2028 – riduce il costo di CallData per consentire più dati nei blocchi, buono per il [ridimensionamento del Livello 2](/developers/docs/scaling/#layer-2-scaling).
EIP-2200 – altre alterazioni del prezzo del carburante dell'opcode.
-
---
-### Constantinople {#constantinople}
+### Constantinople {#2019}
-#### Riepilogo {#constantinople-summary}
+#### Riepilogo {#istanbul}
La diramazione Constantinople:
@@ -431,18 +419,17 @@ La diramazione Constantinople:
EIP-1052: Introduce l'istruzione EXTCODEHASH per recuperare l'hash del codice di un altro contratto.
EIP-1234 – assicura che la blockchain non si congeli prima del proof-of-stake e riduce la ricompensa per blocco da 3 a 2 ETH.
-
-## 2017 {#2017}
+## 2017 {#istanbul-summary}
-### Byzantium {#byzantium}
+### Byzantium {#constantinople}
-#### Riepilogo {#byzantium-summary}
+#### Riepilogo {#constantinople-summary}
La diramazione Byzantium:
@@ -466,18 +453,17 @@ La diramazione Byzantium:
EIP-100 – modifica la formula di regolazione della difficoltà.
EIP-649 – ritarda la [bomba di difficoltà](/glossary/#difficulty-bomb) di 1 anno e riduce la ricompensa del blocco da 5 a 3 ETH.
-
-## 2016 {#2016}
+## 2016 {#2017}
-### Spurious Dragon {#spurious-dragon}
+### Spurious Dragon {#byzantium}
-#### Riepilogo {#spurious-dragon-summary}
+#### Riepilogo {#byzantium-summary}
La diramazione Spurious Dragon è stata la seconda risposta agli attacchi denial of service (DoS) sulla rete (settembre/ottobre 2016) e ha reso possibile, tra l'altro:
@@ -495,16 +481,15 @@ La diramazione Spurious Dragon è stata la seconda risposta agli attacchi denial
EIP-161 – consente la rimozione dei conti vuoti aggiunti tramite attacchi DoS.
EIP-170 – modifica la dimensione massima del codice che un contratto sulla blockchain può avere, a 24576 byte.
-
---
-### Tangerine Whistle {#tangerine-whistle}
+### Tangerine Whistle {#2016}
-#### Riepilogo {#tangerine-whistle-summary}
+#### Riepilogo {#spurious-dragon}
La diramazione Tangerine Whistle è stata la prima risposta agli attacchi di denial of service (DoS) alla rete (settembre/ottobre 2016) e ha incluso:
@@ -518,16 +503,15 @@ La diramazione Tangerine Whistle è stata la prima risposta agli attacchi di den
EIP-150 – aumenta i costi del carburante degli opcode utilizzabili negli attacchi di spam.
EIP-158 – riduce le dimensioni di stato rimuovendo un gran numero di conti vuoti messi nello stato a costo bassissimo a causa di bug nelle versioni precedenti del protocollo di Ethereum.
-
---
-### Diramazione OAD {#dao-fork}
+### Diramazione OAD {#spurious-dragon-summary}
-#### Riepilogo {#dao-fork-summary}
+#### Riepilogo {#tangerine-whistle}
La diramazione OAD è stata pensata come risposta all'[attacco OAD del 2016](https://www.coindesk.com/learn/understanding-the-dao-attack/), durante il quale un contratto [OAD](/glossary/#dao) non protetto è stato privato di oltre 3,6 milioni di ETH in un solo attacco. La diramazione ha spostato i fondi dal contratto difettoso a un [nuovo contratto](https://etherscan.io/address/0xbf4ed7b27f1d666546e30d74d50d173d20bca754) con una sola funzione: il prelievo. Chi aveva perso fondi ha potuto prelevare 1 ETH per ogni 100 token OAD nel proprio portafoglio.
@@ -539,11 +523,11 @@ Alcuni miner rifiutarono di creare la diramazione perché l'incidente DAO non er
---
-### Homestead {#homestead}
+### Homestead {#tangerine-whistle-summary}
-#### Riepilogo {#homestead-summary}
+#### Riepilogo {#dao-fork}
La diramazione Homestead guardava al futuro. Includeva diverse modifiche al protocollo e un cambiamento che ha dato a Ethereum la possibilità di eseguire ulteriori aggiornamenti della rete.
@@ -556,18 +540,17 @@ La diramazione Homestead guardava al futuro. Includeva diverse modifiche al prot
EIP-7 – aggiunge il nuovo opcode: DELEGATECALL
EIP-8 – introduce i requisiti di compatibilità progressiva a devp2p
-
-## 2015 {#2015}
+## 2015 {#dao-fork-summary}
-### Frontier thawing {#frontier-thawing}
+### Frontier thawing {#homestead}
-#### Riepilogo {#frontier-thawing-summary}
+#### Riepilogo {#homestead-summary}
La diramazione Frontier Thawing ha innalzato il limite di 5.000 [gas](/glossary/#gas) per [blocco](/glossary/#block) e ha impostato il prezzo predefinito del gas a 51 [gwei](/glossary/#gwei). Ciò ha reso possibili le transazioni, che richiedono 21.000 gas. La [bomba di difficoltà](/glossary/#difficulty-bomb) è stata introdotta per assicurare una hard-fork futura verso il [proof-of-stake](/glossary/#pos).
@@ -576,11 +559,11 @@ La diramazione Frontier Thawing ha innalzato il limite di 5.000 [gas](/glossary/
---
-### Frontier {#frontier}
+### Frontier {#2015}
-#### Riepilogo {#frontier-summary}
+#### Riepilogo {#frontier-thawing}
Frontier è stata un'implementazione operativa ma rudimentale del progetto Ethereum. È seguita alla positiva fase di test Olympic. Era destinata agli utenti tecnici, in particolare gli sviluppatori. I [blocchi](/glossary/#block) avevano un limite di 5.000 [gas](/glossary/#gas). Questo periodo di "disgelo" (dall'inglese thawing) ha consentito ai miner di iniziare la propria operatività e ai primi utilizzatori di installare i client senza fretta.
@@ -588,9 +571,9 @@ Frontier è stata un'implementazione operativa ma rudimentale del progetto Ether
-## 2014 {#2014}
+## 2014 {#frontier-thawing-summary}
-### Vendita di Ether {#ether-sale}
+### Vendita di Ether {#frontier}
@@ -600,7 +583,7 @@ Ether fu ufficialmente messo in vendita per 42 giorni. Lo potresti acquistare in
---
-### Pubblicazione dello yellowpaper {#yellowpaper}
+### Pubblicazione dello yellowpaper {#frontier-summary}
@@ -610,9 +593,9 @@ Lo Yellow Paper, redatto dal dott. Gavin Wood, è una definizione tecnica del pr
-## 2013 {#2013}
+## 2013 {#2014}
-### Pubblicazione del whitepaper {#whitepaper}
+### Pubblicazione del whitepaper {#ether-sale}
diff --git a/public/content/translations/it/foundation/index.md b/public/content/translations/it/foundation/index.md
index c742def2847..d1560ff071c 100644
--- a/public/content/translations/it/foundation/index.md
+++ b/public/content/translations/it/foundation/index.md
@@ -1,11 +1,11 @@
---
title: Ethereum Foundation
-description: Scopri di più sulla Ethereum Foundation (EF), un'organizzazione no-profit dedita al supporto di Ethereum e delle tecnologie correlate.
+description: "Scopri di più sulla Ethereum Foundation (EF), un'organizzazione no-profit dedita al supporto di Ethereum e delle tecnologie correlate."
hideEditButton: true
lang: it
---
-# Informazioni sulla Ethereum Foundation {#about-the-ethereum-foundation}
+# Informazioni sulla Ethereum Foundation {#ethereum-foundation}
@@ -13,16 +13,14 @@ La [Ethereum Foundation](http://ethereum.foundation/) (EF) è un'organizzazione
Non è un'azienda, né una no-profit tradizionale. Il suo ruolo non è quello di controllare o guidare Ethereum, e non è l'unica organizzazione che finanzia lo sviluppo critico delle tecnologie correlate a Ethereum. L'EF fa parte di un [ecosistema](/community/) molto più ampio.
-## Iniziative dell'Ethereum Foundation {#ethereum-foundation-initiatives}
-
-### Programma di supporto dell'ecosistema {#ecosystem-support-program}
+## Iniziative dell'Ethereum Foundation {#what-the-ef-does}
+### Programma di supporto dell'ecosistema {#programs-and-initiatives}
Il [programma di supporto dell'ecosistema](https://esp.ethereum.foundation/) esiste per dare sostegno sia finanziario che non a progetti ed entità all'interno di tutta la community Ethereum, con lo scopo di accelerare la crescita dell'ecosistema. È un'espansione dell'originario Ethereum Grants Program, che si concentrava soprattutto sul supporto finanziario.
Scopri di più sul programma di supporto dell'ecosistema, sui destinatari delle sovvenzioni passati e sul processo di candidatura per le sovvenzioni su [esp.ethereum.foundation](https://esp.ethereum.foundation/). Puoi anche consultare l'[Ecosystem Support Program Blog](https://blog.ethereum.org/category/ecosystem-support-program/) o seguire [@EF_ESP](https://twitter.com/EF_ESP) per rimanere al passo con gli ultimi annunci e le notizie più recenti.
-### Devcon {#devcon}
-
+### Devcon {#learn-more}
Fin dal 2014, Ethereum Foundation ha organizzato Devcon, la conferenza annuale per tutti gli sviluppatori Ethereum, i ricercatori, i creatori e i pensatori.
Puoi accedere ai contenuti video o alle conferenze di ogni anno, a partire da quello di creazione, su [archive.devcon.org](https://archive.devcon.org/).
diff --git a/public/content/translations/it/governance/index.md b/public/content/translations/it/governance/index.md
index 21a0a339cf5..fc1dff16672 100644
--- a/public/content/translations/it/governance/index.md
+++ b/public/content/translations/it/governance/index.md
@@ -22,7 +22,7 @@ Nessuna persona possiede o controlla il protocollo Ethereum, ma è comunque nece
La governance di Ethereum è il processo attraverso il quale vengono apportate modifiche al protocollo. È importante sottolineare che questo processo non ha a che fare con il modo in cui le persone e le applicazioni utilizzano il protocollo, infatti Ethereum è senza autorizzazioni. Chiunque da qualsiasi parte del mondo può partecipare ad attività on-chain. Non ci sono regole fisse su chi può o non può creare un'applicazione o inviare una transazione. Tuttavia, esiste un processo per proporre modifiche al protocollo principale, su cui vengono eseguite queste applicazioni. Poiché molte persone dipendono dalla stabilità di Ethereum, esiste una soglia di coordinamento davvero elevata per i cambiamenti principali, inclusi i processi sociali e tecnici, per garantire che ogni modifica a Ethereum sia sicura e ampiamente supportata dalla community.
-### Governance on-chain e off-chain {#on-chain-vs-off-chain}
+### Governance on-chain e off-chain {#onchain-vs-offchain}
La tecnologia blockchain rende possibili nuove modalità di governance, conosciute come governance on-chain. Per governance on-chain si intende che le proposte di modifica al protocollo sono decise tramite il voto degli stakeholder, che in genere detengono un governance token, e la votazione avviene sulla blockchain. In alcune forme di governance on-chain, le modifiche proposte al protocollo sono già scritte nel codice e vengono implementate automaticamente nel caso in cui vengano approvate dagli stakeholder tramite la sottoscrizione di una transazione.
diff --git a/public/content/translations/it/guides/how-to-create-an-ethereum-account/index.md b/public/content/translations/it/guides/how-to-create-an-ethereum-account/index.md
index b171b3ceb04..245478be491 100644
--- a/public/content/translations/it/guides/how-to-create-an-ethereum-account/index.md
+++ b/public/content/translations/it/guides/how-to-create-an-ethereum-account/index.md
@@ -47,7 +47,7 @@ Alcune applicazioni chiederanno di salvare una "frase di recupero" segreta (a vo
Come utilizzare un portafoglio
-
+
diff --git a/public/content/translations/it/guides/how-to-id-scam-tokens/index.md b/public/content/translations/it/guides/how-to-id-scam-tokens/index.md
index 3af9b81af23..ad4b9dc7072 100644
--- a/public/content/translations/it/guides/how-to-id-scam-tokens/index.md
+++ b/public/content/translations/it/guides/how-to-id-scam-tokens/index.md
@@ -20,7 +20,6 @@ title="Cosa è ARB?"
contentPreview=''>
Arbitrum è un'organizzazione che sviluppa e gestisce [rollup ottimistici](/developers/docs/scaling/optimistic-rollups/). Inizialmente Arbitrum era organizzata come società a scopo di lucro, ma poi ha preso provvedimenti per decentralizzarsi. Nell'ambito di questo processo, hanno emesso un [token di governance](/dao/#token-based-membership) negoziabile.
-
In Ethereum esiste una convenzione per cui, quando una risorsa non è conforme a ERC-20, ne viene creata una versione "wrapped" con il nome che inizia con "w". Quindi, ad esempio, abbiamo wBTC per bitcoin e wETH per ether.
Non ha senso creare una versione wrapped di un token ERC-20 già presente su Ethereum, ma i truffatori si basano sull'apparenza di legittimità piuttosto che sulla realtà sottostante.
-
## Come funzionano i token truffa? {#how-do-scam-tokens-work}
@@ -42,7 +40,6 @@ title="Cosa sono i contratti intelligenti?"
contentPreview=''>
[I contratti intelligenti](/developers/docs/smart-contracts/) sono i programmi che vengono eseguiti sulla blockchain di Ethereum. Ogni token ERC-20, ad esempio, è implementato come un contratto intelligente.
-
In particolare, Arbitrum ha distribuito un contratto che utilizza il simbolo `ARB`. Ma questo non impedisce ad altre persone di distribuire un contratto che utilizza lo stesso simbolo o uno simile. Chiunque scriva il contratto può stabilire ciò che il contratto farà.
diff --git a/public/content/translations/it/nft/index.md b/public/content/translations/it/nft/index.md
index 3279ce0720f..a9ad889f49d 100644
--- a/public/content/translations/it/nft/index.md
+++ b/public/content/translations/it/nft/index.md
@@ -5,11 +5,11 @@ description: Una panoramica dei NFT su Ethereum
lang: it
template: use-cases
emoji: ":frame_with_picture:"
-sidebarDepth: 3
+sidebarDepth: 2
image: /images/infrastructure_transparent.png
alt: Un logo Eth visualizzato tramite ologramma.
summaryPoint1: Un modo pe rappresentare qualsiasi cosa sia univoca, come una risorsa basata su Ethereum.
-summaryPoint2: I NFT stanno dando ai creatori di contenuti più potere che mai.
+summaryPoint2: "I NFT stanno dando ai creatori di contenuti più potere che mai."
summaryPoint3: Basati sui contratti intelligenti, sulla blockchain di Ethereum.
---
diff --git a/public/content/translations/it/roadmap/account-abstraction/index.md b/public/content/translations/it/roadmap/account-abstraction/index.md
index 8695d3cd058..11786ab121e 100644
--- a/public/content/translations/it/roadmap/account-abstraction/index.md
+++ b/public/content/translations/it/roadmap/account-abstraction/index.md
@@ -1,6 +1,6 @@
---
title: Astrazione account
-description: Una panoramica dei piani di Ethereum per rendere i conti degli utenti più semplici e sicuri
+description: "Una panoramica dei piani di Ethereum per rendere i conti degli utenti più semplici e sicuri"
lang: it
summaryPoints:
- L'astrazione del conto semplifica molto la creazione di portafogli di contratti intelligenti
@@ -61,7 +61,6 @@ La gestione del gas, inoltre, è di molto migliorata con l'astrazione del conto.
La gestione del gas è una delle frizioni principali per gli utenti di Ethereum, principalmente perché gli ETH sono la sola risorsa utilizzabile per pagare le transazioni. Immagina di avere un portafoglio con un saldo di USDC, ma nessun ETH. Non puoi spostare o scambiare quei token USDC, poiché non puoi pagare il gas. Non puoi nemmeno scambiare gli USDC per ETH, poiché anche questo costa del gas. Dovresti inviare altri ETH al tuo conto da una piattaforma di scambio o da un altro indirizzo per risolvere il problema. Con i portafogli di contratti intelligenti, invece, puoi semplicemente pagare il gas in USDC, liberando il tuo conto. Non devi più mantenere un saldo di ETH in tutti i tuoi conti.
L'astrazione del conto, inoltre, consente agli sviluppatori di dapp di essere creativi con la gestione del gas. Ad esempio, potresti riuscire a iniziare a pagare una commissione fissa mensile alla tua DEX preferita, per delle transazioni illimitate. Le Dapp potrebbero offrire di pagare tutte le tue commissioni di gas per conto tuo, come ricompensa per aver utilizzato la loro piattaforma, o come offerta di inserimento. Per gli sviluppatori, sarebbe molto più facile innovare sul gas, quando i portafogli di contratti intelligenti sono supportati al livello del protocollo.
-
Le sessioni fidate, inoltre, sono potenzialmente trasformative per le esperienze degli utenti, specialmente per applicazioni come il gaming, in cui grandi numeri di piccole transazioni, potrebbero necessitare dell'approvazione in un breve tempo. Approvare individualmente ogni transazione spezzerebbe l'esperienza di gioco, ma l'approvazione permanente non è sicura. Il portafoglio di un contratto intelligente potrebbe approvare certe transazioni per un dato tempo, fino a un valore specifico o solo per certi indirizzi.
@@ -77,7 +76,6 @@ I portafogli di contratti intelligenti, ad oggi, esistono, ma implementarli è i
EIP-2771 introduce il concetto delle meta-transazioni, che consentono a terze parti di pagare i costi del gas degli utenti senza apportare modifiche al protocollo di Ethereum. L'idea è che le transazioni firmate da un utente sono inviate a un contratto `Corriere`. Il corriere è un'entità fidata che verifica che le transazioni siano valide, prima di inviarle a un ripetitore di gas. Ciò avviene all'esterno della catena, evitando il bisogno di pagare il gas. Il ripetitore di gas passa la transazione a un contratto `Destinatario`, pagando il gas necessario per rendere la transazione eseguibile su Ethereum. La transazione è eseguita se il `Corriere` è noto ed è ritenuto attendibile dal `Destinatario`. Questo modello semplifica, per gli sviluppatori, l'implementazione di transazioni a gas zero per gli utenti.
-
@@ -87,7 +85,6 @@ L'EIP-4337 è il primo passo verso il supporto dei portafogli di contratti intel
Anche il funzionamento dei portafogli cambierà sotto EIP-4337. Invece di far reimplementare da ogni portafoglio una logica di sicurezza complessa ma comune, queste funzioni saranno affidate a un contratto del portafoglio globale, noto come "punto d'accesso". Questo, gestirebbe le operazioni come il pagamento delle commissioni e l'esecuzione del codice dell'EVM, così che gli sviluppatori di portafogli possano concentrarsi sul fornire eccellenti esperienze agli utenti.
Nota: il contratto del punto d'accesso dell'EIP-4337, è stato distribuito alla Rete Principale di Ethereum l'1 marzo 2023. Puoi visualizzare il contratto su Etherscan.
-
@@ -95,7 +92,6 @@ Anche il funzionamento dei portafogli cambierà sotto EIP-4337. Invece di far re
L'EIP-2938 mira ad aggiornare il protocollo di Ethereum introducendo un nuovo tipo di transazione, AA_TX_TYPE che include tre campi: nonce, target e data, dove nonce è un contatore di transazioni, target è l'indirizzo del contratto del punto d'accesso, e data è il bytecode dell'EVM. Per eseguire queste transazioni, devono essere aggiunte due nuove istruzioni (note come codici operativi) all'EVM: NONCE e PAYGAS. Il codice operativo NONCE traccia la sequenza della transazione e PAYGAS calcola e preleva il gas necessario per eseguire la transazione dal saldo del contratto. Queste nuove funzionalità consentono a Ethereum di supportare nativamente i portafogli di contratti intelligenti, poiché l'infrastruttura necessaria è integrata nel protocollo di Ethereum.
Nota che l'EIP-2938 non è correntemente attiva. La community, al momento, preferisce EIP-4337 poiché non richiede modifiche al protocollo.
-
@@ -103,7 +99,6 @@ Nota che l'EIP-2938 non è correntemente attiva. La community, al momento, prefe
L'EIP-3074 mira ad aggiornare i conti posseduti esternamente di Ethereum, consentendo loro di delegare il controllo a un contratto intelligente. Ciò significa che la logica dei contratti intelligenti potrebbe approvare le transazioni originate da un EOA. Questo consentirebbe funzionalità come la sponsorizzazione del gas e le transazioni raggruppate. Perché funzioni, devono essere aggiunti due nuovi codici operativi all'EVM: AUTH e AUTHCALL. Con l'EIP-3074, i benefici del portafoglio di un contratto intelligente sono resi disponibili senza la necessità di un contratto, invece un tipo specifico di contratto privo di stato, privo di fiducia e non ggiornabile, noto come "invocatore", gestisce le transazioni.
Nota che EIP-3074 non è correntemente attivo. La community, al momento, preferisce EIP-4337 poiché non richiede modifiche al protocollo.
-
## Stato attuale {#current-progress}
diff --git a/public/content/translations/it/roadmap/beacon-chain/index.md b/public/content/translations/it/roadmap/beacon-chain/index.md
index fdfafae0a45..d4529c6a841 100644
--- a/public/content/translations/it/roadmap/beacon-chain/index.md
+++ b/public/content/translations/it/roadmap/beacon-chain/index.md
@@ -6,7 +6,7 @@ template: upgrade
image: /images/upgrades/core.png
alt:
summaryPoint1: La Beacon Chain ha introdotto il proof-of-stake all'ecosistema di Ethereum.
-summaryPoint2: Si è unita alla catena di proof-of-work originale di Ethereum a settembre 2022.
+summaryPoint2: "Si è unita alla catena di proof-of-work originale di Ethereum a settembre 2022."
summaryPoint3: La Beacon Chain ha introdotto la logica del consenso e il protocollo di gossip dei blocchi, che ora protegge Ethereum.
---
@@ -32,7 +32,7 @@ Lo staking ha un ruolo simile a quello che aveva il [mining](/developers/docs/co
La transizione al proof of stake ha reso Ethereum significativamente più sicura e decentralizzata rispetto al proof of work. Più persone parteciperanno alla rete, più questa diventerà decentralizzata e protetta dagli attacchi.
-E l'utilizzo del proof of stake come meccanismo di consenso è un componente fondamentale per [l'Ethereum sicuro, ecosostenibile e scalabile che conosciamo ora](/roadmap/vision/).
+E l'utilizzo del proof of stake come meccanismo di consenso è un componente fondamentale per [l'Ethereum sicuro, ecosostenibile e scalabile che conosciamo ora](/staking/).
diff --git a/public/content/translations/it/roadmap/danksharding/index.md b/public/content/translations/it/roadmap/danksharding/index.md
index 59099359eac..6a853f4f77e 100644
--- a/public/content/translations/it/roadmap/danksharding/index.md
+++ b/public/content/translations/it/roadmap/danksharding/index.md
@@ -22,13 +22,11 @@ Ciò è costoso perché elaborato da tutti i nodi di Ethereum e risiede per semp
I rollup sono un metodo per scalare Ethereum raggruppando le transazioni all'esterno della catena e, in seguito, pubblicando i risultati su Ethereum. Un rollup, essenzialmente, si compone di due parti: dati e controllo dell'esecuzione. I dati sono la sequenza completa delle transazioni elaborate da un rollup per produrre il cambiamento di stato pubblicato su Ethereum. Il controllo d'esecuzione è la ri-esecuzione di tali transazioni da un utente onesto (dimostratore) per aassicurarsi che il cambiamento di stato proposto sia corretto. Per effettuare il controllo d'esecuzione, i dati della transazione devono essere disponibili per un tempo sufficiente perché chiunque possa scaricarli e controllarli. Ciò significa che qualsiasi comportamento disonesto dal sequenziatore del rollup puà essere identificato e sfidato dal dimostratore. Tuttavia, non è necessario che sia disponibile per sempre.
-
I rollup pubblicano gli impegni ai dati delle proprie transazioni on chain e, inoltre, rendono disponibili i dati effettivi nei blob di dati. Ciò significa che i dimostratori possono verificare che gli impegni siano validi o sfidare i dati che ritengono siano errati. Al livello del nodo, i blob di dati sono conservati nel client del consenso. I client del consenso attestano di aver visto i dati e che sono stati propagati per la rete. Se i dati fossero conservati per sempre, tali client si allargherebberò, determinando grandi requisiti hardware per l'esecuzione di nodi. Invece, i dati sono eliminati automaticamente dal nodo ogni 18 giorni. Le attestazioni del client del consenso dimostrano che vi è stata un'opportunità sufficiente, affinché i dimostratori potessero verificare i dati. I dati effettivi possono essere memorizzati off-chain dagli operatori di rollup, dagli utenti o da terzi.
-
### Come sono verificati i dati dei blob? {#how-are-blobs-verified}
@@ -48,13 +46,11 @@ La cerimonia KZG dell'EIP-4844 era aperta al pubblico e decine di migliaia di pe
Quando un rollup pubblica dati in un blob, fornisce un "impegno" che viene pubblicato sulla catena. Questo, è il risultato della valutazione di un adattamento polinomiale ai dati, in certi punti. Questi punti sono definiti dai numeri casuali generati nella cerimonia KZG. I dimostratori, quindi, possono valutare la polinomiale agli stessi punti, per poter verificare i dati; se arrivano agli stessi valori, allora i dati sono corretti.
-
Se qualcuno conoscesse le posizioni casuali utilizzate per l'impegno, sarebbe facile, per loro, generare una nuova polinomiaale che si adatti a quei punti specifici (cioè, una "collisione"). Ciò significa che potrebbero aggiungere o rimuovere i dati dal blob e, comunque, fornire una prova valida. Per impedirlo, invece di dare ai dimostratori le posizioni segrete effettive, ricevono in realtà le posizioni, avvolte in una "scatola nera" crittografica, utilizzando le curve ellittiche. Questi, infatti, rimescolano i valori in modo tale che i valori originali non siano decodificabili, ma con dimostratori e verificatori capaci in algebra, le polinomiali sono ancora valutabili ai punti rappresentati.
-
@@ -70,13 +66,11 @@ Funziona espandendo i blob collegati ai blocchi da sei (6) nel proto-dankshardin
La separazione di propositori e costruttori è necessaria per impedire ai singoli validatori di dover generare costosi impegni e prove, per 32 MB di dati del blob. Questo metterebbe a dura prova gli staker domestici e richiederebbe loro di investire in hardware più potenti, danneggiando la decentralizzazione. Invece, i costruttori di blocchi specializzati si prendono la responsabilità di questo costoso lavoro di calcolo. Poi, mettono a disposizione i propri blocchi ai propositori di blocchi per la trasmissione. Il propositore di blocchi, semplicemente, sceglie il blocco più redditizio. Chiunque può verificare i blob in modo economico e rapido, a significare che ogni normale validatore può verificare che i costruttori di blocchi si stiano comportando onestamente. Questo permette di elaborare i blob di grandi dimensioni senza sacrificare la decentralizzazione. I costruttori di blocchi malevoli potrebbero semplicemente essere esplusi dalla rete e tagliati; altri arriverebbero al loro posto, poiché la costruzione di blocchi è un'attività redditizia.
-
Il campionamento della disponibilità dei dati è necessario perché i validatori verifichino in modo rapido ed efficace i dati dei blob. Utilizzando il campionmento della disponibilità dei dati, i validatori possono essere davvero certi che i blob di dati fossero disponibili e che siano stati inviati correttamente. Ogni validatore può campionare casualmente alcuni punti di dati e creare una prova, a significare che nessun validatore deve verificare l'intero blob. Se mancano dei dati, saranno identificati rapidamente e il blob sarà respinto.
-
### Stato attuale {#current-progress}
diff --git a/public/content/translations/it/roadmap/future-proofing/index.md b/public/content/translations/it/roadmap/future-proofing/index.md
index 9166a97866d..6047829e3d4 100644
--- a/public/content/translations/it/roadmap/future-proofing/index.md
+++ b/public/content/translations/it/roadmap/future-proofing/index.md
@@ -1,6 +1,6 @@
---
title: Rendere Ethereum a prova di futuro
-description: Questi aggiornamenti cementano Ethereum come lo strato fondamentale, resiliente e decentralizzato per il futuro, indipendentemente da ciò che conterrà.
+description: "Questi aggiornamenti cementano Ethereum come lo strato fondamentale, resiliente e decentralizzato per il futuro, indipendentemente da ciò che conterrà."
lang: it
image: /images/roadmap/roadmap-future.png
alt: "Roadmap di Ethereum"
diff --git a/public/content/translations/it/roadmap/merge/index.md b/public/content/translations/it/roadmap/merge/index.md
index 06cded798a0..eed70dddc1f 100644
--- a/public/content/translations/it/roadmap/merge/index.md
+++ b/public/content/translations/it/roadmap/merge/index.md
@@ -5,8 +5,8 @@ lang: it
template: upgrade
image: /images/upgrades/merge.png
alt:
-summaryPoint1: La Rete Principale di Ethereum utilizza il proof-of-stake, ma non è sempre stato così.
-summaryPoint2: L'aggiornamento dal meccanismo originale di proof-of-work al proof-of-stake, è stato detto La Fusione.
+summaryPoint1: "La Rete Principale di Ethereum utilizza il proof-of-stake, ma non è sempre stato così."
+summaryPoint2: "L'aggiornamento dal meccanismo originale di proof-of-work al proof-of-stake, è stato detto La Fusione."
summaryPoint3: La Fusione si riferisce all'unione della Rete Principale di Ethereum con una blockchain di proof-of-stake separata, detta Beacon Chain, ora coesistenti come un'unica catena.
summaryPoint4: La Fusione ha ridotto il consumo energetico di Ethereum di circa il 99,95%.
---
@@ -88,7 +88,6 @@ Gli elementi d'azione chiave includono:
- Autenticare i client di esecuzione e di consenso con un segreto JWT condiviso, così che possano comunicare in sicurezza tra loro.
Non completare i suddetti elementi farà sì che il tuo nodo risulti "offline", finché entrambi i livelli non saranno sincronizzati e autenticati.
-
Per ulteriori informazioni, consulta questo post del blog di Tim Beiko su Come La Fusione Influenza il Livello d'Applicazione di Ethereum.
-
## La Fusione e il consumo energetico {#merge-and-energy}
@@ -116,7 +114,7 @@ La Fusione ha segnato la fine del proof-of-work per Ethereum e ha dato inizio al
## La Fusione e il ridimensionamento {#merge-and-scaling}
-La Fusione ha inoltre gettato le basi per ulteriori aggiornamenti di scalabilità, impossibili sotto il Poof of Work, portando Ethereum un po' più vicina al raggiungimento della completa scalabilità, sicurezza e sostenibilità delinate nella [visione di Ethereum](/roadmap/vision/).
+La Fusione ha inoltre gettato le basi per ulteriori aggiornamenti di scalabilità, impossibili sotto il Poof of Work, portando Ethereum un po' più vicina al raggiungimento della completa scalabilità, sicurezza e sostenibilità delinate nella [visione di Ethereum](/energy-consumption/).
## Equivoci su La Fusione {#misconceptions}
@@ -135,7 +133,6 @@ Eseguire un nodo che non produce blocchi è possibile per chiunque, in entrambi
L'abilità per chiunque di gestire il proprio nodo è assolutamente essenziale per mantenere la decentralizzazione della rete di Ethereum.
[Ulteriori informazioni sull'esecuzione di un proprio nodo](/run-a-node/)
-
tabella di marcia incentrata sui rollup, gli sforzi si concentrano sul ridimensionamento delle attività degli utenti al [livello 2](/layer-2/), consentendo alla Rete Principale di Livello 1 di essere un livello di accordo decentralizzato e sicuro, ottimizzato per l'archiviazione dei dati dei rollup, per aiutare a rendere esponenzialmente più economiche le transazioni dei rollup. La transizione al Proof of stake è un precursore essenziale per realizzarlo. [Ulteriori informazioni su gas e commissioni.](/developers/docs/gas/)
-
indirizzo di prelievo per iniziare a ricevere pagamenti automatici di qualsiasi saldo di staking in eccesso (ETH superiori a 32, da ricompense del protocollo). Questo aggiornamento, inoltre, ha consentito la capacità di un validatore di sbloccare e rivendicare l'intero saldo all'uscita dalla rete.
[Maggiori informazioni sui prelievi in staking](/staking/withdrawals/)
-
- L'emissione di staking esatta fluttua a seconda dell'importo totale di ETH in staking
- **Da La Fusione, restano approssimativamnte soltanto 1.700 ETH/giorno, riducendo la nuova emissione totale di ETH di circa l'88%**
- La bruciatura: questa, fluttua secondo la domanda di rete. _Se_ per un dato giorno si osserva un prezzo di gas medio di almeno 16 gwei, questo compensa effettivamente i circa 1.700 ETH emessi ai validatori e porta l'inflazione netta di ETH a zero, o meno, per quel giorno.
-
## Pre-Fusione (storico) {#pre-merge}
@@ -63,7 +62,9 @@ Offerta totale di ETH: **circa 120.520.000 ETH** (al momento della Fusione a set
**Circa l'11,3%** era emesso agli staker sul livello del consenso (0,52 / 4,61 * 100)
+
+
## Post-Fusione (oggi) {#post-merge}
@@ -97,7 +98,9 @@ Tasso di emissione annualizzato totale: **circa 0,52%**
Riduzione netta nell'emissione annuale di ETH: **circa 88,7%** ((4,61%-0,52%) / 4,61% * 100)
+
+
## La bruciatura {#the-burn}
@@ -109,7 +112,9 @@ La forza opposta all'emissione di ETH è il tasso a cui gli ETH sono bruciati. P
La bruciatura delle commissioni è divenuta attiva con l'[aggiornamento di Londra](/ethereum-forks/#london) ad agosto 2021 e resta immutata da La Fusione.
+
+
Oltre alla bruciatura della commissione, implementata dall'aggiornamento di Londra, i validatori, inoltre, possono incorrere in sanzioni per essere online o, peggio, possono ricevere tagli per l'infrazione di regole specifiche che minacciano la sicurezza della rete. Queste, risultano in una riduzione degli ETH dal saldo di quel validatore, che non è ricompensato direttamente a nessun altro conto, bruciandoli/rimuovendoli effettivamente dalla circolazione.
diff --git a/public/content/translations/it/roadmap/pbs/index.md b/public/content/translations/it/roadmap/pbs/index.md
index 4b0b292c707..be168336e77 100644
--- a/public/content/translations/it/roadmap/pbs/index.md
+++ b/public/content/translations/it/roadmap/pbs/index.md
@@ -1,6 +1,6 @@
---
title: Separazione proponente-sviluppatore
-description: Scopri come e perché i validatori di Ethereum divideranno le proprie responsabilità di costruzione e trasmissione dei blocchi.
+description: "Scopri come e perché i validatori di Ethereum divideranno le proprie responsabilità di costruzione e trasmissione dei blocchi."
lang: it
---
@@ -21,7 +21,6 @@ I [mempool crittografati](https://www.youtube.com/watch?v=fHDjgFcha0M&list=PLpkt
Potenti organizzazioni possono spingere i validatori a censurare le transazioni da o verso certi indirizzi. I validatori si conformano a tale pressione rilevando gli indirizzi nella lista nera del proprio gruppo di transazioni e omettendoli dai blocchi che propongono. Dopo la PBS, non sarà più possibile poiché i propositori di blocchi non sapranno quali transazioni stanno trasmettendo nei propri blocchi. Potrebbe essere importante, per certi individui o app, conformarsi alle regole di censura, ad esempio, quando è emanata una legge nella loro regione. In tali casi, la conformità si verifica a livello di applicazione, mentre il protocolo rimane privo di permessi e di censura.
-
## PBS e MEV {#pbs-and-mev}
diff --git a/public/content/translations/it/roadmap/scaling/index.md b/public/content/translations/it/roadmap/scaling/index.md
index 54d6c3f2ac9..2d511aa85e6 100644
--- a/public/content/translations/it/roadmap/scaling/index.md
+++ b/public/content/translations/it/roadmap/scaling/index.md
@@ -1,6 +1,6 @@
---
title: Ridimensionare Ethereum
-description: I rollup raggruppano le transazioni al di fuori della catena, riducendo i costi per l'utente. Tuttavia, il modo in cui i rollup utilizzano i dati al momento è troppo costoso, il che limita l'economicità delle transazioni. Il Proto-Danksharding lo corregge.
+description: "I rollup raggruppano le transazioni al di fuori della catena, riducendo i costi per l'utente. Tuttavia, il modo in cui i rollup utilizzano i dati al momento è troppo costoso, il che limita l'economicità delle transazioni. Il Proto-Danksharding lo corregge."
lang: it
image: /images/roadmap/roadmap-transactions.png
alt: "Roadmap di Ethereum"
diff --git a/public/content/translations/it/roadmap/security/index.md b/public/content/translations/it/roadmap/security/index.md
index 11dfbd8b335..8526aae04e7 100644
--- a/public/content/translations/it/roadmap/security/index.md
+++ b/public/content/translations/it/roadmap/security/index.md
@@ -1,6 +1,6 @@
---
-title: Un Ethereum più sicuro
-description: Ethereum è la piattaforma di contratti intelligenti più sicura e decentralizzata che esista. Tuttavia, restano ancora da implementare alcuni miglioramenti in modo che Ethereum resti resiliente a qualsiasi livello di attacco anche in un futuro lontano.
+title: "Un Ethereum più sicuro"
+description: "Ethereum è la piattaforma di contratti intelligenti più sicura e decentralizzata che esista. Tuttavia, restano ancora da implementare alcuni miglioramenti in modo che Ethereum resti resiliente a qualsiasi livello di attacco anche in un futuro lontano."
lang: it
image: /images/roadmap/roadmap-security.png
alt: "Roadmap di Ethereum"
diff --git a/public/content/translations/it/roadmap/single-slot-finality/index.md b/public/content/translations/it/roadmap/single-slot-finality/index.md
index d8e0bc0c4a6..02ba9bcc682 100644
--- a/public/content/translations/it/roadmap/single-slot-finality/index.md
+++ b/public/content/translations/it/roadmap/single-slot-finality/index.md
@@ -1,6 +1,6 @@
---
-title: Finalità dello spazio singolo
-description: Spiegazione della finalità dello spazio singolo
+title: "Finalità dello spazio singolo"
+description: "Spiegazione della finalità dello spazio singolo"
lang: it
---
diff --git a/public/content/translations/it/roadmap/user-experience/index.md b/public/content/translations/it/roadmap/user-experience/index.md
index 2748d708027..3713de6141f 100644
--- a/public/content/translations/it/roadmap/user-experience/index.md
+++ b/public/content/translations/it/roadmap/user-experience/index.md
@@ -1,6 +1,6 @@
---
title: Migliorare l'esperienza degli utenti
-description: Per molti, è ancora troppo complesso utilizzare Ethereum. Per incoraggiare l'adozione di massa, Ethereum deve ridurre drasticamente le proprie barriere d'accesso; gli utenti devono ricevere i benefici dell'accesso decentralizzato, privo di permessi e resistente alla censura a Ethereum, ma dev'essere privo di frizione, tanto quanto utilizzare una tradizionale app del web2.
+description: "Per molti, è ancora troppo complesso utilizzare Ethereum. Per incoraggiare l'adozione di massa, Ethereum deve ridurre drasticamente le proprie barriere d'accesso; gli utenti devono ricevere i benefici dell'accesso decentralizzato, privo di permessi e resistente alla censura a Ethereum, ma dev'essere privo di frizione, tanto quanto utilizzare una tradizionale app del web2."
lang: it
image: /images/roadmap/roadmap-ux.png
alt: "Roadmap di Ethereum"
diff --git a/public/content/translations/it/roadmap/verkle-trees/index.md b/public/content/translations/it/roadmap/verkle-trees/index.md
index 59cae3a2e7c..02bb4b09d23 100644
--- a/public/content/translations/it/roadmap/verkle-trees/index.md
+++ b/public/content/translations/it/roadmap/verkle-trees/index.md
@@ -18,7 +18,6 @@ Gli alberi di Verkle sono un passaggio fondamentale sul percorso per i client di
I client di Ethereum, al momento, utilizzano una struttura di dati nota come Albero di Patricia di Merkle per memorizzarne i dati di stato. Le informazioni sui singoli conti sono memorizzati come foglie su un albero e, le coppie di foglie, ricevono ripetutamente un hash finché non ne resta soltanto uno. Questo hash finale è noto come la "radice". Per verficare i blocchi, i client di Ethereum eseguono tutte le transazioni in un blocco e aggiornano il proprio albero di stato locale. Il blocco è considerato valido se la radice dell'albero locale è identica a quella fornita dal propositore di blocchi, poiché qualsiasi differenza nel calcolo effettuato dal propositore del blocco e dal nodo di convalida, formerebbe un hash di radice completamente differente. Il problema è che la verifica della blockchain richiede che ogni client memorizzi l'intero albero di stato per il blocco di testa e per diversi blocchi storici (di default, su Geth, sono mantenuti i dati di stato per 128 blocchi oltre la testa). Ciò richiede che i client abbiano accesso a una grande quantità di spazio su disco, limitando l'esecuzione dei nodi completi su hardware economici e poco potenti. Una soluzione è aggiornare l'albero di stato a una struttura più efficiente (l'albero di Verkle), riepilogabile utilizzando un piccolo "testimone" ai dati, condivisibile invece dei dati di stato completi. Riformattare i dati di stato in un albero di Verkle è una pietra miliare per spostarsi verso i client privi di stato.
-
## Cos'è un testimone e perché è necessario? {#what-is-a-witness}
@@ -34,7 +33,6 @@ Sotto lo schema di impegno polinomiale, i testimoni hanno dimensioni gestibili,
Le dimensioni dei testimoni variano a seconda del numero di foglie che include. Supponendo che il testimone copra 1000 foglie, un testimone per un albero di Merkle occuperebbe all'incirca 3,5 MB (ipotizzando 7 livelli all'albero). Un testimone per gli stessi dati in un albero di Verkle (ipotizzando 4 livelli all'albero) occuperebbe circa 150 kB; **circa 23 volte più piccolo**. Questa riduzione delle dimensioni del testimone consentirà ai testimoni del client di essere accettabilmente piccoli. I testimoni polinomiali variano da 0,128 a 1 kB a seconda dello specifico impegno polinomiale utilizzato.
-
## Qual è la struttura di un albero di Verkle? {#what-is-the-structure-of-a-verkle-tree}
diff --git a/public/content/translations/it/social-networks/index.md b/public/content/translations/it/social-networks/index.md
index 47d7099ccb2..2c62d2f1d3f 100644
--- a/public/content/translations/it/social-networks/index.md
+++ b/public/content/translations/it/social-networks/index.md
@@ -65,18 +65,18 @@ I post pubblicati su Mirror sono memorizzati permanentemente su Arweave, una pia
Gli utenti utilizzano il token [ERC-20](/glossary/#erc-20) nativo della piattaforma $MIND per pagare gli articoli. Inoltre, gli utenti, possono anche guadagnare token $MIND, pubblicando contenuti popolari, contribuendo all'ecosistema e riferendo altri alla piattaforma.
-## Utilizzare i social decentralizzati {#use-decentralized-social-networks}
+## Utilizzare i social decentralizzati {#farcaster}
- **[Status.im](https://status.im/)**: _Status è un'app di messaggistica sicura che utilizza un protocollo open source e tra pari, nonché la crittografia end-to-end per proteggere i tuoi messaggi dalle terze parti._
- **[Mirror.xyz](https://mirror.xyz/)**: _Mirror è una piattaforma di pubblicazione decentralizzata e posseduta dagli utenti basata su Ethereum, per il crowdfunding delle idee, la monetizzazione dei contenuti e la creazione di community dal valore elevato._
- **[Lens Protocol](https://lens.xyz/)**: _Lens Protocol è un grafico sociale componibile e decentralizzato che aiuta i creatori a prendere possesso dei propri contenuti, ovunque vadano nel proprio giardino digitale dell'Intenet decentralizzato._
- **[Farcaster](https://farcaster.xyz/)**: _Farcaster è un social sufficientemente decentralizzato. È un protocollo aperto che supporta molti client, proprio come l'email._
-## Social network Web2 su Ethereum {#web2-social-networks-and-ethereum}
+## Social network Web2 su Ethereum {#use-decentralized-social-networks}
Le piattaforme social native del [Web3](/glossary/#web3) non sono le sole che stanno tentando di incorporare la tecnologia della blockchain nei social. Anche molte piattaforme centralizzate stanno pianificando di integrare Ethereum nella propria infrastruttura:
-### Reddit {#reddit}
+### Reddit {#web2-social-networks-and-ethereum}
Reddit ha [pubblicizzato i Punti della Community](https://cointelegraph.com/news/reddit-to-reportedly-tokenize-karma-points-and-onboard-500m-new-users): token ERC-20 che gli utenti possono guadagnare pubblicando contenuti di qualità e contribuendo alle community online (subreddit). Puoi riscattare tali token in una subreddit per ottenere privilegi e vantaggi esclusivi. Per questo progetto, Reddit sta lavorando con Arbitrum, una rete di [livello 2](/glossary/#layer-2) progettata per ridimensionare le transazioni di Ethereum.
@@ -84,9 +84,9 @@ Il programma è già attivo: la subreddit r/CryptoCurrency [adopera la propria v
Oltre a utilizzare i Punti della Community per sbloccare funzionalità speciali, gli utenti possono anche scambiarli per valuta legale nelle piattaforme di scambio. Inoltre, l'importo di Punti della Community posseduto da un utente ne determina l'influenza sul processo decisionale all'interno della community.
-## Lettura consigliate {#further-reading}
+## Lettura consigliate {#brave}
-### Articoli {#articles}
+### Articoli {#audius}
- [Decentralizzare i social: una guida allo stack dei social di Web3](https://www.coinbase.com/blog/decentralizing-social-media-a-guide-to-the-web3-social-stack) - _Coinbase Ventures_
- [I social sono la prossima grande opportunità per la decentralizzazione](https://www.coindesk.com/tech/2021/01/22/social-networks-are-the-next-big-decentralization-opportunity/) - _Ben Goertzel_
@@ -95,12 +95,12 @@ Oltre a utilizzare i Punti della Community per sbloccare funzionalità speciali,
- [In che modo la blockchain può risolvere la privacy dei social](https://www.investopedia.com/news/ethereum-blockchain-social-media-privacy-problem-linkedin-indorse/) - _Prableen Bajpai_
- [Decentralizzazione sufficiente per i social](https://www.varunsrinivasan.com/2022/01/11/sufficient-decentralization-for-social-networks) - _Varun Srinivasan_
-### Video {#videos}
+### Video {#sorare}
- [Social decentralizzati spiegati](https://www.youtube.com/watch?v=UdT2lpcGvcQ) - _Coinmarketcap_
- [La blockchain DeSo vuole decentralizzare i social](https://www.youtube.com/watch?v=SG2HUiVp0rE) - _Bloomberg Technology_
- [Il futuro dei social decentralizzati, con Balaji Srinivasan, Vitalik Buterin e Juan Benet](https://www.youtube.com/watch?v=DTxE9KV3YrE) - _ETHGlobal_
-### Community {#communities}
+### Community {#twitter}
- [Subreddit r/CryptoCurrency](https://www.reddit.com/r/CryptoCurrency/)
diff --git a/public/content/translations/it/staking/dvt/index.md b/public/content/translations/it/staking/dvt/index.md
index d2f9a11efe2..b719b9c0de7 100644
--- a/public/content/translations/it/staking/dvt/index.md
+++ b/public/content/translations/it/staking/dvt/index.md
@@ -1,6 +1,6 @@
---
title: Tecnologia del validatore distribuito
-description: La tecnologia del validatore distribuito consente l'operazione distribuita di un validatore di Ethereum da più parti.
+description: "La tecnologia del validatore distribuito consente l'operazione distribuita di un validatore di Ethereum da più parti."
lang: it
---
diff --git a/public/content/translations/it/staking/solo/index.md b/public/content/translations/it/staking/solo/index.md
index d1460e62efc..629e55fc205 100644
--- a/public/content/translations/it/staking/solo/index.md
+++ b/public/content/translations/it/staking/solo/index.md
@@ -71,6 +71,7 @@ Differente dalle sanzioni di inattività per esser offline, il taglio
Ulteriori informazioni sullo slashing e sul ciclo di vita dei validatori
+
@@ -130,7 +131,6 @@ Esistono alcune domande molto comuni sullo staking che meritano di essere affron
Un validatore è un'entità virtuale che risiede su Ethereum e partecipa al consenso del protocollo di Ethereum. I validatori sono rappresentati da un saldo, una chiave pubblica e altre proprietà. Un client del validatore è il software che agisce per conto del validatore detenendone e usandone la chiave privata. Un singolo client del validatore può detenere molte coppie di chiavi, controllando molti validatori.
-
diff --git a/public/content/translations/it/staking/withdrawals/index.md b/public/content/translations/it/staking/withdrawals/index.md
index da48375cdc0..e0317c01898 100644
--- a/public/content/translations/it/staking/withdrawals/index.md
+++ b/public/content/translations/it/staking/withdrawals/index.md
@@ -166,7 +166,6 @@ eventName="read more">
Se fai parte di un [pool di staking](/staking/pools/) o detieni token di staking, dovresti chiedere al tuo fornitore ulteriori dettagli su come vengono gestiti i prelievi dallo staking, poiché ogni servizio opera in modo diverso.
In generale, gli utenti dovrebbero essere liberi di rivendicare i propri ETH in staking sottostanti, o di modificare il fornitore di staking che utilizzano. Se un pool in particolare sta diventando troppo grande, è possibile uscire, riscattare i fondi e rimetterli in staking con un fornitore di dimensioni minori. O, se hai accumulato abbastanza ETH, potresti [fare staking da casa](/staking/solo/).
-
No, se il tuo validatore è ancora attivo sulla rete, un prelievo completo non si verificherà automaticamente. Questo richiede l'avvio manuale di un'uscita volontaria.
Una volta che un validatore ha completato il procedimento di uscita e supponendo che il conto abbia le credenziali di prelievo, il saldo rimanente sarà then prelevato durante la successivapulizia del validatore.
-
Gli operatori del validatore dovrebbero visitare la pagina dei Prelievi del Launchpad di Staking, dove troveranno ulteriori dettagli su come preparare il proprio validatore ai prelievi, le tempistiche degli eventi e ulteriori dettagli sul funzionamento dei prelievi.
Per testare la tua configurazione su una rete di prova, visita il Launchpad di Staking della rete di prova di Holesky per iniziare.
-