Forem: Drayfocus

Best Practices for Building API Gateways in a Microservice Architecture

Drayfocus — Mon, 18 Jul 2022 20:08:53 +0000

In a microservice architecture, the API gateway is a centralized hub that aggregates and distributes information from various services It is the main entry point for all microservices in the architecture that communicates with all other microservices, parses incoming requests and responses, and then routes them to the appropriate services. It also allows clients to access the application via HTTP, forming a layer between the client and the rest of the microservice architecture.

API gateways provide three main services:

Authentication - The apigateway authenticates users and handles authorization. This means that it controls who can access the application.
Authorization - The apigateway handles authorization for requests from clients, ensuring that they can only perform operations allowed by their role or permission level.
Routing - The apigateway routes requests to appropriate microservices based on their path, as defined by a routing table definition.

Benefits of building API gateways.

It can handle authentication, authorization and logging for multiple microservices
It provides a common platform for data consumption by different microservices
It ensures standardized communication between microservices
It can be used to cache data, which improves response time by reducing network latency and bandwidth usage
You can easily scale your application horizontally and vertically by deploying multiple instances of the API gateway

Best practices for setting up an effective API gateway.

Here are 5 best practices you can put in place to build an effective API gateway system.

1. Setup a Network Handler

This is a substantial setup for an API gateway. A network handler is a piece of code that is in charge of sending and retrieving data from other microservices. It communicates directly with the Rest API exposed by each microservice.

2. Consider Direct Database Queries

Direct Database Queries are used to retrieve data from a microservice database using a database user who has read-only access. This works best when the microservices use SQL databases, which allow for complex join queries. This might be a good idea when you need to combine query results from multiple microservices, doing so over the network handler can be expensive.

3. Setup a Data Aggregator

A data aggregator's purpose is to collect data from Network Handler or Direct DB queries, process or modify it, and package it in a format that can be sent to a client.

4. Implement caching into your Network Handler

Caching is essentially a method for your API gateway to save information about all previous requests so that if you receive another request with the same parameters, the gateway will know not to go through the process of actually making the call. Instead of making another call, it will simply retrieve the data from its cache memory and return it because fewer calls are made overall, the load on your servers is reduced, which improves performance and lowers costs.

In your network handler, caching occurs during the GET request and is then cleared or updated during the POST, UPDATE, or DELETE request. Caching should also be made optional for GET requests containing data that is likely to change frequently over time.

5. Implement event based request in your Network Handler

There are two types of requests you can make through your network handler: synchronous and asynchronous. Synchronous requests necessitate the network handler waiting for a response before proceeding with its own processes. Asynchronous requests do not necessitate the network handler waiting for a response before going about its business.

You can create asynchronous requests using event-based request functionality without sacrificing functionality or performance. This functionality is best suited for PUT, POST, or DELETE requests that do not require an immediate response.

Conclusion.

So far, you have learned that API gateways are single points, the benefits of building API gateways, and lastly, 5 tips to building effective API gateway systems which are:

Setting up a Network Handler
Using Direct Database Queries
Setting up a Data Aggregator
Implementing caching into your Network Handler
Implementing event based request in your Network Handler

Bonus.

I decided to make a simple template generator for API Gateways. This template generator implements all of the suggestions made in this article. The template generator is available on github.

In the meantime, the template generator only works for PHP projects; a NodeJS version is in the works. If you can help build for other languages like Python, Go, and so on, please contact me on Twitter at drayfocus.

You can connect to me on Twitter @drayfocus, and Linkedin Akinola Ayomide

Cheers!

Five ways to optimize your backend APIs in a microservice architecture

Drayfocus — Sun, 10 Jul 2022 09:26:59 +0000

In the beginning, there was the monolith. And it was good. You had one application, with a single code base, and it did everything you needed.

But then your business grew, and so did your code base. It started to get hard to manage and maintain, so you split it into multiple services. Then you split those up into even smaller services because each of those new services had their own code base and database.

This is what we call microservice architecture. It's an architectural style where your application is made up of lots of small services (microservices) that work together. Each microservice has its database, programming language, and the team responsible for maintaining it — but they don't have access to any other microservices in the system.

Building a backend system in your microservice architecture is froth with a few problems, so in this article, you are going to learn how to optimize your APIs in a backend service, and address some problems you are likely going to face.

What is API optimization?

API optimization is a process that can be used to improve the performance of your application. Optimizing your API can help reduce latency, decrease response times and improve the user experience.

Why should you optimize your API?

By optimizing your API, you will be able to:

Shorten the amount of time it takes developers to integrate with your API.
Reduce the amount of code required to integrate. This will save you money and increase developer productivity.
Reduce the number of bugs in your API to improve user satisfaction and save money on support costs.
Serve a large number of users who are using your API with various devices, browsers, and networks.

Five ways to optimize your backend APIs in a microservice architecture

When developing your backend APIs in a microservice architecture, some optimizations must be made to improve application performance. Here are some ideas to help you get there.

1. Use the APIGateway pattern instead of directing clients to multiple microservices.

The direct client to multiple microservices patterns allows one client to communicate with multiple microservices by connecting directly to their backend APIs.

One significant disadvantage of this pattern is that it can be difficult to manage the overall architecture. This is because you must configure all of the communication between each of your clients and each service, which can be time-consuming and error-prone.

Another disadvantage is that it does not scale well. When there are too many microservices, it becomes more difficult for your clients to communicate with each one, slowing their ability to send requests and receive responses from each one. This may imply that your system isn't capable of handling as much traffic as it could. Also, security may be an issue in this pattern because all of your microservices are exposed to external API access, exposing your application to multiple points of attack.

An API gateway pattern, on the other hand, is a microservice pattern that enables different microservices to work collaboratively in a distributed system. The API gateway pattern is made up of two parts: the gateway and the API clients. The gateway is in charge of receiving client requests, processing them, and responding to them. The client is in charge of sending requests to and receiving responses from the gateway.

The pattern allows you to build an API gateway that receives calls from other microservices and responds to them on their behalf. The API gateway has its own set of rules and policies that it enforces to ensure that only the appropriate calls are made to the appropriate microservices.

With this pattern, all of your microservices are protected within an internal API system, with only the API Gateway exposed to the outside world. It improves each microservice's autonomy, scalability, and deployment flexibility.

2. Use one database per service instead of a shared-database pattern.

The shared-database pattern is a microservice architecture that employs a shared database to establish a single point of data truth. Because the same database is used across the microservices, you can perform complex queries on the data. While this works well for small applications, it can become complicated for larger ones. For example, if one microservice changes its database schema, other microservices may need to be notified so that they can update their database schema accordingly. There is also a single point of failure for your application because if the database fails, all of your services fail. Because all database workload from all of your microservices is routed to a single database, your API performance may suffer.

The Database-per-Service pattern is one in which each microservice has its database that is configured to be isolated from the others. Each microservice has its database, which can only be accessed by the microservice to which it belongs. This prevents the various databases from interfering with each other or becoming mixed up, making it easier to manage and keep them clean. This pattern directs all database workloads to their respective databases, making it easier to maintain and scale.

Data from each service can only be accessed through the API provided by the service. While this may be fine for backend systems that do not require complex data queries across multiple microservice data sets, it can lead to "API Hell" for those that do.

3. Avoid “API Hell”.

API Hell is a microservice API architecture design pattern in which a single data query action requires multiple API requests to multiple microservices. The network latency that exists when making network requests to other microservices, as well as the n+1 issues that may arise when combining queries for different microservices, make this approach a bad idea.

In an e-commerce application, for example, you might want to get all users' orders and order delivery information. The User microservice holds your users' data, the Order microservice holds your orders, and the Delivery microservice holds your delivery information. To obtain the final data, first, request the User microservice to obtain the users (n), then for each user, obtain their orders from the Order microservice (n+1), and finally, obtain their delivery information for each order (n+2). Keep in mind that each data request requires an API call. While this may not be noticeable when dealing with small amounts of data, it can cause a significant drop in API performance as your data grows. So, how do you solve this?

Here are some approaches you can take to deal with this:

- Duplicate your data:

You can choose to make a copy of the database table that contains related data between microservices. Create a system that updates each copy of the database table when the original table is updated. This allows you to easily combine those data and create your complex query.

The problem with this approach is that it does not ensure data consistency and integrity. Data updates will not be real-time, and any problems that cause a failure in the update of other copies of a database will cause them to be out of sync with inconsistent data.

- Directly read microservices databases from your API Gateway.

You can delegate the heavy lifting to your API gateway. For SQL databases used by microservices, you can create a new read-only database user that reads and combines database tables from different microservices and performs complex join queries at the database level. You can avoid the n+1 problem and data inconsistency issues while still retaining the flexibility and scalability that microservices provide. Data integrity can be ensured because ApiGateway access is read-only, and updates to the database can only be made by the microservice that owns it.

The temptation to move some business logic to the APIGateway is a problem with this approach. You should avoid this at all costs because you undermine the purpose of microservices. Only queries that are not microservices specific should be directed to your APIGateway's database query modules. Database write actions (update, create, and delete) and complex microservices-specific actions are still routed through the API to the appropriate microservice.

4. Implement event-based actions.

Microservices rely heavily on event-based actions. They enable the microservice to sync with other services as needed, reducing overall system latency. This is especially important when multiple services are involved in an interaction, or when working on an application that requires quick action and response times. Client requests to your API Gateway can trigger events, which are then handled by the corresponding microservice.

5. Implement Cache

Caching can be used in a microservice architecture to improve performance and scalability by reducing the number of API calls made to backend services. It's especially useful if your application receives a lot of traffic or needs to handle a lot of requests per second. Requests to other microservices that do not return frequently changing data, such as a list of countries or regions, can be cached on your APIGateway. Instead of making API requests to the microservice every time, your APIGateway can easily get this data from the cache.

Conclusion

So far, you’ve learned about API optimization for microservice architecture. You understood why you need to optimize your APIs and got introduced to five ways to optimize your APIs which include:

Use the APIGateway pattern instead of directing clients to multiple microservices.
Use one database per service instead of a shared-database pattern.
Avoid “API Hell”.
Implement event-based actions.
Implement Cache.

You can connect to me on Twitter @drayfocus, and Linkedin Akinola Ayomide

Cheers!

Building a scalable system from the ground up

Drayfocus — Sun, 10 Jul 2022 09:23:47 +0000

There is a lot to be gained from designing a scalable system from the ground up, especially if you are building it for a startup that is still in its early stages and has the potential to grow. As developers, we are frequently faced with the choice of ignoring scalability and building (version 1) faster or incorporating scalability into the system and moving a little slower. Doing it, either way, has no visible effect at first, but as the system grows larger and begins to do more work, the scalability of the system will be put to test.

At Ceedcap, a start-up studio where I work as a software engineer, the majority of my time is spent designing and developing scalable systems for start-up businesses. It can be difficult to create such a system for projects that must move quickly. But, over time, I was able to decipher the code. To explain my approach, I'll use the most recent project I'm working on (Squareroof) as a case study.

Case study: Squareroof- a platform to easily own shares of rental properties.

Goal: To build a system that enables users to buy shares of properties, administrators to manage the platform activities, and collect and analyze real-estate data.

Timeline (Version 1): 5 weeks

Approach:

1. Use a popular project structure and framework

Photo by Mindinventory

A software project structure is a set of rules that determine how your code, files, and folders will be organized. The project structure makes it easier to find things and for new contributors to understand how your project is organized. It also makes it simple for your team to maintain the same organizational approach from project to project.

Using a popular project structure appears to be the obvious approach, but we are often tempted to create our own, especially when our language of choice does not enforce any. For example, if you use Nodejs, use common project templates provided by frameworks such as Express, if you use Python, use Flasks or Django, and if you use PHP, use Laravel, CodeIgniter, and so on.

The benefit of this is that it makes it easier to onboard new developers who will work on the codebase as the product grows. I chose Laravel Lumen for the backend and VueCLI project structure for the frontend for Squareroof.

2. Choose Microservice over Monolithics:

Photo by Krasamo

Monolithic applications contain everything—front-end, back-end, and databases—in a single location. Because all of the application's components are in one place, they are simple to build and deploy. Microservices is a type of architecture that divides a large computer program into smaller, modular programs. It allows each section of your code to operate independently and focus on its functionality while still communicating with other sections as needed.

I've built several monolithic projects that worked well at first but became a pain as the codebase grew and new features were added. It became more difficult to navigate. This also has an impact on the rate at which new features or changes can be implemented.

Splitting the project components into microservices, on the other hand, made the codebase more manageable and easier to navigate. This is in addition to the benefits of long-term scalability.

Microservices can be difficult and time-consuming to set up. However, with the advent of tools such as Docker and Kubernetes, it is becoming easier. For Squareroof, I decided to devote some of my time to developing a system that makes setting up and publishing a microservice as simple as setting up a monolithic application. This was accomplished by developing a common template for the backend microservices and a separate template for the frontend microservices, and then publishing them using the docker and Kubernetes APIs. This made it simple to quickly spin up a new microservice with only a few steps, without sacrificing scalability.

3. Set up CI/CD (Continuous Integration / Continuous Development) Pipeline

Photo by Wallarm

A CI/CD pipeline is a set of processes that allows for frequent, dependable software releases. The process is known as "continuous integration" and "continuous deployment" because it is automated and can be repeated as many times as needed for new features and updates. It allows developers to automate the process of developing, testing and delivering code.

Initially, I didn't see this as a critical step for Squareroof. To publish a new change, I had the habit of logging into the server and manually running each step. As the codebase grew in size, this became more difficult and time-consuming. Then I decided to implement a CI/CD pipeline by writing all of the manual steps into a script and triggered it whenever I made new changes. This not only gave me more time to code but also eliminated deployment errors and mistakes.

Conclusion

Building a system that can scale with the company can be difficult, but it will save you a lot of time and effort in the long run. You should also recognize that it is a journey. One does not simply build a scalable system and then stop; one must continue to improve on the existing system to fit into solving the problem that the product is addressing.

Let's connect on Twitter @drayfocus and on LinkedIn Akinola Ayomide.

Cheers!

Rust Concepts for Writing Solana Programs

Drayfocus — Sun, 10 Jul 2022 09:21:47 +0000

Developers who turn to Solana do so because Solana has the ability to process many transactions per second. This is possible because Solana does not use only Proof-of-Work (PoW) or Proof-of-Stake (PoS) consensus algorithms like Bitcoin or Ethereum do. Instead, it uses an alternative consensus algorithm called Proof-of-History (PoH) which doesn't require massive amounts of energy like PoW or PoS does.

Solana programs can be written in C, C++ and Rust programming languages. These programs are similar to smart contracts in Ethereum. In this article, you will learn some key concepts in Rust you need to know to write solana programs because unlike C and C++, Rust is a low-level language that gives the feel of a high-level language. Rust automatically takes care of low-level operations, but also exposes these low-level operations to developers. This makes Rust language fast, powerful, and easy to write.

Rust Concepts for Solana Programs

Variable ownership
Struct
Vector, String, and HashMaps
Enums and pattern matching
Error handling
Packages, crates, and modules in Rust

Variable Ownership

Rust variables, like any other programming language, have a life that is determined by the scope in which they are defined. This scope can be either local or global. Rust variables can also be mutable, immutable, or shadowed.

Mutable: These variables are assigned using the "let" keyword, and they can be reassigned. They can also be changed if their values are mutable. An example of a mutable variable is one whose value may change during the lifetime of the program. Examine the code below:

let mut greetings = "hello";

greetings = "Hello world";

Immutable: These variables are assigned using the "const" keyword, and they cannot be reassigned at any point in the program. To make an immutable variable, add the "mut" keyword before it. An example of an immutable variable is one whose value will not change during the lifetime of the program. Sample code:

// variables are immutable by default
let greetings = "hello";

// this will throw an error
greetings = "Hello world";

// You can make a variable mutable by adding the
// "mut" keyword

let mut action = "dancing";

// this would work
action = "singing"; 

// variables defined with the "const" keyword cannot 
// be reassigned or made mutable

const MY_ACTION = "Walking";

// this will throw an error
MY_ACTION = "Dancing";

Shadowing: This is simply a way of showing that you want to reassign a variable to a new one in Rust without changing its value or type. It involves declaring another variable with the same name as the old one and assigning it some value or expression that evaluates that value. Sample code:

fn main() {
    let count = 5;

    let count = count + 1;

    println!("The value of count is: {}", count );
}

There are two types of variable ownership in Rust. These types are called, creatively enough, "Owning" and "Borrowing."

An owning variable owns the data it points to, so the data will be destroyed when that variable goes out of scope. Borrowed variables do not own the data they point to, so this data will not be destroyed when that variable goes out of scope.

You can have both owning and borrowing variables referring to the same piece of data, but you cannot have two owning variables or two borrowing variables referring to the same piece of data at the same time. This is because if you had multiple owning variables pointing to a single piece of data and all those variables went out of scope at the same time, Rust wouldn't know which one(s) should be responsible for destroying that piece of data.

It would be like multiple people trying to eat a single hamburger: how do you decide who gets to keep it? Similarly, if two borrowing variables were pointing to a single piece of data and both tried to change it (for example by assigning a new value), Rust wouldn't know which one(s) should "win" over the other(s). This could easily lead to subtle bugs in your program where one borrows. Here is an example below:

fn main() {
  // You can declare your variable here
    let action = String::from("Walking");

// You need to pass the variable into the "calculate_length" function,
// if pass it like this
// let len = calculate_length(action);
// This means you are transferring the ownership of "action" 
// variable to the function "calculate_length",
// this means the variable would no longer be
// available in the "main" function scope again.

// But since you still need to use the variable 
// in the "println!" macro below, instead of transferring ownership,
// you will send a borrowed reference of the 
// variable to the "calculate_length" function.

    let len = calculate_length(&action); 

    println!("The length of '{}' is {}.", action, len);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

Struct

In Rust, a struct is a custom data type that lets you define the data that you'll use in your code. It's a collection of variables (called fields) that can store different kinds of related information.

Let's say you're building an app that lets users create a profile and track their favorite locations to have brunch. You'll want to keep track of each user's name, age, email address, and the number of times they've been to brunch this month. You can combine these variables into one data type called Profile, like this:

struct Profile {

    name: String,

    age: i32,

    email: String,

    times_been_to_brunch: i32

}

You will use Struct to define and structure on-chain data when building Solana programs.

Vector, String, and HashMaps

These are custom variables in Rust and are known as Collections.

Vectors are like arrays. But unlike arrays, they can grow and shrink based on what's added to them or removed from them and you don't have to specify the length when you declare them.

Vectors in Rust are helpful for when you want to store data in a contiguous area of memory. When you create a vector, it allocates memory along a single, continuous region of space that's guaranteed to be big enough to hold the amount of data you're asking it to. The only downside of vectors is that they can only store one type of data and they don't have key-value pairs. In Solana programs, Vectors are used to collect and handle instructions passed into the program. Here is an example of a vector:

 let my_vector = vec![1, 2, 3];

my_vector.push(4);
my_vector.push(5);

Strings are collections of characters—like "Hello world!". They are another way to store data, but unlike vectors, strings are growable. That means you don't have to specify how big they'll be upfront (which is nice if you don't know how much data you'll need). Like vectors, strings can only store one type of data. But unlike vectors, strings are complicated—they're composed of multiple parts which help with things like indexing and slicing. Here is an example:

 let hello = String::from("السلام عليكم");
 let hello = String::from("Dobrý den");
 let hello = String::from("Hello");
 let hello = String::from("שָׁלוֹם");
 let hello = String::from("नमस्ते");
 let hello = String::from("こんにちは");
 let hello = String::from("안녕하세요");
 let hello = String::from("你好");
 let hello = String::from("Olá");
 let hello = String::from("Здравствуйте");
 let hello = String::from("Hola");

HashMaps allows you to use keys and values for storing information. They're kind of like dictionaries: the key is the word and the value is the definition. Unlike strings and vectors, HashMaps can store different types of keys and values. But because keys are stored in buckets (which means the same bucket could contain multiple keys), HashMaps aren't great for keeping track of ordering. Here is an example:

use std::collections::HashMap;

let mut scores = HashMap::new();

scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Yellow"), 50);

Enums and pattern matching

Enums are a way of grouping together different kinds of data. For example, you could have an enum that represents all the possible playing cards in a deck, like:

enum Card {
   Club(u8),
   Spade(u8), 
   Heart(u8), 
   Diamond(u8)
}

pattern matching:If you want to know what the highest-value card is in a player's hand in your card game, you can use pattern matching to write a function that takes a vector of Cards and returns the highest-value one. For example:

fn main() {

let card_at_hand = [
   Card::Club(4),
   Card::Spade(6),
   Card::Heart(3),
   Card::Diamond(11)
]; 

  let highest_card =    find_highest_card(&card_at_hand);

  println!("The largest card is: {:?}", highest_card);
}

#[derive(Debug)]
enum Card {
   Club(u8),
   Spade(u8), 
   Heart(u8), 
   Diamond(u8)
}



  // This function will get the highest card from a vector collection of different cards
  // passed into it as an argument.
fn find_highest_card(hand: &[Card]) -> Card {

// create a mutable variable that will hold the largest card
// by default you can create a dummy card
     let mut high_card = Card::Club(0);

     let mut highest_number = 0;

     // now lets loop through the card and use 'match' to filter out the 
     // highest card
     for card in hand.iter() {
        match card {
             // if this card matches a club, get its number and check if it is the highest 
             Card::Club(num) if *num > highest_number => {
                 high_card = Card::Club(*num);
                 highest_number = *num;
             },
             // if this card matches a spade, get its number and check if it is the highest
             Card::Spade(num) if *num > highest_number => {
                 high_card = Card::Spade(*num);
                 highest_number = *num;
             },
             // if this card matches a heart, get its number and check if it is the highest
             Card::Heart(num) if *num > highest_number => {
                 high_card = Card::Heart(*num);
                 highest_number = *num;
             },
             // if this card matches a diamond, get its number and check if it is the highest
             Card::Diamond(num) if *num > highest_number => {
                 high_card = Card::Diamond(*num);
                 highest_number = *num;
             },
             // if the card doesn't fit any of the above conditions, do nothing
             _ => ()
        }

     }

     return high_card;
}

In the Solana program, Enum is useful for matching instructions to the right function that would execute the instruction. It works like a web router in many web programming frameworks.

Error handling

Rust has a fairly simple set of tools for error handling.

Rust has a very simple mechanism for handling errors: the Result type, which is an enum that can have either an 'Ok' or an 'Err' variant. Result types can be used in conjunction with functions that have returned, and when those functions are called, the return value of the function will be a Result type. Below is an example of how this works with a couple of functions with the first function returning an integer:

fn add(a: i32, b: i32) -> i32 {

a + b

}

This function will return an integer when you call it, but if you wanted to use it in a situation where the user could input something other than an integer, you can adjust the function to return a Result instead:

fn add(a: i32, b: i32) -> Result<i32> {

Ok(a + b)

}

In Solana programs, you will use the 'Ok' and 'Err' variants of the Result Enum to handle return results or handle errors.

Packages, crates, and modules in Rust

Packages help developers organize their libraries and modules help us organize our code.

Packages are collections of crates. These *crates * are "libraries" or "modules" that can be linked to other crates. Crates have a special root module named after the crate's base directory which contains all the public items in the crate. A single crate can contain multiple files, but there can only be one crate per directory.

Rust has two kinds of crates: binary and library. The main function inside of a binary crate will be compiled into an executable file that runs as a stand-alone file. Binary crates cannot be linked to other crates as library crates can. Instead, they will be run from the command line with the command ".exe". Library crates cannot contain any main functions and will instead be compiled into a ".dll" file (on Windows) or ".so" file (on Unix). The .dll or .so file contains code that is linked to other library crates for use by others.

You will make use of many Solana libraries when building a program, which will provide some helper functions that would make building easier.

Conclusion

In the article, you learned about concepts in Rust used in writing Solana Programs. Concepts such as :

Variable ownership
Struct
Vector, String, and HashMaps
Enums and pattern matching
Error handling
Packages, crates, and modules in Rust. For further information, you can read Rust documentation. In the next article, you will learn how to build a Solana program and launch it on the Solana test blockchain.

Lets connect on Twitter @drayfocus and on LinkedIn Akinola Ayomide.

Cheers!

I Simply Want To Build

Drayfocus — Sun, 10 Jul 2022 09:15:48 +0000

It all started when I saw a mud house project at school. I was only five years old, and I remember being astounded. The mud house was about the height of a red-paint bucket, had a green aluminum roof, and had four rooms with orange bulbs dangling from the roof each. I took turns with my classmates flipping the bulb switches, our excitement going through the roof anytime the orange light came on.

This project sparked my curiosity so much that I decided to build my own. I spent the majority of my childhood and adolescence attempting to do so. I recall spending the money I received for my 16th birthday on building materials (cardboard, gum, cartons, and so on).

I tried numerous times to replicate the mud house project, but I always failed. It's either that I couldn't figure out how to make it work or that I ran out of resources to do so.

When I was 18, I became interested in programming. A friend recommended it to me. He told me I could build things with it. I was intrigued because I had always wanted to build something. I resolved to find out how I could do so.

I've spent the last five years of my life learning and building websites. I adore the fact that I can build anything I want using only my PC. I am no longer limited by how many resources I can obtain, but rather by how much I can imagine. Every day, I jump out of bed, eager to explore my world of limitless possibilities.

Not only do I want to build things, but I also want to build them well. This motivates me to learn about a variety of programming languages, frameworks, and software development domains. I currently have experience with front-end development, backend development, mobile app development, and DevOps.

Programming inspired me to create software, but I still want to do more. I'm hoping that one day I'll be able to build my mud house project.

I love creating things. Let's talk about it if that's something you're interested in.

Twitter - @drayfocus

LinkedIn - Ayomide Akinola

Cheers!

Introduction to Rust Programming for Solana

Drayfocus — Sun, 10 Jul 2022 09:12:45 +0000

Solana programs can be written in C, C++ and Rust programming language. These programs are similar to smart contracts in Ethereum. C and C++ are low-level languages because many computer low-level operations like memory management are not done automatically, but they are much faster than high-level languages like Python, Javascript, PHP and so on, which take care of low-level operations automatically. On the other hand, Rust is a low-level language that gives the feel of a high-level language. Rust automatically takes care of low-level operations, but also exposes these low-level operations to developers. This makes Rust language fast, powerful, and easy to write.

This article is part of a series and in the article series, I will introduce some basic concept of Rust programming that is needed to successfully write a solana program. For this article I will address the following:

Installing Rust and Cargo
Writing your first Rust program
Rust common programming concepts

Installing Rust and Cargo

We need to have Rust installed on our machine to run Rust code. To install Rust, follow this installation documentation.

Once you are done with the installation, type this in your terminal

rustc --version

This prints out the Rust compiler version installed.

Rust, like many other low-level languages, has to be compiled to machine language before running. Rustc is responsible for that.

Cargo, rust equivalent to Javascript's NPM and PHP's Composer is also installed when you install Rust. Apart from package (also know as crate) management, cargo is used to improve Rust development flow, such as compiling and running code with a single command and setting up a new Rust project with a standard folder structure.

To confirm Cargo was installed on your machine run,

cargo --version

This should print out the cargo version installed.

Write your first Rust program

To get started, open your terminal to the folder you want your program to be. Then create a new program using this command

cargo new my_first_program

This should print this

Created binary (application) `my_first_program` package

You will see a new folder named "my_first_program" created in your present folder. Open the "my_first_program" folder in your favourite code editor. For me, I use VSCode, here is the content of my folder,

The file "Cargo.toml" is similar to package.json in Javascript or composer.json in PHP. It is used to manage rust dependecies in your program.

[package]
name = "my_first_program"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

Inside the "src" folder, you have "main.rs" file. Rust files end with .rs extension. This main.rs is the entrypoint of the program, similar to index.js in Javascript. It contains a function "main",

fn main() {
    println!("Hello, world!");
}

"fn" is used to define a function in Rust, and "printIn!" marco is similar to console.log() in Javascript or print() in python.

Now that you have your first program setup, let's run it. Open your teminal and make sure it is on your program directory, then run

cargo run

This command will compile your code then run it. The output should be similar to this

 Compiling my_first_program v0.1.0 (/home/dray/www/Rust/my_first_program)
    Finished dev [unoptimized + debuginfo] target(s) in 1.25s
     Running `target/debug/my_first_program`
Hello, world!

Or you can also try it out on this interactive code editor.

%[https://codepen.io/drayfocus/pen/GROXbxx]

Congratulations! You just built your first Rust program. To build a complex Rust program, you will need to understand how to use variables, functions and other programming concepts in Rust.

Rust common programming concepts

Like every programming language, Rust makes use of common programming concepts like:

Variables
Constant
Function
Loops
Control flow

Let's explore each concepts

Variables

Variables in Rust are defined with the "let" keyword. For example

let x = 4;

let y = "hello world";

In Rust, there are two types of variable datatype. Scalar and compound datatypes.

Scalar datatypes

Scalar datatypes are datatypes that holds just a single value. Here are some Rust scalar datatype:

Intergers Integers are numbers that can either be positive or negative. Unsigned integers can only take positive values (so no need of adding + or - sign, because they will always be positive), while signed interger can take both negative and positive values. Integers are also represented by the range of number they can store. For example, a signed 8-bit number can store numbers from -128 to 127 (check here to learn how to make the calculation). Here are some examples of integers in rust

// The default number datatype is u32 (unsigned 32-bit integer)
let my_number = 23;

// signed 32-bit 
let signed_number:i32 = -34;

// unsigned 8-bit
let x:u8 = 49;

// signed 8-bit
let y:i8 = -34;

Floating point number

This datatype holds decimal numbers. It has two types based its bit length, 32-bit (f32) and 64-bit (f64). f64 is the default in rust.

// default is f64
let my_float = 35.41;

// float with f32
let my_other_float:f32 = 23.4;

Boolean Boolean are true or false values.

let my_bool = false

let my_other_boolean:bool = true

String

This datatype is use for storing string values. It used double quotes around its content

let my_string = "My rust program"

Characters

These datatypes are used to store letters and characters, such as alphabets, emojis, Japanese aphabets and so on. It uses single quotes around its content

let my_char = 'Ƶ'

let love_emoji = '❤️'

Compound datatypes

These are datatypes that holds multiple values into one type. They are of two primitive types, tuples, and arrays.

Tuples

Tuples hold multiple datatypes into one. It has a fixed size, that is, it cannot grow or shrink in size.

let my_tuple:(i32,f64,bool) = (-34, 45.23, true);

You can access each item of a tuple by referencing the item's index,

%[https://codepen.io/drayfocus/pen/ZEaqzeR]

Arrays

Array hold many datavalues, but every items in it must be of the same datatype. It also has a fixed size like tuples.

let my_array = [34,5,6,7];

let my_other_array = ["monday","tuesday","wednesday"];

// this array must contain f64 datatype and must have a lenght of 5
let my_another_array:[f64; 5] = [2.3, 45.5, 56.2, 45.1, 45.6];

Items in a array can be obtained by referencing its index,

%[https://codepen.io/drayfocus/pen/dyZgbZy]

Vectors are another compound datatypes in Rust, but they are not primitive datatypes. Vectors are like arrays, in that they only take items of similar types, but they can have a variable size (items can be added or removed).

Functions

Functions in Rust are similar to functions in other programming languages. It is used in executing blocks of code a line at a time. The "main" function is the entrypoint of a rust program, other functions can be called in the main function.

// in your main.rs

fn main() {
    println!("Hello, world!");
    my_new_function();
}

fn my_new_function() {
    println!("I was called, and I am working!");
}

Run "cargo run" in your terminal to build and run the code. The output should be similar to this

 Blocking waiting for file lock on package cache
    Blocking waiting for file lock on package cache
   Compiling my_first_program v0.1.0 (/home/dray/www/Rust/my_first_program)
    Finished dev [unoptimized + debuginfo] target(s) in 37.28s
     Running `target/debug/my_first_program`
Hello, world!
I was called, and I am working!

or run it on this interactive code editor

%[https://codepen.io/drayfocus/pen/oNoavyg]

Functions can also take parameters and these parameters needs to be typed

fn main() {
    my_func_para(34.3, 45);
}

fn my_func_para(para1: f32, para2: u32) {
    println!("First parameter: {}", para1);
    println!("Seconde parameter: {}", para2);
}

On interactive code editor

%[https://codepen.io/drayfocus/pen/qBVJWMW]

Functions can also return data. This returned data needs to be typed

fn main() {
    println!("5 multiple by 2: {}", multiply_by_two(5));
    println!("60 divided by 5: {}", divide_by_five(60));
}

// with the return keyword and semicolon
fn multiply_by_two(x: u32) -> u32 {
    return x * 2;
}

// without the return keyword and semicolon
fn divide_by_five(y: u32) -> u32 {
    y / 5
}

On the interactive editor

%[https://codepen.io/drayfocus/pen/ExbdYOz]

Loops

Loops are used to run a block of code in a repeated manner. There are three type of loops in Rust: loop, while loop, for loop.

fn main() {
    loop_example();
    while_loop_example();
    for_loop_example();
}

fn loop_example() {
    // create a mutable variable.
    // Variables are immutable by default, so we need to add the mut keyword
    // to make it mutable
    // I will explain the concept of variable mutability and referencing
    // in the next article.
    let mut counter = 0;

    // create a loop
    let result = loop {
        // repeatedly add one to counter
        counter += 1;
        // break out of the loop if counter equals 10
        if counter == 10 {
            break counter;
        }
    };

    println!("The result is {}", result);
}

fn while_loop_example() {
    // create a mutable variable
    let mut counter = 5;

    // while counter is not equal to 0, run the block of code
    while counter != 0 {
        println!("counter is: {}", counter);
        counter -= 1
    }

    // counter is now zero, this will run!
    println!("Counter is empty!");
}

fn for_loop_example() {
    // create an array
    let my_items = [4, 5, 7, 2, 7];

    // loop through all the array items
    for item in my_items {
        println!("for loop item: {}", item);
    }
}

In an interactive code editor

%[https://codepen.io/drayfocus/pen/ZEaqEzP]

Control flow

Control flow are used to control the condition at which a block of code should execute. In Rust, control flow is done using if and if else statement and else if statement

fn main() {
    if_else_example();
    else_if_example();
}

fn if_else_example() {
    let my_value = 2;

    if my_value > 1 {
        println!("I am greater than {}", my_value);
    } else {
        println!("I am less than {}", my_value);
    }
}

fn else_if_example() {
    let my_value = 4;

    if my_value == 1 {
        println!("Value is 1");
    } else if my_value == 2 {
        println!("Value is 2");
    } else if my_value == 3 {
        println!("Value is 3");
    } else {
        println!("Value is 4");
    }
}

In an interactive code editor

%[https://codepen.io/drayfocus/pen/yLPRLeZ]

Conclusion

So far, you have setup your environment for Rust programming, installed Rust compiler, and Cargo. You also wrote your first Rust program and got introduced to common programming concepts that Rust has. In the next article, we will explore other programming concept specific to Rust, like variable ownership, Structs, Enums ( and its special types like Options and Result), Traits and so on.

Let's connect on Twitter @drayfocus, and Linkedin Akinola Ayomide.

Cheers!

Introduction to Solana Blockchain

Drayfocus — Sun, 10 Jul 2022 09:06:14 +0000

Solana is an open-source blockchain system that aims to provide a high-performant, decentralized, secure and scalable system. It was release in April 2019. Solana aims to provide a very fast and scalable system with about 50,000 transactions per second and a maximum of 710,000 transactions per second. This impressively fast system allows the transaction fee to be very low with about $0.00025 per transaction. These are really interesting numbers, but it should also be noted that solana is still less mature when compared to other existing blockchains like Ethereum.

Why does solana exist?

The early blockchain system like Bitcoin and Ethereum are limited in the amount of workload they can process within a given time. For example, bitcoin can process a maximum of 7 transaction per seconds and 30 transactions per second for ethereum. This limitation is responsible for the high transactions fees in the blockchain network, with the average of $60 per transaction for Bitcoin and $65 for Ethereum.

Scalabilty is always at the core of every technology that influences our day to day activities. For instance, Visa processes 1,700 transactions per second on average and can have a maximum of about 65,000 transactions per second. With this in mind, blockchain developers are challenged with creating a system that is decentralized, secure and also scalable. This is where solana comes in.

Difference - Solana and Ethereum blockchains

Solana and ethereum differs majorly in their underlaying technology and consensus mechanism.

Underlaying Technology

Ethereum

Ethereum uses stateful architechture as a mechanism to acheive decentralization. Every transactions in the ethereum blockchain is being transmitted to every nodes on the blockchain in real-time. For example, if I want to send $3 to a friend, the validity of the transaction must be transmitted and updated in all the mining nodes on the ethereum blockchain before the transaction can be valid. This is the major cause of the slow transaction speed in ethereum.

Solana

Solana uses a stateless architechture to acheive decentralization. Every transactions is initially sent to the mining nodes, but there is no need for updating the time the transactions was completed. The time tracking is taken care of by the cryptographical calculations which is made possible by its consensus mechanism (Proof of History).

Consensus Mechanism

Consensus in a blockchain is an agreement protocol to validate that the data about to be added to the blockchain is valid.

Ethereum

Ethereum 1.0 uses the proof of work consensus mechanism. This mechanism ensures that all mining nodes compete to become the leading node (the one that adds a new block to the blockchain) and spends energy by making some high-computational calculations to prove their validity. This is energy consuming and involves a large waste of useful energy. Ethereum 2.0 aims to switch to a better alternative - Proof of Stake. The Proof of Stake is less energy consuming because the leading node is selected at random and also based on its stake ( its total assets on the blockchain).

Solana

Solana uses a combination of Proof of Stake and Proof of History to achieve consensus amongs its validator nodes. The Proof of Stake is similar to that proposed by ethereum 2.0 while the Proof of History helps to support its stateless architechture where the timestamp of each transactions is calculated cryptographically.

The way forward

In the web3 ecosystem, Ethereum is still the most used blockchain in terms of the number of Decentralized applications, Decentralized Finance (DeFi) and Non-Fungible Tokens (NFT) currently hosted on it. That said, solana is one of the fastest growing blockchain for building DeFi , Dapps, and NFTs majorly because of its scalability, fast transaction speed, and low transactions fee.

In the upcoming articles of this series, I will discuss how you can build Web3 apps (NFTs, DeFi and so on) using solana program. Solana program is similar to Ethereum's smart contract but it uses Rust programming language. So, I will also touch on Rust and explain some of the basics concept of Rust you will need to know to build a solana program.

Let's get in touch on Twitter @drayfocus and Linkedin Akinola Ayomide.

Cheers!

Cryptography and its uses

Drayfocus — Sun, 10 Jul 2022 09:02:15 +0000

In 50BC, the roman emperor Julius Ceaser wanted to send secret messages to his generals during the Gallic war. To do that, he converted the plaintext messages to unreadable texts using a process known as cryptography.

Cryptography is coined from the greek word "Krypto" meaning hidden, and "-graphy" meaning writing. It is the study of secret communication using a series of encryption and decryption processes. Encryption is the convertion of human readable data to unreadable data (Ciphertext), while decryption is the conversion of these encrypted data(Ciphertext) to readable data (plaintext).

In this article, we will explore,

How cryptography works
Role of cryptography in Blockchain, and
Other uses of cryptography

How cryptography works

Cryptography makes use of mathematical techniques for secret transmission of private messages usually through an insecure medium. These techniques aim to provide confidentiality, authenticity, and integrity to the message being transmitted.

It achieve confidentiality by converting the plaintext to unreadable text (ciphertext) using encryption algorithms, conserve integrity by using hashing techniques, and authentication using secret keys only known to the communicating parties. These encryption algorithms are of two types:

Symmetric encryption
Asymmetric encryption

Symmetric encryption

Symmetric encryption involves the use of a single secret key to encrypt and decrypt data. For this to work, both the sender and reciever must share the same key. An example of symmetric encryption is the Ceaser Cipher. In Ceaser Cipher, the letters D to Z are encrypted by letters that comes three times latter that them
in the alphabet. While the remaining letters A, B, and C are represented by X, Y, and Z respectively. Here, the secret key is the shift key - "3". For example

Plaintext - "You can now attack"

Ciphertext - "Vlr zxk klt xqqxzh"

This encryption can be cracked because the shift key can easily be determined. Overtime, more secure encryption was developed using advanced mathematic calculations such as permutation, transposition and so on. Other examples of symmetric encryptions are Block Cipher, Steam cipher, and one-time pad cipher. In symmetric encryption, the secret key for encrypting and decrypting data needs to be distributed between the communicating parties. Distributing this secret key securely can be difficult and sometimes involves the establishment of a third party key distribution center.

Asymmetric encryption

This encryption method evolved to solve the key distribution problem in symmetric encryption. Asymmetric encryption make use of two keys, a public key and a private key in the encryption and decryption processes. The public key is freely distributed and it is mathematically derived from the private key. The public key is derived in such a way that it is impossible to reverse engineer it to get the private key.

The private key is used to encrypt the data, which can only be decrypted using the public key. This can also happen interchangably, where the public key is used for encryption and the private key is used for decryption. An example of asymmetric encryption is the Rivest-Shamir-Adleman (RSA) scheme which uses computational factorization together with the public and private key concept to encrypt and decrypt data. Another example is Elliptic Curve Cryptography (ECC) which uses algebric structure of elliptic curves over finite fields, as its computational approach.

Role of cryptography in Blockchain

In blockchain, data are encrypted and grouped into blocks. Blocks are linked through cryptographic hash, hence producing a chain of blocks. Except the first (genesis) block, the linkage of every sucessive block helps to strenghten the authenticity of the preceeding blocks.

Asymmetric encryption is used to generate public and private keys for accounts on blockchain. Bitcoin and Ethereum use the Elliptic Curve Cryptography (ECC). First, a random 256 bit ramdom number is generated. This random number becomes the private key. Then, the encryption algorithm is applied to the private key to generate the public key. This algorithm uses prime number factorization principle which state that, no matter how large a number is, it can be produced by multiplying prime numbers. It is easy to produce a number by multiplying prime numbers but it is very hard to reverse the process. Blockchain relies on this concept to ensure that a public key cannot be reverse engineered to give the private key.

Other uses of cryptography

Cryptography is used in secured wireless communication systems such as Bluetooth and WiFi. Bluetooth uses a symmetric encryption - steam ciphers E0 to encrypt its payload.

Hypertext Transfer Protocol Secure (HTTPS) uses both symmetric and asymmetric encryption to securely transmited data between a web browser and a web server. Let's assume the web browser is the King of France and the web server is the King of Spain.

The king of Spain wants to securely send a large box containing Gold to the king of France. So, the king locked the large box with a special key. He then placed this special key into a small box, which he also locked using a smartlock whose passcode is only known to the king of France. He then sent both large and small boxes to France. For the king of France to access the Gold, he first opened the small box using his secret passcode, then got the special key out of the smaller box, and used it to open up the large box containing the Gold.

The Gold is the data being sent from the web server to the web browser.
The special key is a random symmetric private key generated by the web server.
The locked large box, is the encrypted data using the private key on the web server.
The smartlock used to lock the small box is the public key of the web browser.
The locked small box is the encrypted random private key of the web server using the public key of the web browser.
The secret passcode is the private key of the web browser.

In summary a random private key on the web server is used to encrypt the data, then the random private key is encrypted using the public key of the web browser. The two encrypted data is then sent through the network protocol to the web browser. The web browser uses it's private key to decrypt and extract the random private key of the web server then used the private key to decrypt the encrypted data.

Conclusion

Cryptography plays an important role in many electronic and communication system. It is also the backbone of blockchain technology. Knowing about cryptography will be helpful in building safe and secure applications.

Let's connect on Twitter @drayfocus, and Linkedin Akinola Ayomide.

Cheers!

Book Review: Blockchain in Action

Drayfocus — Sun, 10 Jul 2022 08:58:59 +0000

"Oh my gosh! I am going to become a blockchain expert". That was me after reading the first two chapters of Blockchain in Action. Well, after finishing the book, I haven't become an expert just yet, but I was grounded with the knowlegde and inspiration to become one.

Bina Ramamurthy, the author of Blockchain in action started with explaining the concept of blockchain in simple terms and with relatable examples. Then she took me on a step by step journey of building smart contracts and Decentralized Applications (DApps) using standard engineering design principles.

Blockchain seats on over four decades of research in mathematics, and majorly cryptography. She explained the concept of cryptography and how they are used to enforce security and privacy in blockchain. She explain symmetric and asymmetric encryption keys and how asymmetric encryption is used to generate the public-private key pair used in blockchain to create accounts and signing transactions.

With the help of the book, I built smart contracts addressing real world scenarios such as electronic voting, micropayment channels and electronic educational certification. Each of these examples were progressively converted to a full Decentralized Application. During building, the book introduced me to tools such as Truffle for compliling and testing smart contracts and MetaMask for crypto account management. These smart contracts were deployed on Ganache, a local blockchain network, and a public blockchain networks like the ropsten ethereum network.

The book also explored Fungible and Non-Fungible Tokens (NFTs). Fungible tokens are tokens that are not individually unique and are exchangeable with units of the same kind. Examples are cryptocurrency tokens(Bitcoin, Ethereum). While Non-Fungible tokens are tokens that represent assests that can appreciate or depreciate in value such as lands, art pieces etc. She went further to explaining how to create a fugible tokens and Non-fugible tokens using ethereum standards (ERC20 and ERC721 respectively).

Bina explored the concept of on-chain and off-chain data, explaining that on-chain data are data stored on the blockchain while off-chain data are data in a decentralized application that are stored outside the blockchain. She emphazied the importance of designing a decentralized application with minimal on-chain data so as not to overload the blockchain.

The book explored the decentralized identity of blockchain and the different types of concensus e.g proof of work, proof of authority, and proof of stake. It explained how the concensus used in bitcoin and ethereum are affecting their efficiency and what steps have been taken to solve these problems. She ended with analysing the future of blockchain technology and the different aspects of blockchain that needs innovations from people like you and me.

Bina Ramamurthy is a professor in the university of Buffalo, and she has successfully converted me into the blockchain ecosystem with her work. Like a great teacher, she brought her experience in building distributed systems and demonstrated how to build a scalable blockchain application using design principles.

I will read this book as many times as possible and use it as a reference throughout my career in blockchain. It is a book that demystifies the most advance concepts in blockchain and gives a template of how to build any decentralized application. If you are a developer looking to learn about blockchain technology and also develop smart contracts, this book is for you.

You can get your own copy of Blockchain in Action with 35% discount. Use the discount code: bldrayfocus.

Let's connect on Twitter @drayfocus and Linkedin Akinola Ayomide.

Cheers!

What is a decentralized application (DApp)?

Drayfocus — Sun, 10 Jul 2022 08:58:02 +0000

Developers build decentralized apps (DApps) to make smart contract functionalities available to the end users. In this article, we will discuss:

What are Decentralized Applications (DApps)
Components of a DApp
How these components work together

What are Decentralized Applications

Decentralized applications are softwares that exist and run on a decentralized blockchain system. Simple right? Yes, it is that simple.

They make use of smart contracts to execute actions and commands on a blockchain system. You can learn more about smart contracts in my previous article.

Components of a Decentralized Application

Let's relate a DApp to a small village with a King.

This King stays in a Palace, where he rules and controls the affairs of the village. He is responsible for communicating with his people and also taking care of their needs. His Palace has a highly guarded *Gate * that gives him the needed security and environment to perform all his tasks.

To pass information to his people, the king sends a group of Town Criers . The Town Criers carry information round the village and also takes the request of the people back to the King. Take note, only known and trusted Town Criers are allowed to pass through the Palace's Gate and access the King for security reasons.

In a DApp,

The Palace is the remote CPU which has a blockchain enviroment installed (e.g Ethereum Virtual Machine - EVM). It acts as a blockchain node, which is part of a large decentralized blockchain network like Ethereum.
The King is the Web3 Provider, which resides in the blockchain node. It is responsible for executing commands on the blockchain node. It has direct access and can communicate back and forth with the node.
The palace's Gate is the RPC (Remote Protocol Call) port through which requests to and response from the Web3 Provider passes. This port is usually well secured to protect the blockchain node from cyber attack.
The Town Criers are the Web3 Connectors. They connect to the Web3 Provider through the RPC port. It works like a simple API system that sends request (In JSON) to the Web3 Provider to execute and also recieve the response from the Web3 Provider. A popular example of Web3 Connector is Ethereum's Web3.js package .

Bringing everything together

Now that you know the components of a DApp, let's see how they work together.

The blockchain node is connected to a blockchain system (e.g Ethereum), thus having access to the transactions and blocks of the blockchain. We also deploy our smart contracts to the blockchain system using the blockchain node.
User accounts and wallets are created on this blockchain node and these accounts are responsible for sending and receiving transactions.
Actions and commands won't be auto executed on the blockchain node, so we need an executor. The executor is the Web3 Provider.
Web3 Connector acts as an initiator of an execution. The Web3 Connector can be an API or a User Interface like in MetaMask, Binance, e.t.c.

Conclusion

Every Decentralize Application (DApp) is made up a blockchain node that host accounts, help to deploy the smart contracts on a public or private blockchain system, and has a Web3 Provider that executes commands intiated by a Web3 Connector. I hope you now understand what a DApp is and how it works.

Bonus

There many questions I haven't answered yet. For example, how did I get to understand DApps?

Blockchain in Action by Bina Ramamurthy helped me in preparing this article and
you can get your own copy of Blockchain in Action with 35% discount.

Discount code: bldrayfocus

Let's connect on Twitter @drayfocus and Linkedin Akinola Ayomide.

Cheers!

Deploying and Testing a Smart Contract

Drayfocus — Sun, 10 Jul 2022 08:52:05 +0000

Testing a smart contract before deployment is important because smart contracts are immutable after deployment. Fortunately, Remix IDE from https://remix.ethereum.org has made this easy by providing us with an environment to test our smart contract without any extra setup. It provides us with test accounts and ethers that we can use to perform transactions on an ethereum test network.

In this article, we would be deploying and testing a logistics smart contract. To understand the concept of the smart contract and how it was built, you can check my previous article here.

Deploying our smart contract

Open Remix on your browser, and create a new file "Logistics.sol", if you haven't done that before.
Here is the full source code for our logisitics smart contract,

https://gist.github.com/Doctordrayfocus/8177bd086097ace3c5c6429bba0182d5
We need to compile our code so that we can deploy it on the ethereum network. To do that, go to Remix and switch to the solidity compiler tab on the left. You don't need to make any extra setup, the default language should be "Solidity". Now, click on the "Compile logistics.sol" button to compile the code. You should see something similar to the image below.

Lets proceed to deploy our compiled script. Switch to the deploy tab on Remix. Here, you can select the test environment but can also leave it at the default - "JavaScript VM (London)".

Next is the account drop down. Here, Remix has provided you with 15 test accounts. Select the first account. This account will serve as the Initiator and will be used to deploy the smart contract.

After the account field, the gas limit allows us limit the amount of gas that can be spent during the transaction. You can leave it at its default. Below the gas limit is a field allowing you set the cryptocurrency value to be sent along with a transaction. You can set the value to "30 ether".

Next, click on the "deploy" button to deploy the smart contract. On the console, at the bottom rigth corner of your IDE, Just below the code area, you will see the transaction progress and success logs similar to the image below.

Also, your smart contract will be added to the list of deployed contracts as shown below.

Expand logistics contract and you will see buttons and text fields with names similar to the public state data and functions defined in the smart contract.

These buttons and text fields enable you to easily pass in data and call the smart contract functions directly from Remix.

Now, let's start testing by registering members to the smart contract using the test account Remix provided.

Testing our smart contract

Register a new member

We can achieve this by calling the register function in the smart contract. To register the first member, select a new account from the list of test account. Set the cryptocurrency value to 10 or above (This is a requirement that needs to be met to register a new member based on the smart contract code).

Move to the deployed logistics smart contract session and click on the Register button to invoke the register function of the smart contract which will register the account as a new member. The transaction will be logged in the console as shown below.

Copy the account address of the new member and paste it into a note and label it logistics1. Select a new account and repeat the same step to register the second member on the smart contract. Also, copy the account address and label it logistics2.

You can inspect the data of each member created by passing their account address and calling the membersData,

Request for delivery assistance

Let's make logistics1 request for a delivery assistance. To acheive that, switch back the selected account to that of logistics1. Call the requestForDelivery function of the smart contract by passing in the hashedDeliveryDetails as a random digit e.g (6905597967) and an ether value e.g (20 ether). Click on the **requestForDelivery **in the deployed smart contract. You can inspect the transaction in the console.

For futher testing, you can get the details of the delivery by passing in the hashedDeliveryDetails e.g (6905597967) and clicking the deliveryData button as shown below.

Respond to delivery request

Let's make logistics2 respond to the delivery request. We would need to call the respondToDeliveryRequest function of our smart contract. To do that, we need to provide the hashedDeliveryDetails. We can easily retrieve all available deliveries by calling the getAvailableDeliveries function. This will return an array of the hashedDeliveryDetails of deliveries that are pending.

Change the selected account to that of logistics2, pass in the hashedDeliveryDetails and click on respondToDeliveryRequest button to call the equivalent function. You can inspect the transaction in your console.

After the response has been sent, the delivery will be removed from the available delivery. You can confirm by calling the getAvailableDeliveries again. It will not contain the hashedDeliveryDetails again.

Mark delivery as completed

Here, logistics2 will mark the selected delivery as completed by passing the hashedDeliveryDetails and calling the markDeliveryAsCompleted function. This can only be done by logistics2 and the initiator. You can inspect the transaction in your console.

Mark delivery as confirmed

Switch back the selected account to that of logistics1. Then call the markDeliveryAsConfirmed function by passing the hashedDeliveryDetails. This can also be called by the initiator on behalf of logistics1.

After the delivery has been confirmed, the reputation of logistics2 would increase and the delivery fee would be added to logistics2 balance. You can verify that by passing the account address and calling the membersData.

Unfortunately, I can't write tests for every possible scenario in this article. The tests above are positive tests i.e test made by passing in the correct data. You can perform the negative test by passing in the wrong data or using the wrong account to call a function, then inspect the response.

Conclusion

The goal of this article was to make you familiar with deploying and testing a smart contract using Remix IDE. I hope it was achieved.

You can connect to me on Twitter @drayfocus , and Linkedin Akinola Ayomide .

Cheers!

Building a Smart Contract for Logistics Companies

Drayfocus — Sun, 10 Jul 2022 08:46:25 +0000

Blockchain technology is a revolutionary tool that can be applied to many industries. You have already seen how blockchain can be used as a secure ledger for digital currency, but it also has many other applications. One such application is in the logistics industry.

The logistics industry has been around for decades and the current system works well for most companies. However, there are still some issues within the industry that need to be addressed. For example, there are times when customer orders outweigh the capacity of the logistic company. They usually resolve this by delaying the time of deliveries which doesn't always turn out to give a good customer experience.

Smart contracts are one way to address these issues. In this article, you will look at how smart contracts can be used in the logistics industry and how they can help improve efficiency and help such a logistic company shed some weight by allowing other logistics companies to plug into their system to deliver the order. You will learn how to build a smart contract by building a system that enables a group of logistics companies within a city to work together as a single unit. Each logistic company would be able to offer delivery assistance to other logistics companies that can't process a delivery quickly. Here, the smart contract acts as the trusted enabler, making the companies exchange delivery data and fees without worry.

In this article, you would do the following:

Get familiar with Remix IDE
Define how the smart contract would work
Build our Smart Contract

Remix IDE

In this article, you will use the Remix IDE. The remix is the official Integrated Development Environment for writing Solidity. The remix is similar to most common IDEs like Vscode, Sublime text, and so on. It allows you to quickly build smart contracts, deploy, and test on Ethereum networks without going through extra setups. You can use it directly on your browser at remix.ethereum.org.

Overview

The picture above is what you see the first time you visit Remix. Similar to Vscode, the file explorer is on the left side of your screen, the code area on the right, then the terminal/log below the code area.

File Explorer

This is where you create and manage your files, mostly solidity files (.sol)

Solidity Compiler

Once you are done writing your smart contract, you will need to compile it. With Remix, you can easily configure your compiler and compile your solidity script, so it can run on the Ethereum Virtual Machine.

Deploy and Run Transactions

After successfully compiling your smart contract, you can deploy it on a test Ethereum network and run it directly on Remix IDE.

How will this smart contract work?

The smart contract would be launched by an account into an Ethereum network through a transaction. This account is the contract initiator. The transaction would include some ether (Ethereum cryptocurrency) which the initiator will use to register itself as a member of the smart contract.
Each of the logistic companies would create an account on the Ethereum network. These accounts would be used to register as a member on the smart contract.
During registration, a minimum amount of ether (e.g 10) is set as the registration fee. This fee serves as a requirement for becoming a member of the Logistics smart contract (PS - requirements can vary in real-life applications).
After registration into the smart contract, members are given a reputation number (e.g 10). A member can request delivery assistance from the smart contract. This member is the delivery owner. During this request, an ether amount, equivalent to the delivery fee is sent alongside a hashed (encrypted) data of the delivery.
Any member of the smart contract who is interested in assisting in the delivery would respond to the delivery request, decrypt the delivery details, then use the details to complete the delivery process. This member is referred to as the assisting member of the delivery.
After the delivery is completed, the assisting member marks the delivery as completed on the smart contract. The delivery owner will confirm the completeness of the delivery (This can happen after the customer has indicated that the delivery has been completed).
After the delivery has been confirmed, the delivery fee is sent from the delivery owner's ** balance to the **assisting member balance on the smart contract. The reputation of the assisting member would be increased by some values (e.g 3).
If the delivery failed or was canceled by the assisting member, its reputation would be reduced by some value (e.g 5).
The reputation of every member on the smart contract is important as it serves as a factor to validate the authenticity of each member ( a logistics company).

Build your Smart Contract

A smart contract is made up of data (states), functions to access or change the data, and rules (modifiers) that act as gatekeepers for the data and the functions.

It is a best practice to analyze a smart contract before writing any line of code. Analyzing a smart contract gives clarity on what we want to build.

The diagram below shows an overview of our smart contract.

Your smart contract would be made up of four important components.

Name
State data
Rules or modifiers
Functions

Name

This is simply the name of your contract. It is the first step you need to take in building your smart contract. Go ahead to your Remix IDE, and create a new file named Logistics.sol, then define your smart contract as shown below

pragma solidity >=0.4.16 <0.9.0;
contract Logistics {
// our smart contract code goes here
}

The first line pragma solidity >=0.4.16 <0.9.0 indicates that the solidity version you are using is between 0.4.16 to 0.8.0. This version specification is needed to correctly compile our solidity code. The "contract Logistics" on line 2 defines our smart contract.

States data

States data are variables (data storage containers) whose values are permanently stored in contract storage. It is always present throughout the existence of the contract. Solidity is a typed language and it has different data types similar to C++. In this smart contract, you would only use four data types.

*address *

This is used for storing addresses of contracts or accounts. it is a 160-bit value that does not allow any arithmetic operations.

struct

The struct type is used for storing related data as one.

uint

uint means unsigned integer. it is used for storing integer values

mapping

mapping is quite similar to a javascript array. It is used to store value in a key=>value pair format.

You can check out other data types on Solidity Documentation.

When declaring state data in solidity, the data type is written before the state name. For example,
address payinguser: address is the data type, while payinguser is the name of the state.

Let's define the state data for our smart contract.

initiator -> The address of the account that will launch the logistics smart contract

    address initiator;

memberState -> Holds data for each member registered on the contract. It contains the logistics company's balance and reputation which are both integers.

    struct memberState {
        uint balance;
        uint reputation;
    }

deliveryState -> Holds data for each delivery that will be sent to the smart contract. It contains hashed delivery details, ** delivery fee** in ether, address ** of the **delivery owner, the delivery status which is an integer that describes the present state of the delivery, and lastly, the address of the assisting member.

// when status = 0, it means pending
// when status = 1, it means in progress
// when status = 2, it means completed
// when status = 3, it means confirmed
   struct deliveryState {
        uint deliveryFee;
        uint status;
        uint hashedDeliveryDetails;
        address owner;
        address assistingMember;
    }

membersData -> This maps the account address of every registered member on the smart contract to the memberState, in key => value pair format. The public keyword allows the memberData to be accessed outside the smart contract by the public.

  mapping (address => memberState) public membersData;

members -> This maps the account address of every registered member to their state of membership in the smart contract. The membership state is an integer of either 0 or 1 as the value. 0 indicates no membership, while 1 indicates active membership.

 mapping (address => uint) members;

deliveryData -> This maps the hashed delivery details to a delivery state in the smart contract in a key => value pair format. It is also public and can be accessed outside the smart contract.

mapping (uint => deliveryState) public deliveryData;

Now, add all these data states to your Logistics.sol file. You should have something similar to this:

pragma solidity >=0.4.16 <0.9.0;
contract Logistics {

 // The address of the account that launched the smart contract
    address initiator;

    // state data for each member registered on the contract
    struct memberState {
        uint balance;
        uint reputation;
    }

 // state data for each delivery transactions executed through the smart contract
// when status = 0, it means pending
// when status = 1, it means in progress
// when status = 2, it means completed
// when status = 3, it means confirmed
    struct deliveryState {
        uint deliveryFee;
        uint status;
        uint hashedDeliveryDetails;
        address owner;
        address assistingMember;
    }

    // mapping are live arrays with key and value pairs
    mapping (address => memberState) public membersData;
    mapping (address => uint) members;
    mapping (uint => deliveryState) public deliveryData;
}

Rules or modifiers

Smart contract rules in solidity are defined using the modifier keyword. Modifiers are used for restricting access to data or functions in a smart contract. In this smart contract, you have only one modifier,

onlyMember -> This modifier allows only accounts that are registered as a member of the smart contract to access a particular data or function.

 modifier onlyMember{
        require(members[msg.sender] == 1);
        _;
    }

The msg used in the modifier is a global variable in solidity. It holds the information of a transaction. msg.sender gets the address of the account that initiated the transaction, while msg.value gets the ether (Ethereum cryptocurrency) sent with the transaction.

Add the modifier to your smart contract:

pragma solidity >=0.4.16 <0.9.0;
contract Logistics {

 // The address of the account that launched the smart contract
    address initiator;

    // state data for each member registered on the contract
    struct memberState {
        uint balance;
        uint reputation;
    }

    // state data for each delivery transactions executed through the smart contract
    struct deliveryState {
        uint deliveryFee;
        uint status;
        uint hashedDeliveryDetails;
        address owner;
        address assistingMember;
    }

    // mapping are live arrays with key and value pairs
    mapping (address => memberState) public membersData;
    mapping (address => uint) members;
    mapping (uint => deliveryState) public deliveryData;

 // modifiers
    modifier onlyMember{
        require(members[msg.sender] == 1);
        _;
    }
}

Functions

These are the actions and use-cases of the smart contract. You need to perform verification and validations before performing any action. Verification can be achieved by attaching the right modifier to the function, while validations can be achieved by using simple conditional statements. To return meaningful responses during verification and validation, let's add some error handlers to our smart contract.

 // errors
    error notAuthorized(string reason);
    error insufficientFee(string reason, uint registrationFee);

For your smart contract, you have 7 functions:

constructor -> This function is common to every smart contract and it is called when launching the contract.

 constructor() public payable {
        initiator = msg.sender;
        // here, you will register the initiator of the contract as a member
        members[msg.sender] = 1;
        membersData[msg.sender].balance = msg.value;
        membersData[msg.sender].reputation = 10;
    }

The public keyword indicates that the function can be called outside the smart contract while the payable keyword indicates that the function requires cryptocurrency input.

Here, you set the initiator address and added the account as the first member of the smart contract.

Remember: msg.sender and msg.value are both global variables. msg.sender returns the address to the account that is calling a function while msg.value returns the value of the cryptocurrency attached to the transaction calling the function.

 function register() public payable {
        uint registrationFee = msg.value;
        address newMember = msg.sender;
        if (registrationFee < 10)
           revert insufficientFee({
                reason: "Ether value is less than the required registration fee",
                registrationFee: 10
            });
        members[newMember] = 1;
        membersData[newMember].balance = msg.value;
        membersData[newMember].reputation = 10;
    }

Here, you validated a registration fee of 10 ethers and threw in an error for lesser fees. You also set the membership state, balance, and default reputation for the new member.

requestForDelivery -> A member calls this function to request for delivery assistance. The member must send a hashed delivery detail and an equivalent cryptocurrency value when calling the function.

function requestForDelivery(uint hashedDeliveryDetails) onlyMember public payable {
        if(members[msg.sender] != 1)
           revert notAuthorized({
                reason: "Only members of this contract can request for delivery"
            });

         uint senderReputation = membersData[msg.sender].reputation;
         if(senderReputation < 6)
            revert notAuthorized({
                reason: "You have a low reputation, complete more deliveries to increase your reputations"
            });

        deliveryData[hashedDeliveryDetails].deliveryFee = msg.value;
        deliveryData[hashedDeliveryDetails].status = 0;
        deliveryData[hashedDeliveryDetails].status = hashedDeliveryDetails;
        deliveryData[hashedDeliveryDetails].owner = msg.sender;

        membersData[msg.sender].balance = membersData[msg.sender].balance + msg.value;
    }

In the code above, you used the onlyMember modifier to verify accounts that can access the function. The payable keyword is an indication that payment in the form of cryptocurrency is required. You checked for the reputation of the member to verify its access to request assistance. You also saved the delivery data and temporarily stored the delivery fee in the wallet of the delivery owner. The delivery fee would be sent to the assisting member after completing the delivery.

respondToDeliveryRequest -> Anyone can access the deliveryData since it is public. Interested members can respond to the delivery request by using the hashedDeliveryDetails to respond and handle the delivery.

 function respondToDeliveryRequest(uint hashedDeliveryDetails) onlyMember public {
        if(members[msg.sender] != 1)
           revert notAuthorized({
                reason: "Only members of this contract can respond to delivery request"
            });
        uint memberReputation = membersData[msg.sender].reputation;
         if(memberReputation < 1)
            revert notAuthorized({
                reason: "You have exhausted your reputations"
            });
        uint deliveryStatus = deliveryData[hashedDeliveryDetails].status;
        if(deliveryStatus != 0)
            revert notAuthorized({
                reason: "This delivery is no longer available"
            });

        deliveryData[hashedDeliveryDetails].status = 1;
        deliveryData[hashedDeliveryDetails].assistingMember = msg.sender;
    }

Above, you prevented members with no reputations from assisting in any delivery. You also checked the delivery status to prevent multiple delivery assistance, then updated its status and the assisting member’s address.

markDeliveryAsCompleted -> The assisting member of delivery calls this function after completing the delivery.

function markDeliveryAsCompleted(uint hashedDeliveryDetails) onlyMember public {
        if(members[msg.sender] != 1)
           revert notAuthorized({
                reason: "Only members of this contract can update this delivery"
            });
        address assistingMember = deliveryData[hashedDeliveryDetails].assistingMember;
        if(assistingMember != msg.sender) 
            revert notAuthorized({
                reason: "You don't have access to update this delivery"
            });
        deliveryData[hashedDeliveryDetails].status = 2;
    }

Here, you ensured the account calling the function has the right access then update the delivery status as completed if it does.

markDeliveryAsCancled -> This function is used to cancel delivery in progress. Only the delivery assisting member and the smart contract initiator can access it.

function markDeliveryAsCancled(uint hashedDeliveryDetails) onlyMember public {
        if(members[msg.sender] != 1)
           revert notAuthorized({
                reason: "Only members of this contract can update this delivery"
            });
        address assistingMember = deliveryData[hashedDeliveryDetails].assistingMember;
        if(assistingMember != msg.sender && msg.sender != initiator) 
            revert notAuthorized({
                reason: "You don't have access to update this delivery"
            });

        deliveryData[hashedDeliveryDetails].status = 0;

        if (assistingMember == msg.sender) {
             membersData[msg.sender].reputation = membersData[msg.sender].reputation - 5;
        }

        if (msg.sender == initiator) {
             membersData[msg.sender].reputation = membersData[msg.sender].reputation - 6;
        }
    }

Here, if the delivery was canceled by the assisting member, its reputation drops by 5, but if it was done by the initiator, its reputation will drop by 6.

markDeliveryAsConfirmed -> This function is used to confirm delivery. It can only be called by the owner of the delivery and the contract initiator who calls it when the owner is not available.

function markDeliveryAsConfirmed(uint hashedDeliveryDetails) onlyMember public {
        if(members[msg.sender] != 1)
           revert notAuthorized({
                reason: "Only members of this contract can update this delivery"
            });
        address deliveryOwner = deliveryData[hashedDeliveryDetails].owner;
        if(deliveryOwner != msg.sender && msg.sender != initiator) 
            revert notAuthorized({
                reason: "You don't have access to confirm this delivery"
            });

        deliveryData[hashedDeliveryDetails].status = 3;

        address assistingMember = deliveryData[hashedDeliveryDetails].assistingMember;
        uint deliveryFee = deliveryData[hashedDeliveryDetails].deliveryFee;

        membersData[deliveryOwner].balance = membersData[deliveryOwner].balance - deliveryFee;

        membersData[assistingMember].reputation = membersData[assistingMember].reputation + 3;
        membersData[assistingMember].balance =  membersData[assistingMember].balance + deliveryFee;

    }

Here, you removed the delivery fee from the delivery owner's balance and added it to the assisting member's balance.

This is the full code for our logistics smart contract:

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.16 <0.9.0;

contract Logistics {
    // The address of the account that launched the smart contract
    address initiator;

    // state data for each member registered on the contract
    struct memberState {
        uint balance;
        uint reputation;
    }

 // state data for each delivery transactions executed through the smart contract
// when status = 0, it means pending
// when status = 1, it means in progress
// when status = 2, it means completed
// when status = 3, it means confirmed
    struct deliveryState {
        uint deliveryFee;
        uint status;
        uint hashedDeliveryDetails;
        address owner;
        address assistingMember;
    }

    // mapping are live arrays with key and value pairs
    mapping (address => memberState) public membersData;
    mapping (address => uint) members;
    mapping (uint => deliveryState) public deliveryData;

    // modifiers
    modifier onlyMember{
        require(members[msg.sender] == 1);
        _;
    }

    // errors
    error notAuthorized(string reason);
    error insufficientFee(string reason, uint registrationFee);

    constructor() public payable {
        initiator = msg.sender;
        // here you will register the initiator of the contract as a member
        members[msg.sender] = 1;
        membersData[msg.sender].balance = msg.value;
        membersData[msg.sender].reputation = 10;
    }

    function register() public payable {
        uint registrationFee = msg.value;
        address newMember = msg.sender;
        if (registrationFee < 10)
           revert insufficientFee({
                reason: "Ether value is less than the required registration fee",
                registrationFee: 10
            });
        members[newMember] = 1;
        membersData[newMember].balance = msg.value;
        membersData[newMember].reputation = 10;
    }

    function requestForDelivery(uint hashedDeliveryDetails) onlyMember public payable {
        if(members[msg.sender] != 1)
           revert notAuthorized({
                reason: "Only members of this contract can request for delivery"
            });

         uint senderReputation = membersData[msg.sender].reputation;
         if(senderReputation < 6)
            revert notAuthorized({
                reason: "You have a low reputation. Complete more deliveries to increase your reputation".
            });

        deliveryData[hashedDeliveryDetails].deliveryFee = msg.value;
        deliveryData[hashedDeliveryDetails].status = 0;
        deliveryData[hashedDeliveryDetails].status = hashedDeliveryDetails;
        deliveryData[hashedDeliveryDetails].owner = msg.sender;

        membersData[msg.sender].balance = membersData[msg.sender].balance + msg.value;
    }

    function respondToDeliveryRequest(uint hashedDeliveryDetails) onlyMember public {
        if(members[msg.sender] != 1)
           revert notAuthorized({
                reason: "Only members of this contract can respond to delivery request"
            });
        uint memberReputation = membersData[msg.sender].reputation;
         if(memberReputation < 1)
            revert notAuthorized({
                reason: "You have exhausted your reputations"
            });
        uint deliveryStatus = deliveryData[hashedDeliveryDetails].status;
        if(deliveryStatus != 0)
            revert notAuthorized({
                reason: "This delivery is no longer available".
            });

        deliveryData[hashedDeliveryDetails].status = 1;
        deliveryData[hashedDeliveryDetails].assistingMember = msg.sender;
    }

    function markDeliveryAsCompleted(uint hashedDeliveryDetails) onlyMember public {
        if(members[msg.sender] != 1)
           revert notAuthorized({
                reason: "Only members of this contract can update this delivery"
            });
        address assistingMember = deliveryData[hashedDeliveryDetails].assistingMember;
        if(assistingMember != msg.sender) 
            revert notAuthorized({
                reason: "You don't have access to update this delivery".
            });
        deliveryData[hashedDeliveryDetails].status = 2;
    }

    function markDeliveryAsCancled(uint hashedDeliveryDetails) onlyMember public {
        if(members[msg.sender] != 1)
           revert notAuthorized({
                reason: "Only members of this contract can update this delivery"
            });
        address assistingMember = deliveryData[hashedDeliveryDetails].assistingMember;
        if(assistingMember != msg.sender && msg.sender != initiator) 
            revert notAuthorized({
                reason: "You don't have access to update this delivery"
            });

        deliveryData[hashedDeliveryDetails].status = 0;

        if (assistingMember == msg.sender) {
             membersData[msg.sender].reputation = membersData[msg.sender].reputation - 5;
        }

        if (msg.sender == initiator) {
             membersData[msg.sender].reputation = membersData[msg.sender].reputation - 6;
        }
    }

    function markDeliveryAsConfirmed(uint hashedDeliveryDetails) onlyMember public {
        if(members[msg.sender] != 1)
           revert notAuthorized({
                reason: "Only members of this contract can update this delivery"
            });
        address deliveryOwner = deliveryData[hashedDeliveryDetails].owner;
        if(deliveryOwner != msg.sender && msg.sender != initiator) 
            revert notAuthorized({
                reason: "You don't have access to confirm this delivery"
            });

        deliveryData[hashedDeliveryDetails].status = 3;

        address assistingMember = deliveryData[hashedDeliveryDetails].assistingMember;
        uint deliveryFee = deliveryData[hashedDeliveryDetails].deliveryFee;

        membersData[deliveryOwner].balance = membersData[deliveryOwner].balance - deliveryFee;

        membersData[assistingMember].reputation = membersData[assistingMember].reputation + 3;
        membersData[assistingMember].balance =  membersData[assistingMember].balance + deliveryFee;

    }

}

Congratulations! You just built a Logistics smart contract.

Conclusion

In this article, you learned how to build a smart contract to help Logistics companies become more efficient in how they collaborate . In the next article, you would learn how to deploy and test the smart contract.

Let's connect.

👉 On Twitter @drayfocus

👉 On LinkedIn Akinola Ayomide

Cheers!