Building Decentralized Identity Systems on Celo: A Guide to Creating Secure and Scalable Identity Solutions

Elijah007 · May 2, 2023, 12:47am

Introduction

Celo is a mobile-first blockchain platform that makes financial tools accessible to anyone with a mobile phone. In this tutorial, we’ll cover how to use Celo’s ContractKit library to build a decentralized identity system.

This tutorial will guide you through the process of creating secure and scalable identity solutions. Let’s get started!

Prerequisites

Before we begin, make sure you have the following installed on your system:

Node.js and npm (Node Package Manager)
Git

Step 1: Setting up the Project

Create a new directory for your project and navigate to it in your terminal.
Initialize a new Node.js project by running the following command:
```
npm init -y
```
Install Hardhat and the required plugins by running the following command:
```
npm install --save-dev hardhat hardhat-ethers ethers
```

Create a hardhat.config.js file in the root of your project and add the following code:

require("@nomiclabs/hardhat-ethers");

module.exports = {
  solidity: "0.8.4",
  networks: {
    hardhat: {},
  },
};

Step 2: Configuring Celo ContractKit

Install Celo ContractKit by running the following command:
```
npm install @celo/contractkit
```

Create a new file named celo.js in your project’s root directory and add the following code:

const { ContractKit } = require("@celo/contractkit");

function getCeloKit() {
  const kit = ContractKit.newKit("https://alfajores-forno.celo-testnet.org");
  return kit;
}

module.exports = getCeloKit;

Step 3: Creating the Identity Contract

Create a new directory named contracts in your project’s root directory.

Inside the contracts directory, create a new file named Identity.sol and add the following code:

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

contract Identity {
  mapping(address => bool) public isVerified;

  function verify(address account) external {
    isVerified[account] = true;
  }
}

Step 4: Writing Tests

Create a new directory named test in your project’s root directory.

Inside the test directory, create a new file named identity.js and add the following code:

const { expect } = require("chai");
const { ethers } = require("hardhat");
const getCeloKit = require("../celo");

describe("Identity", function () {
  let identity;
  let accounts;
  let kit;

  before(async function () {
    kit = getCeloKit();
    accounts = await ethers.getSigners();
    const Identity = await ethers.getContractFactory("Identity");
    identity = await Identity.deploy();
    await identity.deployed();
  });

  it("should verify an account", async function () {
    const [account] = accounts;
    await identity.verify(account.address);
    const isVerified = await identity.isVerified(account.address);
    expect(isVerified).to.be.true;
  });
});

Step 5: Running the Tests

Open your terminal and navigate to the root directory of your project.
Run the tests using the following command:
```
npx hardhat test
```

If everything is set up correctly, you should see the test pass, indicating that the account verification functionality works as expected.

Congratulations! You have successfully built a decentralized identity system on Celo using Hard

hat and Celo ContractKit. This tutorial covered the basic setup and implementation of a simple identity contract. Feel free to expand on this foundation to create more sophisticated identity solutions.

Remember to take security precautions when deploying smart contracts and handling user data in decentralized applications. Always thoroughly test and audit your code before deploying it to production environments.

Step 6: Adding Identity Claims

Open the Identity.sol file in the contracts directory.

Modify the contract code as follows:

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

contract Identity {
  struct Claim {
    string key;
    string value;
  }

  mapping(address => bool) public isVerified;
  mapping(address => Claim[]) public identityClaims;

  function verify(address account) external {
    isVerified[account] = true;
  }

  function addClaim(string memory key, string memory value) external {
    require(isVerified[msg.sender], "Sender must be a verified account.");
    identityClaims[msg.sender].push(Claim(key, value));
  }

  function getClaims(address account) external view returns (Claim[] memory) {
    return identityClaims[account];
  }
}

Step 7: Updating the Tests

Open the identity.js file in the test directory.

Modify the test code as follows:

const { expect } = require("chai");
const { ethers } = require("hardhat");
const getCeloKit = require("../celo");

describe("Identity", function () {
  let identity;
  let accounts;
  let kit;

  before(async function () {
    kit = getCeloKit();
    accounts = await ethers.getSigners();
    const Identity = await ethers.getContractFactory("Identity");
    identity = await Identity.deploy();
    await identity.deployed();
  });

  it("should verify an account", async function () {
    const [account] = accounts;
    await identity.verify(account.address);
    const isVerified = await identity.isVerified(account.address);
    expect(isVerified).to.be.true;
  });

  it("should add a claim", async function () {
    const [account] = accounts;
    await identity.verify(account.address);
    const key = "name";
    const value = "Alice";
    await identity.addClaim(key, value);
    const claims = await identity.getClaims(account.address);
    expect(claims).to.have.lengthOf(1);
    expect(claims[0].key).to.equal(key);
    expect(claims[0].value).to.equal(value);
  });
});

Step 8: Running the Tests

Open your terminal and navigate to the root directory of your project.
Run the tests using the following command:
```
npx hardhat test
```

If all goes well, both tests should pass, confirming that the additional claim functionality has been implemented successfully.

Step 9: Deploying the Contract

Open the hardhat.config.js file in the root directory of your project.
Modify the networks section of the configuration as follows:
```
module.exports = {
  solidity: "0.8.4",
  networks: {
    hardhat: {},
    alfajores: {
      url: "https://alfajores-forno.celo-testnet.org",
      accounts: [YOUR_PRIVATE_KEY],
    },
  },
};
```
Replace YOUR_PRIVATE_KEY with your Celo testnet private key. Ensure that you keep your private key secret and do not commit it to a public repository.
Save the file.

Step 10: Deploying the Contract to the Celo Testnet

Open your terminal and navigate to the root directory of your project.
Run the following command to deploy the contract to the Celo testnet:
```
npx hardhat run --network alfajores scripts/deploy.js
```

This command will execute a deploy script. Create a new directory named scripts in your project’s root directory and create a new file named deploy.js inside the scripts directory. Add the following code to the deploy.js file:

const main = async () => {
  const [deployer] = await ethers.getSigners();
  console.log("Deploying contracts with the account:", deployer.address);

  const Identity = await ethers.getContractFactory("Identity");
  const identity = await Identity.deploy();
  await identity.deployed();

  console.log("Identity contract deployed to:", identity.address);
};

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });

After successfully executing the deployment script, you will see the deployed contract address logged to the console.

Congratulations! You have now built a decentralized identity system on Celo using Hardhat and Celo ContractKit. You have also learned how to deploy the contract to the Celo testnet.

Feel free to explore further and enhance the functionality of your decentralized identity system.

What’s Next?

Expand on Identity Mechanisms: Improve your contract to support more features like identity verification, revocation, and recovery.
User Interface: Develop a user-friendly interface using front-end frameworks like React, Angular, or Vue, and connect it to the blockchain using ContractKit.
Integrate with Other Protocols: Explore other protocols in the Celo ecosystem and see how they can be used with your identity system.
Optimize and Secure Your Smart Contract: Improve your smart contract code to minimize gas costs and ensure it is secure against common attacks.

About the Author

Elijah Sorinola

Web3 technical writer with a passion for communicating complex technical concepts in a clear and concise manner. Let’s connect on LinkedIn to discuss your content needs.

References

Elijah007 · May 17, 2023, 9:01pm

@Celo_Academy @joenyzio Just finished working on this. What do you think?

yafiabiyyu · May 18, 2023, 2:40am

@Elijah007 Do you need a reviewer? If so, I can help to do a review

Elijah007 · May 18, 2023, 1:20pm

Yes, @yafiabiyyu kindly review this.

yafiabiyyu · May 18, 2023, 1:22pm

@Elijah007 Okay, I’ll review now

yafiabiyyu · May 18, 2023, 1:42pm

Review results

1.You can use code block for file name or function name.
2. In the ‘Whats Next’ section, at point 7, you forgot to use a closing bracket.
3.Please add a repository of the code you used in this tutorial.

overall it’s good, and only 3 points above in my opinion need to be fixed @Elijah007

Elijah007 · May 18, 2023, 2:20pm

I’ll link the repro now. Not sure I understand the first point. Can you kindly explain? Thanks @yafiabiyyu

yafiabiyyu · May 18, 2023, 2:36pm

Here is an example for the first point: change identity.js to identity.js so that readers can distinguish between them more easily.

Elijah007 · May 19, 2023, 2:51pm

Done. Sorry for the late reply. Had a family emergency. @yafiabiyyu

yafiabiyyu · May 19, 2023, 3:12pm

oh yes it’s okay, I’m ready to wait for news from you

yafiabiyyu · May 19, 2023, 3:28pm

Okay, it’s ready to be published for your tutorial content

Elijah007 · May 19, 2023, 3:41pm

oh great! @yafiabiyyu