Merge pull request #14661 from ethereum/crowdin-january-it-20250113162926684

chore: import translations for it

Author: corwintines

public/content/translations/it/developers/docs/smart-contracts/anatomy/index.md

@@ -1,6 +1,6 @@
 ---
 title: Anatomia dei contratti intelligenti
-description: "Uno sguardo approfondito all'anatomia di un contratto intelligente: le funzioni, i dati e le variabili."
+description: 'Uno sguardo approfondito all''anatomia di un contratto intelligente: le funzioni, i dati e le variabili.'
 lang: it
 ---
 
@@ -16,18 +16,18 @@ Tutti i dati del contratto devono essere assegnati a una posizione: `storage` op
 
 ### Storage {#storage}
 
-I dati persistenti sono detti storage (o spazio di archiviazione) e sono rappresentati da variabili di stato. Questi valori sono memorizzati permanentemente nella blockchain. È necessario dichiarare il tipo così che il contratto possa tenere traccia di quanto storage è necessario sulla blockchain quando viene compilato.
+I dati persistenti sono detti storage (o spazio di archiviazione) e sono rappresentati da variabili di stato.  Questi valori sono memorizzati permanentemente nella blockchain. È necessario dichiarare il tipo così che il contratto possa tenere traccia di quanto storage è necessario sulla blockchain quando viene compilato.
 
 ```solidity
-// Esempio in Solidity
+// Esempio in Solidity 
 contract SimpleStorage {
     uint storedData; // Variabile di stato
     // ...
 }
 ```
 
 ```python
-# Esempio in Vyper
+# Esempio in Vyper 
 storedData: int128
 ```
 
@@ -52,13 +52,13 @@ Per ulteriori spiegazioni, consulta la documentazione:
 - [Vedi Vyper types](https://vyper.readthedocs.io/en/v0.1.0-beta.6/types.html#value-types)
 - [Vedi Solidity types](https://solidity.readthedocs.io/en/latest/types.html#value-types)
 
-### Memory {#memory}
+### Memoria {#memory}
 
 I valori che vengono memorizzati solo per la durata di esecuzione di una funzione di contratto sono detti variabili di memoria. Dal momento che non sono memorizzati in modo permanente sulla blockchain, sono molto più economici da usare.
 
 Scopri di più su come l'EVM memorizza i dati (Archiviazione, Memoria e lo Stack), nella [documentazione di Solidity](https://solidity.readthedocs.io/en/latest/introduction-to-smart-contracts.html?highlight=memory#storage-memory-and-the-stack).
 
-### Variabili d'ambiente {#environment-variables}
+### Variabili ambientali {#environment-variables}
 
 Oltre alle variabili che vengono definite nel contratto, sono presenti alcune variabili globali speciali. Vengono utilizzate principalmente per fornire informazioni sulla blockchain o sulla transazione corrente.
 
@@ -100,7 +100,7 @@ function update_name(string value) public {
 - È dichiarato `public` e quindi chiunque può accedervi
 - Non è dichiarato `view`, quindi può modificare lo stato del contratto
 
-### Funzioni view {#view-functions}
+### Funzioni 'view' {#view-functions}
 
 Queste funzioni promettono di non modificare lo stato dei dati del contratto. Tra gli esempi più comuni vi sono le funzioni "getter": puoi usarle ad esempio per ricevere un saldo dell'utente.
 
@@ -131,7 +131,7 @@ Ecco cosa è considerato modifica dello stato:
 7. Utilizzo di chiamate di basso livello.
 8. Utilizzo di assembly inline contenente determinati opcode.
 
-### Funzioni constructor {#constructor-functions}
+### Funzioni del costruttore {#constructor-functions}
 
 Quando il contratto viene distribuito per la prima volta, le funzioni `constructor` sono eseguite solo una volta. Come accade per `constructor` in molti linguaggi di programmazione basati su classi, queste funzioni spesso inizializzano le variabili di stato ai valori specificati.
 
@@ -167,7 +167,7 @@ Oltre alle variabili che vengono definite nel contratto, sono presenti alcune fu
 
 Queste, consentono ai contratti di inviare ETH agli altri conti.
 
-## Scrivere funzioni {#writing-functions}
+## Scrittura delle funzioni {#writing-functions}
 
 Una funzione ha bisogno di:
 
@@ -201,15 +201,15 @@ contract ExampleDapp {
 
 Un contratto completo potrebbe avere questa forma. Qui la funzione `constructor` fornisce un valore iniziale per la variabile `dapp_name`.
 
-## Eventi e log {#events-and-logs}
+## Eventi e registri {#events-and-logs}
 
-Gli eventi ti consentono di comunicare con il tuo contratto intelligente dal tuo frontend o da altre applicazioni che prevedono un'iscrizione. Quando una transazione è minata, i contratti intelligenti possono emettere eventi e scrivere registri alla blockchain, che il frontend può poi elaborare.
+Gli eventi consentono al tuo contratto intelligente di comunicare con il tuo frontend o con altre applicazioni di iscrizione. Una volta che una transazione viene convalidata e aggiunta a un blocco, i contratti intelligenti possono emettere eventi e registrare informazioni, che possono quindi essere elaborati e utilizzati dal frontend.
 
-## Esempi commentati {#annotated-examples}
+## Esempi annotati {#annotated-examples}
 
 Questi sono alcuni esempi scritti in Solidity. Se vuoi sperimentare con il codice, puoi interagire con questi esempi in [Remix](http://remix.ethereum.org).
 
-### Hello world {#hello-world}
+### Ciao mondo {#hello-world}
 
 ```solidity
 // Specifica la versione di Solidity, utilizzando il controllo delle versioni semantico.

public/content/translations/it/developers/docs/smart-contracts/compiling/index.md

@@ -33,6 +33,10 @@ contract Greeter {
 PUSH1 0x80 PUSH1 0x40 MSTORE PUSH1 0x4 CALLDATASIZE LT PUSH2 0x41 JUMPI PUSH1 0x0 CALLDATALOAD PUSH29 0x100000000000000000000000000000000000000000000000000000000 SWAP1 DIV PUSH4 0xFFFFFFFF AND DUP1 PUSH4 0xCFAE3217 EQ PUSH2 0x46 JUMPI JUMPDEST PUSH1 0x0 DUP1 REVERT JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x52 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0x5B PUSH2 0xD6 JUMP JUMPDEST PUSH1 0x40 MLOAD DUP1 DUP1 PUSH1 0x20 ADD DUP3 DUP2 SUB DUP3 MSTORE DUP4 DUP2 DUP2 MLOAD DUP2 MSTORE PUSH1 0x20 ADD SWAP2 POP DUP1 MLOAD SWAP1 PUSH1 0x20 ADD SWAP1 DUP1 DUP4 DUP4 PUSH1 0x0 JUMPDEST DUP4 DUP2 LT ISZERO PUSH2 0x9B JUMPI DUP1 DUP3 ADD MLOAD DUP2 DUP5 ADD MSTORE PUSH1 0x20 DUP2 ADD SWAP1 POP PUSH2 0x80 JUMP JUMPDEST POP POP POP POP SWAP1 POP SWAP1 DUP2 ADD SWAP1 PUSH1 0x1F AND DUP1 ISZERO PUSH2 0xC8 JUMPI DUP1 DUP3 SUB DUP1 MLOAD PUSH1 0x1 DUP4 PUSH1 0x20 SUB PUSH2 0x100 EXP SUB NOT AND DUP2 MSTORE PUSH1 0x20 ADD SWAP2 POP JUMPDEST POP SWAP3 POP POP POP PUSH1 0x40 MLOAD DUP1 SWAP2 SUB SWAP1 RETURN JUMPDEST PUSH1 0x60 PUSH1 0x40 DUP1 MLOAD SWAP1 DUP2 ADD PUSH1 0x40 MSTORE DUP1 PUSH1 0x5 DUP2 MSTORE PUSH1 0x20 ADD PUSH32 0x48656C6C6F000000000000000000000000000000000000000000000000000000 DUP2 MSTORE POP SWAP1 POP SWAP1 JUMP STOP LOG1 PUSH6 0x627A7A723058 KECCAK256 SLT 0xec 0xe 0xf5 0xf8 SLT 0xc7 0x2d STATICCALL ADDRESS SHR 0xdb COINBASE 0xb1 BALANCE 0xe8 0xf8 DUP14 0xda 0xad DUP13 LOG1 0x4c 0xb4 0x26 0xc2 DELEGATECALL PUSH7 0x8994D3E002900
 ```
 
+Questi sono detti **opcode**, o codici operativi. Gli opcode dell'EVM sono le istruzioni di basso livello eseguibili dalla Macchina Virtuale di Ethereum (EVM). Ogni opcode rappresenta un'operazione specifica, come operazioni aritmetiche, operazioni logiche, manipolazione dei dati, flusso di controllo, ecc.
+
+[Maggiori informazioni sugli opcode](/developers/docs/evm/opcodes/)
+
 ## Applicazioni Web {#web-applications}
 
 Il compilatore produce anche l'**Application Binary Interface (ABI)** che serve all'applicazione per capire il contratto e per chiamarne le funzioni.

public/content/translations/it/developers/docs/smart-contracts/deploying/index.md

@@ -20,16 +20,14 @@ Infine, dovrai compilare il tuo contratto prima di distribuirlo, quindi, assicur
 
 ### Cosa ti serve {#what-youll-need}
 
-- il bytecode del tuo contratto: è generato tramite la [compilazione](/developers/docs/smart-contracts/compiling/)
+- Il bytecode del tuo contratto: è generato tramite la [compilazione](/developers/docs/smart-contracts/compiling/)
 - ETH per gas: imposterai il limite di gas come per altre transazioni, quindi, sappi che la distribuzione del contratto necessita di molto più gasi di un semplice trasferimento di ETH
 - uno script o un plugin di distribuzione.
 - accesso a un [nodo Ethereum](/developers/docs/nodes-and-clients/) tramite esecuzione di un nodo personalizzato, connessione a un nodo pubblico o utilizzando una chiave API con un [servizio di nodi](/developers/docs/nodes-and-clients/nodes-as-a-service/)
 
 ### Passaggi per distribuire un contratto intelligente {#steps-to-deploy}
 
-I passaggi specifici dipenderanno dagli strumenti utilizzati. Per esempio, dai un'occhiata alla [documentazione di Hardhat sulla distribuzione dei tuoi contratti](https://hardhat.org/guides/deploying.html). Questi sono due degli strumenti più popolari per la distribuzione dei contratti intelligenti, che coinvolgono la scrittura di uno script per gestire i passaggi di distribuzione.
-
-Una volta distribuito, il contratto avrà un indirizzo Ethereum come gli altri [conti](/developers/docs/accounts/).
+I passaggi specifici richiesti dipenderanno dal quadro di sviluppo in questione. Ad esempio, puoi consultare la [documentazione di Hardhat sulla distribuzione dei tuoi contratti](https://hardhat.org/guides/deploying.html) o la [documentazione di Foundry sulla distribuzione e verifica di un contratto intelligente](https://book.getfoundry.sh/forge/deploying). Una volta distribuito, il tuo contratto avrà un indirizzo di Ethereum, come gli altri [conti](/developers/docs/accounts/), e potrà essere verificato utilizzando gli [strumenti di verifica del codice sorgente](/developers/docs/smart-contracts/verifying/#source-code-verification-tools).
 
 ## Strumenti correlati {#related-tools}
 
@@ -55,6 +53,13 @@ Una volta distribuito, il contratto avrà un indirizzo Ethereum come gli altri [
 
 - [Documentazione](https://portal.thirdweb.com/deploy/)
 
+**Crossmint - _Piattaforma di sviluppo Web3 per imprese per distribuire contratti intelligenti, consentire i pagamenti con carte di credito e tra catene, e utilizzare le API per creare, distribuire, vendere, memorizzare e modificare i NFT._**
+
+- [crossmint.com](https://www.crossmint.com)
+- [Documentazione](https://docs.crossmint.com)
+- [Discord](https://discord.com/invite/crossmint)
+- [Blog](https://blog.crossmint.com)
+
 ## Tutorial correlati {#related-tutorials}
 
 - [Deploying your first smart contract](/developers/tutorials/deploying-your-first-smart-contract/): _Un'introduzione alla distribuzione del primo contratto su una rete di prova di Ethereum._

public/content/translations/it/developers/docs/smart-contracts/index.md

@@ -109,3 +109,4 @@ I contratti multifirma (a firma multipla), sono conti del contratto intelligente
 - [Coinbase: Cos'è un contratto intelligente?](https://www.coinbase.com/learn/crypto-basics/what-is-a-smart-contract)
 - [Chainlink: Cos'è un contratto intelligente?](https://chain.link/education/smart-contracts)
 - [Video: Spiegato in modo semplice - Contratti intelligenti](https://youtu.be/ZE2HxTmxfrI)
+- [Cyfrin Updraft: Piattaforma di apprendimento e controllo Web3](https://updraft.cyfrin.io)

public/content/translations/it/developers/docs/smart-contracts/languages/index.md

@@ -1,6 +1,6 @@
 ---
 title: Linguaggi dei contratti intelligenti
-description: "Panoramica e confronto dei due linguaggi principali dei contratti intelligenti: Solidity e Viper."
+description: 'Panoramica e confronto dei due linguaggi principali dei contratti intelligenti: Solidity e Viper.'
 lang: it
 ---
 
@@ -11,6 +11,8 @@ I due linguaggi più attivi e gestiti sono:
 - Solidity
 - Vyper
 
+Remix IDE fornisce un ambiente di sviluppo completo per creare e testare i contratti sia in Solidity che in Vyper. [Prova Remix IDE integrato nel browser](https://remix.ethereum.org) per iniziare a programmare.
+
 Gli sviluppatori più esperti potrebbero prendere in considerazione anche Yul, un linguaggio intermedio per la [macchina virtuale Ethereum](/developers/docs/evm/), oppure Yul +, un'estensione di Yul.
 
 Se sei curioso e vorresti aiutare a testare nuovi linguaggi ancora in via di sviluppo, puoi sperimentare con Fe, un linguaggio emergente nel campo dei contratti intelligenti, correntemente ai suoi inizi.
@@ -35,7 +37,7 @@ Una conoscenza pregressa dei linguaggi di programmazione, specialmente JavaScrip
 - [Portale del Linguaggio di Solidity](https://soliditylang.org/)
 - [Solidity per Esempio](https://docs.soliditylang.org/en/latest/solidity-by-example.html)
 - [GitHub](https://github.com/ethereum/solidity/)
-- [Solidity Gitter Chatroom](https://gitter.im/ethereum/solidity) collegato a [Solidity Matrix Chatroom](https://matrix.to/#/#ethereum_solidity:gitter.im)
+- [Solidity Gitter Chatroom](https://gitter.im/ethereum/solidity) collegato alla [Chatroom di Solidity Matrix](https://matrix.to/#/#ethereum_solidity:gitter.im)
 - [Cheat Sheet](https://reference.auditless.com/cheatsheet)
 - [Solidity Blog](https://blog.soliditylang.org/)
 - [Twitter di Solidity](https://twitter.com/solidity_lang)
@@ -138,7 +140,7 @@ ended: public(bool)
 pendingReturns: public(HashMap[address, uint256])
 
 # Crea una semplice asta con `_bidding_time`
-# tempo di offerta in secondi per conto
+# tempo di offerta in secondi per conto 
 # dell'indirizzo del beneficiario `_beneficiary`.
 @external
 def __init__(_beneficiary: address, _bidding_time: uint256):

public/content/translations/it/developers/docs/smart-contracts/libraries/index.md

@@ -79,7 +79,7 @@ Indipendentemente dal metodo utilizzato, includendo una libreria, tieni sempre d
 
 Usare la libreria di un contratto intelligente per il tuo progetto ha diversi benefici. Prima di tutto, fa risparmiare tempo perché fornisce blocchi di programmazione pronti all'uso che puoi includere nel sistema e che non devi programmare autonomamente.
 
-Anche la sicurezza è un importante vantaggio. Le librerie dei contratti intelligenti open source, inoltre, sono spesso molto controllate. Dato che molti progetti dipendono da esse, c'è un forte incentivo da parte della community a revisionarle costantemente. È molto più comune trovare errori nel codice di un'applicazione che nelle librerie riutilizzabili dei contratti. Inoltre alcune librerie sono sottoposte a [audit esterni](https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/audit) per maggior sicurezza.
+Anche la sicurezza è un importante vantaggio. Le librerie dei contratti intelligenti open source, inoltre, sono spesso molto controllate. Dato che molti progetti dipendono da esse, c'è un forte incentivo da parte della community a revisionarle costantemente. È molto più comune trovare errori nel codice di un'applicazione che nelle librerie riutilizzabili dei contratti. Inoltre alcune librerie sono sottoposte a [controlli esterni](https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/audits) per maggior sicurezza.
 
 Tuttavia, l'uso delle librerie dei contratti intelligenti comporta il rischio di includere codice con cui non sei familiare nel tuo progetto. La tentazione di importare un contratto e includerlo direttamente nel progetto è forte, ma se non si sa cosa fa il contratto, si potrebbe inavvertitamente inserire un problema nel sistema a causa di un comportamento imprevisto. Leggi sempre la documentazione del codice che importi e quindi controlla il codice direttamente prima di renderlo parte del tuo progetto.