1. AI Will Become Infrastructure, Not a Product

By 2026, AI will no longer feel “special.”

It won’t just be a standalone product you build or integrate once. Instead, it will be embedded into everything:

• Databases

• CI/CD pipelines

• Monitoring and observability

• APIs and internal tooling

The winning engineers won’t be those who can “prompt well,” but those who understand how to integrate AI into real systems safely and efficiently.

Prompting is not a skill.

System thinking plus AI integration is.

2. Backend and Infrastructure Engineers Will Become More Valuable

Frontend development is increasingly being abstracted by:

• AI UI builders

• Design-to-code tools

• No-code and low-code platforms

But backend and infrastructure work cannot be safely abstracted away.

By 2026, demand will increase for engineers who understand:

• Distributed systems

• Payments and financial flows

• Identity and authentication

• Security and access control

• Databases and data pipelines

• Blockchain and protocol infrastructure

These systems power real businesses—and failures here are expensive.

3. Blockchain Will Quietly Become Financial Infrastructure

The hype phase is ending.

By 2026:

• There will be fewer speculative chains

• More purpose-built blockchains

• Strong focus on stablecoins, RWAs, payments, and settlement layers

The protocols that survive won’t be flashy.

They will be boring, reliable, compliant—and valuable.

Blockchain engineers who focus on UX, security, and real-world use cases will outperform those chasing short-term yield.

4. Engineering Teams Will Get Smaller but Stronger

AI copilots will change team dynamics.

Five strong engineers will outperform fifteen average ones.

Companies will prioritize engineers who:

• Can own problems end-to-end

• Understand the business impact of their work

• Can ship, maintain, and improve systems without heavy supervision

Responsibility per engineer will increase—but so will influence.

5. APIs and Integration Skills Will Explode in Demand

Every company is becoming:

• A payments company

• A data company

• An integration company

By 2026, engineers who can:

• Design clean, intuitive APIs

• Handle edge cases and failure scenarios

• Think in workflows, not just endpoints

• Build reliable, scalable services

…will always be in demand.

Hard Advice for Engineers (No Sugarcoating)

1. Stop Chasing Tools. Master Fundamentals.

Frameworks change.

Languages evolve.

Fundamentals compound.

Double down on:

• Networking basics

• Databases (indexes, transactions, locks)

• Concurrency and parallelism

• System design

• Security fundamentals

Tools are rented.

Fundamentals are owned.

2. Learn to Think Like a Product Owner

By 2026, engineers who ask:

“Why are we building this?”

will outperform those who only ask:

“What ticket am I assigned?”

Understand:

• How the company makes money

• User pain points

• Cost of failure and downtime

Engineering is no longer isolated from business reality.

3. AI Will Expose Weak Engineers, Not Replace Strong Ones

AI will not replace engineers—but it will expose gaps.

Engineers who will struggle:

• Can’t debug without AI

• Don’t understand why code works

• Can’t reason beyond copied solutions

Engineers who will thrive:

• Use AI as an accelerator

• Can review, correct, and improve AI-generated code

• Understand systems deeply

Treat AI like a junior engineer—not your boss.

4. Ownership Will Matter More Than Titles

Your value in 2026 will be defined by what you own.

Own:

• A service

• A protocol

• A deployment pipeline

• A critical business system

“I built this and it runs in production” will matter more than job titles or certificates.

5. Public Proof Will Matter More Than Private Skill

Resumes matter less.

Proof matters more.

Engineers should focus on:

• Shipping real products

• Contributing to open source

• Writing technical content

• Running systems in production

Visibility plus competence creates opportunity.

Final Thought

2026 will not reward the loudest engineers.

It will reward the most useful ones.

Engineers who build reliable systems, understand fundamentals, and take ownership will always be relevant—regardless of how fast technology changes.

Full Code

package oaws

import (
    "fmt"
    "io/ioutil"
    "os"

    "github.com/aws/aws-sdk-go/aws/session"
    "github.com/rs/zerolog/log"
    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/aws/awserr"
    "github.com/aws/aws-sdk-go/service/ses"
)
func NewSession(region string) (sess *session.Session, err error) {
    if region == "" {
        log.Fatal().Msg("Missing region in oaws.NewSession")
    }
    sess, err = session.NewSession(&aws.Config{
        Region: aws.String(region)})
    return
}

func SendRawEmailWithAttachment(sender, recipient, subject, html, text, fileName, region string, attachmentFile *os.File) error {
    // Create a new session using AWS SDK
    sess, err := NewSession(region)

    if err != nil {
        fmt.Println(err.Error())
        return err
    }

    _, err = attachmentFile.Seek(0, 0)
    if err != nil {
        fmt.Println("Error seeking to the beginning of the file:", err)
        return err
    }

    // Read the content of the attachment file
    attachmentContent, err := ioutil.ReadAll(attachmentFile)
    if err != nil {
        fmt.Println("Error reading attachment:", err)
        return err
    }

    // Convert the attachment content to base64
    attachmentData := aws.NewWriteAtBuffer(attachmentContent)

    // Construct the raw email content including the attachment
    rawEmail := fmt.Sprintf(`From: %s
To: %s
Subject: %s
Content-Type: multipart/mixed;
    boundary="a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a"

--a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a
Content-Type: multipart/alternative;
    boundary="sub_a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a"

--sub_a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a
Content-Type: text/plain; charset=iso-8859-1
Content-Transfer-Encoding: quoted-printable

%s

--sub_a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a
Content-Type: text/html; charset=iso-8859-1
Content-Transfer-Encoding: quoted-printable

%s

--sub_a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a--

--a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a
Content-Type: text/plain; name="%s"
Content-Description: %s
Content-Disposition: attachment;filename="%s";
    creation-date="Sat, 05 Aug 2017 19:35:36 GMT";
Content-Transfer-Encoding: base64

%s

--a3f166a86b56ff6c37755292d690675717ea3cd9de81228ec2b76ed4a15d6d1a--
`, sender, recipient, subject, text, html, fileName, fileName, fileName, attachmentData.Bytes())

    // Create a new SES service client
    svc := ses.New(sess)

    // Create the input for sending raw email
    input := &ses.SendRawEmailInput{
        RawMessage: &ses.RawMessage{
            Data: []byte(rawEmail),
        },
    }

    // Send the raw email with the attachment
    _, err = svc.SendRawEmail(input)
    if err != nil {
        handleSendEmailError(err)
        return err
    }

    return nil
}

// Helper function to handle SES send email errors
func handleSendEmailError(err error) {
    if aerr, ok := err.(awserr.Error); ok {
        switch aerr.Code() {
        case ses.ErrCodeMessageRejected:
            fmt.Println(ses.ErrCodeMessageRejected, aerr.Error())
        case ses.ErrCodeMailFromDomainNotVerifiedException:
            fmt.Println(ses.ErrCodeMailFromDomainNotVerifiedException, aerr.Error())
        case ses.ErrCodeConfigurationSetDoesNotExistException:
            fmt.Println(ses.ErrCodeConfigurationSetDoesNotExistException, aerr.Error())
        default:
            fmt.Println(aerr.Error())
        }
    } else {
        fmt.Println(err.Error())
    }
}

Sample Usage

func GenerateTXTContent(contentArray []string) string {
    // Create a buffer to hold the contents in memory
    var buffer bytes.Buffer

    // Loop through the array and write contents to the buffer
    for _, content := range contentArray {
        buffer.WriteString(content + "\n")
    }

    // Convert the buffer to a string
    return buffer.String()
}

func GenerateTempFileContent(txtContent, fileName string) (*os.File, error) {
    // Create a temporary file in memory
    tmpFile, err := os.CreateTemp(".", fileName+"*.txt")
    if err != nil {
        fmt.Println("Error creating temporary file:", err)
        return nil, err
    }
    defer os.Remove(tmpFile.Name()) // Clean up the temporary file

    // Write the contents to the temporary file
    _, err = tmpFile.WriteString(txtContent)
    if err != nil {
        fmt.Println("Error writing to temporary file:", err)
        return nil, err
    }

    return tmpFile, nil
}

        var vouchers []string
            for i := 0; i < len(generateVoucherResponse.Item); i++ {
                vouchers = append(vouchers, generateVoucherResponse.Item[i].Code)
            }

            txtContent := GenerateTXTContent(vouchers)

            file, err := GenerateTempFileContent(txtContent, schoolDetailsRequest.Item.ID.String())
            if err != nil {
                return utils.ReturnError(w, err, http.StatusInternalServerError)
            }

            defer file.Close()
            recipient := Email

            SendRawEmailWithAttachment(consts.SenderEmail, recipient, "Registration Confirmation", `Welcome`, "Welcome", "filename.txt", cfg.AWSSESRegion, file)

Let's break down the key components of this code and understand how it achieves the task of sending emails with attachments.

1. Importing Packages

The code begins by importing necessary packages, including the AWS SDK for Go and other standard Go packages.

package oaws

import (
    "fmt"
    "io/ioutil"
    "os"

    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/aws/awserr"
    "github.com/aws/aws-sdk-go/service/ses"
)

2. Function to Send Raw Email with Attachment

The SendRawEmailWithAttachment function is the core of this package. It takes various parameters such as sender, recipient, subject, HTML and plain text content, file name, AWS region, and an attachment file. It constructs a raw email with a multipart structure that includes both the email body and the attachment.

func SendRawEmailWithAttachment(sender, recipient, subject, html, text, fileName, region string, attachmentFile *os.File) error {
    // ... (code continues below)
}

3. Creating an AWS Session

The function starts by creating an AWS session using a helper function named NewSession. If an error occurs during session creation, it prints an error message and returns the error.

4. Preparing Attachment Content

The code reads the content of the attachment file and converts it to base64 format. It then constructs the raw email content by combining the email body and attachment.

5. Constructing Raw Email

The raw email is constructed as a multipart message, including both alternative text/plain and text/html content for the email body. It also includes the attachment with relevant metadata.

6. Creating SES Service Client

A new SES service client is created using the AWS session.

svc := ses.New(sess)

7. Creating Input for Sending Raw Email

The input for sending raw email is created with the raw email data.

input := &ses.SendRawEmailInput{
    RawMessage: &ses.RawMessage{
        Data: []byte(rawEmail),
    },
}

8. Sending Raw Email

Finally, the function attempts to send the raw email using the SES service client. If an error occurs, the handleSendEmailError function is called to handle specific SES-related errors.

9. Handling SES Send Email Errors

A helper function, handleSendEmailError, is defined to handle errors that may occur during the SES send email operation. It checks the error type and prints specific error messages based on the SES error code.

Conclusion

This Go package provides a convenient way to send raw emails with attachments using AWS SES. Just copy what you need, my usage would not be the same as yours. So far as you provide the right paramters to the sendEmail function, you should be good to go.

First I just want to take a moment to laugh small, 😂😂😂😂 why? the plans I had for 2023 come be like say na small pikin write am, because none of those things really happened.

Secondly, 2023 in conclusion was a rough one for me.. what I ordered was not what I got but in all things, I'm greatly to God for not shaming me regardless. I really wish I had enough strength to give more details about how each month went, the ups and downs, and the stories learned and taught 😂.

Some Quick Statistics

A lot more happened but this is all I can remember, happy reading.

Physical Status - Had zero major problems, hit the gym like it was the last, and added some flesh I struggled to gain thanks to supplements and of course, muscles to steal your babe.

Mental Status - This particular period when I lowkey could not help being unproductive coupled with confusion. This happened because, for a long period, i inhaled so much camphor and did not realize it was messing me up mentally.

Spiritual Status - I understood more that everyone needs to have where they get their power from ( Babalawo included), just pick a side.

Social Status - Someone I saw as a big brother scammed me and I had to end that relationship. Connected with more females than ever this year (don't get me wrong but feel free). Linked up with my previous employee. Convocation happened.

Financial Status - I barely saved this year. Cost me over 10 Million naira to go through the year in one piece.

Career Status - My Contract expired around April and I did not bother applying for new roles particularly because I was not prepared for that mental stress just yet. I completed all freelance projects except one. Started a new role around November. I was in Lagos for OSCA Fest 2023. Tried making sense of my startup 😪. Spoke at Devfest Owerri and Polygon Guild Enugu.

Plans for 2024

I'll spend my time upskilling and improving on existing skills. And making good money. 2024 would make it 7 Years in Tech (clap hand for Jesus). For a long while, I've always wanted to do some ethical hacking stuff, so 2024 is the year of cybersecurity with a focus on Cloud Security, Penetration Testing, and network engineering. I'll recommend you do the same.

I hope to help more people as much as I can in 2024.

I also look forward to daily income.

My Catch phrase for next year would be "Hide your devices", e get why.

Install Package

Add Twilio SendGrid to your composer.json file. If you are not using Composer, I highly recommend it. It's an excellent way to manage dependencies in your PHP application.

{
  "require": {
    "sendgrid/sendgrid": "~7"
  }
}

or simply just install via the terminal using the command:

composer require "sendgrid/sendgrid"

Get API key

An API key is required to authenticate your request and you can always get one when you signup on SendGrid. Once you have this key, copy and paste it somewhere in your project, for me, I've been able to read environment variables from a .env file using this package. Just find a way to store your API key and the security of that key is your concern, try not to push that key to public version control platforms like GitHub, Sendgrid would disable this API Key once they find out ( don't ask me how ), and this is bad for production.

Code

<?php
require 'vendor/autoload.php';

use SendGrid\Mail\From;
use SendGrid\Mail\Mail;
use SendGrid\Mail\Personalization;
use SendGrid\Mail\Subject;
use SendGrid\Mail\To;
use SendGrid\Mail\HtmlContent;
use SendGrid\Mail\Substitution;


function sendBulkMail($receipientsData, $from, $subject, $message, $fromName)
    {


        $from_ = new From($from, $fromName);
        $htmlContent = new HtmlContent(
            $message
        );
        $email = new Mail($from_,null,$subject,null, $htmlContent);

        foreach ($receipientsData as $reciepient) {

            $personalization = new Personalization();
            $personalization->addTo(new To(
                $reciepient[0],
                $reciepient[1]
            ));

            $personalization->setSubject(new Subject($subject));
             $personalization->addDynamicTemplateData(new Substitution("-first_name-",$reciepient[1]));            

        }

        $sendgrid = new \SendGrid($_ENV['SEND_GRID']);
        try {
           $response =  $sendgrid->send($email);
            print $response->statusCode() . "\n";

            return true;
        } catch (Exception $e) {
            return false;
        }
    }

$message = "<div>Hello -first_name-</div>";
sendBulkMail([["test@gmail.com","Alfred"],["test2@gmail.com","Star"]],"alfred@codemon.me","Test",$message,"Alfred");

The sendBulkMail function accepts the following parameter

• A Multidimensional array of your users' data, each user has an email and a name, think of this as an array of arrays.

• Senders email

• Email Subject

• HTML content ( you can use twig to load your HTML template )

• Senders Name

Code Explanation

 $personalization = new Personalization();
 $personalization->addDynamicTemplateData(new Substitution("-first_name-",$reciepient[1]));

In order to personalize emails for each user, we construct a new Personalization class which has helpful methods to set dynamic data for each user. Calling the addDynamicTemplateData method on this class lets us substitute a placeholder with the actual valid on the HTML template. In our case, we want to replace -first_name- with the name of the current user.

It's important to note that your placeholder string (-first_name-) can take any format as you wish, it can look like this {{first_name}} as well.

 $sendgrid = new \SendGrid($_ENV['SEND_GRID']);

This line of code simply sets our API key and like mentioned earlier, I'm currently loading environment variables from a .env file, but you can as well just hardcode your API Key( not recommended).

Conclusion

Thanks to Sendgrid, you do not need to set up a ridiculous code block to send emails to multiple users, using this method is fast and saves some costs too. In this blog post, you've learned how to send personalized emails to multiple users using SendGrid PHP SDK, hope it made sense. Leave a comment with your questions and kind words, see you!

So, in case you are in a hurry to read through I suggest you plan another time/day to come back here with your popcorn and Hennessy. Now, for those who are ready for some undiluted content, get your seat belt crossed, it's about to be a long ride because I'm about to tell a story that has never been told 😌.

For a while, I've been contemplating writing things and just needed a valid reason. I'm certain I might not be able to capture every single thing that happened this year, so this is me giving it a shot and putting my brain to the test.

Flashback to 2021

Last year was a good one and had a good number of achievements and all whatnot, you can check out my 2021 review here so I won't repeat them here. Skipping to the good part, I made a few goals for myself regarding the year 2022 and it's quite interesting how much I was able to check on that list, I say interesting because the moment that article got published was the last time I checked it consciously to look through what I had planned for the new year and create a road map for myself.

Quite an interesting list all around money and web3, and you know web3 is all about the money not literally, so it's safe to create a formula for this purpose Money === Web3. I'm happy for the much I was able to achieve excluding the blockchain course and attending Davido's concert. About the blockchain course, I had made reasonable progress and this reviewer just kept making life hard for me, or was it just me and my poor writing skills? Anyway, I got paid for trying to make sense and also sincerely wished the course went live. About Davido's concert, omoh! I did not really take that too serious but remember trying to check and enquire about his concerts in Lagos, but later found one in Ghana on the 31st of December. I love you OBO but my parents would kill me 😂, missing cross-over service for what?.

How it Started

Just like many, kicked off the year in church while attending a cross-over service in a different parish for the first time in years. Something quite spectacular about this service, boy oh boy! I prayed 💀. Wasn't sure why but it was different and intense, felt like the likes of those who attend mountain of fire church without screaming "fire fire fire". After the whole prayer thing, this confidence showed up and the thought of "this is my year" kept running from that day onwards. 2022 Shall we?

For each month in the year, I'll talk about a few highlights and end it with a photo to crown it all up. Ready? Go!

Jan 2022.

One of my goals for the new year was to fully transition into the web3 space. I made intentional moves by improving myself technically in preparation for what was to come. I figured it was time to move on from my current role as a front-end engineer because I personally believed I had made significant impacts and played important roles for the three years spent. For two reasons I was so down to leaving, one which was the salary pay, and secondly, I got so engrossed with blockchain technology.

Two months before 2022, I started job hunting for web3 roles via LinkedIn, and even with the normal rejections, I was able to land two different roles, part-time and contract work. The funny thing about the contract role was, I didn't realize it was a contract role till a few months later 😂, one of those companies that hire without the need for a signed agreement. You can check my LinkedIn for more details on the two roles.

Feb 2022

Love is in the air, wahlauuur! This month, I started making plans to purchase one fine Lexus like that, as a birthday gift for myself, but a few talks and bad dreams about this idea made it die off. I think this was the month where we had that heartbreak song that says " break up na national cake e go touch everybody " 🫣.

A few days into the month, while on blockchain salary, I randomly stepped into a shop at the mall in Owerri and made my first apple product purchase after forming that I don't like them. I think part of the reason was that a friend of mine needed my help to make a phone purchase for his girl for valentines day then I also had a bulk of cash at hand that same day and decided to let go of a few on a new phone, I guess the iPhone was my valentines gift to myself from myself.

If you are a student of FUTO, you'll understand the struggles of getting a reasonable internet speed, for this purpose I had exhausted all options to get good internet and the last on my mind was to get a network booster, which I later did and only worked on the first day of installation, this has to be one hell of an annoying purchase.

Lastly, I finally graduated from 6 months of blockchain training with Emurgo academy thanks to ABCD (African Blochain center for developers). Fun fact; I was given the opportunity to work on the front end of their website.

March 2022

My birth month, and have never been so excited about this year's celebration. As usual, had my cake done by a very good friend of mine, Faith. She's been doing this since 2020 and is good at what she does, so if you need her cake services leave a comment and I'll find a way to link you up.

My birthday is on the 5th of March, and for this, I made sure it was a little different by taking my first studio picture and then trying to get myself a reasonable birthday present.

Oh, yea, I paid for food and drinks for friends and we had a crazy party that night. My initial plan was to actually just disguise and share money on the streets as a way of showing love but could not get hold of neat naira notes before my birthday. So instead, during the late-night party, I decided to let go of some dollar notes and a few naira note to spray while we all danced to loud music. I personally had fun for the day and was close to attempting a ridiculous giveaway for my WhatsApp contacts( around 2M) , and no I was not high at all, thank God for the gift of sense.

As usual, received warm wishes and a few gifts but one which made good sense was a framed photo of myself by Elvis and Tobe. After setting my eyes on this frame, I fell in love with the whole concept of framing people's photos. But please if you are to frame somebody, use a fine picture abeg. The whole concept and design put into making the frame was what made it unique, had this shine shine thing on it and I loved it.

Not to forget, I interviewed with x-team for some senior blockchain role and got served a chilled breakfast when I felt it was all settled.

ASUU Strike 2022 😂 was also a thing that began this month.

It was an interesting month indeed, can't say it all here.

April 2022

I got back home because of the ASUU strike (which started the previous month) to escape debit alert and bad network too. For the first time, I visited a spa to begin my skincare journey but nothing prepared me for the pain, I came out with a face looking rather swollen 😂. This month came with its difficulties at work because I was trying to balance organizing an event which took plenty of my time and work too.

While scrolling Twitter, I came across a blockchain event happening in Enugu, I didn't want to be in the crowd and that was how I reached out to Uche to co-organize that event, and our friendship began, cool story.

Remember this song, "Show me a jigga lemme see, and let me see a woman that he is with", remixed with mayorkun ? Yea, it was this month too, feeling old? 🫣 I almost attempted to shame myself again by participating in that dance challenge, it was indeed an addictive jam and was all over ticktok.

Public servants attempted to stress me while trying to make changes to my NIN credentials, but money stopped the nonsense. I started making plans to renew my passport this month.

May 2022

Because of the love I have for drones, I figured it would be a nice addition to my gadget collection. I always admired the way that baby moves so quickly and high. A few people advised me not to get the drone from jumia, but because I've got a coconut head, I went ahead to make the order together with a terrible HD camera.

12th May was the day to pick up my items, I went to the pickup station myself after it could not be delivered to my doorstep for some silly reasons. Got to the pickup station and it was my turn to claim my order, I was excited to see my baby drone. On receiving the items, the box containing the drone felt really light and I did not want to believe what I was thinking, I took it all to the car and went back home.

Finally, I unboxed the drone, and looking at the inferior parts it came with, I immediately knew that was a red flag, how could this thing possibly fly, I asked myself. Oh well, I thought it might not be that bad and went ahead to fix the parts together piece by piece till I was done. The drone looked like a bad guy already, and I turned on the camera, sad to say but this stuff had one of the worst pixels I've seen, redmi phones have better cameras. I ignored the camera and took it out to perform a flight test together with my little cousin.

Feeling like a drone pilot already, I made the first attempt to make the drone take off and it seemed like every control was the direct opposite and this stuff could not fly above my knees, I was mad at that point. Guess who was excited? My little cousin was amazed by the ability of that shit to at least try to get up from the ground, girl was having the time of her life and then there was me on the other end thinking of how to return this piece of a joke.

Others

• Attended my first tech meetup in Enugu, it was a flutter developer meetup. I Met Mrs. Cynthia Peter and Sage for the first time physically.

• 25th May, I had the privilege to meet up with Ayo who was a speaker at the polygon Guild event in Enugu. Two days later, I also met Big Joe who also was a speaker.

• May 27th was a Friday, end-of-the-month party at Xend finance and I was in attendance together with organizers & Speakers for the Polygon Guild event.

• Polygon Guild Enugu had its maiden event on the 28th of May, 2022. It was a big one, with amazing techies around.

June 2022

Back to work after I had almost messed up by not informing my colleagues about my unavailability due to my commitment to organizing Polygon Guild last month. Another Big Tech event was about to hit Enugu again; The Binance BCAT event is one I'll love to refer to as a "tech concert", reasons because it featured celebrities like Dan dizzy and Alex Ekubo, with over 4000 in attendance.

I personally did not want to get involved with organizing because of work, and my goal for this event was to get away with as many swags as possible together with IK, my guy. Before the main BCAT event, there was another mini event that happened to be the reason why I own a wicrypt device, got that baby for free, and this was the beginning of my swag hunt and it felt good.

June got me a connection with Ernest, "onyeoma" at boundless pay. We started talking after I informed him of my intentions to fly to Lagos for a blockchain event just to perform some Ticktok wonders, he felt it was a good idea and this was the beginning of my preparation for another web3 event called "Blockchain Vibes Lagos".

Others

• Purchased a MacBook

• Attempted to do a pedicure for the first time, which turned out to be the last time because this left me with a serious injury.

• Finally got my international passport in preparation for my trip to Dubai for the world cup with my friends and somebody's daughter.

July 2022

The Blockchain vibes event was drawing closer and had to book flights to Lagos and the cost felt like I should just use Peace Mass instead of air peace.

God no go shame me, on the 8th of July, I was excited and already packed my bag the previous day. Like any Lagos flight, you'll most likely see one celebrity, in my case, it was Yul Edochie sitting comfortably in business class while I walked past shamelessly to economy class.

The flight was smooth and got to Lagos to meet heavy rain which almost got my Mac spoilt. The cost of transportation from the airport to my Airbnb on the island reminded me of the reasons why I will not pitch my tent in Lagos.

Speaking of my Airbnb, it is a true definition of beauty. You know when people do "what you ordered vs what you got" and what you got was terrible, well this wasn't my case, the environment on the inside out felt it was made just for me.

A few days before 23rd Jul, Uche called me and needed me to show up for a wedding engagement which he tried to deny wasn't for him.

Others

• Attended Blockchain Vibes Lagos on the 9th of Jul, and was it worth it? It's either a yes or No, so No.

• Visited Landmark beach to compensate for the disappointment the previous day.

• Got back to Enugu and attended Google I/O.

• I registered for my PVC

August 2022

August felt like my breakthrough month regarding my skincare routine, felt like this was finally making sense after all. This same month I got the information about the Dubai visa ban on Nigerians and my plans to make the trip was immediately ruined, but the money was saved.

I started working on an idea of mine, called this "Kira", Kira is a WhatsApp bot that provides automated buying and selling of goods and services without the need for a web or mobile app. Because of this, I created and registered a parent company together with Chibueze and Anderson, called Vendbase.

On a sad note and for some reason, my employers could not pay salaries anymore due to bankruptcy, this gave rise to thoughts of moving to a new place where I'll be challenged beyond what I already know and get better pay as well. I began job hunting through Linkedin and other web3 career listing platforms.

Others

• Had my first virtual speaking engagement hosted by mara.

Sept 2022

Have you ever anticipated rejection emails? Well, this was my mindset because of the way I submitted my applications in bulk and most times without reading job requirements; I was desperate, tired, and on the verge of just giving up on job hunting. Coupled with the fact that companies were laying off workers in large numbers, how do I even tell my mum I'm trying to compete with someone who just left Google or Microsoft? 😂 I realized this and kept using this as an excuse for the massive rejection emails.

A few days into the month, Apple released the iPhone 14 series and other amazing gadgets and it felt like a good time to appreciate the hard work they had put in and purchase a second iPhone. The main reason behind the purchase was my constant nagging about how small my initial device was compared to my palm size, as usual, I randomly stepped into a dealer's shop and performed magic.

I got invited to speak at GDG Enugu Code jam, on "The fun side of Coding, Creative Problem solving". If you asked me what transpired on that virtual call, I shamed myself but na only me notice am. I really didn't have time to think deeply about the topic and the timing too was not the best for me because I was on some mini vacation outside Enugu during that period and had plans to just chill and do less brain work.

About the vacation, I traveled to Owerri and spent most of my days indoors at BonTripod Hotel. If you are looking for a very nice environment and got the money to spend, bon tripod hotel is a place to try out.

Just before the month ended, I started working on Bonpay, which is a crypto payment framework for accepting payments on your existing apps in crypto or NFT. I'm currently looking for designers to jump on this project to create a landing page for this in the spirit of open source. Check out a demo here.

Oct 2022

To start the month with bliss, Uche got married to his baby on the 8th of Oct where I served as not just a hot kid but a shameless & humble pilot for his baby.

Still semi-jobless, ASUU decided to call off the 8-months strike without collecting payment, DumbFucks! I'm sorry but hear me out, why would you do shakara and still trip? why? mtcheww .... I wasn't entirely happy with the news because my goal to resume school working in a new web3 role looked far-fetched.

On the 5th of Oct, I finally completed the bonPay project in two weeks and it was ready for production use, it shipped with a web and react SDK. Yay!! Felt like codemon again.🫣

Back to the whole job hunting thing, I realized sending applications were no longer working and decided to make use of my network. Reached out to my boss, mentor, and CEO of xend finance informing him about my difficulties and need for a new role, he requested what I looked for in a role which I sent in immediately, and after three days he informed me about a possible role coming from a friend of his.

The next Saturday morning, I got a call from Sir Eke who's the CEO of risevest, and spoke for about 20 mins, there and then was the end of my job hunting. Let me re-phrase something sir Eke said during the call, he said "Feel free to end your job hunting", and this was how I resumed a Senior Blockchain engineering role without any interviews or DSA tests, I also was able to resume school the happiest and most recent employee at assetBase.

Others

• Got accepted into the Master track of the Polygon African Bootcamp

• Selected to advocate for blockchain adoption as a Mara Campus Campus in FUTO.

• My eyesight got bad and visited a clinic for a checkup and expensive test just to be given an eye drop to go home with and return next year.

Nov 2022

On the 1st of Nov, we lost my own son, ifeanyi Adeleke 😩. How could such a bad thing happen to my own Davido, he's such a good man for God's sake nau!

Back to school, feeling all pumped up and ready to finally finish a 5-year course turned almost 7 years. I resumed on the 4th of Nov and Immediately remembered how terrible my network would get and how many debit alert I would be getting during this period.

A few days after the resumption, Chidera invited me to meet with the core-team members of the GDSC community on campus and that exactly was something I had in mind, reason because I admired the team spirit and needed the same type of energy for the Mara developer community.

Everyone on that team felt normal, just one person's character stood out, not for bad though. Amarachi pulled up late, and even though she apologized, I was so certain e no really concern her, this move and more made me pick interest to know what was inside the girl's head, but sha na just first impression, nothing much 😂. Although she didn't get to be a campus captain, I made sure she was part of the team.

During the meeting, I did some motivational talks and finally was able to refer a few persons as Mara campus captains, Cisca and Chidera emerged captains thereafter.

Register to join Mara on Campus

https://docs.google.com/forms/d/e/1FAIpQLSfRTJsg-zZX3WAuMhA5eKy7jsLSi2JbHr6JOyEUWDaZgx-kRQ/viewform

As a way to show fan love, I mounted a frame of my fav artist just side by side with my own picture frame on my wall, at some point it felt like we had some resemblance but no, it's just my brain playing with me.

Later into the month, specifically on the 21st of Nov, I had my first project defense and it was a success even though I did not have my project ready beforehand.

Others

• Spoke at a Twitter Space hosted by sendchamp

• Preparations for Mara developer Campus Club meetup started.

• Final year exams started on the 28th of Nov.

Dec 2022

Finally, we are here! Exams, Events, Debits, etc. It was just a lot and remember I still got work to do ooh! Spotify sent in my wrap for the year and I only wondered why Davido did not make number one on my Top Fav Artists, he's number one in my heart always.

GDG Owerri DevFest was on the 10th of Dec and even though I wasn't ready to make any technical presentations, I still ended up taking up the role of " Minister of Enjoyment" and this meant I was going to lose money to make people happy, well played Joy. Thanks to Chidera and the upper echelons at Google, we were able to transport a good number of students in FUTO, to and fro.

The following day was my fellowship send forth, I attend RCF on campus once once 😂. I left the fellowship with just one friend; Do You remember Faith from the month of March? She's one big aunty in whom I'm well pleased, patronize her.

With an amazing team, together we successfully organized an info session for the Mara Developer Campus Club on the 17th of Dec, and the event was graced by the presence of both Idris and Paloma who are both Dev Rel and Dev Advocate at mara, respectively. Later that day, I attended a picnic organized by my departmental-level mates because I needed to taste chicken.

Others

• 9th of Dec, I wrote my last final year exams.

• Got a Christmas package from sendchamp.

Conclusion

I'm eternally grateful to God for the gift of men and for constantly directing my steps in the right direction. I had a wonderful 2022, hope you did too.

Shout Out

To you! Yes, you. For taking out time to read this long article. And to my baby, who's my baby? 😂

Did you get something out of this article? Let me know in the comment section, I'll be happy you did.

Plans for 2023

• Support more people in the web3 Space with my full chest.

• Attempt to contribute to the go-ethereum project.

• Move to a new apartment.

• Catch more flights.

• Improve my technical competence.

• Attempt building a startup.

• Make more meaningful connections.

An interface in Go defines a set of methods that a type must implement to satisfy the interface. This means that any type that implements the methods defined in an interface is said to implement the interface.

For example, suppose we have an interface called Shape that defines the methods Area() and Perimeter() for calculating the area and perimeter of a shape. We could define the Shape interface like this:

type Shape interface {
    Area() float64
    Perimeter() float64
}

Now, any type that implements the Area() and Perimeter() methods can be said to implement the Shape interface. For example, we could define a Rectangle type that satisfies the Shape interface like this:

type Rectangle struct {
    width  float64
    height float64
}

func (r *Rectangle) Area() float64 {
    return r.width * r.height
}

func (r *Rectangle) Perimeter() float64 {
    return 2 * (r.width + r.height)
}

Here, the Rectangle type implements the Area() and Perimeter() methods, so it satisfies the Shape interface. This means that we can use a Rectangle value wherever a Shape is expected, and the appropriate method will be called automatically.

In this way, polymorphism in Go allows us to write code that can work with multiple types in a consistent manner, without needing to know the specific type of an object at compile time.

Example Code

package main

import "fmt"

type person struct{
    firstname string;
    lastname string
}

type human interface{
   talk()
}

func (p person) talk(){
  fmt.Println("My name is", p.firstname)
}
func main(){
    person1 := person{
        firstname: "Alfred",
        lastname: "Johnson-awah",
    }

    person1.talk()
}

In the code above we created a person struct which has the firstname and lastnameproperties. To showcase polymorphism, we created an interface with a function of talk. Lastly, we have implemented the talk function and attached it to a struct type of person . This means that any identifier of type person would always have a method talk and at the end of the day, we can boldly say that the identifier (person1 in our case) is of both person and human type, this is polymorphism.

You can still go ahead and add more complex code by implementing type assertion using a switch statement as seen below.

package main

import "fmt"

type person struct {
    firstname string
    lastname  string
}

type seniorMan struct {
    person
    hasACar bool
}

type human interface {
    talk()
}

func (p person) talk() {
    fmt.Println("My name is", p.firstname)
}

func (p seniorMan) talk() {
    fmt.Println("I am a person and senior man, see my ID", p, "and i have a car too", p.hasACar)
}

func resolveType(h human) {
    switch t := h.(type) {
    case person:
        fmt.Println("This is a normal person", t.firstname)
    case seniorMan:
        fmt.Println("This is a senior man, does this person have a car?", t.hasACar)

    }
}
func main() {
    person1 := person{
        firstname: "Alfred",
        lastname:  "Johnson-awah",
    }

    seniorMan1 := seniorMan{
        person: person{
            firstname: "Joe",
            lastname:  "Biden",
        },
        hasACar: true,
    }

    resolveType(seniorMan1)
    resolveType(person1)

    person1.talk()
}

Running this code on the console, your output should be like the below:

This is a senior man, does this person have a car? true
This is a normal person Alfred
My name is Alfred

The seniorMan struct type inherits properties of the person struct type with an additional property hasACar . The most important exerpt of this code is the resolveType function which uses a switch state to person type assertion on interfaces to find out their underlying types and execute the correct block of code.

Conclusion

In this blog post, we learnt about polymorphism and how it stems from interface implementation.

In this blog post, we will learn about upgradeable smart contracts, different upgrade patterns, reasons behind smart contract upgrades, and finally, how to utilize the Hardhat framework to aid in deploying and implementing smart contracts that can be upgraded or updated. You can always deploy and interact with upgraded smart contracts on different chains or networks, but we would deploy our contracts to the polygon network for speed, low gas fees, and security.

Prerequisites for this article include fundamental knowledge of smart contract development with solidity, some level of familiarity with terminal (bash/cmd), and good knowledge of javascript. Going forward, I'll assume you understand how the blockchain works, have prior programming experience, know what smart contracts are, and have had some time to review some polygon basics.

If you are not interested in the theoretical aspect, feel free to jump to the code section of this blog post and begin to implement an upgradeable smart contract.

What are Upgradeable Smart Contracts

Before proceeding to discuss upgradeable smart contracts, let's briefly talk a bit about some characteristics of smart contracts and the EVM. Smart contracts were created to be immutable once deployed ( assigned a hex address ), for this reason, the term "upgradable smart contracts" might be counterintuitive, but hold on 🫣.

During the process of upgrading smart contracts, you are still following the immutability law of smart contracts, but instead of making changes to the contract to be updated, you replace it with a new copy of a smart contract. It's almost like upgrading your Lexus car; upgrades are typically accomplished through "facelifting," which is the process of removing the old exterior and replacing it with new parts that are similar to those found in a later model of your Lexus car.

Let's quickly see a few reasons why you might want to make your smart contracts upgradeable:

• Bug fixes before an exploit take place. to boost performance.

• Modifying functionality that is no longer necessary or deemed useful. to make the code more efficient in its use of Ethereum gas. to adapt to changes in society, markets, or technology. to avoid the necessity of transferring an entire user base to a new version of the application.

How to upgrade smart contracts

There exist various methods of implementing upgradeable smart contracts, but all follow the proxy principle. The proxy principle is a software engineering practice that involves eliminating direct messaging or access to another system. For example, instead of sending requests directly to a backend server, there would exist a proxy server that receives this request and later sends it on behalf of the client or sender; this process is called a reverse proxy. A proxy would serve as a middleman between two software programs. A similar approach is implemented for an upgradeable smart contract.

So, in the context of smart contracts, there would be a proxy contract and a logic contract. Dapp users would always interact with the proxy contract, and a similar function call is made on the logic contract. Like any other smart contract, the proxy contract includes functions and data storage. As mentioned initially, users communicate directly with the proxy contract instead of the logic contract, and one would expect that a proxy contract contains similar functions as the logic contract. But that's not the case; I'll explain.

When a function call is made to a proxy contract, the contract checks if that function exists; otherwise, a fallback function is called on the proxy contract. Inside this callback function on the proxy contract are implementations that attempt to call the same function made by the user on the logic contract but in the context of the proxy contract.

In conclusion, utilizing the proxy pattern would include the need for a proxy contract and a logic or implementation contract. It's also important to note that logic contracts are the only ones that would get replaced while keeping the address of the proxy contract the same.

There are three methods of implementing a proxy pattern, which includes:

1. Simple Proxy Pattern

2. Transparent Proxy Pattern

3. Universal Upgradable Proxy Standard (UUPS)

To save time, we would cover just the simple proxy pattern and the transparent proxy pattern because I am kind enough.

Simple Proxy Pattern

This method of implementing an upgradeable contract basically involves a user directly calling a proxy contract instead of the logic contract. Both the proxy and logic contracts have something in common: an execution context. An execution context is basically an environment or space where code is run. Every smart contract has its own execution context. Also like any other contract, the proxy contract has its own state and by taking advantage of this we can easily replace the logic contract and still retain the state on the proxy contract.

The proxy contract uses storage variables to keep track of the address of the logic smart contract. This is how it can redirect transactions and invoke the relevant logic smart contract. Proxy contracts can make calls to the relevant logic smart contract by making use of something called a [delegateCall] (https://docs.soliditylang.org/en/v0.8.6/introduction-to-smart-contracts.html?highlight=delegatecall#delegatecall-callcode-and-libraries).

A delegate call is somehow different from a regular function call in the sense that the code at the target address is executed in the context of the calling contract. In our case, the code from the logic contract is executed in the context of the proxy contract, and state changes are eventually made on the proxy contract, therefore decoupling the application. If the logic contract’s code is meant to cause a change in storage variables, those changes are reflected in the proxy contract’s storage variables, i.e., in the proxy contract’s state.

From the look of things, we can refer to the proxy contract as the data contract, and for this reason, the proxy contract should not be replaced but rather the logic contract.

When the proxy contract receives a function call for a function that it does not support, the proxy contract’s fallback function will be invoked to handle that function. The proxy contract uses custom logic inside its fallback function, where a delegate call would be implemented to redirect calls to logic contracts.

Now that the application state and the application logic are decoupled in the EVM, we can upgrade the application by changing the logic contracts and giving the new addresses to the proxy. But the application’s state isn’t affected by this upgrade.

Transparent Proxy Pattern

Function calls initiated by the end user are always routed to the logic contract rather than the proxy contract. If the caller is an administrator of the proxy, however, the proxy will invoke its own administrative function.

Calling administrative functions in the proxy contract to manage upgradeability and other administrative tasks should only be performed by an administrator, and if a conflict occurs, it is reasonable to assume that the administrator intended to call the proxy contract's function and not the logic contract's function. If the caller is a non-administrator address, however, the proxy will always delegate the call to the relevant logic contract. The caller can be identified by examining the message.sender value.

In this pattern, the proxy contract would have logic in its fallback function to parse message.sender and the function selector that is being called, and accordingly invoke one of its own functions or delegate out to a logic contract.

Code Time: Upgradeable smart contracts with hardhat

In this section, we will be making use of the transparent proxy pattern, utilizing contracts from OpenZeppelin and Hardhat for development.

Within the Hardhat development tool lie functions like deployProxy that track the logic contract for us and give us easy access to upgrade functionality. By default, the address that deployed the contract is the one that has admin rights to upgrade it.

To create a new Hardhat project, create a new directory and name it whatever you want, then copy and run the commands below.

 npm init --y

 yarn add -D @openzeppelin/contracts-upgradeable @openzeppelin/hardhat-upgrades @nomiclabs/hardhat-ethers ethers dotenv

The first command will simply generate an empty npm project without going through an interactive process. The y stands for yes. The latter will download the necessary dependencies for our project.

Finally, to complete the setup for hardhat, run yarn hardhat, you'll be faced with an interactive terminal. Create a javascript project, place the hardhat project at the root, add a .gitignore file and you should be good to go.

This command would create a default ``hardhat.config.js```. This file created would be placed at the root of your project directory and comes along with some default settings which you should overwrite by pasting in the code below.

require('dotenv').config()
require("@nomiclabs/hardhat-ethers");
require("@openzeppelin/hardhat-upgrades");

const MUMBAI_RPC_URL = process.env.MUMBAI_RPC_URL
const PRIVATE_KEY = process.env.WALLET_PRIVATE_KEY_DEV;

module.exports = {
 solidity: "0.8.17",
 defaultNetwork: "mumbai",
 networks: {
   localhost: {
     chainId: 31337,
   },
   mumbai: {
     url: MUMBAI_RPC_URL,
     accounts: PRIVATE_KEY ? [PRIVATE_KEY] : [],
     chainId: 80001,
   },
 }
};

Mumbai is the testnet for the polygon network, to get an RPC URL head to alchemy and create a new app setting the network to Polygon Mumbai, then copy the HTTPS URL and paste it into your .env file. Your .env file should be placed at the root of your project and should have contents like:

MUMBAI_RPC_URL=https://polygon-mumbai.g.alchemy.com/v2/<APIKAY>
WALLET_PRIVATE_KEY_DEV=<YourPrivateKey>

You can test your setup by compiling the contracts created for you by running the command: yarn hardhat compile . This would compile all contract files in the contracts directory if it has not compiled the files in that folder before or one of the solidity files has changed beforehand, you have two new folders, “Artifacts” and “cache,” in your project directory.

Next, we would make use of the existing contract created for us by hardhat and prepare this contract to be upgradeable. To make this happen, the Lock contract needs to inherit the Initializable from openzeppelin upgradeable contract and lastly, create one important function with a name initialize. Copy and Paste the code below into your contracts/Lock.sol file and after that, I'll explain some important patterns noticed.

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;

import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
// Uncomment this line to use console.log
// import "hardhat/console.sol";

contract Lock is Initializable {
    uint public unlockTime;
    address payable public owner;
    address payable private admin;

    event Withdrawal(uint amount, uint when);

   function initialize(address _admin) public initializer {
       admin = payable(_admin);
       owner = payable(_admin);
   }

    function withdraw() public {
        // Uncomment this line, and the import of "hardhat/console.sol", to print a log in your terminal
        // console.log("Unlock time is %o and block timestamp is %o", unlockTime, block.timestamp);

        require(block.timestamp >= unlockTime, "You can't withdraw yet");
        require(msg.sender == owner, "You aren't the owner");

        emit Withdrawal(address(this).balance, block.timestamp);

        owner.transfer(address(this).balance);
    }
}

One thing to notice is that this contract does not have a constructor function which is weird. The reason behind this stems from a rule which states that when using Open Zeppelin upgradable contracts, we cannot include a constructor in our smart contracts.

Instead, we create our own construtor-like functionality by extending the Initializable base contract, which helps us apply an initializer modifier to the initialize() function. We can name the initialize function anything we like, but by using initialize, the Hardhat plugin will recognize it and will call that function by default. If we have an initializer function by another name, we would need to specify the name of our initializer. OpenZeppelin Contracts provides the Initializable base contract that allows you to tag a method as initializer, ensuring it can be run only once.

Deploy Contract

When deploying this contract, we will need to specify the initializer function name (only when the name is not the default of initialize) and provide the admin address that we want to use. To deploy our contract, we need to update the deploy script found in scripts/deploy.js, copy and paste the code below into the deploy file.

// The Open Zeppelin upgrades plugin adds the `upgrades` property
// to the Hardhat Runtime Environment.
const { ethers, network, upgrades } = require("hardhat");
const fs = require('fs');

async function main() {
  var dir = './deployed';

  if (!fs.existsSync(dir)){
    fs.mkdirSync(dir);
  }


 // Obtain reference to contract and ABI.
 const LockContract = await ethers.getContractFactory("Lock");
 console.log("Deploying Lock to ", network.name);

 // Get the first account from the list of 20 created for you by Hardhat
 const [account1] = await ethers.getSigners();

 //  Deploy logic contract using the proxy pattern.
 const LockContract_ = await upgrades.deployProxy(
   LockContract,

   //Since the logic contract has an initialize() function
   // we need to pass in the arguments to the initialize()
   // function here.
   [account1.address],

   // We don't need to expressly specify this
   // as the Hardhat runtime will default to the name 'initialize'
   { initializer: "initialize" }
 );
 await LockContract_.deployed();
  await fs.writeFileSync(`${dir}/proxy.txt`,LockContract_.address)

 console.log("LockContract deployed to:", LockContract_.address);
}

main();

In other to run the script and deploy our contract to the mumbai testnet, we make use of hardhat on the terminal by running the following command:

yarn hardhat run ./scripts/deploy.js

The script does a couple of interesting things:

1. Creates a text file under a directory where we save our deployed proxy address for easy retrieval.

2. Deploys our logic contract using proxy pattern and contracts interface by open zeppelin.

3. Initialize the contract by setting your wallet address as the admin.

4. Saves the address of our proxy/data contract to a file in our working directory.

Upgrade Contract

Previously we have deployed our logic contract using the proxy pattern and saved our address to a file. Moving forward, let's create an upgraded version of the lock contract. Create a new file under the contracts folder and name it contracts/upgrade_lock.sol, copy and paste the upgraded contents and we would review the code in a bit.

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;

import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
// Uncomment this line to use console.log
// import "hardhat/console.sol";

contract UpgradedLock is Initializable {
    uint public unlockTime;
    address payable public owner;
    address payable private admin;

    uint public ownerBalance;

    event Withdrawal(uint amount, uint when);

   function initialize(address _admin) public initializer {
       admin = payable(_admin);
       owner = payable(_admin);
       unlockTime = block.timestamp;
       ownerBalance = 50;
   }

    function withdraw(uint amount) public {

        require(block.timestamp >= unlockTime, "You can't withdraw yet");
        require(msg.sender == owner, "You aren't the owner");
        require(ownerBalance-amount > amount, "You can't withdraw that amount,too much");
        emit Withdrawal(amount, block.timestamp);

        ownerBalance -= amount;
    }
}

In our previous Lock contract, the withdraw function was defined in such a way that it would drain the contract's funds and send them to the owner. But in our current implementation of the upgraded Lock contract, we want the owner to specify the amount they wish to withdraw and also introduced a new variable to track the amount the owner has left which we can later on read because it is a public variable.

Now we have our upgraded Contract, it's time to actually write a script that would help us to upgrade our previous logic contract with a new and improved version. To do this, create a new script file and call this one scripts/upgrade_lock.js , then copy and paste the code below.

const { ethers, upgrades } = require("hardhat");
const fs = require("fs");

async function main() {

  const deployedProxyAddress = fs.readFileSync('./deployed/proxy.txt',{
    encoding: 'utf8'
  })
  console.log('Lock Contract Proxy Address: ' + deployedProxyAddress)

  const UpgradedLockV2 = await ethers.getContractFactory(
    "UpgradedLock"
  );

  console.log("Upgrading Lock Contract to V2...");

  await upgrades.upgradeProxy(deployedProxyAddress, UpgradedLockV2);
  console.log("Lock Proxy upgraded");
}

main();

In the above script we retrieve our proxy address previously deployed from the text file and supply it to the upgradeProxy function together with the contract factory of the new version of our Lock contract. Now everything looks good and ready, you can now run and upgrade your lock contract by running the following command below.

yarn hardhat run ./scripts/upgrade_lock.js

If your script runs successfully, your terminal should have a similar output as below but a different proxy contract address.

Lock Contract Proxy Address: 0x7C40C2af5073132f5C3c5cc04A270a8104Dd5E19 
Upgrading Lock Contract...
Lock Proxy upgraded
✨  Done in 55.41s.

To actually verify that the contract has been upgraded, you shouldd visit the address on polygon ether scan and navigate to the events tab where you would see the latest event emitted, which is a deployed event. In my case the url for my deployed contract is https://mumbai.polygonscan.com/address/0x7C40C2af5073132f5C3c5cc04A270a8104Dd5E19#events.

You probably noticed the highlighted address, this is the address of the upgraded contract. So this obviously means that for every upgrade, there's a new implementation contract deployed and this is the only address that gets to change, the proxy contract address always remains constant.

Interact with deployed contract

To interact with our deployed contract, it's usually easier to visit the address on the block explorer and play with the contracts method but in this case, it's going to be a little bit technical to carry out because we are dealing with proxy contracts and we also have imports from GitHub which would also be an issue at some point and would require getting API keys from polygon scan. So to tackle this, we are going to be interacting with our contract using the hardhat tool on the terminal.

Now let’s use the Hardhat console to interact with the upgraded contract.

Run the following command to enter into hardhats interactive node environment.

yarn hardhat console

Your output should look like blow:

Welcome to Node.js v14.19.3.
Type ".help" for more information.
>

Currently, the terminal expects some javascript code and right now, we are set to start writing some code, something you probably are already used to. You can copy and paste the following code into your terminal.

 const LockV2 = await ethers.getContractFactory("UpgradedLock")

 const deployedlockV2 = await LockV2.attach("0x7C40C2af5073132f5C3c5cc04A270a8104Dd5E19")

 await deployedlockV2.withdraw(1)

 let currentBalance =  await deployedlockV2.ownerBalance()

Here's a brief explanation of what's going on there:

• We are getting the upgraded contract factory.

• Attaching the deployed proxy address to the contract factory.

• Call the withdraw function.

• check the new balance of the owner.

You might end up with a fail transaction due to errors from your HttpProvider, alchemy. One solution to this is to change to another provider or switch to the goerli test net and make sure to update your RPC URL with one that interacts with the Ethereum goerli network.

Why Polygon?

Things are hard, why make life even harder for yourself or your team? There are a couple of drawbacks with most blockchain networks which include the High cost of transactions on-chain, very slow speed, security concerns, etc. Deploying on the polygon network gives you unbeatable access to very low transaction cost ( almost costs nothing), super fast transaction settlement, high throughput, and still implements the best of security strategies (zk proofs). Polygon offers a variety of solutions for everyone including the polygon supernet, polygon zkEVM, which I strongly recommend you check out and explore one of these unique products and what they have to offer. Want to get started with polygon? Visit their website today and thank me later.

Conclusion

In this long blog post, we have learned how to use the hardhat development framework to deploy smart contracts, upgrade a smart contract using the Transparent proxy pattern, view and read events on the block explorer and finally interact with your deployed contract via the hardhat interactive console. I hope you've learned a couple of new things, in case you have issues with running the code feel free to drop a comment or reach out to me on Twitter. Here's a link to the repository that contains all the code in this tutorial.

What is OpenZeppelin

The standard for secure blockchain applications. OpenZeppelin provides security products to build, automate, and operate decentralized applications. They also protect leading organizations by performing security audits on their systems and products. Cool yeah? Openzeppelin provides standard interfaces that smart contract developers can use to build tokens of various ERC standards.

Build Secure Smart Contracts in Solidity

OpenZeppelin Contracts helps you minimize risk by using battle-tested libraries of smart contracts for Ethereum and other blockchains. It includes the most used implementations of ERC standards. If you are feeling like you've been doing things the wrong way, now is the time to repent, get started with using Openzeppelin contracts today.

Openzeppelin Defender

Now you know a little bit about openzeppelin, it's about time to talk about Openzeppelin Defender. Going further I'll be referring to "Openzeppelin Defender " as just "defender". Defender is a web application that helps you to manage your already deployed smart contract with lower risk, on most EVM-compatible chains. Defender comes with four different sub-features which include admin, relay, autotask, and sentinel. We'll go through each of these sub-features one after the other and in another blog post, I'll explain how to use these individual sub-features.

Admin

The admin feature in defender provides an interface to automate and secure all your smart contract administration. Administration mistakes on protocols and applications put user funds at risk. With Defender Admin, you can seamlessly manage all smart contract administration including access controls, upgrades, and pausing. And one exciting thing is that it works with popular multi-sigs including Gnosis Safe. With admin, you get to add contracts using the address and create proposals.

A proposal is basically a request to make certain administrative function calls to the contract. It would typically include functions from your contract that modifies the state of your contract. To get the best out of this feature, it's recommended that your contract is EIP-1967 compliant. You can still add a contract to Defender Admin and run admin operations on it. Proposals must be approved by all admins before the function in there can be executed.

Relay

The Defender Relay service allows you to send transactions via a simple HTTP API or directly from your Autotasks, via unique accounts assigned exclusively to you. Relay takes care of private key secure storage, transaction signing, nonce management, gas price estimation, and resubmissions. Another good side is, all your transactions are broadcasted through multiple network providers for high availability. With relayers in the picture, you don’t need to worry about securing your private keys in your backend scripts or monitoring your transactions to ensure they get mined. Relayers are perfect solutions for most back-end tasks such as air-dropping NFTs, moving funds, and administrative management for your protocol. In conclusion, relay eliminates the need to use private keys which usually would serve as a signer or provider on your back-end during transaction calls.

Autotasks

Just as the name implies, autotasks allow users to schedule and automate calls to the smart contract. Think of cron jobs for your contracts. In a nutshell, an Autotask is a snippet of javascript code invoked at a regular interval, similar to a serverless function. And as a matter of fact, they are implemented with Lambda functions. With Autotasks, you can also use features from the relay service as well, the defender has a way to connect the two to create magic. Autotasks are quite interesting and I'll dedicate a whole article talking about how to get the best out of them.

Sentinel

The sentinel services offer transaction monitoring capabilities to your smart contracts based on certain pre-defined conditions. Conditions could be when an event has been triggered, a function has been called, or transaction calls with certain critical parameters. You can use Sentinel to report to the government a suspicious transaction that has occurred. Sentinels do not stop a transaction from occurring, they basically let you know certain conditions were met during a transaction or function call. For instance, you want to get an alert when an address deposits a particular amount of ether to your contract. Notifications to such triggers can be gotten via email, slack, discord, datadog, or telegram.

Conclusion

Defender provides components that you probably have written yourself, you should consider moving that to a more secure and battle-tested platform and save yourself the thought of things going wrong with your implementation. To me, the defender is a mini cloud service provider and another awesome web2/3 implementation.

Lastly, if any of these four components interests you and would want to ensure I make a dedicated blog post for each of them, leave a comment below and that would make sure they would leave my drafts. See you on the other side 🇳🇬.

How to identify a generic

Generics can be associated with functions, enums, structs, return type and variables.

In Function Definitions

pub fn returnData (name: &char) -> &char{
  name
}

pub fn returnData<T> (name: T) -> T{
  name
}

The first function can be identified as a regular function with no generic syntax, but on the other hand, we have another function, which does the same thing but this time uses a generic. We can consider the second function as a better approach, why? Utilizing generics, in this case, gives us the freedom to pass any data type as a parameter, unlike the first function which requires only a parameter of data type &char.

returnData<T> means, this function accepts one parameter of type T. T literally means, any type e.g int, uint, floats, struct, etc. You could actually name is anything but the convention is T which means Type, we can decide to re-write the function using a new name like returnData<MyType>, and this works fine so far as you use this same name as the parameter type (name: MyType) and maybe a return type ( -> MyType). The whole <T> thing you see is the presence and usage of a generic.

fn main() {

pub fn returnData<T> (name: T) -> T{
  name
}
let data = returnData(String::from("Alfred"));

let age = returnData(27);
println!("{} is my name", data);
println!("{} is my age", age);

}

Try it here.

In Struct Definitions

struct User {
  name: &String,
  email: &String,
  age: u8
}

struct User<T,U> {
    name: T,
    email: T,
    age: U
}

Structs are used to create user-defined data structures, and we can use generics to make them even better. You can see the difference between the two structs, the second introduced the generic data type.

Focusing on the second struct, with name as User, we expect this struct to have fields with either a data type of T or/and U. Again, T could be of any type i.e signed integer, unsigned integer, floating-point numbers, or even char.

fn main(){

struct User<T,U,V> {
    name: T,
    email: U,
    age: V
}

struct Fullname {
 fname: String,
 lname: String
}

let user1: User<&str, &str, f64> = User { name: "Alfred", 
email: "alfred@codemon.me", age:10.1};




let _fullname = Fullname { fname: String::from("alfred"), 
lname: String::from("johnson") };

let user2: User<Fullname, &str, u8> = User { name: _fullname, 
email: "fred@gmail.com", age: 32};


println!("User 1: name is {}, email is {} and age is {}",
user1.name, user1.email, user1.age);

println!("User 2: first name is {}, last name is {}, email is {} and age is {}",
user2.name.fname, user2.name.lname, user2.email, user2.age)

}

Try it here.

In enums

Enums are similar to structs mostly in syntax but personally, it's used to define custom data types just like structs. The fields in an enum are expected to be related in some way, unlike struct which gives more flexibility.

enum Colors {
  red,
  green,
  blue,
  custom(String)
}

enum Colors <T>{
  red,
  green,
  blue,
  custom(T)
}

Web developers know we can represent colors in different ways, hex, RGB, or by their name. The first enum does not give room for us to create a custom color, it must be a string. But with the second enum, we can define a custom color in our enum. Assuming we want to represent a custom RGB color, we can proffer a solution as seen below.

fn main(){

enum Colors <T>{
  Green,
  Blue,
  Custom(T)
}

let white_tuple = ("#","f","f","f");
let white: Colors<(&str, &str, &str, &str)> = Colors::Custom(white_tuple);
let blue: Colors<(&str, &str, &str, &str)> = Colors::Blue;
let green: Colors<(&str, &str, &str, &str)> = Colors::Green;
}

Conclusion

I hope you've been able to understand the generic syntax and maybe give you a solution to a problem you have been trying to solve.

Shoutout

Basically, I personally do not think react apps should be deployed to Heroku, just find the likes of netlifyor vercel, they do better with deploying react applications.

Tools you would need

• heroku cli
• node and npm
• git bash
• existing react app scafolded from create-react-app package

Let's Deploy that App

I'll have to say this, the best way to get your react app to heroku is via the cli tool. Deploying from a GitHub repository would show you pepper you might not have enough milk to help you. Below are the steps to follow, we are assuming you have your terminal open inside the projects folder. Follow the steps below to reach your promised land.

Step 1: Login to your heroku Account

After running the command below, you would be required to hit any key and you'll be redirected to a web interface to login to the account you'll want to use for this deployment.

heroku login

Step 2: Create an App on Heroku

You can skip this if you already have an app created on your Heroku account to where your react app should be deployed to.

heroku create react-heroku-codemon-way

A successful creation would output the URL of your newly created app, something like https://react-heroku-codemon-way.herokuapp.com | https://git.heroku.com/react-heroku-codemon-way.git

0x687d0848507F90dCE542d13D5A824575Df5aBBe0

You know what to do

Step 3: Add project to github remote

If you did not skip step 2, copy the git remote URL with a .git extension and keep. For an existing application, your URL should look similar to what we have in step 2, something like this https://git.heroku.com/your-app-name.git, copy that and keep. You can always get your Remote git url from your app dashboard, under the settings tab.

Now run the command below

git remote add heroku URL-You-copied

Step 4: Stage, Commit and Push to Github

git add .
git commit -m "Deploy in jesus Name"
git push heroku [branchName]

Branch Name could be main, master or rubbish , it's basically the branch you want to push to heroku. At this point, heroku does the remaining work , building a production build and then preparing your application to go live, it might take a while but it must work.

NB: If your react app uses environment variables, do not forget to add them from your heroku app dashboard, under settings.

Bye!!!

0x687d0848507F90dCE542d13D5A824575Df5aBBe0