If you've written JavaScript or Python, you already have the mental models needed for Solidity. The syntax will feel familiar, but the environment is completely different. Every line of code incurs a cost to execute. Every variable is permanently stored on thousands of computers worldwide. And once deployed, your code is immutable - bugs become features forever.

It might sound intimidating at first, but once you understand the fundamentals, it becomes much more approachable.

By the end of this tutorial, you'll understand how to write a token contract and why each piece works the way it does. We'll build a simplified ERC20 token that could be deployed on Ethereum, Monad, or any EVM-compatible chain.

Setting Up Your First Smart Contract

A smart contract is like a vending machine; it holds value, has rules, and executes automatically. The contract we're building today will create and manage tokens that could represent anything: loyalty points at your local coffee shop, shares in an investment fund, or coins in a game economy.

Before we can build this digital vending machine, we need a workspace. That's where Remix IDE comes in; think of it as your contract workshop.

We'll use Remix IDE, a powerful, web-based development environment for Solidity, to keep things simple and get you writing code right away. There's no need to install anything; open it in a new tab, and you'll be ready.

Once Remix loads:

1. Look for the contracts folder in the file explorer (left sidebar).

2. Right-click the file icon and create a new file called MyToken.sol.

3. Click on your new file to open it.

Next, create the basic structure of your token.

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;
contract MyToken {
    // Token Implementation here!
}

That might look like a lot at first glance, but let’s break it down step-by-step:

• // SPDX-License-Identifier: MIT: This comment specifies the contract's license. Including the comment is a best practice and helps build trust in the open-source community.

• pragma solidity ^0.8.20;: This line tells the compiler which version of Solidity to use. The ^ means it will accept version 0.8.20 or any newer minor version (like 0.8.21) but not major updates that could break compatibility (like 0.9.0).

• contract MyToken { ... }: This declares our contract. If you come from an object-oriented language like Python or JavaScript, you can think of a contract as a class. It's a blueprint for the logic and data that will live on the blockchain.

Giving Your Token an Identity

Now, let's define what makes our token unique. Just like how the US Dollar has a name ("Dollar"), symbol ("$"), and can be divided into cents, our token needs these fundamental properties:

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;
contract MyToken {

    // Token metadata - this is what makes your token unique

    string public name = "MyToken";
    string public symbol = "MTK";
    uint8 public decimals = 18; // Standard for most tokens
    uint256 public totalSupply; // How many tokens exist in total
}

In the code snippet above, we've just introduced a few core concepts:

• State Variables: These variables (name, symbol, decimals, totalSupply) are stored permanently on the blockchain. Think of them as the properties of a class instance.

• Data Types: We're using string for text, uint8 for an 8-bit unsigned integer (perfect for decimals), and uint256for a 256-bit unsigned integer, the standard for token amounts.

• Visibility (public): Marking a state variable as public has a significant impact. The Solidity compiler automatically creates a "getter" function for it. This means anyone can read its value from the blockchain for free. This is our first look at a view-only function.

Now we have a token with an identity, but we're missing the most important part - a way to track who owns what. Let's build the ledger that makes this a real token.

The Token Ledger: Who Owns What?

At its core, a token contract has one fundamental job: answering the question, "How many tokens does this address have?" To keep track of this, we need a ledger. In traditional systems, a bank’s database manages account balances. In Solidity, the ideal tool for this job is a mapping.

//...

contract MyToken {

    // ... inside contract MyToken

    // A mapping from an address to their token balance.
    mapping(address => uint256) public balances;
}

A mapping in Solidity is like a hash map or dictionary you might know from other programming languages. This particular mapping, called balances, links an address to a uint256 value. Think of it as a super-efficient dictionary: you give it an address, and it instantly tells you the token balance for that address. No searching or sorting needed; just instant lookups.

• address: This is a special data type that holds a 20-byte Ethereum address. It's the unique identifier for a user's wallet or another smart contract.

• balances[someAddress]: When you query this, it returns the token balance for someAddress. If that address has never received tokens before, the balance defaults to 0.

For example:

balances[0x123...] = 1000;  // This address has 1000 tokens

balances[0x456...] = 500;   // This one has 500

Since we marked the balances mapping as public, we automatically get a getter function. We can now create a more explicit balanceOf function that matches the ERC20 standard.

// ... inside contract MyToken

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

Notice the view keyword. This explicitly tells the Ethereum Virtual Machine (EVM) that this function only reads from the blockchain state and doesn't modify it. Calling view functions is free from the outside world because they don't require a transaction to be mined.

Perfect! We can track balances, but everyone's balance is zero. Time to create some tokens.

Creating Tokens

Currently, our token exists, but nobody currently holds any. It's like opening a bank with no money. Let's fix that by creating a minting function that can allow users to mint tokens:

//...

contract MyToken {

    // Previous code...

    // The address that deployed this contract (the creator)
    address public owner;

    // This special function runs ONCE when the contract is deployed
    constructor() {
        owner = msg.sender; // Crown yourself as the owner!
    }

    function mint(address to, uint256 amount) public {
        // Only the owner can create new tokens
        require(msg.sender == owner, "Nice try! Only the owner can mint.");

        totalSupply += amount; // Increase total supply
        balances[to] += amount; // Give tokens to the recipient
    }
}

Whoa, a lot just happened. Let's unpack it.

msg.sender is a global variable available in every function. It always contains the address of whoever called this function. It's unfakeable, unhackable, and always reliable, and it's how your contract identifies who is talking to it. Think of it as a caller ID that works.

In our constructor, we're using it to remember who deployed the contract. That person becomes the owner, the only one allowed to mint new tokens.

As you explore Solidity, you'll encounter tx.origin, a variable that seems helpful but hides a dangerous flaw. Let's explore why msg.sender is always the right choice:

// Dont do this
require(tx.origin == owner, "Only owner");

// Do this instead
require(msg.sender == owner, "Only owner");

For example, using tx.origin for authorization is dangerous because it can make your contract vulnerable to phishing-style attacks. If User A calls MaliciousContract B, which then calls YourContract C, msg.sender in C will be B's address, but tx.origin will be User A's address.

If you authorize based on tx.origin, MaliciousContract B could trick User A into triggering an action on your contract that they never intended. Always use msg.sender for authorization.

Now our token can be minted, but there’s still a problem. How does the outside world know when tokens are created?

This touches on a core blockchain principle: transparency through observation. Unlike traditional systems where a server pushes updates to clients, blockchain works on a "pull" model.

Your wallet, Etherscan, and every DeFi protocol must actively watch for changes. Without a standardized way to signal "something important happened here," they'd have to scan every single storage change - an impossibly expensive and slow process.

Events solve this by creating an efficient notification layer on top of the blockchain.

Events in Your Smart Contract

Events are the backbone of blockchain visibility. Block explorers use them to show transaction history, wallets listen for them to update your balance, and DeFi protocols track them for analytics. Plus, they're 8x cheaper than storing data.

To implement events in your contract, you declare the event, which is similar to defining a notification template, and then trigger it after your preferred function call or action, as shown in the following code.

//...

contract MyToken {

    // Previous code...

    // Declare an event
    event Transfer(address indexed from, address indexed to, uint256 value);

    function mint(address to, uint256 amount) public {

        require(msg.sender == owner, "Only owner can mint");
        totalSupply += amount;
        balances[to] += amount;

        // Fire the event! Tell the world tokens were created
        emit Transfer(address(0), to, amount);
    }
}

When minting, we show tokens from address(0). This is the universal signal for "new tokens created."

Minting is great, but tokens that can't move aren't very useful. Let's add the ability to transfer tokens between addresses.

The Transfer Function

Create the transfer function named transfer with the following code snippet:

//...

function transfer(address to, uint256 amount) public returns (bool) {

    // Check 1: Do you have enough tokens?
    require(balances[msg.sender] >= amount, "Not enough tokens!");

    // Check 2: Are you sending to a real address?
    require(to != address(0), "Can't send to the zero address");


    // The actual transfer (order matters for security!)
    balances[msg.sender] -= amount; // Take from sender
    balances[to] += amount; // Give to recipient

    // Announce it to the world
    emit Transfer(msg.sender, to, amount);

    return true; // ERC20 standard says return true on success
}

The code snippet above does the following:

• First, we checked if you're not trying to send more tokens than you have (no overdrafts in blockchain).

• Next, we made sure you're not accidentally burning tokens by sending to the zero address.

• Then we performed the actual transfer to subtract from the sender and add to the recipient.

• We announced the transfer with an event (this is how MetaMask knows to update your balance).

• Finally, we returned true because that's what the ERC20 standard expects on success.

So far, only you can transfer your own tokens. But what if you want a decentralized exchange (DEX) like Uniswap to be able to pull 100 of your tokens to swap them for another asset? You can't give the DEX your private key. That’s where delegation and token approval come in; they let you authorize a third party to spend tokens on your behalf, without handing over full control.

The Token Approval Mechanism

The token approval mechanism is a two-step process:

• Approve: You (the owner) call the approve function to authorize another address (the spender) to withdraw up to a certain amount of your tokens.

• TransferFrom: The spender then calls transferFrom to move the tokens from your account to a destination.

Let’s add this functionality to our contract.

To implement the approve function, add the following code snippet:

//...

contract MyToken {

    // Previous code...

    // Who is allowed to spend what: owner => spender => amount
    mapping(address => mapping(address => uint256)) public allowance;

    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );

    function approve(address spender, uint256 amount) public returns (bool) {

        require(spender != address(0), "Can't approve zero address");

        // "I allow this spender to use up to this amount of MY tokens"
        allowance[msg.sender][spender] = amount;

        emit Approval(msg.sender, spender, amount);
        return true;
    }
}

Next, implement the transferFrom function:

//...

function transferFrom(
    address from,
    address to,
    uint256 amount
) public returns (bool) {

    // Check 1: Does the owner have enough tokens?
    require(balances[from] >= amount, "Owner doesn't have enough tokens");

    // Check 2: Are YOU allowed to move this many?
    require(
        allowance[from][msg.sender] >= amount,
        "You're not approved for that amount"
    );

    // Check 3: Valid recipient?
    require(to != address(0), "Can't send to zero address");

    // Update the allowance FIRST (very important!)
    allowance[from][msg.sender] -= amount;

    // Then do the transfer
    balances[from] -= amount;
    balances[to] += amount;

    emit Transfer(from, to, amount);
    return true;
}

With approve and transferFrom, our token is now composable. It can interact with other smart contracts in a secure, decentralized way. The nested mapping for allowance might look intimidating, but it's just a way to record that the owner has allowed this spender to use this amount.

In a real-world scenario using the Uniswap DEX we mentioned earlier, this is how it would look:

1. You approve(uniswapRouter, 100) - "Uniswap can use 100 of my tokens".

2. You call Uniswap's swap function.

3. Uniswap calls transferFrom(you, liquidityPool, 100).

4. You get ETH back.

It's like writing a check - you specify the amount and recipient, but they decide when to cash it.

This approval system seems bulletproof, right? You control who can spend your tokens and how much. What could go wrong?

Well, here's where things get spicy. This approval system has a hidden flaw. Imagine writing someone a check, then trying to write them a smaller check to replace it - they might cash both. This exact problem has been used to steal tokens from real projects.

For example:

• Alice approves Bob for 100 tokens.

• Alice changes her mind and sends a transaction to reduce it to 50.

• Bob sees Alice's pending transaction.

• Bob quickly uses the current 100 approval.

• Alice's new 50 approval goes through.

• Bob uses the 50 approval, too.

• Bob got 150 tokens instead of 50! 😱

So, how do you avoid this scenario? The fix involves modifying the contract by adding increaseAllowance and decreaseAllowance functions, thereby making approval changes atomic and preventing race conditions.

//...

function increaseAllowance(
    address spender,
    uint256 addedValue
) public returns (bool) {

    allowance[msg.sender][spender] += addedValue;
    emit Approval(msg.sender, spender, allowance[msg.sender][spender]);
    return true;
}

function decreaseAllowance(
    address spender,
    uint256 subtractedValue
) public returns (bool) {

    uint256 currentAllowance = allowance[msg.sender][spender];
    require(currentAllowance >= subtractedValue, "Can't decrease below zero");

    allowance[msg.sender][spender] -= subtractedValue;
    emit Approval(msg.sender, spender, allowance[msg.sender][spender]);
    return true;
}

These functions fix the race condition by changing HOW we update approvals:

• increaseAllowance: Adds to the current allowance instead of replacing it.

• decreaseAllowance: Subtracts from the current allowance (with a safety check).

• Both are atomic operations - no window for attackers to exploit.

• If Bob has 100 and you decrease by 50, he ends up with exactly 50.

Our token is now secure, feature-complete, and ready for production. However, there's one important question we haven't answered: how will other smart contracts recognize that our token has these exact functions? When Uniswap tries to interact with our token, how does it know we have transfer, approve, and transferFrom?

This is where standards come in. Let's implement the IERC20 interface.

Making It Standard: The IERC20 Interface

Our token works great, but how do other contracts know what functions it has? This is where interfaces shine; they're like a contract's API specification that shows certain functions exist.

Let's implement the standard IERC20 interface:

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

interface IERC20 {

    // Read functions
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function allowance(address owner, address spender) external view returns (uint256);

    // Write functions
    function transfer(address to, uint256 amount) external returns (bool);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);

    // Events
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

contract MyToken is IERC20 {
    // Our implementation...
}

The Interface implementation above gives our contract:

• Composability: Any contract expecting IERC20 can work with your token.

• Type Safety: The compiler ensures you implement every required function.

• Documentation: Clear specification of what your contract can do.

• Standards: Following ERC20 means instant compatibility with thousands of dApps.

Congratulations! You've just built a functional, simplified ERC20 token from scratch. Here is the complete code for MyToken.sol.

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function allowance(
        address owner,
        address spender
    ) external view returns (uint256);

    function transfer(address to, uint256 amount) external returns (bool);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
}

contract MyToken is IERC20 {

    // Token metadata
    string public name = "MyToken";
    string public symbol = "MTK";
    uint8 public decimals = 18;
    uint256 public totalSupply;

    // Contract owner (can mint new tokens)
    address public owner;

    // Balances ledger
    mapping(address => uint256) public balances;

    // Allowances ledger
    mapping(address => mapping(address => uint256)) public allowance;

    constructor() {
        owner = msg.sender;
    }

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

    function mint(address to, uint256 amount) public {

        require(msg.sender == owner, "Only owner can mint");
        require(to != address(0), "Cannot mint to zero address");

        totalSupply += amount;
        balances[to] += amount;

        emit Transfer(address(0), to, amount);
    }

    function transfer(address to, uint256 amount) public returns (bool) {

        require(balances[msg.sender] >= amount, "Insufficient balance");
        require(to != address(0), "Cannot transfer to zero address");

        balances[msg.sender] -= amount;
        balances[to] += amount;
        emit Transfer(msg.sender, to, amount);
        return true;
    }

    function approve(address spender, uint256 amount) public returns (bool) {
        require(spender != address(0), "Cannot approve zero address");

        allowance[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public returns (bool) {

        require(balances[from] >= amount, "Insufficient balance");
        require(
            allowance[from][msg.sender] >= amount,
            "Insufficient allowance"
        );

        require(to != address(0), "Cannot transfer to zero address");

        allowance[from][msg.sender] -= amount;
        balances[from] -= amount;
        balances[to] += amount;

        emit Transfer(from, to, amount);
        return true;
    }

    function increaseAllowance(
        address spender,
        uint256 addedValue
    ) public returns (bool) {
        allowance[msg.sender][spender] += addedValue;
        emit Approval(msg.sender, spender, allowance[msg.sender][spender]);
        return true;
    }

    function decreaseAllowance(
        address spender,
        uint256 subtractedValue
    ) public returns (bool) {

        uint256 currentAllowance = allowance[msg.sender][spender];
        require(
            currentAllowance >= subtractedValue,
            "Decreased allowance below zero"
        );

        allowance[msg.sender][spender] -= subtractedValue;
        emit Approval(msg.sender, spender, allowance[msg.sender][spender]);

        return true;
    }
}

Testing Your Token

You can test your token step by step right in Remix:

• Compile: Hit Ctrl+S or click the Solidity compiler tab.

• Deploy: Go to the "Deploy & Run" tab, click "Deploy".

• Mint some tokens: Call mint with your address and 1000000000000000000000 (that's 1000 tokens with 18 decimals).

• Check your balance: Call balanceOf with your address.

• Send tokens: Try transferring to another address.

• Test approvals: Approve an address and test transferFrom.

Something to note here is that when you set a balance in your mapping, Solidity performs complex cryptographic calculations to determine exactly where on the blockchain to store that data. And every storage operation has a different gas cost. Let's take a deeper look at storage and gas optimization

Storage and Gas Optimization

Now that you understand the basics, let's take a closer look at how Solidity stores your token data and how to optimize for gas costs.

How Storage Slots Work

When you write:

balances[0x123...] = 1000;

Solidity doesn't just put this somewhere random. It computes:

bytes32 slot = keccak256(abi.encode(address(0x123...), uint256(1)));

// Where 1 is the storage slot of the balances mapping

This addressing ensures:

• No collisions between different addresses

• Predictable gas costs (SSTORE costs 20,000 gas for new values)

• Infinite capacity without pre-allocation

Gas Optimization Tips

1. Pack your variables:

// Expensive (uses 3 storage slots)

contract Inefficient {
    uint256 a; // Slot 0
    uint128 b; // Slot 1 (wastes 128 bits)
    uint128 c; // Slot 2 (wastes 128 bits
}

// Cheap (uses 2 storage slots)

contract Efficient {
    uint256 a; // Slot 0
    uint128 b; // Slot 1 (first half)
    uint128 c; // Slot 1 (second half)
}

2. Use events instead of storage for historical data:

• Storage: 20,000 gas.

• Event: 2,500 gas (8x cheaper).

3. Short-circuit your requirements:

// Check cheap conditions first

require(spender != address(0), "Invalid spender"); // cheap check
require(balances[msg.sender] >= amount, "Insufficient balance"); // expensive check

Common Pitfalls and Security Considerations

Now that you've built a token, let's talk about what could go wrong and how we've protected against it:

1. Integer Overflow (Pre-Solidity 0.8)

Before Solidity 0.8, numbers could "wrap around" like a car odometer going from 999,999 to 000,000:

uint256 balance = type(uint256).max; // Biggest possible number

balance += 1; // Would wrap to 0!

Think of it like filling a glass of water, once it's full, adding more makes it overflow. Luckily, modern Solidity stops this automatically, but older contracts needed special SafeMath libraries to check every calculation.

2. Reentrancy Protection

To explain this, let’s say you're at an ATM that gives you cash before updating your balance. If you could somehow trigger it multiple times before it updates, you could drain the account. That's reentrancy.

Our token prevents this by always updating balances BEFORE doing anything else:

// Good: Update state before external calls
balances[msg.sender] -= amount;              // 1. Update state
balances[to] += amount;                      // 2. Update state
emit Transfer(msg.sender, to, amount);       // 3. Then emit event


// Bad: External call before state update
emit Transfer(msg.sender, to, amount);       // If this calls external code...
balances[msg.sender] -= amount;              // ...they could call transfer again!
balances[to] += amount;

3. Front-Running Protection

Front-running is like someone cutting in line at the store because they saw what you're buying. On blockchain, bots can see your pending transaction and submit their own with higher gas fees to go first.

The approval race condition we fixed earlier is one example. Here are others:

• Maximal Extractable Value (MEV) Bots: Automated programs that watch for profitable trades and jump in front. Like ticket scalpers, but for blockchain transactions.

• Sandwich Attacks: A bot sees you trying to buy tokens on a DEX. They buy first (driving up the price), let your transaction go through at the higher price, then sell immediately after. You're the "meat" in their profit sandwich.

• Priority Gas Auctions: When multiple bots compete to front-run, they keep raising gas prices to go first, like an auction where everyone loses except miners.

What You've Accomplished

Take a moment to appreciate what you've built. This isn't just a toy, it's a real token contract that could be deployed on any EVM chain.

You now understand:

• State & Storage: How data lives forever on the blockchain.

• Access Control: Using msg.sender to secure functions.

• Events: Broadcasting actions to the world.

• View Functions: Free data reads for users.

• The Approval Pattern: The foundation of all DeFi.

• Security Best Practices: From Reentrancy to Race Conditions.

• Interfaces: How contracts guarantee compatibility

• Gas Optimization: Making your contracts efficient

What Next?

Your token is alive and functional, but why stop here? The real fun begins when you start adding features that production tokens use. Implement a burn function to allow users to destroy their tokens permanently, a powerful feature for deflationary tokenomics. Add a maximum supply cap to ensure only a fixed amount can ever exist. Develop a pausability feature for emergencies, enabling temporary freezes on all transfers and related activities.

Advanced Extensions to Explore

• ERC20Permit: Gasless approvals using signatures

• Flash Minting: Create and destroy tokens within a single transaction

• Rebase Tokens: Tokens that adjust all balances periodically

• Fee-on-Transfer: Tokens that take a percentage on each transfer

Once you're happy with the smart contract, it's time to make it accessible. Create a web interface using ethers.js or web3.js, allowing users to interact with your token without needing to write code. Deploy it to Monad's testnet to experience blazing-fast transactions in a real blockchain environment.

Resources for Continued Learning

• OpenZeppelin Contracts

• Ethereum Yellow Paper

This isn't a typical blog I write, but I'm going to share some raw thoughts along with rhetorical questions that you might find useful and helpful.

It's interesting to see how fast the ecosystem moves today, which has made me think a lot over the past few months about what comes next. Yes, what comes after accomplishments?

What comes after reaching the goal you set a year or two ago?
What comes after overcoming your biggest challenge, whether in skills or leadership??

Have you ever thought about the different phases of the internet we've experienced over the years and wondered what the developers from those times are doing today? Let me take you back a bit. You might know about our various internet phases: from 1995 to 2000 (Web1), 2000 to 2020 (Web2, which is still active), and now Web3 and Web5 up to the present.

Yes, Web5. If this is your first time hearing about Web5, you can learn about it with this breakdown from Adewale Abatti (Acekyd).

It's fascinating to see how things have changed over time. But can you guess what the different eras have in common? Please take a moment to think about it.

The tech skill!

Yes, tech skills are transferable skills you can own, nurture, and improve without worrying about the next iteration of the internet or trends. Before I stray too far, let me bring you back to why you're reading this: it's about valuing depth over trends or, simply put, Depth over Trend. However, you prefer to call it.

Let's talk about what's important, what you need, and why you need it. I will also share what I have learned from the past months of thinking about what truly matters, using the history I mentioned earlier. As you all know, data don’t lie.

Depth vs Trend

To explain this concept the way I think about it, and how I believe everyone reading this should subconsciously think about it, is to use the idea of trade.

"Depth" refers to the volume and liquidity at different price levels in the order book, while "Trend" refers to the overall direction of price movement over time. Think of it this way: trends are what everyone can see. They're the apparent upward or downward movements that catch attention. People chase trends because they're visible and exciting - like jumping on the AI bandwagon or whatever’s hot on Twitter this week.

But depth? That's where the real value sits. It’s having deep knowledge or capability that persists regardless of market conditions. Trends come and go, but depth gives you staying power.

What makes them similar is that both can lead to success. You can make quick wins following trends like day traders can profit from momentum. But the difference is sustainability.

Depth wins in the long run because it builds compounding value. While trend-chasers constantly restart with each new wave, depth-focused players build foundations that strengthen over time. When the trend inevitably shifts, those without depth get washed out, while those with substantive knowledge or skills remain valuable.

As Warren Buffett says - when the tide goes out, you discover who’s been swimming naked. Depth is your protection when trends reverse.

Why should you care?

Even if you think all that matters is money, who doesn't like money? Understanding the difference between depth and trends isn’t just academic. It directly impacts where you invest your limited time and energy.

Chasing trends without depth is like buying into market momentum without understanding fundamentals. Sure, you might catch some upside, but you're essentially gambling. When the music stops, you're left without a chair.

Trends often shine a lot, and if you aren't careful as a builder, founder, or developer, it's very easy to get carried away with them. But then, I know what you might be thinking: ” Everyone is doing it”, ” It’s the next big thing,” “I don’t want to miss out,” and all that. But in reality, there are different phases of life, the same as tech and the tech ecosystem in general.

Depth, on the other hand, is compound interest for your career and business. Each layer of deep understanding builds on previous layers, creating compounding returns that trends can't can't.

Take developers who studied fundamental programming concepts versus those who just learned the trending framework of the month. When React inevitably gives way to the next big thing, guess who adapts faster? The ones with depth.

Or consider founders who deeply understand customer problems versus those chasing funding trends. When venture capital dried up in 2022-2023, companies with genuine market depth survived while trend-chasers ran out of runway.

The market eventually rewards depth not because it's virtuous but because it's viable. And in an increasingly noisy world where everyone chases the same trends, depth is your unfair advantage.

Every person who created something different focused on depth, which often comes from a deep work state—a flow state of continuous, focused work. With trends, you stay at the top. It only requires shallow work to produce something of substance. - Blessing Adesiji

What can you do differently?

Stop treating tech like a fashion show. Take a breath instead of reflexively jumping on every new framework, language, or platform that trends on X(Formerly Twitter).

Ask yourself: "Does it solve a fundamental problem, or is it just shiny?"

It doesn’t mean you should isolate yourself and not keep abreast of what's going on around you.

Develop your Bulls***t detector. When everyone's hypineveryone's thing, that's your cue that's skeptical. The real opportunities often lie in areas others overlook because they're too busy following the crowd.

Allocate your learning time like an investment portfolio:

• 70% toward deepening your understanding of fundamentals that won't change.

• 20% tailoring adjacent skills that complement your core.

• 10% experimenting with trends.

Build relationships with people who prioritize depth. You become the average of the five people you spend the most time with, so surround yourself with depth-seekers who ask hard questions rather than trend-followers who chase easy answers.

Perhaps most importantly, be willing to be temporarily uncool. The paradox is that ignoring what's trendy positions you to catch more immense, meaningful waves later.

Self Reflection

Take a moment to audit your recent decisions. How many were made because "everyone is doing it" versus a ”deep understanding of underlying value”?

Look at your skill set critically. If the tech landscape dramatically changed tomorrow, which of your abilities would remain valuable? Those are your depth areas.

Consider your heroes in tech. Are they known for riding trends or creating fundamental value regardless of market conditions? What can you learn from their approaches?

Ask yourself the uncomfortable question: "Am I building something that will matter in five years?" If not, you might be optimizing for trends over depth.

Finally, depth isn't just technical knowledge; it's understanding people, problems, and principles. The most profound insights often come from connecting dots across disciplines rather than narrowing down to what's happening.

The choice between depth and trend is not a career strategy. It's a philosophy about how you want to contribute to the world. Choose wisely.

Olanetsoft ✍️

Axelar has long been the best way to connect EVM and Cosmos chains via bridged assets. With General Message Passing, that connection goes beyond bridging, supporting a new generation of cross-chain applications that combine the best of Cosmos and EVM.

In this tutorial, you will learn how to:

• Build and deploy an EVM smart contract on Avalanche

• Build and deploy a CosmWasm contract on Osmosis

• Send a message from a CosmWasm contract to Avalanche

• Read a message from an EVM smart contract on Avalanche

• Send a message from EVM to a CosmWasm contract on Osmosis

• Read a message from a CosmWasm contract on Osmosis

Prerequisites

• Practical understanding of how to build a CosmWasm contract

• Basic understanding of how to build EVM smart contract

• Install osmosisd CLI

  • Download and install the osmosisd CLI by following the instructions here. If the installation wizard does not work, build from the source using the following commands:

git clone https://github.com/osmosis-labs/osmosis.git
cd osmosis
make build

• Create a Wallet

  • If you don't have a wallet yet, create one using the following command:

osmosisd keys add wallet

• Obtain Test Tokens

  • Get some test tokens from the Osmosis Testnet Faucet.

• Ensure you have Docker installed to build the contract.

• A wallet with an Avax token for testing. If you don’t have these tokens, you can get Avax from the Avalanche faucet.

What is a CosmWasm contract?

CosmWasm is a smart contracting platform designed for the Cosmos ecosystem. In simple terms, it utilizes WebAssembly (Wasm) in the Cosmos (Cosm) way.

CosmWasm contracts provide advanced smart contract capabilities within the Cosmos ecosystem, leveraging the performance and security advantages of WebAssembly and Rust. This allows developers to create complex, interoperable, and secure decentralized applications across various Cosmos-based blockchains.

What is Axelar Cosmos general message passing (GMP)

General Message Passing (GMP) empowers developers with the ability to build interchain-native applications that make cross-chain function calls and synchronize state in a way that is completely abstracted for the user.

In simpler terms, Axelar GMP enables developers to build applications that integrate functions (such as smart contracts) hosted on various connected chains, similar to using Lego bricks.

Axelar has expanded General Message Passing (GMP) to support Cosmos blockchains. With Axelar, you can now send and receive messages on EVM chains and Cosmos chains. Messages sent to Cosmos chains can be received by CosmWasm smart contracts (on blockchains with CosmWasm support), or those messages can be received natively at the consensus layer as part of Go code.

Cosmos GMP works by sending and receiving through IBC’s memo field. Cosmos chains that support GMP should integrate the appropriate middleware and verify the message source.

Project setup and installation

To start the project setup and installation quickly, clone this project on GitHub using the following command:

git clone https://github.com/axelarnetwork/send-message-from-cosmos-to-evm-example.git

Make sure you're on the start branch using the following command:

git checkout start

Next, change the directory into the cloned folder and install the project locally using npm with the following command:

cd send-message-from-cosmos-to-evm-example && npm i

Create a .env file

Run the following command to create an .env file:

touch .env

Add your axl private key to .env

Export your osmo prefix address private key and add it to the .env file you just created:

PRIVATE_KEY= // Add your account private key here

Build and deploy a CosmWasm contract on Osmosis

The cloned project has the following folder structure that already contains the WASM contract; the next step you will be taking is to build and deploy the contract.

├── wasm
│ ├── src
│ │ ├── contract.rs
│ │ ├── error.rs
│ │ ├── ibc.rs
| │ ├── lib.rs
│ │ ├── msg.rs
│ │ ├── state.rs
| │ ├── unit_tests.rs
│ ├── cargo.lock
│ ├── corgo.toml
├── .env
├── node_modules
├── package.json
├── package-lock.json
├── README.md
└── .gitignore

In the contract.rs, the following was implemented:

• Initialization: The instantiate function sets up the contract by saving the initial configuration and a placeholder message into the contract's storage.

• Message Sending: The execute function handles various ExecuteMsg variants to send messages to EVM or Cosmos chains using Axelar GMP, constructing and dispatching messages with the necessary payload and metadata.

• Message Reception: The contract includes functions (receive_message_evm and receive_message_cosmos) to receive and store messages from EVM and Cosmos chains, decoding the payload and saving it in the contract's state.

• IBC Integration: It leverages Inter-Blockchain Communication (IBC) to send cross-chain messages, specifically designed to work with Axelar's GMP for transferring messages and funds across chains.

• Query Stored Messages: The query function enables retrieval of stored messages via the GetStoredMessage query, returning the sender and message details stored in the contract.

Build the CosmWasm contract

Navigate into the wasm folder and build the contract with the following command:

docker run --rm -v "$(pwd)":/code \
  --mount type=volume,source="$(basename "$(pwd)")_cache",target=/code/target \
  --mount type=volume,source=registry_cache,target=/usr/local/cargo/registry \
  cosmwasm/rust-optimizer:0.12.13

Make sure you have Docker daemon running before running the command above.

You should see something similar to what is displayed below on your terminal if the build is successful:

Info: RUSTC_WRAPPER=sccache
Info: sccache stats before build
Compile requests                      0
Compile requests executed             0
Cache hits                            0
Cache misses                          0
Cache timeouts                        0
Cache read errors                     0
Forced recaches                       0
Cache write errors                    0
Compilation failures                  0
Cache errors                          0
Non-cacheable compilations            0
Non-cacheable calls                   0
Non-compilation calls                 0
Unsupported compiler calls            0
Average cache write               0.000 s
Average cache read miss           0.000 s
Average cache read hit            0.000 s
Failed distributed compilations       0
Cache location                  Local disk: "/root/.cache/sccache"
Cache size                            0 bytes
Max cache size                       10 GiB
Building contract in /code ...
    Finished release [optimized] target(s) in 0.44s
Creating intermediate hash for send_receive.wasm ...
ebea0ee2e90b34fe4d55bd011051213938b95d596d6b56853c6e3e9bda8630ad  ./target/wasm32-unknown-unknown/release/send_receive.wasm
Optimizing send_receive.wasm ...
Creating hashes ...
c255d85938b647f59fcb77fe9d52ceefef5e510cd71364c522ce9ce25d3de8cc  send_receive.wasm
Info: sccache stats after build
Compile requests                      0
Compile requests executed             0
Cache hits                            0
Cache misses                          0
Cache timeouts                        0
Cache read errors                     0
Forced recaches                       0
Cache write errors                    0
Compilation failures                  0
Cache errors                          0
Non-cacheable compilations            0
Non-cacheable calls                   0
Non-compilation calls                 0
Unsupported compiler calls            0
Average cache write               0.000 s
Average cache read miss           0.000 s
Average cache read hit            0.000 s
Failed distributed compilations       0
Cache location                  Local disk: "/root/.cache/sccache"
Cache size                            0 bytes
Max cache size                       10 GiB
done

Upload the CosmWasm contract

Next, you need to upload the contract using the following command:

osmosisd tx wasm store ./artifacts/send_receive.wasm --from wallet --gas-prices 0.4uosmo --gas auto --gas-adjustment 1.5 -y -b sync --output json --node https://rpc.osmotest5.osmosis.zone:443 --chain-id osmo-test-5

You should see something similar to what is displayed below on your terminal if the upload is successful:

gas estimate: 3150117
{
    "height":"0",
    "txhash":"339C8D4E8BB10E0DD337F79ACC26BB825C341E6DAFE803C5E8F8C2B42E9D5A33",
    "codespace":"","code":0,"data":"",
    "raw_log":"","logs":[],
    "info":"","gas_wanted":"0","gas_used":"0","tx":null,
    "timestamp":"","events":[]
}

Instantiate the CosmWasm contract

To instantiate the CosmWasm contract, you will need a CodeId. To retrieve that, copy the transaction hash from the terminal response and paste it on Mintscan; in the transaction details, you should see a CodeId similar to this.

Next, instantiate the contract with the following command:

osmosisd tx wasm instantiate <codeId> '{"channel":"channel-4118"}' --from wallet --label "send_receive" --gas-prices 0.1uosmo --gas auto --gas-adjustment 1.3 --no-admin -y -b sync --output json --node https://rpc.osmotest5.osmosis.zone:443 --chain-id osmo-test-5

Replace <codeId> with the actual code ID of your transaction. You should see something similar to what is displayed below on your terminal if the instantiation is successful:

gas estimate: 208330
{
    "height":"0",
    "txhash":"6F2FD21EF41267562826444DB29091CA163941BC31AB5FCC085A42B3F67E2317",
    "codespace":"","code":0,"data":"","raw_log":"","logs":[],
    "info":"","gas_wanted":"0","gas_used":"0",
    "tx":null,"timestamp":"","events":[]
    }

You have successfully built, uploaded, and instantiated the CosmWasm contract. In the next section, you will build and deploy the EVM smart contract on Avalanche in this example and then interact with the EVM contract from the CosmWasm contract.

Save the CosmWasm contract address

You will need the CosmWasm contract address later in this tutorial. You can find it in the contract details on Mintscan by pasting the transaction hash and saving it somewhere. In this example, the contract address is osmo1vqgrchlfuymkjrzmrjznpam3xtzfemthzue43yt8l4ug046rtvwqarcl8r.

Build and deploy an EVM smart contract on Avalanche

In this session, you will build and deploy an EVM smart contract to Avalanche, a contract you will interact with from the CosmWasm you deployed.

To quickly build and deploy the EVM smart contract, you can use https://remix.ethereum.org/, a powerful toolset for developing, deploying, debugging, and testing Ethereum and EVM-compatible smart contracts.

Build contract

Create a new file titled SendReceive.sol inside the contracts folder and copy the code from this gist into it.

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

import {AxelarExecutable} from "@axelar-network/axelar-gmp-sdk-solidity/contracts/executable/AxelarExecutable.sol";
import {IAxelarGateway} from "@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IAxelarGateway.sol";
import {IAxelarGasService} from "@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IAxelarGasService.sol";
import {StringToAddress, AddressToString} from "@axelar-network/axelar-gmp-sdk-solidity/contracts/utils/AddressString.sol";

contract SendReceive is AxelarExecutable {
    using StringToAddress for string;
    using AddressToString for address;

    IAxelarGasService public immutable gasService;
    string public chainName; // name of the chain this contract is deployed to

    struct Message {
        string sender;
        string message;
    }

    Message public storedMessage; // message received from _execute

    constructor(
        address gateway_,
        address gasReceiver_,
        string memory chainName_
    ) AxelarExecutable(gateway_) {
        gasService = IAxelarGasService(gasReceiver_);
        chainName = chainName_;
    }

    function send(
        string calldata destinationChain,
        string calldata destinationAddress,
        string calldata message
    ) external payable {
        require(msg.value > 0, 'Gas payment is required');

        // 1. Generate GMP payload
        bytes memory executeMsgPayload = abi.encode(msg.sender.toString(), message);
        bytes memory payload = _encodePayloadToCosmWasm(executeMsgPayload);

        // 2. Pay for gas
        gasService.payNativeGasForContractCall{value: msg.value}(
            address(this),
            destinationChain,
            destinationAddress,
            payload,
            msg.sender
        );

        // 3. Make GMP call
        gateway.callContract(destinationChain, destinationAddress, payload);
    }

    function _encodePayloadToCosmWasm(bytes memory executeMsgPayload) internal view returns (bytes memory) {
        //   Schema
        //   bytes4  version number (0x00000001)
        //   bytes   ABI-encoded payload, indicating function name and arguments:
        //   string                   CosmWasm contract method name
        //   dynamic array of string  CosmWasm contract argument name array
        //   dynamic array of string  argument abi type array
        //   bytes                    abi encoded argument values

        // contract call arguments for ExecuteMsg::receive_message_evm{ source_chain, source_address, payload }
        bytes memory argValues = abi.encode(
            chainName,
            address(this).toString(),
            executeMsgPayload
        );

        string[] memory argumentNameArray = new string[](3);
        argumentNameArray[0] = "source_chain";
        argumentNameArray[1] = "source_address";
        argumentNameArray[2] = "payload";

        string[] memory abiTypeArray = new string[](3);
        abiTypeArray[0] = "string";
        abiTypeArray[1] = "string";
        abiTypeArray[2] = "bytes";

        bytes memory gmpPayload;
        gmpPayload = abi.encode(
            "receive_message_evm",
            argumentNameArray,
            abiTypeArray,
            argValues
        );

        return abi.encodePacked(
            bytes4(0x00000001),
            gmpPayload
        );
    }

    function _execute(
        string calldata /*sourceChain*/,
        string calldata /*sourceAddress*/,
        bytes calldata payload
    ) internal override {
        (string memory sender, string memory message) = abi.decode(payload, (string, string));
        storedMessage = Message(sender, message);
    }
}

In the contract above,

• Contract Initialization: The SendReceive contract inherits from AxelarExecutable and initializes the Axelar gas service and chain name in its constructor

• Sending Messages: The send function allows users to send messages to a specified destination chain and address, requiring a gas payment. It generates a General Message Passing (GMP) payload, pays for the gas, and makes the call through the Axelar gateway

• Payload Encoding: The _encodePayloadToCosmWasm internal function encodes the message payload into a specific format required for CosmWasm contracts, including schema versioning and argument encoding

• Message Reception: The _execute function decodes the received message payload and stores the message in the contract's state, handling incoming messages from other chains

Compile contract

You can proceed to compile the smart contract. Click the compile icon, and then the compile buttons are shown below.

Deploy contract

Deploying the smart contract to Avalanche testnets requires specifying the Axelar Gateway Service and Gas Service contracts in the argument. Here is the list of Axelar Gas Service and Gateway contracts for all the chains currently supported by Axelar.

This contract you want to deploy requires the Gas Service, Gateway, and Chain Name, which will be passed on to the constructor before deployment, as shown below.

Click the deploy icon on Remix, as shown below.

Select the deployment target, Injected Provider - MetaMask.

Add the Axelar Gateway: 0xC249632c2D40b9001FE907806902f63038B737Ab and the Gas Service: 0xbE406F0189A0B4cf3A05C286473D23791Dd44Cc6 contract address deployed on Avalanche and chain name: Avalanche.

Next, click the transact button.

Copy contract address

Copy the contract address and save it somewhere; you will need it in the following section to send a message from the Coswasm contract to Avalanche.

Address 0x113BD07720a5Ae9104C5d54fBDfA83F792afc8e0 Details - Avalanche Testnet.

Send a message from a CosmWasm contract to Avalanche

You are all set to send a message from the CosmWasm contract you deployed to Avalanche. Create a new file with the name index.js in the root directory.

Import dependencies

To import the required dependencies add the following code snippet.

require("dotenv").config();
const { GasPrice } = require("@cosmjs/stargate");
const { SigningCosmWasmClient } = require("@cosmjs/cosmwasm-stargate");
const { AxelarQueryAPI } = require("@axelar-network/axelarjs-sdk");
const { DirectSecp256k1Wallet } = require("@cosmjs/proto-signing");
const { fromHex } = require("@cosmjs/encoding");

• The script uses dotenv to load environment variables and imports essential modules from @cosmjs/stargate, @cosmjs/cosmwasm-stargate, @axelar-network/axelarjs-sdk, and @cosmjs/proto-signing to interact with Cosmos and Axelar networks

• The fromHex function from @cosmjs/encoding is imported for decoding hex strings, which is crucial for handling private keys and other hexadecimal data formats

Set up the environment, API settings, token, and contract details

You need to define a few variables to be used in the script for the environment, API settings, token, and contract details. To do that, add the following code snippet.

//...

// Environment and API settings
const privateKey = process.env.PRIVATE_KEY;
const rpcEndpoint = "https://rpc.osmotest5.osmosis.zone";
const chainId = "osmosis-7";
const testnetEnvironment = "testnet";

// Token and contract details
const aUSDC =
  "ibc/1587E7B54FC9EFDA2350DC690EC2F9B9ECEB6FC31CF11884F9C0C5207ABE3921"; // aUSDC IBC address
const osmoDenom = "uosmo";
const gasPriceString = `0.4${osmoDenom}`;
const wasmContractAddress =
  "osmo1vqgrchlfuymkjrzmrjznpam3xtzfemthzue43yt8l4ug046rtvwqarcl8r";

Add EVM contract details

//...

// Message details
const destinationChain = "Avalanche";
const destinationAddress = "0x113BD07720a5Ae9104C5d54fBDfA83F792afc8e0"; // Replace with the Avalanche address you deployed
const messageToSend = "Hello world from Osmosis!";

Replace 0x113BD07720a5Ae9104C5d54fBDfA83F792afc8e0 with the contract address you copied from Remix earlier when you deployed on Avalanche.

Decode the Private Key and Create a Wallet

Now, decode your private key and create a wallet:

//...

(async () => {
  try {
    // Decode the private key from hex
    const decodedPrivateKey = fromHex(privateKey);

    // Create a wallet from the private key
    const wallet = await DirectSecp256k1Wallet.fromKey(
      decodedPrivateKey,
      "osmo",
    );
    const [{ address }] = await wallet.getAccounts();
  } catch (error) {
    console.error("An error occurred:", error);
  }
})();

Connect to the Client

Set up the client to interact with the blockchain:

//...

// Connect to the client
const gasPrice = GasPrice.fromString(gasPriceString);
const client = await SigningCosmWasmClient.connectWithSigner(
  rpcEndpoint,
  wallet,
  { gasPrice },
);

Retrieve and Log Balances

Retrieve the balances of aUSDC and OSMO tokens and log them:

//...

// Retrieve balances
const balanceUsdc = await client.getBalance(address, aUSDC);
const balanceOsmo = await client.getBalance(address, osmoDenom);

// Log wallet information
console.log("----- Wallet Info -----");
console.log(`Wallet address: ${address}`);
console.log(`aUSDC balance: ${balanceUsdc.amount / 1e6} aUSDC`);
console.log(`Osmo balance: ${balanceOsmo.amount / 1e6} OSMO\\n`);

Estimate Gas Fee

Estimate the gas fee for sending the message:

//...

// Estimate gas fee
const api = new AxelarQueryAPI({ environment: testnetEnvironment });
const gasAmount = await api.estimateGasFee(
  chainId,
  destinationChain,
  100000,
  "auto",
  "aUSDC",
);
console.log(`Estimated gas fee: ${parseInt(gasAmount) / 1e6} aUSDC`);

Check for Sufficient Balances

Ensure you have enough balances to cover the gas fees:

//...

// Check for sufficient balances
if (balanceUsdc.amount < gasAmount) {
  console.error("Insufficient aUSDC balance to pay for gas fee");
  return process.exit(0);
}

if (balanceOsmo.amount < 1e6) {
  console.error("Insufficient OSMO balance to pay for gas fee");
  return process.exit(0);
}

Query Message from the Osmosis Contract

Retrieve a stored message from the Osmosis contract:

//...

// Query message from the osmosis contract
const response = await client.queryContractSmart(wasmContractAddress, {
  get_stored_message: {},
});
console.log("Message from Osmosis contract:", response.message);

Prepare and Send the Message

Prepare the payload and send the message to the Osmosis contract:

//...

// Prepare payload to send message to osmosis contract
const payload = {
  send_message_evm: {
    destination_chain: destinationChain,
    destination_address: destinationAddress,
    message: messageToSend,
  },
};

const fee = {
  amount: gasAmount,
  denom: aUSDC,
};

console.log("Sending message to Osmosis contract...");

// Execute transaction
const result = await client.execute(
  address,
  wasmContractAddress,
  payload,
  "auto",
  undefined,
  [fee],
);

console.log("Sent:", result.transactionHash);

Test sending a message from Coswasm contract to Avalanche

You have successfully implemented sending messages from the CosmWasm contract you deployed earlier. It's time to test the implementation. Use the following command to run the script and ensure you are in the project's root directory.

node index.js

You should see something similar to what is displayed below on your terminal if the test is successful:

----- Wallet Info -----
Wallet address: osmo16m62wcd7dyednttjgayc08n22z509a70vcekuu
aUSDC balance: 48.553691 aUSDC
Osmo balance: 109.698386 OSMO

Estimated gas fee: 0.344874 aUSDC
Message from Osmosis contract: none
Sending message to Osmosis contract...
Sent: F19AB19C94794CF5BD2E480E1CEFD893D1E74E7CC709ADC8260736BCC253AD27

In case you run into an error like the following:

Error: Client network socket disconnected before secure TLS connection was established
    at connResetException (node:internal/errors:705:14)
    at TLSSocket.onConnectEnd (node:_tls_wrap:1594:19)
    at TLSSocket.emit (node:events:525:35)
    at endReadableNT (node:internal/streams/readable:1358:12)
    at processTicksAndRejections (node:internal/process/task_queues:83:21) {
    code: 'ECONNRESET',
    path: null,
    host: 'rpc.osmotest5.osmosis.zone',
    port: 443,
    localAddress: undefined
}

Wait a bit and retry.

If you encounter the error "Insufficient aUSDC balance to pay for gas fee," please proceed to the Axelar Discord server. In the faucet channel, kindly paste your axl wallet address in this format: !faucet axelar16m62wcd7dyednttjgayc08n22z509a70qduwp0, and then conduct an IBC transfer to your osmo wallet address.

Check transaction on Axelarscan testnet.

If you do not have any errors, you can copy the transaction hash logged on the console, head over to the Axelarscan testnet, and paste it; you should be able to see how the message is sent from Osmosis to Avalanche via Axelar. You can find an example of the transaction here.

Read a message from an EVM smart contract on Avalanche

You have successfully sent a message from your CosmWasm contract to Avalanche; let's confirm that the message was actually sent and arrived on Avalanche.

Head back to https://remix.ethereum.org/, find the contract you deployed earlier, and click on the storedMessage button, as shown below. You should see "Hello world from Osmosis!" logged, which indicates that your message was successfully sent from the CosmWasm contract and received on the Avalanche contract.

Send a message from EVM to a CosmWasm contract on Osmosis

You have been able to send the message successfully in the previous step; now, proceed to send a message from Avalanche to the same CosmWasm contract on Osmosis. To do that, on Remix, click on the arrow icon beside the “Send” button and enter the following details.

destinationChain: osmosis-7

destinationAddress: osmo1vqgrchlfuymkjrzmrjznpam3xtzfemthzue43yt8l4ug046rtvwqarcl8r

message: Hello from Avalanche

Make sure to replace osmo1vqgrchlfuymkjrzmrjznpam3xtzfemthzue43yt8l4ug046rtvwqarcl8r with your contract address on Osmosis.

Next, pass a gas value in Gwei, in this example we passed 10000000 Gwei.

After confirming the transaction on the MetaMask popup, you can proceed to verify the transaction onchain on the Axelarscan testnet by copying the transaction hash and pasting it. Here is an example.

Read a message from a CosmWasm contract on Osmosis

In the previous step, you have successe=fully sent a message from Avalanche to Osmosis, in this step you will read the message from Osmosi to confirm it was truly received on Osmosis. To do that, create a new file, read.js, in the root folder of your project and add the following code snippet.

require("dotenv").config();
const { GasPrice } = require("@cosmjs/stargate");
const { SigningCosmWasmClient } = require("@cosmjs/cosmwasm-stargate");
const { DirectSecp256k1Wallet } = require("@cosmjs/proto-signing");
const { fromHex } = require("@cosmjs/encoding");

// Environment and API settings
const privateKey = process.env.PRIVATE_KEY;
const rpcEndpoint = "https://rpc.osmotest5.osmosis.zone";

// Token and contract details
const aUSDC =
  "ibc/1587E7B54FC9EFDA2350DC690EC2F9B9ECEB6FC31CF11884F9C0C5207ABE3921";
const osmoDenom = "uosmo";
const gasPriceString = `0.4${osmoDenom}`;
const wasmContractAddress =
  "osmo1vqgrchlfuymkjrzmrjznpam3xtzfemthzue43yt8l4ug046rtvwqarcl8r";

(async () => {
  try {
    // Decode the private key from hex
    const decodedPrivateKey = fromHex(privateKey);

    // Create a wallet from the private key
    const wallet = await DirectSecp256k1Wallet.fromKey(
      decodedPrivateKey,
      "osmo",
    );
    const [{ address }] = await wallet.getAccounts();

    // Connect to the client
    const gasPrice = GasPrice.fromString(gasPriceString);
    const client = await SigningCosmWasmClient.connectWithSigner(
      rpcEndpoint,
      wallet,
      { gasPrice },
    );

    // Retrieve balances
    const balanceUsdc = await client.getBalance(address, aUSDC);
    const balanceOsmo = await client.getBalance(address, osmoDenom);

    // Log wallet information
    console.log("----- Wallet Info -----");
    console.log(`Wallet address: ${address}`);
    console.log(`aUSDC balance: ${balanceUsdc.amount / 1e6} aUSDC`);
    console.log(`Osmo balance: ${balanceOsmo.amount / 1e6} OSMO\n`);

    // Query message from the osmosis contract
    const response = await client.queryContractSmart(wasmContractAddress, {
      get_stored_message: {},
    });
    console.log("Message from Osmosis contract:", response.message);
  } catch (error) {
    console.error("An error occurred:", error);
  }
})();

You should see something similar to what is displayed below on your terminal if the test is successful:

----- Wallet Info -----
Wallet address: osmo16m62wcd7dyednttjgayc08n22z509a70vcekuu
aUSDC balance: 48.208817 aUSDC
Osmo balance: 109.58592 OSMO

Message from Osmosis contract: Hello from Avalanche

Woohoo! If you made it this far, congratulations.

Conclusion

In this tutorial, you have learned how to build and deploy an EVM smart contract on Avalanche, build and deploy a CosmWasm contract on Osmosis, send a message from a CosmWasm contract to Avalanche, read a message from an EVM smart contract on Avalanche, send a message from EVM to a CosmWasm contract on Osmosis, and read a message from a CosmWasm contract on Osmosis.

By mastering these steps, you can effectively create interoperable decentralized applications that leverage the strengths of both EVM-based and Cosmos-based blockchain networks.

Reference

• Axelar Cosmos General Message Passing

• Axelarscan Testnet

• Osmosis Testnet Faucet

• Osmosis Testnet Explorer

Verifying the authenticity of each image in this gallery could be difficult, right? How can they prove the images haven't been manipulated, or how can you confirm everything is as it should be? That's where Merkle's proofs come into play, as they offer a solution to verify the integrity of large datasets without the need to inspect each item individually.

In this tutorial, you will learn about Merkle proofs, how to create them using a Merkle Tree, and how to implement Merkle proofs for whitelisting email addresses using JavaScript.

To understand how Merkle proofs help verify the authenticity and integrity of your data without the need to check each piece individually, such as your image gallery, as discussed earlier, you first need to understand the structure that underpins them: the Merkle Tree.

What is a Merkle Tree?

A Merkle Tree, also known as a hash tree, is a binary tree structure used to verify a data set's integrity effectively. It was a concept named after the computer scientist Ralph Merkle, who patented it in 1979.

This binary tree structure has each leaf node representing a block of data or a piece of information. Instead of containing the data directly, the internal nodes hold a cryptographic hash of their child nodes. The tree is built by repeatedly hashing pairs of child nodes until a single root hash is achieved.

Components of Merkle Tree

Merkle Tree image by Teemu Kanstrén

A Merkle tree has three different components, as shown in the image above Merkle root, Merkle branches, and Merkle leaves. Let's take a look at what they are.

• Merkle root is derived from hashing together the child hashes beneath it and down to the leaves. It is a single hash on its own that represents the top of the Merkle tree, as shown in the image above and is often used to store block headers in blockchain content without downloading the entire block.

• In a Merkle tree, we have Merkle branches, intermediate nodes between Merkle roots and Merkle leaves. Each branch node is created by hashing together the hashes of its child nodes. These branches form the connections between the leaves (where the data resides) and the Merkle root, making it easier to ensure that the Merkle tree can be efficiently traversed and verified.

• Merkle leaves are the nodes at the bottom layer of the Merkle tree. They contain hashes of the actual data stored. The leaves are the foundation of the Merkle tree, as their hashes are combined and rehashed to produce the hashes of the nodes above them, ultimately leading to the Merkle root.

Additionally, we have the Data nodes, a layer representing how data is supplied to start the process before it hashed in the next layer(Merkle leaves), which is the Merkle leaves, as shown in the image.

What is a Merkle Proof?

A Merkle proof is a method used to verify the presence and integrity of specific data within a dataset using a Merkle tree. It comprises a single data block (leaf), a series of hashes from the tree (branches), and the Merkle root.

While Merkle proof is used to verify the presence of specific data within a dataset using a Merkle tree, here are some areas where Merkle proof can be applied.

• In a distributed system for data verification

• Secure communication protocols

• Data storage solution

• Cryptocurrencies and blockchain

Implementing a Merkle Proof for Whitelisting Email Addresses

Let's implement a Merkle proof for whitelisting email addresses in this section.

Prerequisite

• Node.js and its package manager NPM, version 18. Verify Node.js is installed by running the following terminal command: node -v && npm -v

• A basic understanding of JavaScript

Project Setup and Installation

Navigate to any directory of your choice, and then run the following commands to create a new folder and change the directory into the folder:

mkdir merkle-proof-tutorial
cd merkle-proof-tutorial

Next, you need to install the merkletreejs and crypto-js libraries, which will be needed to create a Merkle tree and hash data using the following command:

npm i merkletreejs crypto-js

Create a new file proof.js feel free to name it whatever you want, but for this tutorial, you will name it proof.js.

Import Libraries

You will be using the merkletreejs and crypto-js libraries in this example to create a Merkle tree and hash the data, respectively.

Navigate into the proof.js file and add the following code snippet:

const { MerkleTree } = require('merkletreejs')
const SHA256 = require('crypto-js/sha256')

Create a List of Emails to Be Whitelisted

You need to create a list of emails to be whitelisted. In this example, you will add three emails, but it could be millions of emails, depending on the data you want to test with. Add the following code snippet to create an array of three email addresses:

//...

// List of email addresses to be whitelisted
const emails = ["example1@mail.com", "example2@mail.com", "example3@mail.com"];

Convert Emails to Hashes and Build the Merkle Tree

Next, you need to convert each email into a hash and create the Merkle tree using the hashed emails with the following code snippet:

//...

// Convert each email into a hash
const leaves = emails.map(email => SHA256(email));

// Create the Merkle Tree using the hashed emails
const tree = new MerkleTree(leaves, SHA256);

// Get the root and convert it to a hexadecimal string
const root = tree.getRoot().toString('hex');

Add Function to Verify Whitelisted Emails

In the previous step, you created a tree for the addresses; next, you must create a function to prove if an email is part of the whitelisted emails.

Create a function verifyEmail:

//...

// Function to verify if an email is whitelisted
const verifyEmail = (email) => {
  // Hash the email to be verified
  const hashedEmail = SHA256(email);

  // Get the proof for the hashed email from the tree
  const proof = tree.getProof(hashedEmail);

  // Verify the proof against the root of the tree; returns true if valid, false otherwise
  const verified = tree.verify(proof, hashedEmail, root);

  // Log the result to the console
  console.log(`${email} is ${verified ? "whitelisted" : "not whitelisted"}.`);
};

In the code snippet, you created a function verifying whether an email is whitelisted. To do this, you:

• Hashed the email to be verified using SHA256

• Got the proof for the hashed email using the getProof method

• Verified the proof against the root of the tree

Here is what the complete code looks like:

const { MerkleTree } = require("merkletreejs");
const SHA256 = require("crypto-js/sha256");

// List of email addresses to be whitelisted
const emails = ["example1@mail.com", "example2@mail.com", "example3@mail.com"];

// Convert each email into a hash
const leaves = emails.map((email) => SHA256(email));

// Create the Merkle Tree using the hashed emails
const tree = new MerkleTree(leaves, SHA256);

// Get the root and convert it to a hexadecimal string
const root = tree.getRoot().toString("hex");

// Function to verify if an email is whitelisted
const verifyEmail = (email) => {
  // Hash the email to be verified
  const hashedEmail = SHA256(email);

  // Get the proof for the hashed email from the tree
  const proof = tree.getProof(hashedEmail);

  // Verify the proof against the root of the tree; returns true if valid, false otherwise
  const verified = tree.verify(proof, hashedEmail, root);

  // Log the result to the console
  console.log(`${email} is ${verified ? "whitelisted" : "not whitelisted"}.`);
};

Test the Verification Function

In this section, you will test the verification function with a whitelisted and non-whitelisted email.

Test with a whitelisted email address by calling the verifyEmail function inside the script file.

//...

verifyEmail("example2@mail.com");  // Expected output: "example2@mail.com is whitelisted."

To run the script, use the following command:

node proof.js

The result printed on the console will return a response as shown below, indicating the email address is whitelisted because it is part of the emails we added to the email array.

Next, test with an email that is not whitelisted.

//...

verifyEmail("x@mail.com"); 
// Expected output: "x@mail.com is not whitelisted."

You should see a response indicating the email is not whitelisted, as shown below. This is because it wasn't part of the emails whitelisted, meaning there is no proof for the email address to indicate it was part of the tree.

Conclusion

In this tutorial, you learned about Merkle proofs, how they can be used to ensure the integrity of datasets in applications, how to create them using a Merkle Tree, and how to implement Merkle proofs for whitelisting email addresses using JavaScript.

References

• Merkle Tree

• Merkletreejs SDK

It's been a while since I published my last piece of content here. I'm back—not to dwell on the gap but to share my excitement for what lies ahead. Above all, I'm celebrating a year as a Developer Advocate working on Axelar with the best engineers and teams in web3. Woohoo 🥳

As I sit down to pen this reflection, I'm reminded of the countless stories where individuals embark on journeys filled with unknowns, armed with nothing but a heart full of dreams and a relentless drive to explore. This narrative resonates universally, mirroring the essence of human curiosity and our innate desire to push beyond the familiar confines of our world.

Exactly one year ago, I found myself at the threshold of such an adventure with Axelar. Much like the protagonist of a story who steps into a new realm, I was filled with a blend of excitement and uncertainty.

In this blog post, I invite you to join me on a retrospective voyage through my first year at Axelar. It's a story of growth, learning, and the relentless pursuit of building bridges in the digital world.

The Motivation

In the early days, we had Bitcoin, Vitalik and his team take significant steps to enrich the developer ecosystem by enabling applications to leverage the blockchain through smart contracts. This sparked immense excitement in the "crypto" space, particularly among builders and the curious. It means that whether you were actively involved in the space or not, you couldn't ignore the buzz about NFTs, haha.

Fast forward to late 2021, I became really curious about what powers NFTs. At that time, the space saw an unprecedented boom, and it was everywhere. However, as a backend developer, I used my curiosity to focus on learning about the technology rather than the "hype." Discovering blockchain and its amazing features that could be leveraged made me dive deep into the "Rabbit Hole," and the rest was history.

But there was a problem; wait, what?

Yes, I'll discuss the problem in one of the sections of this post; keep reading.

Back to my motivations, Axelar wasn't just another company; it promised a quest toward building the future of interoperability—a concept as vast and uncharted as the deepest oceans or the farthest galaxies in our collective imagination.

This journey at Axelar became my canvas, on which I've painted days of rigorous challenges, moments of unprecedented innovation, and the unyielding pursuit of something truly groundbreaking. It's a tale not unlike those of explorers of old, who set sail to discover new worlds or scientists on the cusp of breakthroughs that could redefine the boundaries of what we believe is possible.

First-Year Milestone

The list is looooooooooooong!

One of my greatest achievements so far has been collaborating with incredibly talented, brilliant, and passionate engineers and leaders under the guidance of my manager, Stephen Fluin, and the DevRel Team. We've made significant improvements to the current system, focusing on developer experience, supporting developers and partners, and fostering community and leadership, among many other areas. It's already been a year, but it still feels like day one. ;)

During this period, I've learned a great deal about Axelar. I've assisted partners with integration, enabling them to launch on the mainnet. I've delivered numerous talks and workshops internationally and locally, created boilerplate projects for building and testing cross-chain transactions locally or on testnets using Foundry, hosted and judged several hackathons, enhanced developer documentation to support developer success, and worked with top industry leaders, projects, and products.

Additionally, I've built strong relationships, increased developer engagement, gathered feedback to enhance our products, and contributed significantly to developing our developer community, among many other activities.

Building the Interoperability Future

In the previous step, I mentioned there was a problem, and I promised to discuss it. The issue is well-known in the blockchain space, where all blockchain ecosystems, including both EVM and non-EVM chains, operate in isolation. These are great solutions that many products use, but there isn't a way to connect these ecosystems together in a decentralized manner without compromising security, decentralization, or the developer experience.

Guess what? We have an answer, and that's Axelar, connecting over 60+ chains, improving developer experience, security through decentralization, and much more.

That's not all; developing with Axelar Virtual Machine elevates the whole process of connectivity, supporting Interchain Maestro and Interchain Amplifier.

What does this mean for the future of interoperability?

With the Interchain Amplifier, developers can deploy and manage their multi-chain dApp instances using the Interchain Token Service, which went live on the mainnet in January. Additionally, the Interchain Amplifier, recently launched, offers a permissionless model and service. This allows anyone to easily create a connection to the Axelar network and all its interconnected chains.

Why I'm Excited

Everything, YES, everything. One of my greatest aspirations in life and as a professional is always to make an impact and provide solutions to help humanity.

Tiny changes, Remarkable Results - JamesClear

If you're also working on Axelar and reading this, thank you for being amazing and for all the support so far.

To the tech community, tech twitter, Developer DAO, and all the builders, a big thank you for your support. It means a lot to me.

Gracias!

In this tutorial, you will learn how to build a cross-chain airdrop decentralized application (dApp) using Solidity, Next.js, and Axelar General Message Passing (GMP) for distributing tokens across multiple chains.

What are we building? This application guides you through a simple four-step process that empowers users to:

• Connect their wallet.

• Authorize the airdrop token amount for spending.

• Add wallet addresses.

• Distribute tokens from Polygon to Avalanche testnet via airdrop.

To get started quickly, you'll find the entire code for this tutorial on GitHub. This way, you can explore the application's inner workings as you follow along.

Prerequisite

Before getting started, you need the following prerequisites:

• Node.js and its package manager NPM, version 18. Verify Node.js is installed by running the following terminal command: node -v && npm -v

• A basic understanding of JavaScript, Solidity, and React/Next.js.

Project Setup and Installation

To start the project setup and installation quickly, clone this project on GitHub using the following command:

git clone https://github.com/axelarnetwork/cross-chain-airdrop-dapp.git

Make sure you're on the start branch using the following command:

git checkout starter

Next, change the directory into the cloned folder and install the project locally using npm with the following command:

cd cross-chain-airdrop-dapp && npm i && npm run dev

The npm run dev will start a Next.js hot-reloading development environment accessible by default at http://localhost:3000.

To successfully create a smart contract for an airdrop using Axelar's general message passing, it's important to understand how it enables cross-chain interaction. The following section will explain how it works.

Getting Started with Axelar General Message Passing (GMP)

Axelar's General Message Passing (GMP) feature empowers developers to call any function on interconnected chains seamlessly.

With GMP, developers gain the ability to:

1. Call a contract on chain A and interact with a contract on chain B.

2. Execute cross-chain transactions by calling a contract on chain A and sending tokens to chain B.

Building a smart contract using Hardhat and Axelar GMP

In this section, you will build the smart contract leveraging Axelar GMP to airdrop tokens from the Polygon testnet to the Avalanche testnet.

Navigate to the project's root folder you cloned in the previous step, and then run the following commands to create a new Hardhat project.

mkdir hardhat cd hardhat npm install --save-dev hardhat

Get a sample project by running the command below:

npx hardhat

Accept the following options:

The @nomicfoundation/hardhat-toolbox plugin includes all the commonly used packages and recommended Hardhat plugins for starting development with Hardhat.

In case it wasn't installed automatically, install this additional requirement using the following command:

npm i @nomicfoundation/hardhat-toolbox@3.0.0

Next, install @axelar-network/axelar-gmp-sdk-solidity for Axelar General Message Passing SDK in Solidity and dotenv with the following command:

npm i @axelar-network/axelar-gmp-sdk-solidity@3.6.1 dotenv

To ensure everything functions properly, execute the following command within the hardhat directory.

npx hardhat test

You will see a passed test result in your console.

To start building from scratch, it's important to clean up the directory. To accomplish this task, delete Lock.js from the test folder and remove deploy.js from the scripts directory. After that, navigate to the contracts folder and delete Lock.sol.

Delete lock.js file

The folders themselves should not be deleted!

Create an Airdrop.sol file inside the contracts directory and update it with the following code snippet. When using Hardhat, file organization is crucial, so pay attention!

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

import {AxelarExecutable} from "@axelar-network/axelar-gmp-sdk-solidity/contracts/executable/AxelarExecutable.sol";
import {IAxelarGateway} from "@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IAxelarGateway.sol";
import {IERC20} from "@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IERC20.sol";
import {IAxelarGasService} from "@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IAxelarGasService.sol";

// Airdrop contract that inherits from AxelarExecutable
contract Airdrop is AxelarExecutable {
    // Immutable reference to the gas service contract
    IAxelarGasService public immutable gasService;

    // Variables to track airdrop details
    uint256 public amountReceived;
    address[] public airdropRecipients;

    // Constructor to initialize the contract
    constructor(address gateway_, address gasReceiver_) AxelarExecutable(gateway_) {
        // Initialize the gas service contract
        gasService = IAxelarGasService(gasReceiver_);
    }

    // Function to initiate airdrop to multiple recipients on another chain
    function sendToMany(
        string memory destinationChain,
        string memory destinationAddress,
        address[] calldata destinationAddresses,
        string memory symbol,
        uint256 amount
    ) external payable {
        // Require a gas payment for the transaction
        require(msg.value > 0, "Gas payment is required");

        // Get the token address associated with the provided symbol
        address tokenAddress = gateway.tokenAddresses(symbol);

        // Transfer tokens from sender to this contract
        IERC20(tokenAddress).transferFrom(msg.sender, address(this), amount);

        // Approve the gateway to spend tokens on behalf of this contract
        IERC20(tokenAddress).approve(address(gateway), amount);

        // Encode the recipient addresses into a payload
        bytes memory payload = abi.encode(destinationAddresses);

        // Pay for native gas using the gas service contract
        gasService.payNativeGasForContractCallWithToken{value: msg.value}(
            address(this),
            destinationChain,
            destinationAddress,
            payload,
            symbol,
            amount,
            msg.sender
        );

        // Initiate a contract call on the gateway
        gateway.callContractWithToken(
            destinationChain,
            destinationAddress,
            payload,
            symbol,
            amount
        );
    }

    // Function to retrieve the list of airdrop recipients
    function getRecipients() public view returns (address[] memory) {
        return airdropRecipients;
    }

    // Internal function to execute airdrop on the current chain
    function _executeWithToken(
        string calldata,
        string calldata,
        bytes calldata payload,
        string calldata tokenSymbol,
        uint256 amount
    ) internal override {
        // Decode the payload to get the recipient addresses
        address[] memory recipients = abi.decode(payload, (address[]));

        // Get the token address associated with the provided symbol
        address tokenAddress = gateway.tokenAddresses(tokenSymbol);

        // Set amountReceived and airdropRecipients variables
        amountReceived = amount;
        airdropRecipients = recipients;

        // Calculate the amount of tokens to send to each recipient
        uint256 sentAmount = amount / recipients.length;

        // Transfer tokens to each recipient
        for (uint256 i = 0; i < recipients.length; i++) {
            IERC20(tokenAddress).transfer(recipients[i], sentAmount);
        }
    }
}

In the code snippet above:

• It defines a Solidity contract named Airdrop that extends the AxelarExecutable contract.

• The contract imports several Solidity interfaces and contracts from the @axelar-network/axelar-gmp-sdk-solidity package.

• The constructor of the contract takes two parameters: gateway_ and gasReceiver_. It initializes the gasService variable with the gasReceiver_ address and calls the constructor of the AxelarExecutable contract with the gateway_ address.

• The contract has a function namesendToMany that is external and payable. It takes several parameters, including destination chain, destination address, destination addresses (array), symbol and amount. It requires that the message value (attached Ether) is greater than 0, transfers tokens from the sender to the contract, approves the transfer to the gateway, and performs a native gas payment using the gasService contract. It then calls the callContractWithToken function of the gateway contract.

• The contract has a public function name and returns the array of airdrop recipients.

• The contract has an internal function name _executeWithToken that is called by theAxelarExecutable contract. It takes parameters including a payload (an array of addresses, which we have chosen in this tutorial but it can store any other data types) and a token symbol.

• It decodes the payload, transfers tokens to the recipients, and updates the amountReceived and airdropRecipients variables.

Set up deployment script

Create a deploy.js file in the scripts folder and add the following code snippet:

const hre = require("hardhat");

async function main() {
  const Airdrop = await hre.ethers.deployContract("Airdrop", [
    "",
    "",
  ]);

  await Airdrop.waitForDeployment();

  console.log(`Airdrop contract deployed to ${await Airdrop.getAddress()}`);
}

// We recommend this pattern to be able to use async/await everywhere
// and properly handle errors.
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

In the code snippet above:

• The main function has the Airdrop contract deployed using the deployContract, a method with two strings as arguments.

• The await Airdrop.waitForDeployment() statement ensures that the deployment is completed before moving forward.

• The deployed contract's address is logged into the console.

Set up remote procedure call (RPC) to testnet

A remote procedure call (RPC) is a protocol used for communication between client and server systems in a network or blockchain environment. It enables clients to execute procedures or functions on remote servers and receive the results. RPC abstracts the underlying network details and allows clients to invoke methods on servers as if they were local.

Before you proceed to set up RPC, create a .env file using the command below:

touch .env

Ensure you are in the hardhat directory before running the command above.

Inside the .env file you just created, add the following key:

PRIVATE_KEY= // Add your account private key here

Getting your private account key is easy. If you use MetaMask, take a look at this post. Keep in mind that exporting the private key can differ for other wallet providers.

Next, set up RPC for Polygon and Avalanche test networks by updating the hardhat.config.js file with the following code snippet:

require("@nomicfoundation/hardhat-toolbox");
require("dotenv").config({ path: ".env" });
require("solidity-coverage");

const PRIVATE_KEY = process.env.PRIVATE_KEY;

// This is a sample Hardhat task. To learn how to create your own go to
// <https://hardhat.org/guides/create-task.html>
task("accounts", "Prints the list of accounts", async (taskArgs, hre) => {
  const accounts = await hre.ethers.getSigners();

  for (const account of accounts) {
    console.log(account.address);
  }
});

// You need to export an object to set up your config
// Go to <https://hardhat.org/config/> to learn more

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  solidity: "0.8.9",
  networks: {
    mumbai: {
      url: "https://rpc.ankr.com/polygon_mumbai",
      chainId: 80001,
      accounts: [PRIVATE_KEY],
    },
    avalancheFujiTestnet: {
      url: "https://avalanche-fuji-c-chain.publicnode.com",
      chainId: 43113,
      accounts: [PRIVATE_KEY],
    },
  },
};

You have successfully configured the RPC for Polygon and Avalanche test networks. In the next step, you will deploy smart contracts to these networks.

Deploy smart contract to Polygon and Avalanche networks

In this section, you will deploy the smart contract to Polygon and Avalanche testnets. However, before you proceed, you need to specify the Axelar Gateway Service and the Gas Service contract in the hre.ethers.deployContract() method within the deploy.js file you created earlier.

You can find the list of Axelar Gas Service and Gateway contracts for all the chains currently supported by Axelar here.

To ensure successful contract deployment, you also need a faucet for your Polygon and Avalanche testnet accounts. To get the Polygon faucet, visit this link; and for the Avalanche faucet, access it here.

Deploy to Polygon testnet

Update the deploy.js file inside the scripts folder to deploy to Polygon testnet with the following code snippet:

//...

async function main() {

  // Update arguments with the Axelar gateway and
  // gas service on Polygon testnet
  const Airdrop = await hre.ethers.deployContract("Airdrop", [
    "0xBF62ef1486468a6bd26Dd669C06db43dEd5B849B",
    "0xbE406F0189A0B4cf3A05C286473D23791Dd44Cc6",
  ]);

  //...
}

//..

To deploy the contract on the Polygon testnet, run the following command:

npx hardhat run scripts/deploy.js --network mumbai

For example, the contract address will be displayed in your console: 0xe66f6e95E3edECe3567290751c024B19DEebAACd.

Deploy to Avalanche Fuji testnet

Update the deploy.js file inside the scripts folder to deploy to Avalanche testnet with the following code snippet:

//...

async function main() {
  // Update arguments with the Axelar gateway and
  // gas service on Avalanche testnet
  const Airdrop = await hre.ethers.deployContract("Airdrop", [
    "0xC249632c2D40b9001FE907806902f63038B737Ab",
    "0xbE406F0189A0B4cf3A05C286473D23791Dd44Cc6",
  ]);

  //...
}

//..

To deploy the contract on the Avalanche testnet, run the following command:

npx hardhat run scripts/deploy.js --network avalancheFujiTestnet

The contract address will be displayed on your console; for example, 0x86bE218aD2CC1Dc3270c4A594E7BA52Fd03d6a46. Save both deployed contract addresses, as you will need them for frontend integration.

Integrating a Next.js frontend application with smart contract

In the previous steps, you successfully built and deployed the smart contract. Now, it's time to interact with it from the frontend, just as you would typically engage with dApps on the web.

Having already cloned the Next.js frontend project and set up the configuration for WAGMI and Rainbowkit, you can now move forward with updating the existing application and connecting your smart contract for testing, enabling interaction with it as you would with decentralized web applications.

Implementing smart-contract write functionality

Interacting with our contract is relatively straightforward from the frontend application, thanks to WAGMI, RainbowKit, and Ethers.

To interact between the Polygon and Avalanche testnets, you will need the Avalanche Fuji testnet RPC URL, the Polygon contract address and the Avalanche contract address. Create a .env.local file in the root directory by using the command below:

touch .env.local

Ensure you are in the root directory before running the command above.

Inside the .env.local file you just created, add the following:

NEXT_PUBLIC_AVALANCHE_RPC_URL=https://avalanche-fuji-c-chain.publicnode.com 
NEXT_PUBLIC_POLYGON_CONTRACT_ADDRESS=<POLYGON_CONTRACT_ADDRESS> 
NEXT_PUBLIC_AVALANCHE_CONTRACT_ADDRESS=<AVALANCHE_CONTRACT_ADDRESS>

Replace <POLYGON_CONTRACT_ADDRESS> with the contract address, you deployed to the Polygon testnet and replace <AVALANCHE_CONTRACT_ADDRESS> with the contract address you deployed to the Avalanche Fuji testnet earlier in this tutorial.

Next, you need to implement the write functionality for the smart contract. In this case, you must specify the airdrop amount and approve it by granting the contract permission to spend it. Only then can you input the wallet addresses to receive the airdrop and send it to them.

To enable the approval and airdrop feature, simply add this code snippet into the pages directory's index.js file. Be sure to import all essential functions from WAGMI, including the @axelar-network/axelarjs-sdk, Polygon, Avalanche Fuji testnet contract addresses, Airdrop contract and Avalanche Fuji testnet RPC URL.

//...

import {
  useContractWrite,
  useContractRead,
  usePrepareContractWrite,
  useWaitForTransaction,
  erc20ABI,
  useAccount,
} from "wagmi";
import { ethers } from "ethers";
import {
  AxelarQueryAPI,
  Environment,
  EvmChain,
  GasToken,
} from "@axelar-network/axelarjs-sdk";

import AirdropContract from "../hardhat/artifacts/contracts/Airdrop.sol/Airdrop.json";

const POLYGON_CONTRACT_ADDRESS =
  process.env.NEXT_PUBLIC_POLYGON_CONTRACT_ADDRESS;
const AVALANCHE_CONTRACT_ADDRESS =
  process.env.NEXT_PUBLIC_AVALANCHE_CONTRACT_ADDRESS;
const AVALANCHE_RPC_URL = process.env.NEXT_PUBLIC_AVALANCHE_RPC_URL;

export default function Home() {
//...
}

Next, create the following state variables and functions to interact with the smart contract you created earlier.

//...

export default function Home() {
  const [darkMode, setDarkMode] = useState(false);
  const [amount, setAmount] = useState(0);
  const [Addresses, setAddresses] = useState("");
  const { address } = useAccount();
  const [isSendButtonVisible, setIsSendButtonVisible] = useState(false);
  const [isApproveButtonVisible, setIsApproveButtonVisible] = useState(true);
  const [isTextareaVisible, setIsTextareaVisible] = useState(false);
  const api = new AxelarQueryAPI({ environment: Environment.TESTNET });
  const [gasFee, setGasFee] = useState(0);

const toastOptions = {
    position: "top-right",
    autoClose: 8000,
    closeOnClick: true,
    pauseOnHover: false,
    draggable: true,
  };

  // Approve aUSDC to be spent by the contract
  const { data: useContractWriteUSDCData, write: approveWrite } =
    useContractWrite({
      address: "0x2c852e740B62308c46DD29B982FBb650D063Bd07", // Address of the aUSDC contract
      abi: erc20ABI,
      functionName: "approve",
      args: [
        POLYGON_CONTRACT_ADDRESS,
        ethers.utils.parseUnits(amount.toString(), 6),
      ],
    });

  const { data: useWaitForTransactionUSDCData, isSuccess: isUSDCSuccess } =
    useWaitForTransaction({
      hash: useContractWriteUSDCData?.hash,
    });

  // Check Allowance
  const {
    data: readAllowance,
    isError: isAllowanceError,
    isLoading: isAllowanceLoading,
  } = useContractRead({
    address: "0x2c852e740B62308c46DD29B982FBb650D063Bd07", // Address of the USDC contract
    abi: erc20ABI,
    functionName: "allowance",
    args: [address, POLYGON_CONTRACT_ADDRESS],
  });

  // Estimate Gas
  const gasEstimator = async () => {
    const gas = await api.estimateGasFee(
      EvmChain.POLYGON,
      EvmChain.AVALANCHE,
      GasToken.MATIC,
      700000,
      2
    );
    setGasFee(gas);
  };

  // Send Airdrop
  const { data: useContractWriteData, write } = useContractWrite({
    address: POLYGON_CONTRACT_ADDRESS,
    abi: AirdropContract.abi,
    functionName: "sendToMany",
    args: [
      "Avalanche",
      AVALANCHE_CONTRACT_ADDRESS,
      Addresses.split(","),
      "aUSDC",
      ethers.utils.parseUnits(amount.toString(), 6),
    ],
    value: gasFee,
  });

  const { data: useWaitForTransactionData, isSuccess } = useWaitForTransaction({
    // Calling a hook to wait for the transaction to be mined
    hash: useContractWriteData?.hash,
  });

//...
}

In the code above,

• The useState hook was utilized to create several state variables, including darkMode, amount, Addresses, isSendButtonVisible, isApproveButtonVisible, isTextareaVisible and gasFee.

• The component utilizes the useAccount hook to get the address variable.

• An instance of AxelarQueryAPI is created with the TESTNET environment and assigned to the api variable.

• The component sets up a toastOptions object used for displaying toast notifications.

• The code uses the useContractWrite hook twice, first to Approve aUSDC to be spent by the contract and then to sendToMany in the Airdrop contract with various arguments.

• It also uses the useWaitForTransaction hook to wait for the transactions to be mined, checking for success in both cases.

Next, you can create a function to handle sending the airdrop, managing the Approve functionality, and utilizing the useEffect hook.

//...

export default function Home() {
//...

// Handle send airdrop button
  const handleSendAirdrop = async () => {
    if (!(amount && Addresses)) {
      toast.error("Please enter amount and addresses", toastOptions);
      return;
    }

    if (isAllowanceError) {
      toast.error("Error checking allowance", toastOptions);
      return;
    }

    write();
    toast.info("Sending Airdrop...", {
      ...toastOptions,
    });
  };

  // Handle Approval
  const handleApprove = () => {
    if (!amount) {
      toast.error("Please enter amount", toastOptions);
      return;
    }
    approveWrite();

    toast.info("Approving...", toastOptions);
  };

 useEffect(() => {
    //...

    // The gas estimator
    gasEstimator();

    isSuccess
      ? toast.success("Airdrop sent!", {
          toastOptions,
        })
      : useWaitForTransactionData?.error || useContractWriteData?.error
      ? toast.error("Error sending message")
      : null;

    if (isUSDCSuccess) {
      toast.success("USDC Approved!", { toastOptions });
      setIsApproveButtonVisible(false);
      setIsSendButtonVisible(true);
      setIsTextareaVisible(true);
    } else if (
      useWaitForTransactionUSDCData?.error ||
      useContractWriteUSDCData?.error
    ) {
      toast.error("Error approving USDC", { toastOptions });
    }
  }, [
    //...
    useContractWriteData,
    useWaitForTransactionData,
    useContractWriteUSDCData,
    useWaitForTransactionUSDCData,
  ]);

//...

  return (
    //...
  )
}

Update the Approve, Send button and textarea with the following code snippet to approve and send the airdrop cross-chain.

//...

export default function Home() {
//...

  return (
    <div className="container mx-auto px-4 flex flex-col min-h-screen">
      <header className="py-4">
         {/* ... */}
      </header>

      <main className="flex-grow flex flex-col items-center justify-center">

            {/* ... */}

            {isTextareaVisible && (
              <div className="flex flex-col mb-4">
                <label className="font-semibold mb-2">Addresses</label>
                <textarea
                  placeholder="Enter addresses (separate with a comma)"
                  className="border border-gray-300 rounded-lg p-2 h-32"
                  onChange={(e) => setAddresses(e.target.value)}
                />
              </div>
            )}
            {isApproveButtonVisible && (
              <button
                className="bg-blue-500 hover:bg-blue-600 text-white py-2 px-6 rounded-full mr-5"
                onClick={() => handleApprove()}
                display="none"
              >
                Approve
              </button>
            )}
            {isSendButtonVisible && (
              <button
                className="bg-blue-500 hover:bg-blue-600 text-white py-2 px-6 rounded-full"
                onClick={handleSendAirdrop}
              >
                Send
              </button>
            )}

          {/* . */}

      </main>
      <ToastContainer />
      <footer className="flex justify-center items-center py-8 border-t border-gray-300">
        {/* . */}
      </footer>
    </div>
  );
}

You can test the send functionality to see what you have so far, but you won't be able to retrieve it on the destination chain because the retrieval functionality hasn't been implemented yet.

The image below illustrates this by showing a waiting for response... message. Don't worry; you'll implement the retrieval functionality in the next step.

Implementing smart-contract read functionality

In the previous step, you learned how to write to a smart contract from the frontend, and now this section will guide you through implementing the functionality to read data from a smart contract.

Update the index.js with the following code snippet to read the airdrop details, including the recipient's addresses and amount.

//...

export default function Home() {
  //...
 const [amountReceived, setAmountReceived] = useState(0);
 const [airdropRecipients, setAirdropRecipients] = useState([]);

//...

// Read data from Avalanche
  const provider = new ethers.providers.JsonRpcProvider(AVALANCHE_RPC_URL);
  const contract = new ethers.Contract(
    AVALANCHE_CONTRACT_ADDRESS,
    AirdropContract.abi,
    provider
  );

  async function readDestinationChainVariables() {
    try {
      const amountReceived = await contract.amountReceived();

      const airdropRecipients = await contract.getRecipients();

      setAmountReceived(amountReceived.toString());

      setAirdropRecipients(airdropRecipients);
    } catch (error) {
      console.log(error);
    }
  }

 useEffect(() => {
    //...
  readDestinationChainVariables();

 }, [ //...
]);

//...
}

In the code above,

• Two state variables, amountReceived and airdropRecipients , were set up using the useState hook to store the amount and recipients.

• An instance of ethers.providers.JsonRpcProvider was created to connect to the Avalanche blockchain.

• Defines a contract instance using ethers.Contract with the specified Avalanche contract address and ABI for the AirdropContract.

• The function readDestinationChainVariables is defined to read data from the Avalanche contract, including the amount received and the list of airdrop recipients.

• Inside useEffect, the readDestinationChainVariables function is called to fetch and update the state variables when the component mounts and when other dependencies change.

Next, update the UI to be rendered.

 //...

export default function Home() {

<main className="flex-grow flex flex-col items-center justify-center">

    {/* ... */}

          <div className="border border-gray-300 rounded-lg p-8 m-2 ">
            <h2 className="text-2xl font-bold mb-4">Airdrop Status 🎉</h2>
            {airdropRecipients.length > 0 ? (
              <>
                <div className="flex flex-col">
                  <p className="font-semibold mb-2">
                    Total Amount:{" "}
                    <span className="font-normal text-gray-500">
                      {amountReceived / 1000000}
                    </span>
                  </p>

                  <p className="font-semibold mb-2">
                    Total Addresses:{" "}
                    <span className="font-normal text-gray-500">
                      {airdropRecipients.length}
                    </span>
                  </p>

                  {airdropRecipients.map((recipient, index) => (
                    <div className="flex flex-col" key={index}>
                      <p className="font-semibold mb-2">
                        Address:{" "}
                        <span className="font-normal text-gray-500">
                          {recipient}
                        </span>
                      </p>
                      <p className="font-semibold mb-2">
                        Amount Received:{" "}
                        <span className="font-normal text-gray-500">
                          {amountReceived / airdropRecipients.length / 1000000}
                        </span>
                      </p>
                    </div>
                  ))}
                </div>
              </>
            ) : (
            <span className="text-red-500">Waiting for response...</span>
            )}
          </div>
        </div>
      </main>

{/* . */}

}

Trying the application

Hurray 🥳 , you have successfully built a cross-chain airdrop dApp with Solidity, Next.js & Axelar General Message Passing.

You can find the complete code for this project on GitHub.

What Next?

This post covered the utilization of Axelar GMP with callContractWithToken, but that's not all General Message Passing can do.

You can always explore other functionalities like callContractWithToken, SendToken, Deposit addresses, NFT Linker, JavaScript SDK, etc.

If you've made it this far, you're fantastic! You can post about your experience building or following along with this tutorial to show your support to the author and tag @axelarcore.

Conclusion

In conclusion, this tutorial demonstrated how to create a cross-chain airdrop dApp using Solidity, Next.js and Axelar GMP. You learned how to deploy a smart contract, interact with multiple blockchains, and build a frontend application to facilitate token distribution.

As a result, you now better understand how to leverage Axelar's powerful features to develop cross-chain dApps.

Reference

• Axelar General Message Passing

• Axelar Documentation

• Hardhat

• RainbowKit

• Next.js

Existing solutions, like cross-chain bridges, create problems like fragmented fungibility (bridged tokens are nonfungible with versions on other chains) and loss of custom functionality. Interchain Tokens solve that problem, extending tokens' fungibility and custom functionality into deployments on multiple chains.

Interchain Tokens are a groundbreaking development in the world of blockchain, creates a truly interoperable ecosystem.

The Axelar Interchain Token Portal is a helpful tool that simplifies the process of creating and deploying ERC-20 tokens, providing support for standardized and canonical tokens.

This tutorial will walk you through the step-by-step process of creating, registering, and deploying an Interchain Token using the Axelar Interchain Token Portal and interacting with the token across multiple blockchains.

You will need Avalanche Fuji testnet faucet tokens; you can get some here if you don't have them.

Step 1: Create and deploy an ERC0-20 token

In this step, you will create and deploy an ERC-20 token on a testnet environment. The tutorial will walk you through the process of deploying it on the Avalanche Fuji testnet using the Axelar Interchain Token Portal testnet. However, you can deploy it on any supported chain without limitation; it doesn't necessarily have to be on Avalanche.

Go to https://testnet.interchain.axelar.dev/ to create and deploy a new token. Click the Deploy a new Interchain Token button.

Provide the necessary token information in the fields: Token Name, Symbol, Decimals and preferred Amount to mint.

Please be aware that the default for Amount to mint in the user interface is set to 0, but it should not be left at 0. If you do not select advanced settings and change Amount to mint to a nonzero number, the token will remain stuck, and to mint later won’t be allowed. I recommend adding a default token based on your preference but ensure it is not set to 0.

Next, click on the Deploy button.

Hooray! You have successfully deployed and registered your token successfully. Next, click on Go to the token page!

Step 2: Register and deploy an ERC-20 token as an Interchain Token on Polygon and Moonbase

Choose the blockchain on which you want to deploy remote tokens. In this tutorial, you will deploy to Polygon and Moonbase testnet, respectively.

Next, you should see a display similar to the one shown below, indicating that the token has been registered and is currently being deployed to the selected remote chains, in this case, Polygon and Moonbase testnet.

Once successfully deployed, which may take a few minutes, you should see something similar to what is displayed below.

Step 4: Interact with the Interchain Token

In this section, you will interact with the interchain token you just deployed via the Axelar Interchain Token Portal user interface.

To interact with this, you can send balances across these networks, and that's precisely where the magic happens.

Send Token from Avalanche Fuji Testnet to Polygon Testnet

To send tokens from the Avalanche Fuji testnet to the Polygon testnet, click the send button and enter the desired amount of tokens you want to send, as shown below.

The token was sent successfully, and the balance on Polygon is now updated, as shown below.

Send token from Avalanche Fuji testnet to Moonbase testnet

In the previous step, you successfully sent 200 units of your ERC-20 token to the Polygon testnet. Now you will do a similar process to send the token to Moonbase.

The token was sent successfully, and the balance on Moonbase is now updated, as shown below.

Hooray 🥳 With Axelar, you have successfully created, registered and deployed an interchain token using the Axelar Interchain Token Portal and interacting with the token across multiple blockchains.

What's next?

You can learn more about Interchain Tokens and how they are created and managed by the new Interchain Token Service. It allows you to send tokens cross-chain, build asset bridges, build asset transfers into your Interchain dApp, and take on many other use cases.

If you've made it this far, you're fantastic! You can post about your experience building or following along with this tutorial to show your support to the author and tag @axelarcore.

Conclusion

This post covered the step-by-step process of creating, registering, and deploying an interchain token using the Axelar Interchain Token Portal and interacting with the token across multiple blockchains.

Reference

• Axelar Interchain Tokens

• Axelar Documentation

• Axelar Interchain Token Portal

npx hardhat run scripts/deploy.js --network <testnet>

After spending a couple of hours debugging, I realized that I had followed a similar process to deploy the contract just last week, and it worked perfectly. However, it is no longer working now.

I figured this error was due to the changes/upgrades in @nomicfoundation/hardhat-toolbox to version 3.0.0 when you create a new hardhat project.

The old way of writing the deployment script that caused the error:

const hre = require("hardhat");

async function main() {
  const Contract = await hre.ethers.getContractFactory("Contract");
  const contract = await Contract.deploy(
    "<Your constructor argument here>"
  );

  await contract.deployed();

  console.log(`Contract deployed to ${contract.address}`);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

How to write the deployment script to fix the error:

const hre = require("hardhat");

async function main() {
  const Contract = await hre.ethers.deployContract("Contract", 
    ["<Your constructor argument here>"]
  );

  await Contract.waitForDeployment();

  console.log(`Contract deployed to ${await Contract.getAddress()}`);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

That's it 🥳🥳🥳

This post explained and fixed the error in deployment caused by the hardhat tools upgrade to version 3.0.0 when deploying a contract to testnet.

I'd love to connect with you on Twitter | LinkedIn | GitHub | Portfolio

See you in my next blog article. Take care!!!

The programmable blockchain interoperability layer bridges different blockchain networks, facilitating the exchange of information and assets securely and efficiently. It enables smooth interaction by providing a standardized framework for cross-chain communication, allowing various blockchain networks to interoperate seamlessly.

In this tutorial, you will learn how to build a full-stack interchain decentralized application with Next.js, Solidity, and Axelar General message passing to send messages from one blockchain to another.

For a quick start, you can find the complete code for this tutorial on GitHub. However, in the video provided below, you can see the completed app that offers users the ability to:

• Connect their wallet

• Enter their desired message for cross-chain interaction

• Send the message from Binance to Avalanche

Getting Started with Axelar General Message Passing

Axelar's General Message Passing (GMP) feature empowers developers by enabling them to call any function on interconnected chains seamlessly.

With GMP, developers gain the ability to:

1. Call a contract on chain A and interact with a contract on chain B.

2. Execute cross-chain transactions by calling a contract on chain A and sending tokens to chain B.

Prerequisite

Before getting started, you need the following prerequisites:

• Node.js and its package manager NPM, version 18*. Verify Node.js is installed by running the following terminal command: node -v && npm -v

• A basic understanding of JavaScript, Solidity, and React/Next.js

Project Setup and Installation

To start the project setup and installation quickly, clone this project on GitHub. Make sure you're on the starter branch using the following command:

git clone <https://github.com/axelarnetwork/fullstack-interchain-dapp>

Next, install the project locally after cloning it using the following command in your terminal.

Here's how you can install the project using npm:

cd fullstack-interchain-dapp && npm i && npm run dev

Next.js will start a hot-reloading development environment accessible by default at http://localhost:3000.

Building a Smart Contract with Hardhat and Axelar GMP

In this section, you will build an interchain smart contract leveraging the Axelar GMP feature to send messages from one chain to another.

Navigate to the project's root folder you cloned in the previous step, and then run the following commands to create a new Hardhat project.

mkdir hardhat
cd hardhat
npm install --save-dev hardhat

Let's get a sample project by running the command below:

npx hardhat

We'll go with the following options:

What do you want to do?

✔ Create A JavaScript Project

✔ Hardhat project root:

? Do you want to add a .gitignore? (Y/n) › y

? Do you want to install this sample project's dependencies with npm (hardhat @nomicfoundation/hardhat-toolbox)? (Y/n) › y

The @nomicfoundation/hardhat-toolbox plugin bundles all the commonly used packages and Hardhat plugins recommended to start developing with Hardhat.

Just in case it didn't install automatically, install this other requirement with the following command:

npm i @nomicfoundation/hardhat-toolbox

Next, install @axelar-network/axelar-gmp-sdk-solidity for Axelar General Message Passing SDK in Solidity and dotenv with the following command:

npm i @axelar-network/axelar-gmp-sdk-solidity dotenv

To ensure everything works, run the command below in the hardhat directory.

npx hardhat test

You will see a passed test result in our console.

Delete Lock.js from the test folder and delete deploy.js from the scripts directory. After that, go to contracts and delete Lock.sol.

The folders themselves should not be deleted!

Create a SendMessage.sol file inside the contracts directory and update it with the following code snippet. When using Hardhat, file layout is crucial, so pay attention!

// SPDX-License-Identifier: MIT
// SPDX license identifier specifies which open-source license is being used for the contract
pragma solidity 0.8.9;

// Importing external contracts for dependencies
import { AxelarExecutable } from '@axelar-network/axelar-gmp-sdk-solidity/contracts/executable/AxelarExecutable.sol';
import { IAxelarGateway } from '@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IAxelarGateway.sol';
import { IAxelarGasService } from '@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IAxelarGasService.sol';
import { IERC20 } from '@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IERC20.sol';

contract SendMessage is AxelarExecutable {

    string public value;
    string public sourceChain;
    string public sourceAddress;

    IAxelarGasService public immutable gasService;

    constructor(address gateway_, address gasReceiver_) AxelarExecutable(gateway_) {
        // Sets the immutable state variable to the address of gasReceiver_
        gasService = IAxelarGasService(gasReceiver_);
    }

    function sendMessage(
        string calldata destinationChain,
        string calldata destinationAddress,
        string calldata value_
    ) external payable {

        bytes memory payload = abi.encode(value_);

        if (msg.value > 0) {
            gasService.payNativeGasForContractCall{ value: msg.value }(
                address(this),
                destinationChain,
                destinationAddress,
                payload,
                msg.sender
            );
        }
        // Calls the Axelar gateway contract with the specified destination chain and address and sends the payload along with the call
        gateway.callContract(destinationChain, destinationAddress, payload);
    }

    function _execute(
        string calldata sourceChain_,
        string calldata sourceAddress_,
        bytes calldata payload_
    ) internal override {
        // Decodes the payload bytes into the string value and sets the state variable for this contract
        (value) = abi.decode(payload_, (string));

sourceChain = sourceChain_;
        sourceAddress = sourceAddress_;
    }
}

In the code snippet above we:

• Create a SendMessage contract that extends the AxelarExecutable contract

• Import AxelarExecutable, IAxelarGateway, IAxelarGasService from the @axelar-network/axelar-gmp-sdk-solidity library.

• Define four state variables: value, sourceChain, sourceAddress, and gasService. The gasService state variable is immutable and can only be set during contract deployment.

• Initialize the gasService variable with the provided gasReceiver_ address.

• Create a sendMessage function that takes three string parameters: destinationChain, destinationAddress, value_ and it utilizes gasService.payNativeGasForContractCall with native gas (Ether).

• Utilized the gateway contract's callContract function with the specified destinationChain, destinationAddress, and payload parameters.

• The _execute function decodes the payload bytes into the value string and updates the state variables sourceChain and sourceAddress.

Setup Deployment Script

Next, create a deploy.js file in the scripts folder and add the following code snippet:

// We require the Hardhat Runtime Environment explicitly here. This is optional
// but useful for running the script in a standalone fashion through `node <script>`.
//
// You can also run a script with `npx hardhat run <script>`. If you do that, Hardhat
// will compile your contracts, add the Hardhat Runtime Environment's members to the
// global scope, and execute the script.
const hre = require("hardhat");

async function main() {
  const SendMessage = await hre.ethers.getContractFactory("SendMessage");
  const sendMessage = await SendMessage.deploy(
    "",
    ""
  );

  await sendMessage.deployed();

  console.log(`SendMessage contract deployed to ${sendMessage.address}`);
}

// We recommend this pattern to be able to use async/await everywhere
// and properly handle errors.
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

In the code snippet above:

• The main function has the SendMessage contract factory obtained using hre.ethers.getContractFactory.

• The sendMessage contract is deployed using the SendMessage.deploy method with two strings as arguments.

• await sendMessage.deployed() statement ensures that the deployment is completed before moving forward.

• The deployed contract's address is logged into the console.

Setup Remote Procedure Call (RPC) to Testnet

Remote Procedure Call (RPC) is a protocol used for communication between client and server systems in a network or blockchain environment. It enables clients to execute procedures or functions on remote servers and receive the results. RPC abstracts the underlying network details and allows clients to invoke methods on servers as if they were local.

Before you proceed to set up RPC, create a .env file using the command below:

touch .env

Ensure you are in the hardhat directory before running the command above.

Inside the .env file you just created, add the following key:

PRIVATE_KEY= // Add your account private key here

Getting your private account key is easy. Check out this post.

Next, set up RPC for Binance and Avalanche networks by updating the hardhat.config.js file with the following code snippet:

require("@nomicfoundation/hardhat-toolbox");
require("dotenv").config({ path: ".env" });
require("solidity-coverage");

const PRIVATE_KEY = process.env.PRIVATE_KEY;

// This is a sample Hardhat task. To learn how to create your own go to
// <https://hardhat.org/guides/create-task.html>
task("accounts", "Prints the list of accounts", async (taskArgs, hre) => {
  const accounts = await hre.ethers.getSigners();

  for (const account of accounts) {
    console.log(account.address);
  }
});

// You need to export an object to set up your config
// Go to <https://hardhat.org/config/> to learn more

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  solidity: "0.8.9",
  networks: {
    bsc: {
      url: "<https://data-seed-prebsc-1-s1.binance.org:8545>",
      chainId: 97,
      accounts: [PRIVATE_KEY],
    },
    avalancheFujiTestnet: {
      url: "<https://avalanche-fuji-c-chain.publicnode.com>",
      chainId: 43113,
      accounts: [PRIVATE_KEY],
    },
  },
  mocha: {
    timeout: 10000000000,
  },
};

You have successfully configured RPC for Binance and Avalanche test networks, you will proceed with the smart contract deployment to those networks in the following step.

Deploy Smart Contract to Binance and Avalanche Network

In this section, you will deploy the smart contract to Binance and Avalanche Testnet. However, before you proceed, you need to specify the Axelar Gateway Service and the Gas Service Contract in the SendMessage.deploy() method within the deploy.js file you created earlier.

You can find the Axelar Gas Service and Gateway contracts list for all the chains Axelar currently supports here.

You also need a faucet for your Binance and Avalanche accounts to ensure successful contract deployment. To obtain the Binance faucet, visit this link, and for the Avalanche faucet, access it here.

Deploy to Binance Testnet

Update the deploy.js file inside the scripts folder to deploy to Binance testnet with the following code snippet:

//...

async function main() {
  //...

  // Update arguments with the Axelar gateway and
  // gas service on Binance testnet
  const sendMessage = await SendMessage.deploy(
    "0x4D147dCb984e6affEEC47e44293DA442580A3Ec0",
    "0xbE406F0189A0B4cf3A05C286473D23791Dd44Cc6"
  );

  //...
}

//..

To deploy the contract on the Binance testnet, run the following command:

npx hardhat run scripts/deploy.js --network bsc

For example, the contract address will be displayed in your console: 0xC1b8fC9208E51aC997895626b0f384153E94f2A7.

Deploy to Avalanche Fuji Testnet

Update the deploy.js file inside the scripts folder to deploy to Avalanche testnet with the following code snippet:

//...

async function main() {
  //...

  // Update arguments with the Axelar gateway and
  // gas service on Avalanche testnet
  const sendMessage = await SendMessage.deploy(
    "0xC249632c2D40b9001FE907806902f63038B737Ab",
    "0xbE406F0189A0B4cf3A05C286473D23791Dd44Cc6"
  );

  //...
}

//..

To deploy the contract on the Avalanche testnet, run the following command:

npx hardhat run scripts/deploy.js --network avalancheFujiTestnet

The contract address will be displayed on your console; for example, 0x2a03DCB9B24431d02839822209D58262f5e5df52. Make sure to save both deployed contract addresses, as you will need them for front-end integration.

Integrating a Nextjs Frontend Application with Smart Contract

In the previous steps, you successfully built and deployed the smart contract. Now, it's time to interact with it from the front end, just as you would typically interact with decentralized applications on the web.

You already have the Next.js frontend project cloned, and the configuration for WAGMI and Rainbowkit is set up. This means you can proceed to update the existing application and connect your smart contract for testing.

Implementing Write Smart Contract Functionality

Interacting with our contract is quite simple from the front-end application, thanks to WAGMI, RainbowKit, and ethers.

Create a .env.local file in the root directory using the command below:

touch .env.local

Ensure you are in the root directory before running the command above.

Inside the .env.local file you just created, add the following key:

NEXT_PUBLIC_AVALANCHE_RPC_URL=https://avalanche-fuji-c-chain.publicnode.com
NEXT_PUBLIC_BSC_CONTRACT_ADDRESS=<BSC_CONTRACT_ADDRESS>
NEXT_PUBLIC_AVALANCHE_CONTRACT_ADDRESS=<AVALANCHE_CONTRACT_ADDRESS>

Replace <BSC_CONTRACT_ADDRESS> with the contract address, you deployed to the Binance testnet and replace <AVALANCHE_CONTRACT_ADDRESS> with the contract address, you deployed to the Avalanche Fuji Testnet earlier in this tutorial.

Next, implement the write functionality for the smart contract, add the following code snippet to the index.js file located in the pages directory.

//...

const BSC_CONTRACT_ADDRESS = process.env.NEXT_PUBLIC_BSC_CONTRACT_ADDRESS;
const AVALANCHE_CONTRACT_ADDRESS =
  process.env.NEXT_PUBLIC_AVALANCHE_CONTRACT_ADDRESS;
const AVALANCHE_RPC_URL = process.env.NEXT_PUBLIC_AVALANCHE_RPC_URL;

export default function Home() {
//...

const [message, setMessage] = useState(""); 
const [sourceChain, setSourceChain] = useState(""); 

const { config } = usePrepareContractWrite({ // Calling a hook to prepare the contract write configuration
  address: BSC_CONTRACT_ADDRESS, // Address of the BSC contract
  abi: SendMessageContract.abi, // ABI (Application Binary Interface) of the contract
  functionName: "sendMessage", // Name of the function to call on the contract
  args: ["Avalanche", AVALANCHE_CONTRACT_ADDRESS, message], // Arguments to pass to the contract function
  value: ethers.utils.parseEther("0.01"), // Value to send along with the contract call for gas fee
});

const { data: useContractWriteData, write } = useContractWrite(config); 

const { data: useWaitForTransactionData, isSuccess } = useWaitForTransaction({ 
  hash: useContractWriteData?.hash, // Hash of the transaction obtained from the contract write data
});

const handleSendMessage = () => {
  write(); // Initiating the contract call

  toast.info("Sending message...", {
    position: "top-right",
    autoClose: 5000,
    hideProgressBar: false,
    closeOnClick: true,
    pauseOnHover: false,
    draggable: true,
  });
};

useEffect(() => {
    const body = document.querySelector("body");
    darkMode ? body.classList.add("dark") : body.classList.remove("dark");

    isSuccess
      ? toast.success("Message sent!", {
          position: "top-right",
          autoClose: 7000,
          closeOnClick: true,
          pauseOnHover: false,
          draggable: true,
        })
      : useWaitForTransactionData?.error || useContractWriteData?.error
      ? toast.error("Error sending message")
      : null;
  }, [darkMode, useContractWriteData, useWaitForTransactionData]);

return (
    //..
   )
}

In the code snippet above:

1. Two state variables, message and sourceChain, are declared using the useState hook to hold the message content and source chain, respectively.

2. The usePrepareContractWrite hook is called to prepare the configuration for a contract write operation. It takes several parameters, such as the BSC contract address, ABI, function name, arguments, and value.

3. useContractWrite hook retrieves the contract write data and the write function based on the configuration obtained from the previous step.

4. useWaitForTransaction hook is called to wait for the transaction to be mined. It takes the hash of the transaction obtained from the contract write data.

5. handleSendMessage function is defined, which initiates the contract call by invoking the write function.

6. useEffect hook performs actions when certain dependencies change to display toast notifications for successful or failed message sending.

Update the Send button and textarea with the following code snippet to send messages and retrieve the data to be sent.

//...

return (
    //...
    <div className="border border-gray-300 rounded-lg p-8 m-2 ">
        <h2 className="text-2xl font-bold mb-4">Send Message 📓 </h2>
        <textarea
            //...
            onChange={(e) => setMessage(e.target.value)}
        />
        <button
            //...
            onClick={() => handleSendMessage()}
         >
            Send
        </button>
     </div>
    //...
  );
}

Implementing Read Smart Contract Functionality

In the previous step, you implemented the functionality for writing to a smart contract from the front end. This section will teach you how to implement the functionality for reading data from a smart contract.

Update the index.js with the following code snippet:

//...

export default function Home() {
  //...

  const [value, setValue] = useState("");

  const provider = new ethers.providers.JsonRpcProvider(AVALANCHE_RPC_URL); // Create an instance of JsonRpcProvider with Avalanche RPC URL

  const contract = new ethers.Contract(
    AVALANCHE_CONTRACT_ADDRESS, 
    SendMessageContract.abi,

    provider
  );

  async function readDestinationChainVariables() {
    try {
      const value = await contract.value(); 
      const sourceChain = await contract.sourceChain();

      setValue(value.toString()); // Convert the value to a string and store it
      setSourceChain(sourceChain); // Store the source chain
    } catch (error) {
      toast.error("Error reading message"); // Display an error toast if reading fails
    }
  }

  useEffect(() => {
    readDestinationChainVariables(); // Call the function to read destination chain variables

    //...
  }, [darkMode, useContractWriteData, useWaitForTransactionData]);

  return (
    //...

        {value ? ( // Add value here
              <>
                //...
              </>
            ) : (
              <span className="text-red-500 ">waiting for response...</span>
         )}
  );
}

In the code above,

1. An instance of the JsonRpcProvider class from the ethers.js library is created using the Avalanche RPC URL (AVALANCHE_RPC_URL) as the parameter.

2. An instance of the Contract class from the ethers.js library is created, representing a contract on the Avalanche network. It takes parameters such as the contract address (AVALANCHE_CONTRACT_ADDRESS), ABI (SendMessageContract.abi), and provider.

3. An asynchronous function named readDestinationChainVariables is defined. It attempts to read the contract's value and source chain variables using the value() and sourceChain() functions, respectively.

4. If an error occurs during the reading process, a toast notification with the message "Error reading message" is displayed.

5. The useEffect hook calls the readDestinationChainVariables function when certain dependencies change.

Trying the Application

Hurray 🥳 , you have successfully built and deployed a full-stack interchain decentralized application.

You can find the GMP transaction on Axelarscan Testnet here and the complete code for this project on GitHub.

What Next?

This post covered the utilization of Axelar's General Message Passing with callContract, but that's not all the General Message Passing can do.

You can always explore other functionalities like callContractWithToken, SendToken, Deposit addresses, NFT Linker, JavaScript SDK, etc.

If you've made it this far, you're awesome! You can also tweet about your experience building or following along with this tutorial to show your support to the author and tag @axelarcore.

Conclusion

This tutorial taught you how to build a full-stack interchain decentralized application using Next.js, Solidity, and Axelar's General Message Passing. You learned how to deploy and send messages from Binance to Avalanche test networks and interact with them through a Next.js frontend application.

Reference

• Axelar General Message Passing

• Axelar General Message Passing Video Tutorial

• Axelar Documentation

• Hardhat

• RainbowKit

• Next.js

This article will examine some of the top tools available to content creators today. If you're a seasoned blogger or a business owner looking to up your content game, read on to discover the AI tools to help you create content that truly stands out.

Content AI Tools ✍️

Article Idea Generator

Article Idea Generator is an open-source tool powered by AI technology designed to help writers overcome the frustration of writer's block. Whether you're a seasoned writer or just starting, it's the perfect solution for generating new article ideas.

Copy AI

Copy.ai is an AI tool that creates content to help boost conversion rates. Copy.ai makes it easy for marketers and copywriters to test the app. If you're new to Copy.ai, you'll get a 7-day free trial of the Pro plan and 2,000 words to use each month - no strings attached! We won't ask for any credit card information until you're ready to upgrade your account.

Grammarly

Grammarly is an AI-powered writing assistant that checks grammar, spelling, and punctuation errors.

Headline Analyzer

Headline Analyzer is an AI tool that analyzes headlines for emotional appeal, word choice, and length.

Puzzle

Puzzle is an AI tool for building a knowledge base for your team and customers. Puzzle Labs believe understanding complex information should be easy and enjoyable, especially when managing your glossary. This enables you to provide the most effective customer instruction experience possible.

Hashnode AI-powered Writing Assistance (Beta)

This AI-powered writing assistance offers the following features:

• Paraphrasing, to improves the natural flow and readability of your content.

• Automated creation of outlines, summaries, and code blocks.

• Access to an AI-powered chatbot that assists with a wide range of writing and editing tasks, akin to GitHub's co-pilot for technical writing.

Articoolo

Articoolo is an AI content generation tool that creates unique articles from scratch using natural language processing.

Unbounce

Unbounce is an AI-powered landing page builder with intelligent features that let you create beautiful, high-performing marketing campaigns in just a few minutes.

Phrasee

Phrasee is an AI-powered email marketing tool that uses natural language generation to optimize email subject lines, body text, and calls-to-action.

MarketMuse

MareketMuse is an AI-driven content optimization platform that uses natural language processing to identify gaps in content and suggest improvements.

Audio and Video AI Tools 📸

Lumen5

Lumen5 is an AI-powered video creation platform that converts text-based content into engaging videos with images, music, and animations.

VoicePen AI

VoicePen AI helps you convert audio content into blog posts using AI in minutes.

Vidyo

Vidyo is an AI tool for making short-form videos from long-form content. It uses AI to help you create shorter, socially ready clips from your long videos, saving you 90% of the time and effort.

Podcastle

Podcastle is an AI tool for studio-quality recording from your computer. Podcastle help builds next-generation audio content creation and editing tools.

Otter

Otter helps pilot your meetings with AI using a meeting assistant that records audio, writes notes, automatically captures slides, and generates summaries.

Cleanvoice

Cleanvoice is an artificial intelligence which removes filler sounds, stuttering, and mouth sounds from your podcast or audio recording.

Soundraw

Soundraw is an AI tool for creating original music content. If you've found a song that can't be used because of its long introduction or is too loud for a quiet scene in your video, Soundraw is the solution. You can edit the song with a few clicks to fit your needs.

Design AI Tools 🏝️

illustroke

illustroke is an AI tool for creating stunning and unique vector illustrations from text prompts.

Flair

Flair is an AI tool for designing branded content.

Stockimg

Stockimg is an AI tool for generating the perfect stock photo, for example, a book cover, wallpaper, poster, logo, illustration etc.

Canva

Canva is an AI-powered design tool that provides templates, images, and graphics for creating visual content.

Lucidpress

Lucidpress is an AI-powered design tool that allows the creation of engaging presentations, brochures, and flyers with drag and drops editor.

Conclusion

As a content creator, the journey to crafting compelling content can be a daunting task. But in this ever-evolving digital era, numerous tools and resources are available to help you streamline your content creation process and make it more effective.

This post highlights several tools essential for content creators to improve their productivity while AI does the other heavy lifting.

I'd love to connect with you on Twitter | LinkedIn | GitHub | Portfolio

See you in my next blog article. Take care!!!

This is a standard error; you might find a solution online, but I tried most of them all, it didn't work for me. This article will provide a simple and practical guide on fixing the React Hydration Error in Nextjs with examples of my errors and how I set them.

Whether you're a beginner or an experienced developer, this guide will help you understand errors causes and provide practical solutions to fix them.

So, let's dive in and solve this problem once and for all!

Understanding React Hydration

It's essential to understand React hydration as a developer who wants to build efficient and reliable web applications using React and Nextjs.

What is a React Hydration?

The React hydration process involves attaching event handlers and states to the server-side markup during Server-Side Rendering (SSR). As a page loads, React reconciles the server-generated markup with the client-side markup and attaches event handlers and states.

The web application must behave correctly and interact with the end user during this process. The application might throw an error if the React Hydration process fails or behave unexpectedly if the operation fails.

Therefore, it's crucial to understand how React Hydration works and how to fix any issues that arise during the process.

Causes of React Hydration Error in Nextjs

React Hydration Errors in Nextjs can be caused by inconsistencies between server and client-rendered markup and mismatched component states.

When the markup generated on the server side differs from what is generated on the client side, or when the state of a component on the server side doesn't match the state on the client side, the application can throw errors or behave unexpectedly.

Identifying and fixing these issues can be challenging, but understanding their causes is essential to improving web application performance and reliability.

A Practical Guide to Fix React Hydration Error in Nextjs

There are a couple of ways to fix the Reactjs hydration error, but I will share the standard and the hydration error I encountered while working on this decentralized identity project.

Error 🪲

I needed to check if the browser window had a valid ethereum object.

{connection.status === "connected" ? (

    {/* condition when its connected*/}

    ) : typeof window !== "undefined" && "ethereum" in window ? (

    {/* condition when ethereum is available */}

    ) : (

    <p>
     An injected Ethereum provider such as MetaMask
    </p>
)}

How to Fix It 🛠️

In the problem above, adding typeof window !== "undefined" caused the hydration error, which occurs if the server-rendered HTML does not match the client-rendered HTML.

Here's an example of how you can modify the code to avoid a hydration error:

import { useEffect, useState } from 'react';

function MyComponent() {
  const [isEthereumAvailable, setIsEthereumAvailable] =     useState(false);

  useEffect(() => {
    if (typeof window !== 'undefined' && 'ethereum' in window) {
      setIsEthereumAvailable(true);
    }
  }, []);

  return (
    <>
    {connection.status === "connected" ? (

        {/* condition when its connected*/}
      ) : isEthereumAvailable ? (

        {/* condition when ethereum is available */}

      ) : (
       {/* condition when ethereum is not available */}
      )
    }
    </>
  );
}

Error 🪲

{connection.status === "connected" && record && record.content && (
    <div>
        {/* condition when ethereum is not available */}
    </div>
     ) : (
    <p>No profile found.</p>
)}

In the code snippet above, connection and record is an object; meanwhile, the record is fetched asynchronously, leading to hydration.

How to Fix It 🛠️

{connection.status === "connected" && record && record.content ? (
    <div>
        {/* condition when ethereum is not available */}
    </div>
     ) : (
    <p>No profile found.</p>
)}

record.content It is fetched asynchronously and can differ between the server and client rendering; the initial server-rendered HTML may not match the client-rendered HTML. Changing the last && operator to a ternary ? fixed the problem.

I hope you find this helpful post and fix any React hydration error within 3 minutes.

Conclusion

In conclusion, this post teaches us how a hydration error can occur in Next.js when the server-rendered HTML output doesn't match the client-rendered HTML output. This can happen when client-side-only code, such as code that depends on the window object, is executed during server rendering.

Additionally, you can ensure that the data used to render your components is consistent between the server and client, especially when the data is asynchronously fetched.

By following these best practices, you can ensure that your Next.js application renders correctly without any hydration errors. Always test your application thoroughly to catch any issues before deploying to production.

Reference

• Nextjs React Hydration Error

• Fix Next.js: "Text content does not match server-rendered HTML."

I'd love to connect with you on Twitter | LinkedIn | GitHub | Portfolio

See you in my next blog article. Take care!!!

The Article Idea Generator is an open-source tool powered by AI technology designed to help writers overcome the frustration of writer's Block.

Whether you're a seasoned writer or just starting, this generator is the perfect solution for generating new and unique article ideas. It uses advanced algorithms to analyze your topic and suggest a wide range of opinions, from the most straightforward to the most imaginative.

This post will help you understand writer's Block and also introduce you to the new tool called Article Idea Generator.

Inspiration ✨

I ran a pool late last year; find the tweet here called the Article Streak challenge, specifically to encourage content creators to discover their strengths and consistently produce quality articles.

I often get questions like; I don't know what to write, How can I find a topic to write about, I think I can't do this because it's tough getting a topic, How can I get inspiration for what to write about

However, I came across Hassan El Mghari's project Twitterbio Generator then I got the inspiration to help solve the writer's issue I mentioned earlier using the approach that leverages OpenAI, giving birth to Article Idea Generator.

Understanding Writer's Block ✍️

Causes of Writer's Block ✅

1. Lack of inspiration or ideas - Article Idea Generator fix this

2. Overwhelming self-doubt or negative self-criticism

3. Fear of failure or not meeting expectations and perfectionism or pressure to produce perfect work

4. Excessive stress or burnout & difficulty balancing work and personal life

5. Distractions or lack of focus or discipline

6. Burnout or fatigue from excessive writing.

It is crucial to remember that every writer has a different experience with writer's Block, and other people may have various causes.

Effects of writer's Block on the writing process ✅

1. Delay in completing writing projects and meeting deadlines

2. Decreased productivity, creativity, frustration, and dissatisfaction with one's writing

3. Increased stress and anxiety and loss of confidence in one's writing abilities

4. Difficulty generating new ideas or finding inspiration

5. Stagnation in personal and professional growth as a writer

6. Financial loss, in case the writer is unable to deliver work on time

It's essential to address writer's Block promptly, as it can cause long-term damage to a writer's career and personal well-being.

Common strategies to overcome writer's Block ✅

• Concentrating on frequently writing, even if that means setting modest objectives initially.

• Taking breaks and caring for oneself

• Altering the context or atmosphere for writing

• Brainstorming or free writing to come up with new ideas

• Trying out new writing prompts or activities

• Working with other authors or asking for critiques from others.

• Reassessing the writing project's objectives and priorities.

• Dividing the writing process into more manageable, smaller segments.

• Refusing to be critical of oneself and adopting a growth mentality

• Trying out various writing types or styles

Finding what works best for each writer is crucial, as is persevering in attempting several methods until the Block is removed.

Introduction to the Article Idea Generator ⭐️

What is the Article Idea Generator ✅

The Article Idea Generator's user-friendly interface makes it easy to get started, regardless of your technical expertise. Enter a few keywords related to your topic and hit Enter. The generator will then produce a list of potential article ideas you can use to inspire your writing.

The open-source nature of the Article Idea Generator ensures that it's always up-to-date and constantly improving, so you can be confident that you're getting the best possible results. The tool is also highly customizable, allowing you to refine your results and generate ideas that are explicitly tailored to your needs.

Whether you're a blogger, content marketer, freelance writerIt is the perfect solution for anyone looking to improve their writing. So, if you're struggling with writer's Block, why not try it out today and discover the power of AI-driven inspiration? With the Article Idea Generator, you'll always have ideas!

How Article Idea Generator works ✅

1. Enter anything you may want to write about

2. Click Enter

3. Optionally, you can check the "Enable SEO and Clickbait Feature.". This feature would help tailor your idea to relevant search and make it SEO-compatible and a Clickbait approach to driving more traffic to your blog.

4. That's it 🥳

Key features and benefits of the Article Idea Generator ✅

By coming up with fresh and original ideas for articles, blog posts, and other writing assignments, the Article Idea Generator is a tool that assists writers in getting over writer's Block.

Some key features and benefits of the Article Idea Generator include:

• Quick and easy idea generation: The Article Idea Generator provides a list of potential article topics, saving writers time and effort in brainstorming.

• Diverse ideas: The Article Idea Generator offers a wide selection of views across various industries and hobbies by drawing from millions of datasets used to train the AI model of prospective article ideas.

• Customization: Allowing users to filter their results based on particular SEO keywords or categories would help them find more ideas pertinent to their writing tasks.

• Inspiration: The Article Idea Generator helps to spark inspiration and creativity by presenting ideas that writers may not have thought of on their own.

• Overcoming writer's Block: By providing a steady stream of new and unique article ideas, the Article Idea Generator helps writers overcome writer's Block and maintain their productivity.

• Time-saving: The Article Idea Generator saves writers necessary time and allows them to concentrate on the writing process by removing the need for lengthy brainstorming sessions.

Using the Article Idea Generator to Overcome Writer's Block 🔥

To use the Article Idea Generator to overcome writer's Block, follow these steps:

1. Choose a reliable and reputable Article Idea Generator.

2. Enter keywords or phrases related to your writing project.

3. Review the list of ideas generated by the tool and select one that interests you.

4. Use the concept as a springboard to develop more concepts or modify the concept to suit your writing project.

5. Start your article, blog post, or other writing assignments using the topic as a guide.

It's crucial to remember that numerous tools are available for overcoming writer's Block, and the Article Idea Generator is simply one of them. Additionally, it's critical to be flexible and open to the tool's suggestions.

The Article Idea Generator can be used with other techniques like taking breaks, trying various writing styles, and adopting a development mindset to help authors get over writer's Block and continue to be productive.

How Article Idea Generator has helped writers overcome writer's Block. 💙

I wish I could share all the feedback, but check this tweet reply and quote retweet to see how this tool is changing lives, helping people to be more creative, and overcoming writer's Block easily.

The Tech Stack 🛠️

NextJS - React application framework

TailwindCSS - For styling the project

TypeScript - A strongly typed programming language that builds on JavaScript, giving you better tooling at any scale.

Vercel Function - For streaming responses from OPEN AI

GitHub - To host the code

Vercel - To deploy and host the project

Contributing 🤝

Please read the contributing guide if you want to contribute to this project. If you have any ideas or suggestions, feel free to open an issue or a pull request.

If you like this project, please give it a star ⭐️

Conclusion

This post teaches us about writer's Block, its causes, and shared strategies to overcome it. It also introduces you to the Article Idea Generator tool, how it works, how to overcome writer's Block using it, and feedback on how it has helped writers.

Reference

• Article Idea Generator

• Twitterbio Generator

• OpenAI

• Vercel

I'd love to connect with you on Twitter | LinkedIn | GitHub | Portfolio

See you in my next blog article. Take care!!!

Smart contracts are self-executing contracts with the terms of the agreement written directly into code. They are a vital component of decentralized applications and are crucial for creating trustless and transparent systems. As the demand for decentralized applications rises, understanding and using smart contracts is a prerequisite skill for developers building and developing applications in Web3.

Does the cosmos support smart contracts? Yes. In this tutorial, we will learn about the Cosmos ecosystem and how to build and deploy a smart contract on the cosmos network.

Understanding the Cosmos Network

The Tendermint Core consensus engine powers the independent, parallel blockchains that make up the decentralized Cosmos Network. The Cosmos Network aims to build a decentralized network of interconnected blockchains that can expand and cooperate, facilitating the exchange of data and value between various blockchain platforms.

Tendermint is a Byzantine Fault Tolerant (BFT) consensus engine that enables fast and secure transaction processing. It allows a group of validators to agree on the state of the network through a voting procedure. Tendermint enables quicker transaction processing than conventional proof-of-work consensus methods, such as those employed by Bitcoin and Ethereum (Now Proof of Stake).

The Cosmos Network's use of the Inter-Blockchain Communication (IBC) protocol is crucial. Interoperability across several blockchain systems is made possible by IBC, which enables the transfer of value and data between various blockchains in the Cosmos Network.

Additionally, the Cosmos Network features a hub-and-spoke architecture that enables the development of standalone blockchains (spokes) that can communicate with the Cosmos Hub (the hub). Data and currency can be exchanged between the various blockchains in the network thanks to the Cosmos Hub, which acts as the network's hub.

Scalability, security, and interoperability are just a few of the Cosmos Network's benefits over other blockchain platforms. It is an intriguing and promising blockchain network overall.

It is a desirable alternative for developers looking to create decentralized applications due to its capacity to handle colossal throughput and connect several blockchains.

Why Cosmos?

The Inter-Blockchain Communication (IBC) protocol and the Tendermint Core consensus engine form the Cosmos network's foundation, enabling the exchange of value and data between various blockchains within the Cosmos Network. This was covered in more detail in the previous section when we discussed the Cosmos ecosystem.

The Cosmos Network's main traits include the following:

• Tendermint Core Consensus Engine: A Byzantine Fault Tolerant consensus engine, Tendermint provides quick and secure transaction processing.

• Inter-Blockchain Communication (IBC) protocol: IBC enables communication across several blockchains inside the Cosmos Network, allowing for the exchange of value and data.

• The Cosmos Network provides support for custom token creation. These tokens can be used in decentralized apps to represent digital assets or as payment.

• Scalability: Using independent blockchains with Tendermint Core enables quicker transaction processing times and the capacity to process many transactions per second.

• Interoperability: The Cosmos Network's interoperability feature enables developers to create decentralized applications that communicate with many blockchain systems, including Bitcoin, Ethereum, and others.

• Hub-and-spoke architecture: The Cosmos Network's hub-and-spoke architecture enables the development of separate blockchains that can communicate with the Cosmos Hub. The network's central node, the Cosmos Hub, facilitates the exchange of money and information among its several blockchains.

In the following section, let's dive deeply into the practical aspect of building and deploying smart contracts on the cosmos network.

Prerequisite

Let's make sure Node/NPM is set up on our computer. Here is a guide if we don't already have it installed.

Project Setup and Installation

Let's navigate to the terminal. We'll need to cd into any directory of our choice and then run the following commands:

mkdir cosmos-project
cd cosmos-project 
npm init -y 
npm install --save-dev hardhat

Let's create a sample project by using the following command:

npx hardhat

The above command will check if we have hardhat installed globally; if not, it will download it from the npm registry and run the command using the downloaded version.

Accept the following options.

Let's run the command below to verify that everything is operating as it should.

npx hardhat test

A passing test result will appear in our console.

Now, Lock.js may be removed from the test directory and deploy.js the scripts directory. After that, delete Lock.sol in the contracts directory.

The folders themselves should not be deleted!

Create a Greeter Smart Contract

This section will create a Greeter.sol file in the contract directory with the following code snippet.

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

// Define a smart contract called "Greeter"
contract Greeter {
    // Define a public variable called "greeting" of type string
    string public greeting;

    // Define a constructor that takes in a string and assigns it to the "greeting" variable
    constructor(string memory _greeting) {
        greeting = _greeting;
    }

    // Define a function called "setGreeting" that allows the "greeting" variable to be changed
    function setGreeting(string memory _greeting) public {
        greeting = _greeting;
    }

    // Define a function called "greet" that returns the current "greeting" variable
    function greet() public view returns (string memory) {
        return greeting;
    }
}

In the code snippet above, it's important to note that the line SPDX-License-Identifier: UNLICENSED serves as a unique identifier to signify that the code is unlicensed and available for anybody.

Testing the Smart Contract

Create a new file called Greeter-test.js inside the test directory and update it with the following code snippet.

const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("Greeter", function () {
  it("Should deploy the Greeter contract", async function () {
    // Get the contract factory for the "Greeter" contract
    const Greeter = await ethers.getContractFactory("Greeter");
    // Deploy the contract to the blockchain
    const greeter = await Greeter.deploy("Hello, world!");

    // Wait until the contract is deployed
    await greeter.deployed();

    // Check that the contract's greet() method returns the expected greeting
    expect(await greeter.greet()).to.equal("Hello, world!");
  });

  it("Should return the new greeting once it's changed", async function () {
    // Get the contract factory for the "Greeter" contract
    const Greeter = await ethers.getContractFactory("Greeter");
    // Deploy the contract to the blockchain
    const greeter = await Greeter.deploy("Hello, world!");

    // Wait until the contract is deployed
    await greeter.deployed();

    // Check that the contract's greet() method returns the expected greeting
    expect(await greeter.greet()).to.equal("Hello, world!");

    // call the setGreeting method
    const setGreetingTx = await greeter.setGreeting("Hola, mundo!");

    // wait until the transaction is mined
    await setGreetingTx.wait();

    // Check that the contract's greet() method returns the new greeting
    expect(await greeter.greet()).to.equal("Hola, mundo!");
  });
});

Next, run the following command in the terminal to compile test cases.

 npx hardhat test

We should have something similar to what is shown below.

Compile and Deploy the Greeter Smart Contract to the Cosmos Network

To compile the smart contract, we will need to create a new file deploy.js inside the scripts folder and update it with the following code snippet.

const main = async () => {
  // Get the contract factory for the "Greeter" contract
  const greeterContractFactory = await hre.ethers.getContractFactory("Greeter");

  // Deploy the contract to the blockchain
  const greeterContract = await greeterContractFactory.deploy(
    "Hello, Hardhat!"
  );

  // Wait until the contract is deployed
  await greeterContract.deployed();

  // Log the address of the deployed contract
  console.log("Greeter Contract deployed to: ", greeterContract.address);
};

const runMain = async () => {
  try {
    // Call the main function
    await main();
    process.exit(0);
  } catch (error) {
    // Log any errors that occur
    console.log(error);
    process.exit(1);
  }
};

// Run the main function
runMain();

In the code snippet above,

• This script deploys a smart contract called Greeter to the blockchain using the hre.ethers library.

• The greeterContractFactory.deploy() method deploys a new contract instance to the blockchain.

• await greeterContract.deployed() method is used to await the contract deployment.

• The address of the deployed contract is then logged into the console, and then runMain() function is a wrapper function that runs the main function and catches any possible errors.

Next, create .env on the project's root directory to store the private key, which we will use in the hardhat.config.js file during deployment.

PRIVATE_KEY=

Navigate to the hardhat.config.js file and then add the following code snippet.

require("@nomicfoundation/hardhat-toolbox");
require("dotenv").config();

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  // Specify version of solidity compiler
  solidity: "0.8.17",

  // Define networks to be used for testing and deployment
  networks: {
    // Hardhat network is a built-in development network in Hardhat
    hardhat: {
    },
    // Local network is a network running on localhost
    local : {
      url: "http://localhost:8545",
    },
    // evmos network is a network hosted by evmos
    evmos: {
      url: "https://eth.bd.evmos.dev:8545",
      // Use the private key specified in the .env file
      accounts:[process.env.PRIVATE_KEY],
    },
  },
};

This is a configuration file for the Hardhat development environment.

We will deploy the smart contract in the next step, but we need to ensure we fund our wallet with a test EVMOS (A decentralized proof of stake blockchain in the Cosmos ecosystem) token. Set up evmos on MetaMask and fund the wallet using this evmos faucet site.

After requesting a faucet, we should have something similar to what is shown below.

Now we can deploy the smart contract on the Cosmos network using the following command.

npx hardhat run --network evmos scripts/deploy.js

Verify Contract Deployment on EVM Explorer

Let’s view this block in the EVM Explorer https://evm.evmos.dev

To follow up, you can find the entire code for this project here.

Conclusion

This article provided a beginner-friendly guide to building and deploying smart contracts on the Cosmos network. Using the Hardhat development environment, we also demonstrated how to deploy a smart contract to the Cosmos network.

I'd love to connect with you on Twitter | LinkedIn | GitHub | Portfolio

See you in my next blog article. Take care!!!

We can implement a suitable solution once we identify the error that led to a specific issue and learn in-depth details about the error's nature.

This guide will provide tips and tools for debugging smart contracts to help Web3 developers ensure their contracts work as intended.

Debugging Smart Contracts

Smart contract debugging is identifying and fixing errors in smart contracts. It is essential in developing any decentralized application as it ensures the contracts function as intended.

Contract development can run into several problems, including unpredictable behaviour, coding errors, and security flaws. Debugging can assist in resolving these problems and preventing more serious ones from developing later.

Implementation, testing, and deployment are only a few processes in developing a smart contract. A crucial phase in each of these steps is debugging. After deploying the contract, debugging helps find and correct flaws in the code introduced during the writing phase.

Debugging assists in finding and correcting issues that might have gone unnoticed during the writing stage during the testing phase. Debugging also ensures that the contract is deployed correctly and interacts with the blockchain as intended during deployment.

Debugging Tips

Writing smart contracts that are easy to debug is a crucial step in development. Below are some tips for writing smart contracts that are easy to debug:

• Use simple, evocative names for your variables and functions so that anyone can quickly grasp what each one does and spot mistakes.

• Utilize the built-in solidity function called require to ensure that a particular condition is satisfied before the contract can continue executing. It's a valuable tool for debugging because it halts contract execution when the need is unmet, enabling programmers to locate the problem quickly.

• The Truffle Debugger is a powerful tool that you can use to debug contracts during the testing stage. It allows developers to review the code, inspect variable values, and revert to previous states.

• The Remix IDE is a popular online code editor for Solidity. It contains an integrated debugging function that enables programmers to browse the code and check the values of variables.

Categories of Ethereum Smart Contract Errors

Syntax, runtime, and logic errors are the most frequent problems engineers face while writing or running code for Solidity contracts.

Syntax Error

A syntax error in a smart contract is a mistake in the code that prevents the computer from understanding it. Simple errors like omitting a semicolon or misusing a term can constitute a syntax fault.

Logical Error

A logical error in a smart contract refers to a mistake in the code that doesn't prevent it from being executed but causes it to produce unexpected or incorrect results.

For instance, a contract transfers money to the incorrect address when sending money from one account to another.

An audit of a smart contract can find logical problems since, sometimes, from the developer's perspective, everything is going according to plan. Even though there might not be a bug in the code, an auditor can still execute a smart contract to look for security vulnerabilities, examine the business logic, and find loopholes.

Runtime Error

Any error during the execution of a contract is called a runtime error. This may occur if a contract fails to handle unexpected inputs or conditions correctly or attempts to carry out an operation prohibited by the underlying blockchain.

For instance, a contract that tries to transfer more money than is allowed in an account would result in a runtime error.

Runtime problems are more challenging to diagnose than syntax faults since they are not known before being deployed on a blockchain and can only occur when a smart contract's state changes.

Common Runtime Errors

Let's look at the most common runtime errors when developing smart contracts for the Ethereum network.

Stack Overflow

In Solidity, a stack can only hold 1024 frames, meaning a function can only call itself 1024 times before a stack overflow happens. If there is an attempt to execute a function recursively and there is no condition to stop it, stack overflow will occur.

pragma solidity ^0.8.0;

contract Overflow {
  function count(uint256 num) public returns (uint256) {
    return count(num + 1);
  }
}

Overflow o = new Overflow();
o.count(1); // This will cause a Stack Overflow error as the function keeps calling itself infinitely.

Stack Underflow

When there is an attempt to pop a nonexistent variable in assembly language, a stack underflow happens.

Solidity doesn't have a stack-based execution model like some other programming languages, such as C, so it's impossible to cause a Stack Underflow error in Solidity the same way it is in those languages.

However, Solidity does have some exceptions that can be thrown if a contract runs out of gas, which can be thought of as a similar concept to Stack Underflow. Here's an example of Solidity code that can potentially cause an Out of Gas error:

pragma solidity ^0.8.0;

contract Underflow {
  function loop(uint256 num) public returns (uint256) {
    for (uint256 i = 0; i < num; i--) {
      // Do some operation
    }
    return num;
  }
}

Underflow u = new Underflow();
u.loop(1); // This code may run out of gas as the for loop condition will always be true and the loop will continue indefinitely, potentially causing an Out of Gas error.

Execution Reverted

When a contract stops the execution of a transaction that deviates from its business logic, revert errors happen. Contracts usually include checks for various required criteria. The contract deems a transaction invalid and halts execution if it doesn't meet all requirements.

It's vital to remember that a transaction will only be reverted if it was attempted to be completed but could not be executed based on the smart contract's logic; in this case, the EVM will return an error, and the transaction will be reverted.

pragma solidity ^0.8.0;

contract Revert {
  function transfer(address payable recipient, uint256 amount) public {
    require(amount > 0, "Amount must be greater than zero");
    recipient.transfer(amount);
  }
}

Revert r = new Revert();
r.transfer(address(0), 0); // This code will cause an Execution Reverted error as the `require` statement will fail since the amount is zero, causing the function to revert its execution.

Out-of-Gas

Out-of-gas error occurs when you don't provide enough gas to execute a transaction or gas is insufficient to complete a transaction.

pragma solidity ^0.8.0;

contract OutOfGas {
    function consumeGas() public {
        while (true) {
            // Do some computation that consumes gas
        }
    }
}

OutOfGas o = new OutOfGas();
o.consumeGas(); // This code may run out of gas as the while loop runs indefinitely, consuming all available gas.

Invalid Opcode

The Invalid opcode errors occur when EVM encounters an incompatibility with a contract. For instance, when the contract was compiled with an unsupported compiler.

JUMP Errors

The invalid jump happens when you try to call a function that doesn't exist, such as when you call a function of one contract through another contract that doesn't exist. A similar issue can happen when you use assembly language and point to false memory.

pragma solidity ^0.8.0;

contract JumpError {
  function jump() public returns (uint256) {
    uint256 x = 1;
    if (x == 1) {
      return 1;
    } else {
      return 2;
    }
    return 3; // This code is unreachable and can cause a "JUMP" error.
  }
}

JumpError j = new JumpError();
j.jump(); // This code may cause a "JUMP" error as the final return statement is unreachable.

Debugging Tools

This previous section taught us about common errors in building and deploying smart contracts. Now, we will check out the tools for debugging smart contracts.

Hardhat & Truffle

Hardhat is an open-source development environment for Ethereum. It includes tools for developing, testing, and deploying smart contracts. Hardhat also has a built-in debugger allowing developers to review the code and inspect variable values.

Truffle is a popular development framework for Ethereum. It includes a suite of tools for developing, testing, and deploying smart contracts. Truffle also consists of the Truffle Debugger, a powerful tool for debugging contracts during the testing stage.

Remix

Remix is a popular online code editor for Solidity. It has a built-in debugging feature lets developers scan the code and inspect variable values.

EtherScan

Etherscan is a blockchain explorer for Ethereum. It allows developers to inspect and debug contracts deployed on the Ethereum blockchain.

The stage of development and the project's particular requirements will determine the best tool to use for debugging contracts.

Remix and EtherScan are better suited for the deployment stage, while Truffle and Hardhat are better suited for testing. Truffle and Hardhat offer more sophisticated debugging tools, such as stepping code and returning to earlier states. Remix and Etherscan, on the other hand, provide additional visibility and transparency into the deployed contract.

Testing various tools to determine which best suits the project's demands is crucial.

Conclusion

Debugging smart contracts is a critical stage in creating decentralized apps for the blockchain. Web3 developers can ensure that their contracts operate as intended by following the advice and using the resources described in this guide.

As technology and best practices advance, it's critical to keep learning and experimenting with new tools and strategies for debugging contracts.

Resources

• Ethereum Developers Tools list

• Smart Contract tools you need to know

• Guide to Ethereum Developer Tools

• How to Debug Smart Contract Transactions

I'd love to connect with you on Twitter | LinkedIn | GitHub | Portfolio

See you in my next blog article. Take care!!!

Let’s jump in, build, and deploy an ERC721 NFT to see how it works.

What is the Infura NFT SDK?

The Infura NFT SDK is an SDK that allows you to build and interact with NFTs easily. It’s implemented in TypeScript, a programming language that is a strict superset of JavaScript. The SDK includes the ability to create, mint, and manage NFTs and query information about them.

The significant part is that it abstracts away the technical details so you can focus on the core functionality of your dApp instead of the (often difficult) details. It’s all about ease of use with Infura SDKs!

Supported chains include:

Write

• Ethereum: Mainnet, Goerli, Sepolia

• Polygon: Mainnet, Mumbai

Read

• Ethereum: Mainnet, Goerli, Sepolia

• Polygon: Mainnet, Mumbai

• BSC: Mainnet

By using the Infura NFT SDK, you also get access to Infura's core functionality and infrastructure, which provides access to Ethereum (and other blockchains) without requiring you to run a full node. With the SDK, you can leverage many capabilities, making it easier to build and scale your dApps.

So let’s build an NFT and see what the SDK can do.

Building and Deploying ERC721 NFT

We will build a dApp and smart contract on Ethereum and use the SDK to create a new NFT. We’ll do all this on the Ethereum Goerli testnet, so we don’t have to worry about defects or the cost of deploying to the mainnet.

Prerequisite

Before getting started, you need the following prerequisites:

• Node.js and its package manager NPM. Verify you have Node.js installed by using the following terminal command: node -v && npm -v

• TypeScript installed

• An Infura account

• A basic understanding of TypeScript and JavaScript

• MetaMask

Infura

The Infura NFT SDK is really simple to use. In fact, most of this tutorial is just the setup and configuration needed to create a dApp. Let’s start by logging in to your Infura account. You should be on your dashboard, where you can create a new key, as shown below. We’ll create a new key for this project.

Click the “Create a New Key” button and fill in the required information.

After creating your key, your project ID will be visible on your dashboard under the API KEY section, as shown below. Copy and keep it somewhere; you’ll need it later in this tutorial.

Set up IPFS project on Infura Dashboard

Now, let’s create an IPFS project. IPFS is a P2P distributed file system for storing and accessing files (and other data). It works well with blockchain. We’ll need IPFS (and these credentials) to upload and store the metadata of our NFT project.

Head to your dashboard and create another new key by clicking “Create a Key”, as shown below.

This time we’ll choose IPFS as the network. This project will work on the mainnet and (what we will use it for) testnet.

After creating your key, you’ll see your project ID and API key secret under the API KEY section of your dashboard. You’ll need this later as well, so copy it and keep it somewhere safe.

Project Setup and Installation

Next, we’ll set up and initialize a node.js Typescript project. Use the following commands in your console:

mkdir typescript-nft-demo && cd typescript-nft-demo

npm init -y

npm install -D typescript ts-node

npx tsc --init

Open the project in your preferred development environment. For example, if you are using Visual Studio Code, use the following command to open the project automatically:

code .

Install the Project Libraries

Next, we need to install the Infura SDK and dotenv library for reading the environment variables.

Use the following command:

npm install @infura/sdk dotenv

Your project should have something similar to what is shown below:

Create a .env file at your project's root and add the following variables to it:

INFURA_PROJECT_ID=<YOUR-INFURA-PROJECT-ID>

INFURA_PROJECT_SECRET=<YOUR-INFURA-PROJECT-API-KEY>

WALLET_PRIVATE_KEY=<YOUR-WALLET-MNEMONIC/PRIVATE-KEY>

EVM_RPC_URL=https://goerli.infura.io/v3/<YOUR-PROJECT-API-KEY>

INFURA_IPFS_PROJECT_ID=<YOUR-INFURA-IPFS-PROJECT-ID>

INFURA_IPFS_PROJECT_SECRET=<YOUR-INFURA-IPFS-PROJECT-SECRET-KEY>

WALLET_PUBLIC_ADDRESS=<YOUR-WALLET-ADDRESS>

• Replace <YOUR-INFURA-PROJECT-ID> and <YOUR-INFURA-PROJECT-API-KEY> with the ID and API key from the Infura project created earlier in this tutorial.

• Replace <YOUR-INFURA-IPFS-PROJECT-ID> and <YOUR-INFURA-IPFS-PROJECT-SECRET-KEY> with the ID and API key from the IPFS project created earlier in this tutorial.

• On the line starting with EVM_RPC_URL, replace <YOUR-PROJECT-API-KEY> with your Infura API key.

• <YOUR-WALLET-ADDRESS> should be replaced with your public blockchain address.

• <YOUR-WALLET-MNEMONIC/PRIVATE-KEY> is your wallet's private key. Note: Never share your private keys (mnemonic) with anyone, and keep them secure.

You can find your wallet address and private key to your wallet on MetaMask in the following steps:

• Open MetaMask by clicking on the browser extension icon or visiting the MetaMask website.

• Click on the three dots in the top right corner of the MetaMask window.

• Select “Account Details” from the drop-down menu, and click on the “Export Private Key” button.

• A pop-up window will appear, asking you to enter your password. Enter your password and click on the “Unlock” button.

• Once your account is unlocked, you can see your private key.

Remember: keep your private key safe and never share your private key with anyone else. Also, be sure you're connected to the Goerli testnet, not the mainnet, as shown in the image below.

Now that we’ve successfully configured our project, create a new TypeScript file nft.ts at the root level.

Your project structure should look similar to the one below.

Setup Infura Authentication

Authentication from inside our dApp requires our PROJECT_ID and PROJECT_SECRET. We’ll load these from our new .env file.

Create an auth object inside the nft.ts using the following code snippet:

import { config as loadEnv } from "dotenv";
import { SDK, Auth, Metadata, TEMPLATES } from "@infura/sdk";

// load environment variables from .env file
loadEnv();

// Create an instance of the Auth class 
const auth = new Auth({

  // set the projectId taken from the INFURA_PROJECT_ID environment variable 
  projectId: process.env.INFURA_PROJECT_ID,

  // set the secretId taken from the INFURA_PROJECT_SECRET environment variable 
  secretId: process.env.INFURA_PROJECT_SECRET,

  // set the private key taken from the WALLET_PRIVATE_KEY environment variable 
  privateKey: process.env.WALLET_PRIVATE_KEY,

  // set the rpcUrl taken from the EVM_RPC_URL environment variable 
  rpcUrl: process.env.EVM_RPC_URL,

  // set the chainId for the Goerli testnet
  chainId: 5, // Goerli

  // set the options for IPFS
  ipfs: {

    // set the project Id taken from the INFURA_IPFS_PROJECT_ID environment variable
    projectId: process.env.INFURA_IPFS_PROJECT_ID,

    // set the API key secret taken from the INFURA_IPFS_PROJECT_SECRET environment variable
    apiKeySecret: process.env.INFURA_IPFS_PROJECT_SECRET,
  },
});

// Instantiate the SDK
const sdk = new SDK(auth);

Configure the tsconfig.json file as shown. (You might get an error but keep going.) tsconfig.json is a configuration file for TypeScript projects. It’s used to specify the compiler options and files that should be included in the project.

Configure your tsconfig.json with the following code snippet:

{
        "compilerOptions": {

          "target": "ESNext", /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */

          "module": "ES2022", /* Specify what module code is generated. */

          // "rootDir": "./",                                  /* Specify the root folder within your source files. */

          "moduleResolution": "node", /* Specify how TypeScript looks up a file from a given module specifier. */

          "esModuleInterop": true, /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */

          "forceConsistentCasingInFileNames": true, /* Ensure that casing is correct in imports. */

          /* Type Checking */

          "strict": true, /* Enable all strict type-checking options. */

          "skipLibCheck": true /* Skip type checking all .d.ts files. */
      }
}

Next, add the type module to the package.json file using the following code snippet:

//...

"type": "module",
"scripts": {},

//...

Create Token Metadata

Now we’re done configuring. Let’s get to the exciting stuff!

First, we’ll create the token metadata.

Token metadata refers to additional information or data associated with a token (typically an ERC-721 or ERC-1155 token on the Ethereum blockchain). This metadata can include information such as the token's name, symbol, image, and other attributes that describe the token or give it context.

The metadata is stored on the blockchain and is typically represented as a URI or a URL that points to a JSON file containing the metadata.

Inside the nft.ts file, add the following code snippet. It will create and store the token metadata. The metadata class is from the Infura NFT SDK.

(Note: The consensys.net external_url is just for demo purposes here and can be replaced.)

// Define the properties of the token, including its description, external URL, image, name, and attributes
const tokenMetadata = Metadata.openSeaTokenLevelStandard({

  description: "Fantastic creature of different emojis",

  external_url: "https://consensys.net/",

  image: await sdk.storeFile({

    // Store the image from the given URL
    metadata: "https://res.cloudinary.com/olanetsoft/image/upload/c_pad,b_auto:predominant,fl_preserve_transparency/v1672327921/demo.jpg",

  }),
  name: "Kandy Jane",
  attributes: [],
});

// Log the token metadata object to the console
console.log("Token Metadata: ", tokenMetadata);


// Store the token metadata and log the result
const storeTokenMetadata = await sdk.storeMetadata({ metadata: tokenMetadata });

console.log("Store Token Metadata: ", storeTokenMetadata);

Create the Contract Metadata

Contract metadata refers to additional information or data associated with a smart contract on a blockchain network. This metadata can include information such as the contract's name, symbol, version, and other attributes that describe the contract or give it context.

The metadata is stored on the blockchain and is typically represented as a URI or a URL that points to a JSON file containing the metadata.

Create contract metadata using the following code snippet:

//...

// Define the properties of the collection, including its description, external URL, image, name, and attributes
const collectionMetadata = Metadata.openSeaCollectionLevelStandard({

  name: "Emojis collection", // Sets the name of the collection to "Emojis collection"

  description:
    "A small digital image or icon used to express an idea or emotion in electronic communication. Emoji's come in many forms, such as smiley faces, animals, food, and activities. ", // Sets the description of the collection
  image: await sdk.storeFile({

    // Sets the image property of the collection using the storeFile method
    metadata:
"https://res.cloudinary.com/olanetsoft/image/upload/c_pad,b_auto:predominant,fl_preserve_transparency/v1672327921/demo.jpg", // The URL of the image file
  }),

  external_link: "https://google.com/", // Sets the external link property of the collection
});

// Logs the collection metadata to the console
console.log("Collection Metadata:- ", collectionMetadata); 

// stores the metadata using the storeMetadata method
const storeMetadata = await sdk.storeMetadata({ metadata: collectionMetadata }); 

// Logs the store metadata to the console
console.log("Store Metadata: ", storeMetadata);

This code snippet above creates an object collectionMetadata using the openSeaCollectionLevelStandard method from the Metadata class. The openSeaCollectionLevelStandard method creates standard collection-level metadata compatible with OpenSea, a leading marketplace for NFTs. It sets the collection's name, description, image, and external link properties; stores the metadata using the storeMetadata method; then logs it and stores it in the console for debugging.

Create a New Contract and Mint an NFT

Add the following code to create a new contract and mint an NFT using the Infura NFT SDK. Most of this functionality comes to us from our new NFT SDK!

//...

// Create a new contract
const newContract = await sdk.deploy({   // deploys a new contract using the sdk.deploy method

  template: TEMPLATES.ERC721Mintable,     // sets the template for the contract to ERC721Mintable
  params: {
    name: "1507Contract",                  // sets the name of the contract as "1507Contract"
    symbol: "EMOJI",                        // sets the symbol of the contract as "EMOJI"
    contractURI: storeMetadata,             // sets the contract URI with the storeMetadata
  },
});

console.log("Contract Address: \n", newContract.contractAddress);  // logs the contract address to the console

// mint an NFT
const mint = await newContract.mint({  // mints a new NFT using the mint method from the new contract

  publicAddress:
    process.env.WALLET_PUBLIC_ADDRESS ??

    "0x510e5EA32386B7C48C4DEEAC80e86859b5e2416C", // sets the public address of the wallet, if not set it will use the given address

  tokenURI: storeTokenMetadata,                // sets the token URI with the storeTokenMetadata

});

const minted = await mint.wait();            // waits for the minting process to complete

console.log("Minted: ", minted);               // logs the minted NFT to the console

This code creates a new contract using the sdk.deploy method and sets the template for the contract to ERC721Mintable. Then it sets the contract's name, symbol, and contract URI. The contract address is logged for debugging.

It then mints a new NFT using the mint method from the new contract and sets the wallet's public address. If not specified, it uses the given address and then sets the token URI with the storeTokenMetadata.

Finally, it waits for the minting process to complete and logs the minted NFT to the console.

Let’s test it out!

ts-node-esm nft.ts

You should see something similar to what is shown below:

Verify Contract on Account and Goerli Etherscan

Finally, let’s verify the contract using a blockchain explorer on the Goerli Etherscan. Go to the Goerli Ethereum testnet site and paste the transaction hash from your output above (as shown below).

You should see the details.

That was easy! We successfully utilized the Infura NFT SDK to build, deploy, and mint an NFT on the Goerli testnet.

Import token on MetaMask

Let’s look at our new NFT from a front-end perspective using MetaMask. First, we have to import our wallet to MetaMask. Click “Import Tokens”, as shown in MetaMask. (Be sure you are connected to the Goerli Testnet as shown.)

Copy and paste the contract address to import your token on MetaMask, as shown below.

And there it is! An easy and fast way to add NFTs to your dApps. You can use the SDK now to manage the NFTs and more (see the docs for current capabilities).

Verify Minted NFT on OpenSea

We’ve successfully imported the minted NFT on MetaMask, but now let’s verify on OpenSea tesnet. Connect your wallet and view your new NFT. You should have something similar to what is shown below.

For reference, here’s the OpenSea link to the NFT created. You can find the complete code on a GitHub repository here.

Conclusion

In conclusion, the new Infura NFT SDK for TypeScript is a powerful tool for developers looking to incorporate NFTs into their dApps. With its easy-to-use functions and comprehensive features, this SDK makes it simple to deploy, mint, and manage NFTs on the Ethereum blockchain. Sign up and start building!

I'd love to connect with you on Twitter | LinkedIn | GitHub | Portfolio

See you in my next blog article. Take care!!!

On the other hand, the boardroom platform makes discovering, transacting, and improving distributed decision-making across crypto networks a breeze.

In this post, we will learn about DAOs, Boardroom, how to discover DAOs, Boardroom features, and projects.

What is a DAO?

DAOs (decentralized autonomous organizations) are organizations that were created to be automated and decentralized. The community is managed by rules enforced on a blockchain, and decisions are made from the bottom up.

The use of blockchain technology to establish a secure digital ledger to trace digital activities across the internet, toughened against forgery by trustworthy timestamping and the dispersion of a distributed database, is typified by decentralized autonomous organizations.

A decentralized autonomous organization (DAO) operates without the need for hierarchical management and can serve a variety of objectives. These groups can create freelancer networks where contracts pool their funds to pay for software subscriptions, philanthropic organizations where members approve payments, and venture capital businesses run by a group.

What is Boardroom?

The Boardroom is a protocol governance and management software designed to help crypto networks make better-distributed decisions.

In exchange for their efforts, the Boardroom allows DAOs to reward users with a direct ownership position in the platform, aligning their success with the forums.

Boardroom Features

The Boardroom allows stakeholder-owned platforms to scale while maintaining the interests of all stakeholders.

This section will go through some of the key features it comes with out of the box.

Adding a DAO

Adding a DAO to Boardroom is a relatively painless and straightforward process. First, we will click the Add a DAO button in the top right corner of the page, as shown below.

Then, as shown below, we'll be redirected to a new page where we can fill in all of the necessary information about the DAO.

Voila 🥳, our DAO integration is completed.

Profile Management

Boardroom provides us with vital information about each connected wallet, allowing us to see how active they are and how they voted. Let's look at how we can make changes to our profile.

Let's connect our wallet by clicking on the Connect Wallet button on the top-right of the page, as shown below.

Next, we will see a pop-up to select our favorite wallet provider to connect our wallet successfully.

We will be redirected to a new page by selecting the profile option from the dropdown menu shown in the image above.

We can view our profile information, including our wallet address, activities in all projects (including voting history and proposals), voting power, and edit and share profile buttons.

Then, by clicking the edit profile button, we'll see how to update our profile information.

Voting

This section will teach us how to vote on the Boardroom application. We'll go to the DAO page, where we'll be able to vote.

There are numerous methods for locating the DAO where we want to vote. We can either navigate through graphic cards for each DAO or filter by DAO category in the Boardroom.

We'll choose the Developer DAO project for this article because that's where our associated wallet can vote.

Next, we'll click on the Total Proposals number and see all of the proposals for the Developer DAO, which we can then filter to see only the Active ones.

We'll end up with something similar to what's shown below after filtering only the active ones.

We can now read the proposal's background information, see the current voting results, and vote by clicking as shown below.

Delegation

A user may be too busy or choose to have a proxy vote on their behalf, which is simple to set up in the Boardroom application.

As shown below, let's head over to any DAO page to set up Delegation.

When we click on Set Up Delegation, a page will appear asking us to select a delegation type, and there may be a charge for gas.

A new pop-up window will appear, asking us to input the Ethereum address we want to delegate. We can also use Boardroom to look for delegates on a leaderboard.

Boardroom Projects and DAO Discovery

DAOs can scale much faster than corporations since they are more internationally accessible and have fewer entry restrictions.

The Boardroom main page is a great place to look for freshly developed or added DOAs. We can also view all projects by clicking on the Explore Dao tab below.

We can filter by protocol, social services, etc.

We can also read additional information, check the treasury, vote, and view the calendar by clicking on each DAO.

Conclusion

This post explores how to discover DAOs on the Boardroom platform and other essential features such as Projects, Voting, Delegation, and profile maintenance.

Reference

• Boardroom
• Boardroom Projects

I'd love to connect with you at Twitter | LinkedIn | GitHub | Portfolio

See you in my next blog article. Take care!!!

As we take stock of all that has happened, it's easy to feel overwhelmed by the sheer magnitude of it all. But as we look back on the year, we must remember that we are not alone in this journey. We have shared these experiences, and in doing so, we have forged a bond that will carry us forward into the future.

So as I approach the end of the year, I will take a moment to honour all that I have been through and all that I have achieved. Let's embrace the emotions that come with looking back on a year filled with so much. And let's look ahead to the future with hope and determination, knowing that we will face it no matter what comes our way.

I wrote an "End of the Year" review last year, and I got quite a lot of feedback regarding how some folks are being inspired, so let's do this again. You can find the 2021 review here.

Highlights

• I got a new role with a UK-based company as a Backend Developer

• Transitioned into Web3 full-time, securing a role as a Developer Relations Engineer

• Made thousands of $$$ from technical writing

• I bought a new phone Samsung S22+, and Samsung watch5 Pro.

• Travelled to 3 different countries (Let's do more)

• I moved to my new Home (sharing some incredible photos and video soon)

• Invested in real estate

• Spoke at over 50+ tech conf (In-person events, Webinars, Twitter space, podcast etc.)

• Wrote over 40+ technical contents

• Founded Web3 Afrika

  I'll start with a list of things I expected to get done but didn't.

Failure is simply the opportunity to begin again, this time more intelligently. — Henry Ford

Challenges

In this section, I will discuss some challenges I faced. Although I felt so sad about it, but we move !!!

• I got over 50+ rejections, which is way lesser than last year, maybe because I stopped applying to roles at some point. Although I tailored my application to a specific position, I wasn't just applying to roles blindly.

• "Hiring freeze" is what they told me after finalizing the five stages of the interview process (I wish I could mention the company name). I was so pained, but after several interactions with HR, she made me realize it was due to the economic crisis in Europe at the time.

• I got rejected by three giant Web3 companies at stage 3 or 4 after a smooth interview process. I think one of the reasons I figured was because of my location (sad).

• I thought I would write more since I am now in the web3 space full time, but the attention was split between speaking and writing. I failed.

• Invited to speak at CMfest22 and Gdg Ikorodu but didn't make it down. 🥲

  ---

  Life is full of challenges, and it's natural to feel overwhelmed or discouraged when faced with difficulties. But it's important to remember that challenges are a normal and necessary part of life and can help us grow and become stronger.

  So if you're feeling weighed down by challenges, here are a few tips to help you stay motivated and keep moving forward:

  1. Remember that challenges are temporary: No matter how difficult a challenge may seem, it will eventually end. Remember this as you work through your struggles, and remind yourself that things will improve.

  2. Please focus on the things you can control: It's easy to get caught up in the things that are out of our control, but this only leads to frustration and stress. Instead, focus on the things you can control, like your attitude and actions.

  3. Seek support: No one has to face challenges alone. Whether it's a friend, a family member, or a professional, reach out to someone you trust for support and guidance.

  4. Take care of yourself: Don't forget to prioritise your physical and emotional well-being. This might mean getting enough rest, eating healthy, or relaxing and de-stressing.

  5. Find the silver lining: It can be hard to see the bright side when you're going through a tough time but try to look for the small moments of joy and positivity. These can help lift your spirits and motivate you to keep going.

Remember, challenges are a natural part of life and can help us grow and become stronger. So don't let them weigh you down – use them as an opportunity to learn and grow.

Accomplishment

it's a good time to reflect on our actions and achievements over the past 12 months. Whether it's a significant career milestone, a personal achievement, or something small but meaningful, it's essential to take a moment to celebrate our successes and reflect on our progress.

• Built a web3 tool: Twitter bot to simplify web3 terms

• I contributed significantly in my little way to folks within my network to get gigs, full-time roles, advice, guides, writing, understanding blockchain concepts from my talks etc. Here are a few ones I can get my hands on right now.

Click here to view feedbacks

Tiny changes, remarkable result

Tiny changes, remarkable result

Tiny changes, remarkable result

Tiny changes, remarkable result

Tiny changes, remarkable result

Tiny changes, remarkable result

Tiny changes, remarkable result

Tiny changes, remarkable result

Tiny changes, remarkable result

Tiny changes, remarkable result

I know I might not be able to connect with everyone, but there is a quote that resonates with me every time, which I would like to share with everyone reading this piece.

Tiny changes, remarkable result - James Clear

• Donated a token to support those in need of laptops and also several data giveaway to support those learning in tech.

Content

• Made thousands of $$$ from technical writing. Interested to know how? Check this, let's go on a ride in 2023.

• My Hashnode blog crossed 220,000 views, having over 1.2 milion+ views across all platforms.

• Started writing content for Cloudinary(Media Jam) - profile, Web3 Hashnode, Moralis, Alchemy, Better Programming, and LogRocket.

  

  Travel

• I travelled out of the country for the first time in my life.

• Trip to Ghana.

Speaking Engagement

• My first-ever in-person speaking event got approved by OSCAFRICA for OscaFest.

During the Oscafest event after my talk, I got a lot of exciting feedback and started feeling like doing more what people were saying (picking a few).

• Met Nader Dabit at OSCAFEST after connecting online for several years. Thanks for all you do in the community, ser!!

• I was invited to speak at Decode Web3 Series alongside experienced speakers and community builders in the Web3 ecosystem.

• Allowing someone to speak at a web3 Twitter space is not just about giving them a platform – it's about giving them a voice and the chance to share their insights and ideas with the world. Thank you Francesco Ciulla 💙

• "The Web3 Stack" gave another exciting talk at the Web3 Lagos event, where attendees learnt about the core Web3 stack and how to build a decentralized application.

• I gave a hands-on technical session about "The Power of Circle APIs + Building & Deploying a USDC-based Smart Contract" in Lagos and Nairobi at the #Web3Dev22 Roadshow.

• Web3 has come a long way since its inception, and it's clear that it has the potential to revolutionize the way we interact with the internet and each other. At the I4GHACKFEST2022, I gave another talk about building a decentralized application using the appropriate stack.

• Speaking at a developer conference is not just an opportunity to share your knowledge and ideas – it's a chance to inspire and motivate others to pursue their passions and positively impact the world. Thank you, DevFest Lagos, DevFest Nairobi, DevFest Ajah and DevFest Ibadan, for the vast opportunity.

• It was an inspiring moment for me during Devfest Nairobi when I gave a talk about leveraging blockchain technology to build software applications.

• Another exciting moment at the Federal university of technology Owerri.

I wish to list all of the presentations I gave this year. Recall that I stated it's 50+? Knowing that one of my primary goals for 2022 was to speak more was fascinating.

Speaking at a tech conference is a huge accomplishment, and it's natural to feel a sense of pride and accomplishment after such an achievement. But it's important to remember that success is not about resting on your laurels – it's about pushing yourself and striving for even greater things.

If you're feeling overwhelmed or uncertain about what to do next after speaking at a tech conference, here are a few tips to help you stay motivated and keep moving forward:

Remember that success is a journey, not a destination: Success is not about reaching a certain point and then stopping – it's about continuously striving to improve and grow. Keep this in mind as you look ahead to your following goals and challenges.

Community Engagement

• Became Showwcase Community lead focusing on blogging, Javascript and Technical writing community.

• Became Freecodecamp's 2022 top contributor. I love this, and I hope to do more in 2023.

• I was invited to be a judge in a hackathon at Microsoft garage by Africa hack.

• Joined the Stackshift program, Genesis cohort

• Donated to SheCodeAfrica to support the excellent work they do.

• Showwcase AMA

Accomplishments are a natural and essential part of life, and taking the time to celebrate and recognize them is important. But it's also important to remember that accomplishments are not just about recognition or validation – they are also an opportunity for growth and development.

Here are a few tips for embracing your accomplishments and using them to grow:

1. Reflect on what you have learned: Accomplishments are not just about the result but also the journey. Take the time to reflect on what you have learned and how you have grown due to your efforts.

2. Celebrate your successes: Taking the time to celebrate your accomplishments and acknowledge your hard work is essential. Whether with a small celebration or a simple thank you to yourself, make sure to take the time to enjoy your success.

3. Set new goals: Accomplishments are not the journey's end – they are just the beginning. Use your accomplishments as motivation to set new goals and continue growing and developing.

4. Share your success with others: Sharing your accomplishments with others can help inspire and motivate them to pursue their goals. Share your achievements with friends, family, and colleagues, and help them see what is possible with hard work and dedication.

5. Use your accomplishments as a stepping stone: Accomplishments can lead to even bigger and better things. Don't be afraid to challenge yourself and push yourself to new heights.

Embracing your accomplishments is an essential part of personal growth and development. So take the time to celebrate and recognize your successes, and use them as a catalyst for even greater things to come.

Reflection

As the end of the year approaches, it's natural to look back and reflect on all that has happened. This year has been a rollercoaster of emotions from the highs and lows, the joys and struggles, the laughter and tears.

As we reflect on the year, it's essential to take stock of all that we have accomplished and all that we have learned. This might include looking back on our personal and professional goals and the challenges and successes we have encountered.

But it's also essential to look beyond the year's events and consider the broader emerging themes and patterns. What have we learned about ourselves and the world around us? How have our values and priorities changed over the year?

What do we hope to achieve in the coming year? What lessons can we carry forward from this year's experiences?

By reflecting on the year, we can better understand ourselves and the world around us and use this knowledge to inform our future decisions and goals.

I wanted to take a moment to express my heartfelt gratitude to all of you who have supported me throughout my journey this year. Whether you offered encouragement, helped me with practical tasks, or listened to me vent, your support has meant more to me than you will ever know.

This year has had its ups and downs, but I am grateful to have had all of you by my side every step of the way. Your love and support have been a constant source of strength and motivation for me, and I couldn't have made it without you.

Thank you for being such an integral part of my life and believing in me even when I didn't believe in myself. Your love and support mean the world to me, and I am forever grateful to have you all in my life.

Conclusion

It's only natural to take stock of everything that has transpired this year as we near the end of the year. But as we reflect on the year, we must remember that our difficulties have made us more resilient and robust. They have given us the ability to develop, learn, and the fortitude to handle anything life throws at us.

So as we move forward into the coming year, let's take the lessons and experiences of this year with us. Let's embrace the challenges and opportunities that come our way and continue to grow and develop as individuals.

And most importantly, let's remember to be grateful for all that we have and all that we have achieved. Gratitude allows us to find the strength and motivation to keep moving forward, no matter what the future holds.

Thank you for going through this content. We will go harder in the year 2023. ✌️

I'd love to connect with you on Twitter | LinkedIn | GitHub | Portfolio

See you in my next blog article. Take care!!!

\*Disclaimer\*: I am not an expert in any way to figure this out, but this results from research, feedback and mentorship from DevRel professionals with several years of experience in DevRel.

Main Focus of DevRel

The main focus of DevRel is to create a positive perception of the organization and its products or services among developers. This is achieved through various activities such as local meetups, speaking engagements, writing and publishing articles, creating video content, teaching workshops, and more.

To build a DevRel function within your organization, you must first understand the needs and goals of your developer community. DevRel function can be achieved through research, analysis, and direct communication with developers. Once you clearly understand your audience, you can develop strategies and tactics for engaging with them.

One effective way to reach developers is through local meetups and in-person events. These can be an excellent opportunity to connect with developers in your area and showcase your organization and its offerings. Participating in online communities and forums is also a good idea, as these can be a great way to get feedback and build relationships with developers.

In addition to local meetups and online communities, DevRel professionals often engage with the developer community through speaking engagements, writing articles and blog posts, creating video content, and teaching workshops. These activities help establish your organization as a thought leader in the industry and build trust and credibility among developers.

It's also essential for DevRel professionals to be open-minded and willing to learn from the developer community. By listening to and addressing the needs and concerns of developers, you can create a more positive and productive relationship with them.

How to Measure DevRel

There are several ways to measure the effectiveness of a DevRel (Developer Relations) team:

1. Quantity and quality of developer engagement: This can be measured through metrics such as the number of developers reached through events, webinars, and other outreach efforts, as well as the level of engagement and feedback received from developers.

2. Developer satisfaction: It's essential to measure the satisfaction of developers who interact with the DevRel team. This can be done through surveys or other forms of feedback.

3. Product adoption and usage: One key metric for DevRel is developers' adoption and use of the company's products. This can be measured through metrics such as the number of active users or the number of integrations with other tools and platforms.

4. Contributions to open-source projects: If the company has an active open-source community, the DevRel team can track the number and quality of contributions made by developers.

5. Impact on the business: Ultimately, the goal of DevRel is to drive business results. This can be measured by revenue generated from developer-facing products, cost savings from developer support, or other business-specific metrics.

Strategically, here is something to note when measuring DevRel.

How to measure DevRel is not to measure DevRel - Shedrack, DevRel Manager, Wilco

Lessons

• Don't let the hype dictate your relationship.

• Optimize with what you are naturally gifted with, not what the company would expect

• How to measure DevRel is not to measure DevRel.

• The more important thing for DevRel than having a personal brand is having the ability to invest in and create high-quality relationships.

• As a DevRel, you meet people to create genuine relationships, not to grow your network or transactional relationships.

Key Takeaways

Here are some key lessons to take note of as a DevRel professional:

1. Understand the needs and goals of your developer community: It's essential to understand your audience to engage with them clearly and effectively. This can be achieved through research, analysis, and direct communication with developers.

2. Build relationships with developers: The main focus of DevRel is to create positive perceptions of the organization and its products or services among developers. Building relationships with developers through local meetups, speaking engagements, and participating in online communities and forums can help achieve this goal.

3. Establish your organization as a thought leader: Engaging with the developer community through speaking engagements, writing articles and blog posts, creating video content, and teaching workshops can help to establish your organization as a thought leader in the industry and build trust and credibility among developers.

4. Be open-minded and willing to learn: By listening to and addressing the needs and concerns of developers, you can create a more positive and productive relationship with them. Be open-minded and willing to learn from the developer community to support their needs effectively.

5. Stay up to date with industry trends: DevRel professionals need to stay updated with the latest trends and developments in the tech industry to engage with the developer community effectively. This can be achieved through continuous learning and staying connected with industry experts.

Thank you, Tejas, for sharing your experience and answering all my questions about DevRel.

With great appreciation, I thank Kenny for his extraordinary mentorship in helping people transition into the DevRel space and for helping those already in the space better understand the Devrel space through the DXMentorship program.

Conclusion

In conclusion, the role of DevRel is crucial for building and maintaining relationships with developers and the developer community. By focusing on local meetups, speaking, writing, video content, teaching, and workshops, and being open-minded and willing to learn, you can effectively engage with and support the needs of your developer community.

I'd love to connect with you via Twitter | LinkedIn | GitHub | Portfolio

See you in my next blog article. Take care!!!

Problem

I ran into an issue on my Mac OS when installing a blockchain project using the Cosmos SDK, which runs on top of the Tendermint Core consensus engine.

After running the following command:

make install

I ran into the error as shown below:

xcrun: error: invalid active developer path (/Library/Developer/CommandLineTools), missing xcrun at: /Library/Developer/CommandLineTools/us

Please don't panic; you will learn how to fix it quickly.

How to Fix the Error

To fix this error, open the terminal, and run the following command:

xcode-select --install

Why do we need to do this? The problem is that one needs to agree to the license agreement explicitly.

You may get an error message: "Can't install the software because it is not currently available from the Software Update server."

In this case, run the following command xcode-select --reset

Conclusion

It takes a couple of minutes to resolve this issue might be an hour for you; I hope you will fix it in less than 2 minutes.

Kindly Like and share with others. 😊

I'd love to connect with you on Twitter | LinkedIn | GitHub

See you in my next blog article. Take care!!!

This tutorial will teach us how to build and deploy USDC-based smart contracts to the Goerli Ethereum network and integrate with frontend React applications using EthersJs, ReactJs, and tailwind CSS.

Prerequisite

• Make sure to have Node/NPM installed on your computer. To install, click here for a guide.
  • Verify we have Node.js installed by using the following terminal command:

     node -v && npm -v
    

• Basic understanding of JavaScript / ReactJs

What is a Stablecoin?

A stablecoin is a digital currency pegged to a "stable" reserve asset like the U.S. dollar or gold. Stablecoins are designed to reduce volatility relative to unpegged cryptocurrencies like Bitcoin. ~ Coinbase

Stablecoins aim to offer a substitute for the most widely used cryptocurrencies' significant volatility, such as Bitcoin (BTC), which has made crypto investments less suitable for everyday transactions.

Types of Stablecoins

Commodity-backed Stablecoins

Commodity-backed stablecoins are stablecoins pegged to the value of a commodity like industrial metal, oil, or real estate, e.g., Tether Gold (XAUT).

Crypto-backed Stablecoins

Multiple cryptocurrencies support stablecoins to ensure effective risk allocation. Crypto-backed are stablecoins pegged to the value of another, more established cryptocurrency. e.g., DAI, BUSD.

Stablecoins backed by crypto have the benefit of better liquidity. But among the stablecoin variants already in use, crypto-collateralized stablecoins are among the most sophisticated.

Fiat-collateralized Stablecoins

Stablecoins that are "fiat-collateralized" keep a reserve of a fiat currency (or currencies), such as the dollar, as security for the stablecoin's value.

Commodities like crude oil or pricey metals like gold or silver can be used as collateral, such as USDC, USDT, etc.

However, the majority of fiat-collateralized stablecoins have U.S. dollar reserves.

Algorithmic Stablecoins

Algorithmic stablecoins are stablecoins that are not backed by real-world commodities but use algorithms to modulate supply based on their market supply.

Their main difference is how a stablecoin maintains its value by using an algorithm to restrict its supply, a computer program that follows a predetermined formula.

Building USDC-based Smart Contract

In this section, we will build, compile, and deploy the USDC-based smart contract to the Goerli Ethereum testnet.

Write a USDC-based Smart Contract Logic

Let us Navigate to the Remix site and create a new file called UsdcDemo.sol as shown below.

Next, update the UsdcDemo.sol file with the following code snippet.

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

// Abstract
interface USDC {
    function balanceOf(address account) external view returns (uint256);
    function allowance(address owner, address spender) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}

// Contract
contract UsdcDemo{

    USDC public USDc;

    // Contract Owner
    address payable public owner; 

    constructor(address usdcContractAddress) {

        USDc = USDC(usdcContractAddress);

        // User who is calling this function address
        owner = payable(msg.sender);
    }


    function Fund(uint $USDC) public payable {

        // Transfer USDC to this contract from the sender account
        USDc.transferFrom(msg.sender, address(this), $USDC * 10 ** 6);  


        // Transfer to the owner
        USDc.transfer(owner, $USDC * 10 ** 6);  
    }

    // Alternatively 
    // receive() payable external {

        // Send the fund to the owner of the contract.
       // owner.transfer(address(this).balance);
    // }      
}

In the code snippet above, we:

• Created an interface to utilize the function created on the main USDC smart contract
• Created a UsdcDemo contract
• Initialize the USDc variable from the interface created and also the contract owner
• Created the function Fund that accepts a parameter of the amount connected account is willing to fund. Inside this function, we utilized the transferFrom function from the interface to transfer the desired amount from the user to the contract, and then we sent it to the contract's owner using the transfer function.
• Added a receive function which alternatively does the automatic transfer of tokens deposited on the smart contract to the contracts' owner to avoid funds being permanently stuck on the contract

Compile a USDC-based Smart Contract

In this section, we will compile the USDC-based smart contract we wrote in the previous step, as shown below.

Deploy a USDC-based Smart Contract

We successfully built and compiled the USDC-based smart contract in the previous steps. We will proceed to deploy the smart contract to the Goerli Ethereum network.

Ensure you have Metamask installed, or click here to download and install Metamask.

Select the contract UsdcDemo we want to deploy, as shown below.

Next, paste the original USDC contract address 0x07865c6E87B9F70255377e024ace6630C1Eaa37F and click the Deploy button, as shown below.

Metamask will prompt a message to confirm the request then we will see a deployment message on the console, as shown below, after the contract has successfully been deployed on the Goerli Ethereum Network.

We have entirely built and deployed our smart contract. In the next section, we will implement a simple user interface to test and interact with the smart contract using Reactjs.

Building a Frontend Client with ReactJs

Let's clone this project on GitHub to start the project setup and installation.

Next, we will launch the project locally after cloning it using the following command on our terminal.

cd usdcdemo-frontend && npm install && npm run dev

After cloning and installing the project, we should have something similar to what we have below:

Update Project Smart Contract Address and Contract ABI

In this section, we will update the cloned project smart contract address and contract ABI with our own that we just built and deployed.

Please navigate to the Remix Site where we wrote and deployed the USDC-based smart. Copy the contract address and ABI as shown below.

Inside the frontend project, navigate to the utils folder and paste the Abi we copied into the contract.json file.

Next, copy the contract address on the Remix site as shown below.

Inside the index.js file under the pages folder, paste the contract address we just copied to replace the existing one, as shown below.

In the index.js file, we have a few functions named checkIfWalletIsConnected, connectWallet, and Fund; in the following section, we will learn what each function does.

Validate if a User Wallet is Connected

const checkIfWalletIsConnected = async () => {
    try {
      const { ethereum } = window;

      /*
       * Check if we're authorized to access the user's wallet
       */
      const accounts = await ethereum.request({ method: "eth_accounts" });

      // Validate that we have an account
      if (accounts.length !== 0) {
        const account = accounts[0];

        // Set the current account
        setCurrentAccount(account);

        // Display a success message to the user that they are connected
        success("🦄 Wallet is Connected!");
      } else {
        warn("Make sure you have MetaMask Connected!");
      }
    } catch (error) {
      err(`${error.message}`);
    }
  };

Connect Wallet

/**
   * Implement your connectWallet method here
   */
  const connectWallet = async () => {
    try {
      const { ethereum } = window;

      // Check if MetaMask is installed
      if (!ethereum) {
        warn("Make sure you have MetaMask Connected!");
        return;
      }

      //request account access if needed
      const accounts = await ethereum.request({
        method: "eth_requestAccounts",
      });

      // Get the first account we get back
      setCurrentAccount(accounts[0]);
    } catch (error) {
      console.log(error);
    }
  };

Approve

// Check if the user has approved the contract to spend their USDC
  const Approve = async () => {
    try {
      const { ethereum } = window;

      // Check if User already connected a wallet
      if (ethereum) {
        const provider = new ethers.providers.Web3Provider(ethereum);
        const signer = provider.getSigner();

        // Create a contract object
        const usdcContract = new ethers.Contract(
          usdcContractAddress,
          usdcAbi,
          signer
        );

        // Use the approve function to send USDC to the contract
        const usdcTxn = await usdcContract.approve(
          contractAddress,
          ethers.utils.parseUnits("1000", 6)
        );

        // Set the approving state to true
        setApproving(true);

        // Wait for the transaction to be mined
        await usdcTxn.wait();

        // Set the approving state to false
        setApproving(false);

        // Set the isApproved state to true
        setIsApproved(true);

        // Display a success message to the user
        success("🦄 USDC Approved Successfully!");
      }
    } catch (error) {
      err(`${error.message}`);
    }
  };

Fund

// Check if the user has approved the contract to spend their USDC
  const Fund = async () => {
    try {
      const { ethereum } = window;

      //Check is user already connected to a wallet
      if (ethereum) {
        const provider = new ethers.providers.Web3Provider(ethereum);
        const signer = provider.getSigner();

        // Create a contract instance
        const fundContract = new ethers.Contract(
          contractAddress,
          contractABI,
          signer
        );

        console.log("Connected to contract");
        console.log("amount: ", amount);

        // Send the transaction
        const Txn = await fundContract.Fund(amount, {
          gasLimit: 300000,
        });

        console.log("Mining...", Txn.hash);

        // Set the sending state to true
        setSending(true);

        // Wait for the transaction to be mined
        await Txn.wait();

        // Set the sending state to false
        setSending(false);

        console.log("Mined -- ", Txn.hash);

        // Display a success message to the user
        success("🦄 Donation Sent Successfully!");
      } else {
        console.log("Ethereum object doesn't exist!");
      }
    } catch (error) {
      err(`${error.message}`);
    }
  };

Let's head over to our browser to test the application; we should be able to connect our wallet, Approve USDC and donate USDC to the smart contract/owner as shown below.

Kindly Check here for the live demo.

To follow up, you can find the entire code for this project here.

Conclusion

In this article, we learned how to build and deploy USDC-based smart contracts to the Goerli Ethereum network and integrate with frontend React applications using EthersJs, ReactJs, and tailwind CSS.

I'd love to connect with you via Twitter | LinkedIn | GitHub | Portfolio

See you in my next blog article. Take care!!!