Forem: Edwin Anajemba

Using Thirdweb and Hardhat to create and deploy a dApp on the Goerli testnet.

Edwin Anajemba — Fri, 13 Jan 2023 09:10:31 +0000

Technologies

Thirdweb: A tool for creating, deploying, and managing dApps on the Ethereum blockchain
Hardhat: A development environment for Ethereum smart contract development

Steps

First, we need to create a new contract using Thirdweb. Run this command in your terminal: npx thirdweb@latest create --contract.
Next, we need to install the dotenv package to manage our environment variables. Run this command: npm install dotenv.
We will also need to get our private key from MetaMask and the endpoint from https://www.ankr.com/rpc/eth/eth_goerli/.
In the hardhat.config.js file, add the following code to connect to the Goerli testnet and use your private key:

defaultNetwork: 'goerli',
networks: {
hardhat: {},
goerli: {
url: '[https://rpc.ankr.com/eth_goerli](https://rpc.ankr.com/eth_goerli)',
accounts: [0x${process. env.PRIVATE_KEY}]
}
},

Now we can deploy our contract by running the command npm run deploy.
Once the deployment is successful, you will see a link to deploy your contracts on Thirdweb. Open the link and follow the instructions to deploy your contract.
For the client-side of the application, we will create a new app using Thirdweb. Run this command: npx thirdweb@latest create --app.
Select the app name, EVM, and JavaScript as the preferred stack.
Now we will install React Router DOM and check our build so far by running npm install react-router-dom and npm run dev respectively.
Next, delete the src folder and create a new one. Inside the new src folder, create an index.js file and an App.js file.
Use the React functional component file (RAFCE) snippet to create the App component.
Convert the index.js file to main.jsx and App.js to App.jsx
To add styling, we will install and configure Tailwind CSS with Vite. Run these commands:

npm install -D tailwindcss postcss autoprefixer
npx tailwindcss init -p

In the tailwind.config.cjs file, add the desired theme, and extend the font family and box shadow.
In the postcss.config.js file, add the tailwindcss and autoprefixer plugins.
In the index.css file, import the tailwindcss base, components, and utilities.
Finally, run npm run dev in the terminal and your dApp should be up and running.

That's it! You have successfully created and deployed a dApp using Thirdweb and Hardhat. With this setup, you can easily create, deploy and test your dApps on the Goerli testnet. Remember that this is just a basic setup and can be further customized to suit your specific needs. Happy coding!

Understanding File Structure for Backend API development using NodeJS, Express, and PostgreSQL

Edwin Anajemba — Thu, 12 Jan 2023 22:44:53 +0000

Backend API development is an essential part of building modern web and mobile applications. In this article, we will be discussing the file structure for backend API development using Express and PostgreSQL. We will also provide a sample file structure to help you understand how to organize your code effectively.

Express is a popular web framework for Node.js that allows developers to easily create and manage web servers and handle HTTP requests. PostgreSQL is an open-source, object-relational database management system (ORDBMS) that is commonly used with Express to store and retrieve data.

When building a backend API using Express and PostgreSQL, it's important to organize your code in a logical and easy-to-understand way. One way to do this is by separating your code into different layers: the routing layer, the controller layer, and the model layer.

The routing layer is responsible for handling HTTP requests and directing them to the appropriate controllers. This layer contains all the routes for your API and is usually defined in a single file called "routes.js".
The controller layer is responsible for handling the logic of your API. This layer contains the controllers that handle the requests from the routing layer and interact with the model layer. Each controller is usually defined in its own file and is organized into a "controllers" directory.
The model layer is responsible for interacting with the database. This layer contains the models that define the data structure and perform the database operations. Each model is usually defined in its own file and is organized into a "models" directory.

Here's an example of a sample file structure that follows this organization:

-root
    - controllers
        - users.js
        - posts.js
    - models
        - users.js
        - posts.js
    - routes
        - api.js
    - config
        - database.js
    - app.js
    - package.json

In this example, the "controllers" directory contains the controllers for "users" and "posts", the "models" directory contains the models for "users" and "posts", the "routes" directory contains the routing file "api.js", the "config" directory contains the file "database.js" which have the configuration for connecting to PostgreSQL, and the "app.js" file is the entry point of the application where all the dependencies are imported and the server is started. The "package.json" file contains all the dependencies and scripts needed to run the application.

It is important to note that this is just a sample file structure and it may vary depending on the specific requirements and complexity of the project. Additionally, as the project grows, it is a good practice to keep adding more layers and directories to make the code more modular, maintainable, and scalable.

In summary, a well-organized file structure is crucial for effective backend API development using Express and PostgreSQL. By dividing your code into different layers such as routing, controller, and model, you can increase the modularity, maintainability, and scalability of your code. The sample file structure outlined in this article serves as a guide but can be tailored to meet the unique needs of your project.

How To Build a dApp in Three Steps

Edwin Anajemba — Thu, 12 Jan 2023 22:25:42 +0000

Decentralized applications, or Dapps, are a new way of creating software that utilizes blockchain technology to provide a more secure and transparent environment for users. Building a dApp can seem daunting, but it can be broken down into three simple steps: creating the smart contract, deploying the smart contract, and creating the frontend application.

Requirements

Please ensure you have the following installed:

Step One: Creating the Smart Contract

The first step in building a dApp is creating a smart contract. A smart contract is a self-executing contract that contains the rules and regulations of dApp. It is written in a programming language that is compatible with the blockchain platform being used. For example, if building on the Ethereum blockchain, the smart contract will be written in Solidity.

When writing the smart contract, it's important to consider the functionality and security of the dApp. The smart contract should be tested and reviewed by a team of developers to ensure that it is secure and free of errors.

pragma solidity ^0.8.0;

contract MyDapp {

uint256 public counter;

function incrementCounter() public {
counter++;
}

function getCounter() public view returns (uint256) {
return counter;
}
}

This is a simple example of a smart contract written in Solidity. It has two functions, "incrementCounter" and "getCounter", which allow users to increment and retrieve the value of a counter variable.

Step Two: Deploying the Smart Contract

Once the smart contract is written, it needs to be deployed to the blockchain. This is done using a development framework such as Truffle. The smart contract is compiled and then deployed to the blockchain using the "truffle migrate" command. This command will deploy the smart contract to the blockchain, making it accessible to users.

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

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

This is an example of a Truffle migration file that is used to deploy the "MyDapp" smart contract to the blockchain. It uses the "artifacts.require" function to import the compiled contract and the "deployer.deploy" function to deploy it to the blockchain.

Step Three: Creating the Frontend Application

The final step in building a dApp is creating the frontend application. The frontend application is the user interface of the dApp and allows users to interact with the smart contract. It can be built using JavaScript, HTML, and CSS. The frontend communicates with the smart contract through a web3.js library, which allows developers to interact with the blockchain.

<!DOCTYPE html>
<html>
<head>
<title>My DApp</title>
</head>
<body>
<h1>My DApp</h1>
<p>Counter: <span id="counter"></span></p>
<button id="increment-button">Increment Counter</button>
<script src="[https://cdn.jsdelivr.net/npm/web3@](https://cdn.jsdelivr.net/npm/web3@)1.2.9/dist/web3.min.js"></script>
<script>
// Connect to the blockchain network
if (typeof web3 !== 'undefined') {
web3 = new Web3(web3.currentProvider);
} else {
// set the provider you want from Web3.providers
web3 = new Web3(new Web3.providers.HttpProvider("**[http://localhost:8545](http://localhost:8545/)**"));}
// Set the address of the deployed smart contract
const contractAddress = '0x...';
const contract = new web3.eth.Contract(contractABI, contractAddress);
// Update the counter value on the page
contract.methods.getCounter().call().then(function(counter) {
document.querySelector('#counter').innerHTML = counter;
});
// Add event listener to the increment button
document.querySelector('#increment-button').addEventListener('click', function() {
contract.methods.incrementCounter().send({from: web3.eth.defaultAccount}).then(function() {
contract.methods.getCounter().call().then(function(counter) {
document.querySelector('#counter').innerHTML = counter;
});
});
});
</script>
</body>
</html>

This is an example of a simple HTML, CSS, and JavaScript frontend application that interacts with the deployed smart contract. It uses web3.js library to connect to the blockchain network and the address of the deployed contract. It also has a button that when pressed, it will call the "incrementCounter" function of the smart contract, and updates the counter value displayed on the page.

To summarize, building a dApp involves creating a smart contract, deploying it to the blockchain, and creating a frontend application. It's a process that requires knowledge of blockchain technology, smart contract programming and web development. With the right team and tools, it is possible to create a robust, secure, and user-friendly dApp that can change the way we interact with the internet.

Non-Blockchain Dapps

Edwin Anajemba — Thu, 12 Jan 2023 20:45:43 +0000

Decentralized applications (dapps) are software programs that run on a decentralized network, rather than a single central server. While most dapps are built on blockchain technology, there are also non-blockchain dapps that use other types of decentralized systems to function.

One example of a non-blockchain dapp is a distributed file storage platform like IPFS (InterPlanetary File System). IPFS uses a peer-to-peer network to store and share files, rather than relying on a centralized server. This allows for more robust and secure file storage, as well as faster file transfer speeds.

Another type of non-blockchain dapp is a decentralized social media platform like Mastodon. Mastodon is an open-source, federated platform that allows users to create their own social media networks. These networks can then be connected to one another, creating a decentralized social media ecosystem. Mastodon uses a peer-to-peer network rather than a centralized server, which provides users with more control over their data and greater privacy.

There are also non-blockchain dapps using distributed ledger technology (DLT) other than blockchain. For example, Hashgraph is a DLT that uses a directed acyclic graph (DAG) structure rather than a blockchain. This allows for faster and more efficient transactions and can be used in a variety of dapps such as supply chain management and voting systems.

A non-blockchain dapp that utilizes distributed hash table (DHT) is another type of dapp. DHT is a decentralized system for storing and retrieving data in a peer-to-peer network. This technology can be used for a variety of applications such as peer-to-peer file sharing and distributed databases.

Non-blockchain dapps also have their own set of advantages and disadvantages. For example, non-blockchain dapps can be faster and more efficient than blockchain dapps, but they also may not be as secure or as decentralized. Additionally, non-blockchain dapps may be more challenging to develop and maintain, as they require specialized knowledge and expertise.

In conclusion, non-blockchain dapps are an important part of the decentralized web ecosystem. They provide alternative solutions for decentralized file storage, social media, and other applications, and can be faster and more efficient than blockchain dapps. However, they also come with their own set of challenges and limitations. As the technology and the ecosystem continue to evolve, it will be interesting to see how non-blockchain dapps will change and adapt to meet users' needs.

The Problem with Web3 Is… Dapps?

Edwin Anajemba — Thu, 12 Jan 2023 20:06:56 +0000

Web3, also known as the decentralized web, is a concept that aims to create a more decentralized and open internet. One of the key components of web3 is the use of decentralized applications, or dapps, which are built on blockchain technology.

Dapps, or decentralized applications, are one of the key components of web3 and have the potential to revolutionize the way we use the internet. Unlike traditional apps, dapps are built on blockchain technology, which allows them to be decentralized and open to anyone. This means that dapps can provide users with more control over their data and greater transparency in how their information is used.

While dapps have the potential to revolutionize the way we use the internet, they also come with a number of problems. One of the biggest issues is the lack of user adoption. Despite the hype around dapps, most people have never heard of them or have no idea how to use them.

Another technical challenge is the complexity of building and deploying dapps. Unlike traditional web development, dapp development requires a deep understanding of blockchain technology and smart contract programming. This can make it difficult for developers to create and maintain dapps, which can slow down the development of the ecosystem. However, with the emergence of new development frameworks and toolkits, this is becoming less of a problem.

Security is also a major concern with dapps. Because they are built on blockchain technology, dapps are decentralized and therefore vulnerable to attacks. Hackers can target dapps and steal users' personal information or money, which can be devastating for both the users and the developers.

Finally, there is the issue of regulation. Dapps are built on blockchain technology, which is decentralized and therefore difficult to regulate. This means that there is a lack of oversight and protection for users, which can lead to fraud and other criminal activities.

In conclusion, while dapps have the potential to revolutionize the way we use the internet, they are also facing a number of challenges. User adoption, scalability, security, and regulation are all major issues that need to be addressed before dapps can become mainstream.