Building a Decentralized Document Verification System with QuickNode

Introduction

In today's digital age, verifying the authenticity of documents can be a cumbersome process. Traditional methods often involve relying on centralized authorities or intermediaries, which can be slow and costly. However, blockchain technology provides a solution by enabling the creation of decentralized document verification systems.

In this tutorial, we'll walk you through the process of building a decentralized document verification system using QuickNode, a powerful blockchain infrastructure provider. With QuickNode, we'll access the Ethereum blockchain to store and verify document information securely.

Problem Statement: Imagine a scenario where individuals or organizations need to verify the authenticity of academic certificates, legal documents, or any other vital records. Our solution will allow users to submit documents, and a smart contract on the Ethereum blockchain will verify their authenticity, providing a tamper-proof verification result.

Prerequisites

Before we dive into building the document verification system, make sure you have the following prerequisites:

1. Basic knowledge of blockchain technology and Ethereum.

2. Node.js and npm (Node Package Manager) are installed on your system.

3. A code editor (e.g., Visual Studio Code).

4. An active QuickNode account for accessing Ethereum blockchain data.

Setting Up the Development Environment

Step 1: Installing Dependencies

To get started, create a new directory for your project and open a terminal. Run the following command to initialize your project:

mkdir document-verification-dapp
cd document-verification-dapp
npm init -y

Next, install the required dependencies:

npm install express web3.js ethereumjs-tx

Step 2: Configuring QuickNode

To access the Ethereum blockchain, we'll use QuickNode. Sign up for a QuickNode account and obtain your API key.

Create a file named .env in your project directory and add your QuickNode API key as follows:

QUICKNODE_API_KEY=your_api_key_here

In your JavaScript code, you can access this API key using the process.env object.

const quicknodeApiKey = process.env.QUICKNODE_API_KEY;

We've set up the development environment and configured QuickNode. In the next section, we'll create the smart contract for document verification.

Creating the Smart Contract

Step 3: Designing the Smart Contract

Our document verification system will utilize a smart contract on the Ethereum blockchain. This smart contract will store document hashes and provide verification functions.

Here's a basic outline of the smart contract's functionality:

• Users can submit documents, and the system will generate a unique document hash.

• The document hash will be stored on the blockchain.

• To verify a document, users can provide its hash, and the system will check if it exists on the blockchain.

Let's write the Solidity code for this smart contract. Create a file named DocumentVerifier.sol in your project directory and add the following code:

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

contract DocumentVerifier {
    mapping(bytes32 => bool) private documentRegistry;

    function addDocument(bytes32 documentHash) public {
        documentRegistry[documentHash] = true;
    }

    function verifyDocument(bytes32 documentHash) public view returns (bool) {
        return documentRegistry[documentHash];
    }
}

Step 4: Deploying the Smart Contract

We'll use tools like Truffle or Hardhat to deploy our smart contract to the Ethereum blockchain. For this tutorial, we'll assume you have experience with these tools.

Deploy your smart contract to a testnet or a private Ethereum network. Remember to keep track of the contract's address for later use.

In the next section, we'll build the user interface for our document verification system.

Building the User Interface

Step 5: Developing the Front-End

To interact with our smart contract, we'll create a web-based front-end using HTML, CSS, and JavaScript. Create a directory named public in your project folder and add the following files:

• index.html: The main HTML file for our front end.

• style.css: CSS styles for the user interface.

• app.js: JavaScript code to interact with the smart contract.

Here's a simple structure for index.html:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Document Verification System</title>
    <link rel="stylesheet" href="style.css">
</head>
<body>
    <h1>Document Verification System</h1>

    <!-- Document Submission Form -->
    <div class="form-container">
        <h2>Submit a Document</h2>
        <form id="document-form">
            <label for="document">Choose a document:</label>
            <input type="file" id="document" accept=".pdf, .doc, .docx">
            <button type="submit">Submit</button>
        </form>
    </div>

    <!-- Verification Form -->
    <div class="form-container">
        <h2>Verify a Document</h2>
        <form id="verification-form">
            <label for="document-hash">Enter Document Hash:</label>
            <input type="text" id="document-hash">
            <button type="submit">Verify</button>
        </form>
        <p id="verification-result"></p>
    </div>

    <script src="app.js"></script>
</body>
</html>

`style.css`

/* Add your CSS styles here */

`app.js`

In app.js, we'll use Web3.js to interact with the Ethereum blockchain. Here's a simplified version to get you started:

const documentForm = document.getElementById('document-form');
const verificationForm = document.getElementById('verification-form');
const verificationResult = document.getElementById('verification-result');

documentForm.addEventListener('submit', async (e) => {
    e.preventDefault();
    const documentInput = document.getElementById('document');
    const document = documentInput.files[0];

    // Calculate the document hash (you can use libraries like crypto-js)
    const documentHash = await calculateDocumentHash(document);

    // Call the smart contract to add the document
    await addDocumentToBlockchain(documentHash);

    // Display success message
    alert('Document submitted successfully.');
});

verificationForm.addEventListener('submit', async (e) => {
    e.preventDefault();
    const documentHashInput = document.getElementById('document-hash');
    const documentHash = documentHashInput.value;

    // Call the smart contract to verify the document
    const isVerified = await verifyDocumentOnBlockchain(documentHash);

    // Display verification result
    if (isVerified) {
        verificationResult.textContent = 'Document is verified.';
    } else {
        verificationResult.textContent = 'Document verification failed.';
    }
});

// Functions to interact with the Ethereum blockchain go here

async function calculateDocumentHash(document) {
    // Implement the logic to calculate the document hash here
}

async function addDocumentToBlockchain(documentHash) {
    // Implement the logic to interact with the smart contract to add the document hash
}

async function verifyDocumentOnBlockchain(documentHash) {
    // Implement the logic to interact with the smart contract to verify the document
}

In the JavaScript code above, we've set up event listeners for document submission and verification forms. When a user submits a document, we calculate its hash and add it to the blockchain. For verification, we call the smart contract to check if the document hash exists on the blockchain.

Implementing Document Verification

Step 6: Adding Document Submission

In this step, we'll focus on the JavaScript code to calculate the document hash and add it to the blockchain using Web3.js. Make sure you've included the Web3.js library in your project.

`app.js`

// ... (Previous code)

// Import the Web3.js library
const Web3 = require('web3');

// Initialize Web3 with your Ethereum provider (replace 'YOUR_PROVIDER_URL' with your actual provider)
const web3 = new Web3('YOUR_PROVIDER_URL');

// Define the address and ABI of your deployed smart contract
const contractAddress = 'YOUR_CONTRACT_ADDRESS';
const contractABI = [
    {
        constant: false,
        inputs: [{ name: 'documentHash', type: 'string' }],
        name: 'addDocumentHash',
        outputs: [],
        payable: false,
        stateMutability: 'nonpayable',
        type: 'function',
    },
    // Add other ABI details specific to your contract
];

// Create a contract instance
const contract = new web3.eth.Contract(contractABI, contractAddress);

// Function to calculate the document hash (you can use libraries like crypto-js)
async function calculateDocumentHash(document) {
    // Implement the logic to calculate the document hash here
}

// Function to add the document hash to the blockchain
async function addDocumentToBlockchain(documentHash) {
    try {
        // Get the current Ethereum account
        const accounts = await web3.eth.getAccounts();
        const account = accounts[0];

        // Call the 'addDocumentHash' function of the smart contract
        const result = await contract.methods.addDocumentHash(documentHash).send({
            from: account,
        });

        // Log the transaction details
        console.log('Transaction Hash:', result.transactionHash);
    } catch (error) {
        console.error('Error adding document to blockchain:', error);
    }
}

// ... (Rest of the code)

// Call the 'calculateDocumentHash' and 'addDocumentToBlockchain' functions when submitting a document
documentForm.addEventListener('submit', async (e) => {
    e.preventDefault();
    const documentInput = document.getElementById('document');
    const document = documentInput.files[0];

    // Calculate the document hash
    const documentHash = await calculateDocumentHash(document);

    // Add the document hash to the blockchain
    await addDocumentToBlockchain(documentHash);

    // Display success message
    alert('Document submitted successfully.');
});

// ... (Rest of the code)

In this code, we've added the necessary Web3.js setup, including initializing Web3 with your Ethereum provider, defining the contract address and ABI, and creating a contract instance. The calculateDocumentHash function is responsible for computing the hash of the document (you can use a library like crypto-js for this). The addDocumentToBlockchain function sends a transaction to add the document hash to the smart contract.

Please replace 'YOUR_PROVIDER_URL', 'YOUR_CONTRACT_ADDRESS', and the contract ABI with your actual values.

With this code in place, when a user submits a document, its hash will be calculated, and a transaction will be sent to add it to the blockchain using your smart contract.

Testing the System

Step 7: Testing Document Verification

Before deploying our document verification system to a production environment, it's essential to thoroughly test it. We'll test the document verification process, ensuring that data is stored correctly on the blockchain and that the verification results are accurate.

Enhancing Security and Accessibility

Step 8: Implementing Security Measures

To ensure the security of our document verification system, we'll implement security measures such as encryption and access control. These measures will protect user data and prevent unauthorized access.

We'll dive into security enhancements in the following sections.

Step 9: Making the System Accessible

An accessible system is user-friendly and accommodates users with different needs. In this step, we'll focus on making our document verification system accessible to a wide range of users. We'll address usability and user experience aspects.

Deploying the Document Verification System

Step 10: Preparing for Deployment

With our document verification system fully developed and tested, we're ready to prepare for deployment to a production environment. We'll discuss the steps to ensure a smooth deployment process.

Conclusion

Throughout this tutorial, you've gained hands-on experience in blockchain development, smart contract creation, and front-end integration. You've built a functional decentralized document management system, which can serve as a foundation for more ambitious blockchain projects.

Remember that the blockchain space is dynamic and ever-evolving, with boundless opportunities waiting to be explored. Armed with the knowledge gained here, you're well-equipped to continue your blockchain development journey and contribute to the exciting world of decentralized applications.

Thank you for joining us on this adventure, and we look forward to seeing the innovative applications you build using QuickNode and blockchain technology. If you have any questions or need further assistance, don't hesitate to reach out. Happy coding!

I'd love to connect with you on Twitter | LinkedIn | Portfolio.

About QuickNode

QuickNode is building infrastructure to support the future of Web3. Since 2017, we've worked with hundreds of developers and companies, helping scale dApps and providing high-performance access to 24+ blockchains. Subscribe to our newsletter for more content like this, and stay in the loop with what's happening in Web3!‌