Ecco come è stato sviluppato un sistema di posta elettronica decentralizzato sulla blockchain

La tecnologia blockchain non supporta solo la criptovaluta, ha una vasta gamma di casi d’uso nel mondo reale. Qui, stiamo parlando di un software di posta elettronica decentralizzato basato sulla tecnologia blockchain che è unico per il tradizionale sistema di posta elettronica centralizzato basato su server.

Inoltre, offre maggiore sicurezza, privacy e affidabilità.

Le piattaforme di posta elettronica basate su server centralizzati sono a rischio di problemi di errore a punto singolo. Gli aggressori utilizzano tecniche diverse come attacchi Brute Force e hack del protocollo IMAP o dei server di posta elettronica per ottenere l’accesso non autorizzato agli account degli utenti. Ciò suggerisce che questa generazione moderna richiede una soluzione immediata per controllare i propri dati e la propria privacy con una piattaforma sicura per inviare o ricevere e-mail.

Tenendo presente la decentralizzazione e sfruttando le capacità uniche della blockchain, questo articolo ti insegnerà a sviluppare un software di posta decentralizzato.

Qui, costruiremo un software di posta decentralizzato su Testnet di Rootstock che può essere infine distribuito anche alla mainnet di Rootstock. Il nostro software sarà in grado di inviare o ricevere e-mail, inviare file come allegati, rispondere alle e-mail ed eliminare messaggi. Quindi, sarà interessante. Cominciamo creando la directory del progetto, ad esempio “decentralized-mail”.

📥Requisiti

Prima di iniziare il processo di sviluppo, è necessario avere un’idea delle funzionalità del codice dei linguaggi di programmazione e degli strumenti menzionati.

• Idee sulle funzionalità del codice di JavaScript, Solidity e CSS.

• Node.js: Scarica e installa da NodeJS.org è un’organizzazione senza scopo di lucro..

• Tartufo: Per implementare contratti intelligenti.

  npm install -g truffle
  

• SDK per la pignatta: Per interagire con Pinata

  npm install @pinata/sdk
  

• Assi: Per effettuare richieste HTTP a Pinata.

  npm install axios
  

📥Struttura della directory del progetto

Si prega di notare prima la directory del progetto. Creare le cartelle e i file all’interno delle cartelle passo dopo passo come segue.

📥Sviluppa contratti intelligenti

Dobbiamo creare un file di contratto Solidity. Crea DecentralizedMail.sol nella directory contracts/DecentralizedMail.sol come segue:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract DecentralizedMail {
    struct Message {
        address sender;
        address receiver;
        string content; // IPFS hash or plain text
        string imageHash; // IPFS hash of the image
        uint256 timestamp;
        bool isDeleted; // Flag to mark message as deleted
    }

    Message[] public messages;
    mapping(address => uint256[]) public userMessages;

    event MessageSent(address indexed sender, address indexed receiver, uint256 messageId);
    event MessageDeleted(address indexed user, uint256 messageId);

    function sendMessage(address _receiver, string memory _content, string memory _imageHash) public {
        uint256 messageId = messages.length;
        messages.push(Message({
            sender: msg.sender,
            receiver: _receiver,
            content: _content,
            imageHash: _imageHash,
            timestamp: block.timestamp,
            isDeleted: false
        }));
        userMessages[_receiver].push(messageId);
        userMessages[msg.sender].push(messageId); // Add message to sender's message list
        emit MessageSent(msg.sender, _receiver, messageId);
    }

    function getMessages() public view returns (Message[] memory) {
        return messages;
    }

    function getUserMessages(address _user) public view returns (uint256[] memory) {
        return userMessages[_user];
    }

    function getMessageById(uint256 messageId) public view returns (Message memory) {
        require(messageId < messages.length, "Message does not exist");
        return messages[messageId];
    }

    function deleteMessage(uint256 messageId) public {
        require(messageId < messages.length, "Message does not exist");
        Message storage message = messages[messageId];
        require(message.receiver == msg.sender || message.sender == msg.sender, "Not authorized to delete this message");
        message.isDeleted = true;
        emit MessageDeleted(msg.sender, messageId);
    }

    function getUserInbox(address _user) public view returns (Message[] memory) {
        uint256[] memory messageIds = userMessages[_user];
        Message[] memory inbox = new Message[](messageIds.length);
        uint256 counter = 0;

        for (uint256 i = 0; i < messageIds.length; i++) {
            Message storage message = messages[messageIds[i]];
            if (!message.isDeleted) {
                inbox[counter] = message;
                counter++;
            }
        }

        // Resize the array to fit the number of non-deleted messages
        Message[] memory resizedInbox = new Message[](counter);
        for (uint256 j = 0; j < counter; j++) {
            resizedInbox[j] = inbox[j];
        }

        return resizedInbox;
    }
}

Il nostro contratto fornisce una piattaforma decentralizzata per gli utenti per inviare ( sendMessage viene utilizzata la funzione), recupera (getMessages viene utilizzata la funzione) ed elimina i messaggi (deleteMessage funzione viene utilizzata) in modo sicuro utilizzando la tecnologia blockchain Rootstock. I messaggi vengono archiviati on-chain con dettagli quali mittente, destinatario, contenuto, hash dell’immagine, timestamp e stato di eliminazione.

📥Crea script di migrazione

Abbiamo bisogno di uno script di migrazione per semplificare il ciclo di vita dello sviluppo dello smart contract. Il suo ruolo principale nel nostro progetto è automatizzare e gestire il processo di distribuzione. Crea uno script di migrazione denominato 1_deploy_contracts.js nella directory radice come migrations/1_deploy_contracts.js come segue:

const DecentralizedMail = artifacts.require("DecentralizedMail");

module.exports = function(deployer) {
    deployer.deploy(DecentralizedMail);
};

📥Configura Truffle

Un file di configurazione Truffle è essenziale per definire come e dove verrà distribuito il nostro contratto intelligente.

Per prima cosa, installa la dipendenza usando npm:

npm install @truffle/hdwallet-provider

È progettato per specificare le impostazioni di rete, le versioni del compilatore e altri parametri di distribuzione come segue:

const HDWalletProvider = require('@truffle/hdwallet-provider');
require('dotenv').config();

module.exports = {
    networks: {
        development: {
            host: "localhost",
            port: 8545,
            network_id: "*" // Match any network id
        },
        testnet: { // Renamed from rskTestnet to testnet
            provider: () => new HDWalletProvider(process.env.MNEMONIC, 'https://public-node.testnet.rsk.co'),
            network_id: 31, // RSK Testnet network id
            gas: 5500000, // Gas limit (adjust if necessary)
            gasPrice: 1000000000, // Gas price in wei (1 gwei)
            networkCheckTimeout: 10000 // Timeout for network checks
        }
    },
    compilers: {
        solc: {
            version: "0.8.0"
        }
    }
};

Questa configurazione imposta gli ambienti di distribuzione e le opzioni del compilatore. Garantisce che i contratti siano distribuiti e compilati correttamente per le reti di sviluppo e test.

Nota: creare .env file nella directory root. Ora, crei il file con i seguenti codici e li aggiorni in seguito.

Devi mettere il tuo .env file nella directory principale del progetto come .env.example file come mostrato in Figure 1.

MNEMONIC=your_mnemonic_phrase_here //You need to add your wallet's 12 words mnemonic phrase here
REACT_APP_PINATA_API_KEY=your_pinata_api_key
REACT_APP_PINATA_SECRET_KEY=your_pinata_secret_key
REACT_APP_CONTRACT_ADDRESS=your_rsk_testnet_contract_address

Per favore ricordatelo fare un passo ** perché aggiornerai questo codice in seguito.

📥Imposta IPFS con Pinata

La nostra app di posta supporta anche le funzionalità di condivisione file tramite gli allegati. Quindi, stiamo utilizzando Caricare files funzionalità per IPFS tramite Pinata. Per prima cosa, crea l’account Pinata gratuito Qui.

Crea un file JavaScript per consentire il caricamento dei file nella directory scripts/pinata-upload.js come segue:

const axios = require('axios');
const FormData = require('form-data');
require('dotenv').config();

const API_KEY = process.env.PINATA_API_KEY;
const SECRET_KEY = process.env.PINATA_SECRET_KEY;

async function uploadToPinata(content) {
    const form = new FormData();
    form.append('file', content);

    try {
        const response = await axios.post('https://api.pinata.cloud/pinning/pinFileToIPFS', form, {
            headers: {
                ...form.getHeaders(),
                'pinata_api_key': API_KEY,
                'pinata_secret_api_key': SECRET_KEY,
            },
        });

        return response.data.IpfsHash;
    } catch (error) {
        console.error('Error uploading to Pinata:', error);
        throw error;
    }
}

// Example usage
const fs = require('fs');
const filePath = './example.txt'; // Replace with your file path
const fileContent = fs.createReadStream(filePath);

uploadToPinata(fileContent)
    .then(cid => console.log('File uploaded to IPFS with CID:', cid))
    .catch(err => console.error(err));

Per aggiornare il file, hai bisogno della chiave API e della chiave segreta di Pinata. .env archiviare a Fare un passo** come detto prima. Vai alla tua Piñata Dashboard>Chiavi API>Nuova chiave, e crea la tua nuova chiave API di amministrazione (seleziona la casella Amministratore opzione). Salva le chiavi API e le chiavi segrete in un posto sicuro.

📥Crea un’interfaccia front-end

È un passaggio cruciale. Il nostro front-end è costituito da tutte le funzionalità di base e dai codici per far funzionare le nostre app React sulla testnet Rootstock. Per semplificare il processo di sviluppo del front-end, ho già caricato i codici su GitHub. Puoi scaricarli da QuiInoltre, i codici sono lunghi e il nostro tutorial sarà già lungo, verrai guidato passo dopo passo a scaricare i file corretti da GitHub.

Imposta il progetto React

Apri il terminale dalla directory del tuo progetto e inserisci i seguenti comandi.

npx create-react-app mail-dapp
cd mail-dapp
npm install web3 @pinata/sdk

Crea componenti React

Nel tuo src cartella, creane un’altra components cartella e aggiungere il Upload.js file scaricando da Guida in linea.

Componente principale dell’app

Di nuovo, carica il file App.js in src/components/App.js directory scaricando il file da Guida in linea.

Configurare il punto di ingresso di React

In src cartella, caricare index.js file da Guida in linea.

Passiamo ora in rassegna gli altri componenti di sviluppo che supportano il processo di invio e ricezione di e-mail tramite il sistema di posta decentralizzato sulla testnet Rootstock.

Assicurati di scaricare i file SendMessage.js , Inbox.js, web3.jsE index.css dal Repository GitHub, e posizionarli nelle rispettive directory come mostrato nella directory del progetto Figura 1.

📥Test e distribuzione

Stiamo per testare e distribuire il nostro contratto su RSK Testnet usando Truffle. Seguite le istruzioni passo dopo passo.

Compilare il contratto

Eseguire il seguente comando nel terminale.

truffle compile

Se tutto è andato correttamente, nel terminale verranno visualizzati i seguenti messaggi.

Migra (distribuisci) i tuoi contratti

Quindi, eseguire il seguente comando per distribuire il contratto:

truffle migrate --network testnet

Vedrai qualcosa di simile con l’indirizzo del contratto.

Si prega di copiare l’indirizzo del contratto e aggiornarlo .env archiviare Fare un passo ** sostituendo your_rsk_testnet_contract_address dal tuo indirizzo di contratto effettivo e aggiorna il file. Nota inoltre che, dopo una migrazione del contratto riuscita, troverai il DecentralizedMail.json archiviare \decentralized-mail\build directory. Copia il file JSON e incollalo in decentralized-mail/src/utils/

📥Crea l’app React

Assicurati di aver aggiornato .env file con tutti i dettagli corretti.

Eseguire il seguente comando nel terminale.

npm run build

Dopodiché, installa l’estensione MetaMask sul tuo browser e cambia la testnet RSK aggiungendo i seguenti dettagli:

Vai a Seleziona Rete>Aggiungi rete>RPC personalizzato, e poi inserisci le seguenti informazioni.

• Nome della rete RSK Testnet
• Nuovo URL RPC https://public-node.testnet.rsk.co
• ChainID (facoltativo) 31
• Simbolo (facoltativo) tRBTC

Ora esegui il seguente comando nel terminale.

npm start

Dovresti essere reindirizzato al browser. L’app React invocherà MetaMask. Approva la chiamata. L’interfaccia principale dovrebbe apparire come segue. Prova a inviare un messaggio a un indirizzo, ma tieni presente che hai un po’ di tRBTC nel tuo portafoglio per coprire il gas nella testnet RSK. Puoi ottenere tRBTC gratis da Rubinetto RSK.

Puoi scrivere i testi e allegare file utilizzando Scegli il file opzione. Ho caricato una foto di Nikola Tesla. Assicurati di confermare la chiamata di MetaMask dopo aver inviato l’email all’indirizzo del destinatario. Attendi che la transazione venga confermata dalla blockchain. Una volta completato il processo, vedrai un messaggio di notifica inviato.

Controlliamo se l’indirizzo del destinatario ha il messaggio inviato nella posta in arrivo oppure no.

Perfetto! Puoi vedere il messaggio inviato con il file allegato di Nikola Tesla. Puoi rispondere alla posta in arrivo o anche eliminare la posta in arrivo. Una volta che rispondi al messaggio, apparirà nella sezione posta in arrivo del mittente originale.

Dopo aver risposto al messaggio, questo viene visualizzato nella posta in arrivo.

Vediamo che ne dici della funzionalità di eliminazione dei messaggi. Una volta cliccato sull’icona di eliminazione, l’app React richiama MetaMask per confermare la chiamata. Una volta completata la transazione, verrà contrassegnata e scomparirà dalla posta in arrivo.

In questo modo, abbiamo sviluppato con successo un software di posta decentralizzata basato su blockchain sulla testnet RSK, che può essere distribuito anche sulla mainnet RSK semplicemente modificando i codici.

Si prega di notare che questo è il tutorial per sviluppare una piattaforma di messaggistica decentralizzata con le funzionalità di base. La sicurezza è stata la priorità sin dall’inizio, ma vi avverto di controllare tutto a vostro rischio e pericolo se vi state affrettando a sviluppare il vostro software pronto per la produzione.

Per il codice dettagliato, fare riferimento al repository GitHub: Posta decentralizzata GitHub.

📥Problemi comuni e soluzioni

1.EIP-1559 non supportato

Errore: Valore non valido specificato “Eip1559NotSupportedError“.

Errore: La rete non supporta eip-1559.

Soluzione: Assicurati che il gasPrice è specificato nelle opzioni di transazione. Dovresti anche aggiornare il codice frontend per gestire correttamente i prezzi del gas.

2. Metamask non invocato

Dovresti installare l’estensione MetaMask nel tuo browser e configurare la testnet RSK nella configurazione di rete del tuo Wallet. Esamina attentamente il codice che window.ethereum.enable() viene utilizzato correttamente per richiedere a Metamask l’accesso all’account.

3. Messaggi non visualizzati

Verifica che i messaggi siano correttamente inviati alla posta in arrivo del destinatario. In caso contrario, controlla la logica dello smart contract per l’archiviazione e il recupero dei messaggi.

Conclusione

Questo tutorial ti aiuta a creare una piattaforma di messaggistica decentralizzata basata su blockchain con le caratteristiche e le funzionalità di base. Con questo software di messaggistica, puoi inviare, ricevere, eliminare messaggi e rispondere ai messaggi tramite blockchain. Supporta anche le funzionalità di condivisione file tramite IPFS Pinata. Puoi modificare il codice per aggiungere più funzionalità con un’interfaccia utente accattivante per soddisfare le esigenze dei tuoi utenti.

La blockchain decentralizzata supporta il processo di invio e ricezione dei messaggi con una crittografia avanzata, il che significa che una piattaforma di scambio di posta elettronica decentralizzata potrebbe rivelarsi la scelta migliore in futuro.

Aiuta a proteggere i contenuti dalle note tattiche di phishing degli aggressori. Inoltre, questo tipo di piattaforma di messaggistica è protetta dal noto problema del singolo punto di errore e da altri attacchi dei criminali informatici perché l’indirizzo non è costituito dalle informazioni personali dell’utente.

Fuente