Forem: Ayo Solomon

Golang Frameworks and Libraries for Blockchain Development: Empowering Innovation

Ayo Solomon — Sun, 11 Feb 2024 00:12:17 +0000

Blockchain technology has rapidly gained traction across industries for its ability to revolutionize processes and enhance security.

In the realm of blockchain development, Golang (Go) has emerged as a preferred programming language due to its efficiency, simplicity, and concurrency support. Leveraging Golang, developers can harness various frameworks and libraries to streamline blockchain development. Let’s explore some of the prominent ones empowering innovation in this space:

Hyperledger Fabric: Hyperledger Fabric is a popular framework for building enterprise-grade blockchain networks. Written in Go, Fabric enables developers to create permissioned, private blockchain networks tailored to specific business requirements. It provides modular architecture, allowing for flexibility in consensus mechanisms, smart contract execution, and membership services.
Ethereum Go (Geth): Geth is the official Go implementation of the Ethereum protocol. It serves as both a node for participating in the Ethereum network and a command-line interface for interacting with Ethereum smart contracts. Geth enables developers to deploy, manage, and interact with Ethereum-based decentralized applications (dApps) using Go.
Cosmos SDK: Cosmos SDK is a modular framework for building interoperable, scalable blockchain applications. Written in Go, Cosmos SDK simplifies the development of custom blockchains by providing essential building blocks such as governance, staking, and interchain communication protocols. It empowers developers to create sovereign, interconnected blockchain networks, fostering innovation in decentralized finance (DeFi) and beyond.
Tendermint Core: Tendermint Core is a Byzantine Fault Tolerant (BFT) consensus engine designed to be used with any application-specific blockchain. Written in Go, Tendermint Core provides a secure and efficient consensus mechanism, making it suitable for building high-performance blockchain networks. It can be integrated with various application layers, including Cosmos SDK and Ethereum.
Chaincode (Smart Contract) Libraries: Golang offers robust support for writing smart contracts, also known as chaincode in the context of Hyperledger Fabric. Developers can leverage libraries such as Hyperledger Fabric Chaincode SDK for Go to create smart contracts that govern business logic on blockchain networks. These libraries provide interfaces for interacting with blockchain state and executing transactions securely.
Bitcoin Go (btcd): btcd is an alternative full-node implementation of the Bitcoin protocol written in Go. While Bitcoin Core remains the predominant implementation, btcd offers an alternative for developers seeking to build applications on the Bitcoin blockchain using Go. It provides a comprehensive suite of tools and APIs for interacting with the Bitcoin network programmatically.
Go-Ethereum Libraries: In addition to Geth, the Ethereum ecosystem offers a plethora of Golang libraries for blockchain development. These libraries encompass various functionalities such as cryptography, transaction handling, and Ethereum Virtual Machine (EVM) integration. Developers can leverage libraries like go-ethereum/common, go-ethereum/crypto, and go-ethereum/ethclient to streamline Ethereum-based development in Go.
geth-lte: A rising star in the Ethereum development scene, geth-lte is a Go package designed to empower you with real-time insights into your EVM blockchain. Explore blocks, interact with contracts, and monitor mempool transactions seamlessly within your Golang applications. While still young, geth-lte holds immense potential for developers seeking powerful functionalities and an innovative approach to interacting with their blockchain data as they do easily with ethers.js on javascript Nodejs.

In conclusion, Golang’s robustness and performance make it an ideal choice for blockchain development. With an array of frameworks and libraries at their disposal, developers can accelerate innovation in the blockchain space, building scalable, interoperable, and secure decentralized applications.

Whether building enterprise consortia networks or exploring decentralized finance solutions, Golang empowers developers to shape the future of blockchain technology.

Happy coding!!

What is a private key

Ayo Solomon — Sat, 10 Feb 2024 23:17:06 +0000

Sometime ago I had a discussion or debate or argument with my brother over the safety behind the engineering of crypto/blockchain encryption. This was because I couldn't just shut up about blockchain.

His argument was simple “How do you know or how are you sure that these encryptions you say are secured and unbreakable is actually so, how do you know that they are actually unbreakable and that someone does not have the reverse engineering script hidden somewhere”, while i know a few things i want to share with my connections

Do not be like me,

Crypto keys can actually be decrypted but you will probably die doing it, what i mean is IT IS NOT WORTH IT and here’s why:

From a practical perspective, private keys are numbers within a specific range that allow funds to be spent (which is why keeping them secret is such an imperative).
From a mathematical perspective, a private key is just a random positive integer.

Here is a more technical and accurate description:
The range given to a PRNG(pseudorandom number generators) to securely create a valid Ethereum or Bitcoin private key is 2²⁵⁶ — 1 which is 1.1579209 × 10^77 an is written out as:
115,792,089,237,316,195,423,570,985,008,687,907,853,269,984,665,640,564,039,457,584,007,913,129,639,936,

Due to the immense size of this range, the probabilities of generating two private keys are negligible, which is the reason why your private key is unlikely to be created by another user. To put this into perspective, imagine a combination lock with 78 digits. Each digit can be any number from 0 to 9. Now, if you calculate all the possible combinations, you would have 10 possibilities for each digit (0 through 9). So, the total number of combinations is 10^78.. The set of integers your key is selected from is a massive number — it is roughly the same size as the total amount of visible atoms in the universe. It's akin to picking the same exact combination on that 78-digit lock out of trillions upon trillions of possibilities.

let's me highlight some things:

PRNGs are commonly used in computer programs and cryptography. It is a method used to generate numbers that seem random but are actually determined by a starting value called a seed.

In the context of cryptocurrencies like Ethereum and Bitcoin, a private key is a very important piece of information. It's essentially a secret code that allows you to access and manage your digital currency. Think of it like a super-secret password.

I would like to single out Random numbers to talk a bit about this and give some clarity on how improbable the idea of reverse engineering a public key is
Why is the private key derived from 2²⁵⁶ — 1, The range of 2²⁵⁶ — 1 has been adopted by both Bitcoin and Ethereum, and it works due to the mathematical strategies both blockchains use to create public keys. For instance, Ethereum uses elliptic curves (particularly SECP-256k1) for its public key generation.

In a binary system, the largest number that can be represented with 256 bits is when all bits are set to 1.

In computing, information is stored using binary digits, which can be either 0 or 1. It's a language computers use to represent and understand data. So 2²⁵⁶ is a mathematical way of saying "2 multiplied by itself 256 times." and in computer terms, it represents an incredibly large number because each multiplication by 2 doubles the value.

When you have 256 binary digits, it means you have 256 slots where you can place either a 0 or a 1, if all 256 slots are filled with 1s, you get the largest possible number that can be represented with 256 binary digits. It's like having a digital counter with only 0 and 1, it only goes up to 1 in each slot.

When you subtract 1 from 256 slots filled with 1s (1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111) , you're essentially making the last slot a 0 while keeping all other slots as 1.

The number you get after subtracting 1 is still an incredibly large number, but it's just one less than the largest possible number that can be represented with 256 binary digits. This gives you the largest possible number with 256 bits, making it the maximum value within the constraints of a 256-bit binary number system.

This is a fundamental concept in computer science and cryptography because it defines the upper limit of what can be represented with a certain number of bits.

Now that you understand 2²⁵⁶ and how it relates to computing let’s return back to where we were? , but wait in case you are wondering why use -1 why not just use 2²⁵⁶ well in cryptographic protocols, certain values might need to be randomized or chosen with specific properties to prevent attacks.

Now looping through the range of 2²⁵⁶ — 1 shows why Your private key is like a super rare, one-of-a-kind key to a treasure chest. The range of numbers it could possibly be is so enormous that it's practically impossible for someone else to stumble upon the exact same key by chance. It's like searching for a needle in a haystack the size of the universe!

PRNG can produce any value within this vast range when generating a private key. Each value within this range corresponds to a potential private key and is a large binary number, then this number is encoded to human-readable format for ease of use using Base64 or Base58. And so you have your private keys.

Your crypto public keys on the other hand are generated from your private keys.

This process is unidirectional, which means that you can use your private key to obtain an account, but not an account to obtain a private key.

This unidirectional process is done by cryptographic trapdoor functions.

A trapdoor function is actually a one-way function that only derives its value from a specific input, and it cannot be used to derive the original input from it.

Now Depending on the blockchain ecosystem, these one-way functions vary.

Most popular blockchain systems use elliptic curve-based algebraic constructions to generate their public keys. Independently of these characteristics, the outcome is always deterministic;

Such that: A public key is unique to its corresponding private key, and the private key always generates the same public key.

So here you go, If you want to use a public address to generate a private key, brace yourself up and if you want to randomly get the private key of a bitcoin whale get a quantum computer and I will check on you in the year 2150.

Drop a comment, if this was helpful.

Understanding Golang Channels for Beginners:

Ayo Solomon — Mon, 29 Jan 2024 18:15:04 +0000

In Go or Golang,

channels are like conduits that enable communication between different parts of your program, specifically between goroutines.

Goroutines are lightweight threads in Go, and channels provide a safe way for them to exchange data or informations.

There are 2 known type of channels

Buffered Channels
Unbuffered Channels

Buffered Channels:
Now, let's consider a scenario where friends want to pass multiple balls without waiting or like joggling but among 2 to 3 people.

A buffered channel is like having a small basket - you can fill it with a few balls before the other person has to start taking them.
With a buffered channel, the sender can keep sending data until the buffer is full. Only when the buffer is full will further send operations block, waiting for the receiver to catch up by processing some data. This allows for a certain level of decoupling between the sender and the receiver, improving the overall performance of your concurrent program.
This is very useful for data streaming when dealing with continuous data streams, such as processing data from sensors or IoT devices, buffered channels can help in managing bursts of data. The buffer allows for smoother handling of intermittent spikes in the data stream.
here is an example code:

package main

import "fmt"

func main() {
    // This is an unbuffered channel
    // In most cases ch is a conventional way of naming
    // a channel but as is functional programming you can 
    // actually call it anything you like
    // This channel receives integers and a capacity of 2,
    // we declare it because
    // go is a strictly typed language
    ch := make(chan int, 2)

    // Goroutines sending values to the channel
    go func() {
        ch <- 1
        ch <- 2
    }()

    // Receiving values from the channel
    value1 := <-ch
    value2 := <-ch

    fmt.Println("Received:", value1, value2)
}

Unbuffered Channels:
Imagine two friends passing a ball between with each other. An unbuffered channel is like the ball - only one person can hold it at a time. When one friend (goroutine) has the ball, the other friend has to wait until the first one passes it.
In Go terms the sender goroutine declared as (go func()) sends the message to the unbuffered channel, and the main goroutine receives it. It's like a synchronized dance, ensuring the message is safely passed. here is an example code

package main

import "fmt"

func main() {
    // This is an unbuffered channel
    // In most cases ch is a conventional way of naming
    // a channel but as is functional programming you can 
    // actually call it anything you like
    // This channel receives strings, we declare it because go
    // is a strictly typed language
    ch := make(chan string)

    // Goroutine sending a message to the channel
    go func() {
        ch <- "Hello, Go!"
    }()

    // Receive the message from the channel here by 
    // retrieving it into this variable
    message := <-ch

    fmt.Println("Received:", message)
}

Why Channels in Go? 🚀

Think of channels as friendly messengers 💌 that help different parts of your program talk to each other smoothly. In the world of concurrent programming, where multiple tasks are happening at once (thanks to goroutines in Go), channels act as a safe and organized way for these tasks to share information.

Imagine you have friends working on different parts of a group project. They need to exchange ideas and updates without causing chaos. Channels are like magic postboxes 📬 that ensure each friend gets the right information at the right time, preventing any messy conflicts or misunderstandings.

These channels help you avoid common problems, like two parts of your program trying to grab the same information simultaneously (known as race conditions).

They make your coding journey in Go more enjoyable and less prone to tricky bugs.

So, as you embark on your Go adventure, consider channels as your helpful companions, guiding your program's flow and making sure everything runs harmoniously.

Give them a try—play around with unbuffered and buffered channels—and see how they influence the behavior of your program.

Happy coding, and enjoy the journey! 🌟

Here's my Eth Wallet for tip 0xD48a3323E0349912185Ae4522F083bcc011CEa07

Here's my Polygon Wallet for tip
0xD48a3323E0349912185Ae4522F083bcc011CEa07

Understanding Ethereum JSONRPC Calls

Ayo Solomon — Thu, 28 Sep 2023 20:38:59 +0000

How to get the balance of a token in a smart contract? It is easier than you think. Let’s see how to do it.

To begin with here are a list of hexcode of all major rpc methods, thought you moght need them, thank me with a clap.

eth_sendTransaction: 0x61P62
eth_call: 0x70a08231
eth_getLogs: 0x38404ec1
eth_getBalance: 0x70a08231
eth_getCode: 0x3f2fde38
eth_getStorageAt: 0x6e9d7a86
eth_getTransactionCount: 0x068a23cb
eth_getTransactionReceipt: 0x2ef17100
eth_estimateGas: 0x27a46b71
eth_getBlockByHash: 0x9e33679d
eth_getBlockByNumber: 0x5b86e593
eth_getTransactionByHash: 0x03f123db
eth_getTransactionByBlockHashAndIndex: 0x6b1ee0e2
eth_getTransactionByBlockNumberAndIndex: 0x61b26506
eth_getUncleByBlockHashAndIndex: 0x0ff83c09
eth_getUncleByBlockNumberAndIndex: 0x04b88d73
eth_getCompilers: 0x29eeaa28
eth_compileSolidity: 0x43c251a0
eth_compileLLL: 0x38cfae69
eth_compileSerpent: 0x4db3890e

Let's explain what these are and how they work?

When a web3 developer interacts with node through any rpc provider you send a request through JSON RPC either over HTTP or WebSocket; as a single request or as a batched array. Requests as usually in this format:

{"id":1234,"jsonrpc": "2.0", "method": "eth_foo", "params":[...] }

when you make a call to through the rpc(Remote procedure call) you have to specify the method which tells the node what evm function you want to execute
that is what the "method" is for, the id is just a field to tell the node what request you are making and to ensure that the returned response is the same request sent, "params" we will get into that shortly

Therefore to get the balance of a wallet is as simple as

{
    "jsonrpc": "2.0",
    "method": "eth_getBalance",
    "params": [
        "0xbe991e317fbb4e82f7f99c62096f36b7a24278de",
        "latest"
    ],
    "id": 123
}

Now send this as a post request to any EVM RPC but ensure that the address is in the chain, for example you need to get the balance of a polygon address then you need to make a post request to a polygon RPC like this

we get a return value of

{
    "jsonrpc": "2.0",
    "id": 123,
    "result": "0x4ced0c13df6aba72"
}

when you convert the result from hex to integer, you should get the matic balance of that address(In this example)

So let's do a smart contract call?, yeah...

Interesting right!!

let's back this up and do some explanations

{
    "jsonrpc": "2.0",
    "method": "eth_call",
    "params": [
        {
            "to": "0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063",
            "from": "0xbe991e317fbb4e82f7f99c62096f36b7a24278de",
            "data": "0x70a08231000000000000000000000000be991e317fbb4e82f7f99c62096f36b7a24278de"
        },
        "latest"
    ],
    "id": 1
}

we have our

ID - we already looked at what this is
Method- we have looked at this, this call is used to make a stateless query to the EVM, this means we are making a call that is not changing the state of any data and this won't cost gas at all
JSONRPC- this is the generally accepted rpc version for all node clients and it is version 2.0
Params- this field takes in the arguements we are taking to excute, so let's inspect this

we have
- "to" is always a smart contract, so we enter the contract address here.
- "from" is the user's address just the same way we call the balanceOf function in any solidity ERC20 contract

   function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

, here we pass the user's address which we want to get it's token balance in the contract.

"latest" tells the node that we are making this request to the head of the block, so we want the most recent block result.
"data" is where all the magic happen.
so how did we arrive at this "0x70a08231000000000000000000000000be991e317fbb4e82f7f99c62096f36b7a24278de", remember that list i posted above, the item number 2 "eth_call: 0x70a08231", so this hex code 0x70a08231 is actually a sha3 hash of the conventional ERC20 balanceOf function, what is done is that we get the function name and argument "balanceOf(address)" and then use sha3 encryption to hash, next the first four bytes of this hash which comprise it’s 4-byte signature is then padded with zeros, it is padded so that it can measure up to the required length of the ethereum ABI specification making it 32 characters if you remove the first 0x characters, now what about the the other characters after the zero, well that is your address or the user's address without the 0x.

So it is :
balanceOf=0x70a08231
padded zeros=000000000000000000000000
your address=be991e317fbb4e82f7f99c62096(with the first 2 characters 0x removed)

Join all that and we have the the data :0x70a08231000000000000000000000000be991e317fbb4e82f7f99c62096f36b7a24278de

In the same way you call balance of in a contract function

   function balanceOf("0xbe991e317fbb4e82f7f99c62096")

If you have learned something from this article, please give me a love or drop a comment.

Why do i keep hearing token staking?

Ayo Solomon — Mon, 25 Sep 2023 15:12:30 +0000

In the cryptocurrency world this is understood as giving users some kind of right or reward for as long as they don’t transfer some tokens in their possession.

With a few lines of solidity code you can implement a staking mechanism, one of the most powerful incentive schemes in token economics.

Someone is said to have a stake in a venture when they contribute some assets in exchange of exercising some level of control, influence, or participation in its activities.
A staking mechanism usually encourages token holding against token trading, which in turn is expected to drive up the token valuation.

To build this staking mechanism we will need:

- A staking token.
- Data structures to keep track of stakes, stakeholders and rewards.
- Methods to create and remove stakes.
- A rewards system.

Ready?
Let’s get on with it.

A staking token can be created as an ERC20 token. I’m going to need SafeMath and Ownable later on, so let’s import and use those as well.

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";

/**
 * @title Staking Token (STK)
 * @author Ayo Solomon Nigeria
 * @notice Implements a basic ERC20 staking token with incentive distribution.
 */
contract StakingToken is ERC20, Ownable {
    using SafeMath for uint256;

    /**
     * @notice The constructor for the Staking Token.
     * @param _owner The address to receive all tokens on construction.
     * @param _supply The amount of tokens to mint on construction.
     */
    constructor(address _owner, uint256 _supply) ERC20("StakingToken", "STK") {
        _mint(_owner, _supply);
    }

Looks great for a start, so let's see what's going on here

Stakeholders
In this implementation we are going to keep track of the stakeholders to facilitate a robust distribution of incentives later on. In theory it would be possible to not keep track of them as a normal ERC20 token would do, but in practice it is difficult to ensure that stakeholders don’t game the distribution system if you don’t track them.

For implementation we will just use a dynamic array of stakeholder addresses.


   /**
    * @notice We usually require to know who are all the stakeholders.
    */
   address[] internal stakeholders;

The methods implemented allow just to add a stakeholder, remove a stakeholder, and verify whether an address belongs to a stakeholder. Other more efficient implementations are surely possible but I like this one for readability.

Stakes
A stake at its simplest form will need to record the stake size and the stake holder. A really simple implementation of this could be just a mapping from the address of the stakeholder to the stake size.

   /**
    * @notice The stakes for each stakeholder.
    */
   mapping(address => uint256) internal stakes;

To make the code more readable I’m going to follow the function names from ERC20 and create equivalents to get the data from the stakes mapping.

   /**
     * @notice A method to check if an address is a stakeholder.
     * @param _address The address to verify.
     * @return bool, uint256 Whether the address is a stakeholder,
     * and if so its position in the stakeholders array.
     */
    function isStakeholder(address _address) public view returns (bool, uint256) {
        for (uint256 s = 0; s < stakeholders.length; s += 1) {
            if (_address == stakeholders[s]) return (true, s);
        }
        return (false, 0);
    }

    /**
     * @notice A method to add a stakeholder.
     * @param _stakeholder The stakeholder to add.
     */
    function addStakeholder(address _stakeholder) public {
        (bool _isStakeholder, ) = isStakeholder(_stakeholder);
        if (!_isStakeholder) stakeholders.push(_stakeholder);
    }

    /**
     * @notice A method to remove a stakeholder.
     * @param _stakeholder The stakeholder to remove.
     */
    function removeStakeholder(address _stakeholder) public {
        (bool _isStakeholder, uint256 s) = isStakeholder(_stakeholder);
        if (_isStakeholder) {
            stakeholders[s] = stakeholders[stakeholders.length - 1];
            stakeholders.pop();
        }
    }

    /**
     * @notice A method to retrieve the stake for a stakeholder.
     * @param _stakeholder The stakeholder to retrieve the stake for.
     * @return uint256 The amount of wei staked.
     */
    function stakeOf(address _stakeholder) public view returns (uint256) {
        return stakes[_stakeholder];
    }

    /**
     * @notice A method to the aggregated stakes from all stakeholders.
     * @return uint256 The aggregated stakes from all stakeholders.
     */
    function totalStakes() public view returns (uint256) {
        uint256 _totalStakes = 0;
        for (uint256 s = 0; s < stakeholders.length; s += 1) {
            _totalStakes = _totalStakes.add(stakes[stakeholders[s]]);
        }
        return _totalStakes;
    }

We have giving STK holders the capability to create and remove stakes. We will burn the tokens as they are staked to stop users from transferring them until the stake is removed.

Please note that on stake creation _burn will revert if the user tries to stake more tokens than he owns, and on stake removal the update of the stakes mapping will revert if there is an attempt to remove more tokens that were staked.

Finally, we use addStakeholder and removeStakeholder to have a record of who has stakes, to be used later in the rewards system.

   /**
     * @notice A method for a stakeholder to create a stake.
     * @param _stake The size of the stake to be created.
     */
    function createStake(uint256 _stake) public {
        _burn(msg.sender, _stake);
        if (stakes[msg.sender] == 0) addStakeholder(msg.sender);
        stakes[msg.sender] = stakes[msg.sender].add(_stake);
    }

    /**
     * @notice A method for a stakeholder to remove a stake.
     * @param _stake The size of the stake to be removed.
     */
    function removeStake(uint256 _stake) public {
        stakes[msg.sender] = stakes[msg.sender].sub(_stake);
        if (stakes[msg.sender] == 0) removeStakeholder(msg.sender);
        _mint(msg.sender, _stake);
    }

Rewards mechanisms can have many different implementations and be quite heavy to run. For this contract we will implement a very simple version where the stakeholders periodically receive a reward in STK tokens equivalent to a 1% of their individual stakes.

In more sophisticated contracts the distribution of rewards would be automatically triggered when certain conditions are met, but in this case we will let the owner trigger it manually. Following best practice we will also keep track of the rewards and implement a method to withdraw them.

As before, to make the code readable we have followed the naming conventions from the ERC20.sol contract, first the data structure and data management methods:

   /**
    * @notice The accumulated rewards for each stakeholder.
    */
   mapping(address => uint256) internal rewards;


   /**
    * @notice A method to allow a stakeholder to check his rewards.
    * @param _stakeholder The stakeholder to check rewards for.
    */
   function rewardOf(address _stakeholder)
       public
       view
       returns(uint256)
   {
       return rewards[_stakeholder];
   }

   /**
    * @notice A method to the aggregated rewards from all stakeholders.
    * @return uint256 The aggregated rewards from all stakeholders.
    */
   function totalRewards()
       public
       view
       returns(uint256)
   {
       uint256 _totalRewards = 0;
       for (uint256 s = 0; s < stakeholders.length; s += 1){
           _totalRewards = _totalRewards.add(rewards[stakeholders[s]]);
       }
       return _totalRewards;
   }

Follow the methods to calculate, distribute and withdraw rewards:

   /**
    * @notice A simple method that calculates the rewards for each stakeholder.
    * @param _stakeholder The stakeholder to calculate rewards for.
    */
   function calculateReward(address _stakeholder)
       public
       view
       returns(uint256)
   {
       return stakes[_stakeholder] / 100;
   }

   /**
    * @notice A method to distribute rewards to all stakeholders.
    */
   function distributeRewards()
       public
       onlyOwner
   {
       for (uint256 s = 0; s < stakeholders.length; s += 1){
           address stakeholder = stakeholders[s];
           uint256 reward = calculateReward(stakeholder);
           rewards[stakeholder] = rewards[stakeholder].add(reward);
       }
   }

   /**
    * @notice A method to allow a stakeholder to withdraw his rewards.
    */
   function withdrawReward()
       public
   {
       uint256 reward = rewards[msg.sender];
       rewards[msg.sender] = 0;
       _mint(msg.sender, reward);
   }

Awesome 🥳 🎊,

You just got this running, hope you learned something, if you did like or leave a comment 🧡

Conclusion
A staking and rewards mechanism is a powerful incentive tool that only needs to be as complex as we want to make it. The methods provided in the ERC20 standard and SafeMath allows us to code it in about 200 lines of sparse code.

Full code

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";

/**
 * @title Staking Token (STK)
 * @author Ayo Solomon Nigeria
 * @notice Implements a basic ERC20 staking token with incentive distribution.
 */
contract StakingToken is ERC20, Ownable {
    using SafeMath for uint256;

    /**
     * @notice The constructor for the Staking Token.
     * @param _owner The address to receive all tokens on construction.
     * @param _supply The amount of tokens to mint on construction.
     */
    constructor(address _owner, uint256 _supply) ERC20("StakingToken", "STK") {
        _mint(_owner, _supply);
    }

    /**
     * @notice We usually require to know who are all the stakeholders.
     */
    address[] internal stakeholders;
    /**
    * @notice The accumulated rewards for each stakeholder.
    */
   mapping(address => uint256) internal rewards;
    /**
     * @notice The stakes for each stakeholder.
     */
    mapping(address => uint256) internal stakes;

    /**
     * @notice A method to check if an address is a stakeholder.
     * @param _address The address to verify.
     * @return bool, uint256 Whether the address is a stakeholder,
     * and if so its position in the stakeholders array.
     */
    function isStakeholder(address _address) public view returns (bool, uint256) {
        for (uint256 s = 0; s < stakeholders.length; s += 1) {
            if (_address == stakeholders[s]) return (true, s);
        }
        return (false, 0);
    }

    /**
     * @notice A method to add a stakeholder.
     * @param _stakeholder The stakeholder to add.
     */
    function addStakeholder(address _stakeholder) public {
        (bool _isStakeholder, ) = isStakeholder(_stakeholder);
        if (!_isStakeholder) stakeholders.push(_stakeholder);
    }

    /**
     * @notice A method to remove a stakeholder.
     * @param _stakeholder The stakeholder to remove.
     */
    function removeStakeholder(address _stakeholder) public {
        (bool _isStakeholder, uint256 s) = isStakeholder(_stakeholder);
        if (_isStakeholder) {
            stakeholders[s] = stakeholders[stakeholders.length - 1];
            stakeholders.pop();
        }
    }

    /**
     * @notice A method to retrieve the stake for a stakeholder.
     * @param _stakeholder The stakeholder to retrieve the stake for.
     * @return uint256 The amount of wei staked.
     */
    function stakeOf(address _stakeholder) public view returns (uint256) {
        return stakes[_stakeholder];
    }

    /**
     * @notice A method to the aggregated stakes from all stakeholders.
     * @return uint256 The aggregated stakes from all stakeholders.
     */
    function totalStakes() public view returns (uint256) {
        uint256 _totalStakes = 0;
        for (uint256 s = 0; s < stakeholders.length; s += 1) {
            _totalStakes = _totalStakes.add(stakes[stakeholders[s]]);
        }
        return _totalStakes;
    }

    /**
     * @notice A method for a stakeholder to create a stake.
     * @param _stake The size of the stake to be created.
     */
    function createStake(uint256 _stake) public {
        _burn(msg.sender, _stake);
        if (stakes[msg.sender] == 0) addStakeholder(msg.sender);
        stakes[msg.sender] = stakes[msg.sender].add(_stake);
    }

    /**
     * @notice A method for a stakeholder to remove a stake.
     * @param _stake The size of the stake to be removed.
     */
    function removeStake(uint256 _stake) public {
        stakes[msg.sender] = stakes[msg.sender].sub(_stake);
        if (stakes[msg.sender] == 0) removeStakeholder(msg.sender);
        _mint(msg.sender, _stake);
    }




   /**
    * @notice A method to allow a stakeholder to check his rewards.
    * @param _stakeholder The stakeholder to check rewards for.
    */
   function rewardOf(address _stakeholder)
       public
       view
       returns(uint256)
   {
       return rewards[_stakeholder];
   }

   /**
    * @notice A method to the aggregated rewards from all stakeholders.
    * @return uint256 The aggregated rewards from all stakeholders.
    */
   function totalRewards()
       public
       view
       returns(uint256)
   {
       uint256 _totalRewards = 0;
       for (uint256 s = 0; s < stakeholders.length; s += 1){
           _totalRewards = _totalRewards.add(rewards[stakeholders[s]]);
       }
       return _totalRewards;
   }

     /**
    * @notice A simple method that calculates the rewards for each stakeholder.
    * @param _stakeholder The stakeholder to calculate rewards for.
    */
   function calculateReward(address _stakeholder)
       public
       view
       returns(uint256)
   {
       return stakes[_stakeholder] / 100;
   }

   /**
    * @notice A method to distribute rewards to all stakeholders.
    */
   function distributeRewards()
       public
       onlyOwner
   {
       for (uint256 s = 0; s < stakeholders.length; s += 1){
           address stakeholder = stakeholders[s];
           uint256 reward = calculateReward(stakeholder);
           rewards[stakeholder] = rewards[stakeholder].add(reward);
       }
   }

   /**
    * @notice A method to allow a stakeholder to withdraw his rewards.
    */
   function withdrawReward()
       public
   {
       uint256 reward = rewards[msg.sender];
       rewards[msg.sender] = 0;
       _mint(msg.sender, reward);
   }
}

How to stream pending blockchain transactions with geth(Go-Ethereum)

Ayo Solomon — Sun, 23 Jul 2023 23:44:25 +0000

As the EVM network handles thousands of transactions every minute, developers often require real-time monitoring of pending transactions for various purposes, such as building transaction monitoring systems, auditing smart contracts, tracking network activity or even front-running.

In this technical article,

let's explore how Golang can connect to an EVM node using the WebSocket-based RPC client and subscribes to pending transactions.

We will demonstrate how to effectively monitor real-time pending transactions on the mem-pool, providing you with a solid foundation to build more sophisticated tools tailored to your specific needs.

Why Golang?

Go, commonly known as Golang, is a programming language designed by Google that has gained immense popularity for various reasons. When it comes to real-time Ethereum transaction monitoring, Go offers several key advantages that make it an excellent choice for this particular task.

1. Concurrency and Goroutines:

Go is renowned for its built-in concurrency features, particularly Goroutines. Goroutines allow developers to execute lightweight, concurrent functions concurrently, making it easy to handle multiple tasks simultaneously. In the context of monitoring pending transactions, Goroutines can efficiently manage incoming transactions, ensuring real-time responsiveness and scalability.

2. High Performance:

Go's compilation model and runtime optimizations make it a high-performance language. This is crucial for real-time applications like transaction monitoring, where low latency and responsiveness are essential. Go's efficient execution ensures that the transaction monitoring system can handle a high volume of transactions without performance bottlenecks.

3. Easy-to-Use and Simple Syntax:

Go's syntax is simple, clean, and easy to read, making it approachable for developers of varying experience levels. Its minimalistic design eliminates unnecessary complexity, making it easier to focus on building the core functionality of the monitoring application. This simplicity also leads to more maintainable and less error-prone code.

__Prerequisites

Before we delve into the code, ensure you have the following prerequisites in place:

Golang installed on your system, you can install Golang from here
A basic understanding of Ethereum and its transaction lifecycle

3.An IDE (Visual studio code)

Getting Started

Create a file called main.go and then run

go mod init main

This will create a file called go.mod like below

Now create a file called main.go in the same directory as the go.mod file we created earlier.

At this point, we can now install the go-ethereum package.

To do this run the command below

go get github.com/ethereum/go-ethereum/

it will now appear in our go.mod file and a file named go.sum will also be automatically created carrying all the dependencies.

You should now have something like this:

_Great , we are now set _ ✅

1. Importing Required Packages

The initial part of the code is concerned with importing the necessary packages that enable interaction with Ethereum networks and WebSockets. Notably, we import the following:

import (
    "context"
    "fmt"
    "log"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/ethclient/gethclient"
    "github.com/ethereum/go-ethereum/rpc"
)

let's talk about these a bit

"context" package is essential for handling the context of the application.
"fmt" package allows us to format and print output messages.
"log" package provides error logging functionalities.
"github.com/ethereum/go-ethereum/common" offers Ethereum common data structures.
"github.com/ethereum/go-ethereum/ethclient/gethclient" provides access to the Ethereum client.
"github.com/ethereum/go-ethereum/rpc" enables communication with Ethereum nodes via RPC.

2. Connecting to an Ethereum Node

To interact with the Ethereum network, we need a connection to a node. In this case, i am connecting using the WebSocket-based RPC client from Infura, a popular Ethereum node provider. The node URL is specified as:

client, err := rpc.Dial("wss://polygon-mumbai.infura.io/ws/v3/b2ea..................")
if err != nil {
    log.Fatal(err)
}

Now it is good to note that you will need to use the Infura wss for this to work properly.

So create an Infura account and then switch to websocket RPCs like in the image below

Do not forget to replace the Infura URL with your preferred Ethereum node's WebSocket endpoint.

3. Subscribing to Pending Transactions

Once we have established a connection to the Ethereum node, we can subscribe to pending transactions using the gethclient.New method:

ctx := context.Background()

pendingTxSub := make(chan common.Hash)
sub, err := gethclient.New(client).SubscribePendingTransactions(ctx, pendingTxSub)
if err != nil {
    log.Fatal(err)
}
defer sub.Unsubscribe()

We create a channel pendingTxSub to receive incoming pending transaction hashes. The SubscribePendingTransactions method helps us subscribe to these pending transactions in real-time. Don't forget to unsubscribe from the subscription once you are done with it, hence the defer sub.Unsubscribe().

4. Processing Incoming Pending Transactions

Furthermore, we set up a loop to process incoming pending transactions:

for {
    select {
    case err := <-sub.Err():
        log.Fatal(err)
    case txs := <-pendingTxSub:
        fmt.Printf("Pending Transaction Hash: %s\n", txs.Hex())
    }
}

Here,
we use a select statement to listen for two types of channels: sub.Err() to handle errors and pendingTxSub to process incoming pending transaction hashes. When a new pending transaction is detected, the hash is printed to the console.

Complete code

package main

import (
    "context"
    "fmt"
    "log"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/ethclient/gethclient"
    "github.com/ethereum/go-ethereum/rpc"
)

func main() {
    // Connect to an Ethereum node using an HTTP-based RPC client
    client, err := rpc.Dial("<RPC HERE>")
    if err != nil {
        log.Fatal(err)
    }

    // Create a context to handle the subscription
    ctx := context.Background()

    // Subscribe to pending transactions
     pendingTxSub := make(chan common.Hash)
    sub, err := gethclient.New(client).SubscribePendingTransactions(ctx,pendingTxSub)
    if err != nil {
        log.Fatal(err)
    }
    defer sub.Unsubscribe()

    // Start processing incoming pending transactions
    for {
        select {
        case err := <-sub.Err():
            log.Fatal(err)
        case txs := <-pendingTxSub:
            fmt.Printf("Pending Transaction Hash: %s\n", txs.Hex())

        }
    }
}

Congratulations! 🚀

You have now successfully built a simple Golang application that connects to an Ethereum node, subscribes to pending transactions, and processes them in real-time. This forms the foundation for creating more sophisticated transaction monitoring systems, dApp analytics tools, and auditing solutions.

Feel free to expand on this code and integrate additional features, such as storing transaction data in a database or analyzing the gas fees associated with transactions.

Remember to ensure that your Ethereum node provider supports WebSocket connections, as some providers may offer only HTTP-based RPC access.

If you learned something, please don't forget to react to this post and drop a star on this repo on github.

Happy coding!💯

References

Ayoseun / Listen-to-pending-transactions-using-Geth

This Tutorial demonstrates how to view transactions in the blockchain mempool using golang, Geth

Listen-to-pending-transactions-using-Geth

This Tutorial demonstrates how to view transactions in the blockchain mempool using golang, Geth

View on GitHub

Using one smart contract address across multiple Blockchains.

Ayo Solomon — Sun, 20 Nov 2022 23:21:01 +0000

Using smart contracts with the same address across different Blockchains makes the smart contract super developer-friendly.

It removes the huddle of extra lines of code in trying to maintain addresses for different environments (mainnet vs. testnet) and blockchains (Ethereum, Polygon, Avalanche.). Another great benefit is that social campaigns are also very effective since users need to know or have just one address to interact with.

A typical example is Uniswap. Uniswap usually has one smart contract address that’s maintained across different blockchains. This contract address 0x1F98431c8aD98523631AE4a59f267346ea31F984 is UniswapV3Factory smart contract address across all main nets such as Ethereum, Polygon, Optimism, Arbitrum, and Avalanche.

How is this possible?

This is what I’ll show you. In this article, you’ll get to know how to get and use the same contract address across multiple Blockchains

A smart contract address is deterministic. What this means is that even before deployment, we can determine the smart contract address that will be generated using the wallet address from which the user will deploy the contract and their most recent nonce incremented by one.

For clarity, I’ll briefly explain what nonce and wallets are.

On the EVM(Ethereum Virtual Machine), there are two types of accounts: Externally owned accounts (EOA) and smart contract accounts.

Externally owned accounts are accounts generated as user wallets. They contain a 42-character hexadecimal string, random letters, and numbers.

A smart contract address is also a 42-character hexadecimal string attached to computer programs called smart contracts. Smart contracts are immutable scripts that are executed on the EVM.

Nonce also known as Number Used Only Once is used to record the number of transactions a user has performed on a given Blockchain. It is also used to validate and invalidate a transaction to monitor double-spending attacks.

So now that you understand what Nonce and wallets are, let’s go into the main purpose of this article. How is the address of a smart contract generated?

The smart contract’s address is derived on the Blockchain from two values: a user’s wallet address and the count on the number of transactions the user has sent. So simply put, if you monitor the nonce you can always know what the address of the smart contract will be even before deploying to the Blockchain.

This is done by just computing your nonce and your wallet address.

Let’s look at this…

//this imports the ethers.js library
const ethers = require('ethers')

/**
 * this is your new wallet address, this address shoukd never be used to send or purchase 
 * crypto before deploying smart contract
 */
const walletAddress = "0x331C0A6Bf81A16d366cc73f01Bf86DEfdC8E626A";
//here we are defining the nonce
 const nonce = 0;

 //This deployedAddress veriable uses the ethers.js library to get the contract address
 //by computing the nonce and the wallet address
let deployedAddress = ethers.utils.getAddress(ethers.utils.getContractAddress({from: walletAddress, nonce}));

console.log(deployedAddress);
//Console will print 0x5489e3bF61dde8A04E53b3Ae54E3710E06B3E9ED

When you increase the nonce you’ll notice that the address changes, you can do this by changing the nonce from being 0 to 1 and you should get a different deployment address like this

We can verify that we get this same address for our contract by deploying with Remix IDE.

Finally, when you send a smart contract creation transaction in all the blockchains with this same nonce it will result in the same smart contract address everywhere.

I hope you found this article useful. You could drop feedback or ask your question via the comments, I’ll be glad to help in any way I can.

Here's my ERC20 wallet for tip
0xD48a3323E0349912185Ae4522F083bcc011CEa07