
## I made almost $20k last year freelancing and I quit

If you've read [this article](/why-i-quit-freelancing) you already know that back then I had decided that I want to try my luck getting a job/contract as a dev in a crypto company, even though freelancing wasn't that bad and I was on the up and up.

I did that because:

- Web3 development is generally better paid than web dev;
- It's a grind to find and negociate with new clients all the time;
- I wanted a challenge.

## I announced all of my clients and started looking

This may be something a lot of you don't have the stomach to do, but I simply announced all of my clients I won't be freelancing anymore before having even 1 lead as to getting a job.

I got a tip that [inverse.finance](https://inverse.finance) is hiring and so I started being active on their discord, helping how I could. I also started buggering them about a job.

They were friendly when talking to me (even though I was clear I knew nothing about web3 yet). They told me to learn and build a portfolio using Solidity, ethers.js, hardhat and they'd consider me.

This lead me to build [this](https://github.com/lazaralex98/voting-contract). It's a contract + dApp where you can make proposals for me to make YT videos and vote on existent proposals.

_Side note: I have a [YT channel](https://www.youtube.com/channel/UCBTlMP2ODwm0_Apy4wMoy5g)_

After presenting it to them they told me they are looking for a senior (I obviously don't fit that description yet 😂).

It kinda pissed me off as they could've let me know from the get go, but I did have on small web3 project in my portfolio now, so I moved on.

## An unlikely event presented me another opportunity

I somehow met Frank Turtle ([and I did an interview with him too](https://www.youtube.com/watch?v=5KxMbgragJY)), and he was also looking to break into web3.

He pointed me to [Toucan.earth](https://toucan.earth). They were looking to hire plenty of devs.

So I went straight to their discord and offered to help by building [a Discord Bot that praises people](https://github.com/lazaralex98/toucan-discord-praise-bot).

![Discord Praise Bot](/how-i-got-into-toucan.png)

Literally without any promise (or knowledge about discord bots), I started building this project.

In about 20 days of full-time work on this (quitting all of my client work did have its benefits, you see) I had a ERC20 customised token, a discord bot and a website for authentication.

After showing it to [James](https://twitter.com/positonic) (he's the CTO), he asked me if I want to be paid for the bot.

![How I asked James for a job](/how-i-asked-james-for-a-job.png)

I obviously said no, but I did request a job.

## My trial month

After a short discussion on Zoom (or whatever we used), me and James decided to do a trial month to see if we're a fit.

_Funny fact: He had asked me "when can you start?" twice (before the call and during the call) and I answered "today" or "right now" on both occasions. I think they loved my enthusiasm._

I learned **A LOT** during that trial month. Also, I fell in love with the team & culture, and I guess they liked me too since I got employed full-time. 💚

## Remember the drawbacks talk when I decided to quit freelancing?

I was a bit afraid that maybe I'll be less free/flexible if I got a job vs freelance.

The reality (for me at Toucan), is that I'm just as free, if not more free. I make my own schedule. I can take a day off whenever I feel like it. They don't care where I work from.

And, because this is a full-time position, I actually have better work-life balance.

My teammates are also super cool. I get paid far more per year than I did freelancing. I couldn't be more happy at Toucan.

One of the best decisions I've made.

P.S.: I also want to thank a friend of mine who is the one that initially adviced me to give web3 a shot. He's name is Sam, but I think he may want to stay anonymous. If you're reading this, thanks again Sam 🙏🏻



# Carbon Offsetting 101

I won't dive deep in to this, [Toucan.earth](https://toucan.earth) has material explaining this more in depth, but I'll give you the quick explanation:

Whenever you use electricity, you (likely) generate a certain amount of CO2 (or other greenhouse) gas. This happens because a lot of the electricity of the world is generated from coal.

When you offset carbon, in the roughest & simplest of terms, you pay for someone else to emit less so as to cover for the fact that you emited X CO2.

Since blockchain uses computing power (and electricity), whenever you send someone ETH/MATIC or otherwise interact with a smart contract, **that generates CO2**.

Which brings us to the subject at hand...

# How can you offset the CO2 used by a contract

In this article I will present you [a contract that can offset itself](https://github.com/lazaralex98/eco-1/blob/main/contracts/ContractOffsetterPOC.sol). You can extend your contracts with it or inspire yourself from it.

(In a future article I will present a contract that can offset other contracts and will make it infinitely easier for you to offset your footprint)

This contract is still 'rough around the edges' and has a few caveats that I'll address later.

But let's describe it.

Theoretically, the main/first functionality of this contract is to deposit & redeem BCT for TCO2.

As this contract is used, the contract calculates the footprint of each user (meaning the CO2 that was emitted when using this contract).

For the moment, we are using a hardcoded 0,00000036 TCO2 per transaction to calculate the footprint. The goal is to eventually get a real, peer-reviewed, calculation in place.

At any point in time, the user can check the footprint created by his using of this contract. And he can also offset that footprint (by retiring TCO2).

When the user offsets, he can choose between offsetting ALL his footprint or an amount of his choice. He can't offset more than his footprint.

If the user already has TCO2 in his wallet, he has the possibility to deposit that to this contract in order to retire it and offset the footprint.

It should be noted, everytime you deposit, or redeem, or offset or do any interaction with this contract: that adds to the footprint.

## Caveat #1: You must know how many transactions happen with each method

Because, for now, our only means of calculating footprint per usage is going by that 0,00000036 TCO2 per transaction number... we are forced to know how many transactions happen for each method in the contract that we want to offset.

You'll see what that means as we dive into the code.

## Caveat #2: The emmissions factor

The number (0,00000036 TCO2 per transaction) has been reached as follows:

1. Polygon [claims that their average transaction uses 0.0003 kg of CO2](https://blog.polygon.technology/why-eco-friendly-projects-choose-polygon/).
2. Each TCO2 means 1 tonne of CO2 so do the math and you have 0,0000003 TCO2 per transaction.
3. We added 20% on top of that as a safety number and we have 0,00000036 TCO2 per transaction.

They do not cite any research (as far as I know) to prove that number, but we think Polygon should be trustworthy.

And, given that we have nothing better (yet), this number will have to do for now.

# Let's dive into the code

You can go to [the github](https://github.com/lazaralex98/eco-1/blob/main/contracts/ContractOffsetterPOC.sol) and follow along if you prefer that to the blog.

I'd like to believe that the code is pretty well commented that you could figure stuff out there.

Still, let's take each (critical) part one at a time and attempt to further explain everything.

## addFootprint()

```solidity
mapping(address => uint256) public footprints;

function addFootprint(uint256 _transactions) private {
    footprints[msg.sender] += 360000000000 * _transactions;
}
```

First, the mapping, gives us a way to store a number (representing the footprint) for each user. This is the footprint that the user has created when interacting strictly with this contract.

I'm not sure who reads this, but if you are a beginner, a mapping is simply a collection of key:value pairs. When it's initialized, all keys exist and they have a value of 0 or false (technically not correct, but is an easy explanation). And you can assign/update values as you go.

The following method, which can only be used by the contract itself, takes in (as a parameter) the number of transactions that you want to calculate.

(As I said one caveat is that you have to know how many transactions you've done)

Based on the number of transactions, it calculates the footprint (using the number I mentioned above). The reason why you see 360000000000 and not 0,00000036 is because of how Solidity works.

(For beginners: Solidity has no decimals. Each unit represents an 18th of what would be a unit in JavaScript, for example. So, 1 in JavaScript is actually 1 \* 10\*\*18 in Solidity. 1 ETH is actually equal to 1 \* 10\*\*18 ethers in Solidity.)

## checkTokenEligibility()

```solidity
address public bctAddress = 0xf2438A14f668b1bbA53408346288f3d7C71c10a1;
address public contractRegistry = 0x6739D490670B2710dc7E79bB12E455DE33EE1cb6;

// @description checks if token to be deposited is eligible for this pool
// @param _erc20Address address to be checked
function checkTokenEligibility(address _erc20Address)
private
view
returns (bool)
{
// check if token is a TCO2
bool isToucanContract = IToucanContractRegistry(contractRegistry)
    .checkERC20(_erc20Address);
if (isToucanContract) return true;

// check if token is BCT
if (_erc20Address == bctAddress) return true;

// nothing matches, return false
return false;
}
```

First we see that I stored the BaseCarbonTonne contract address and the TCO2 contract registry address.

The function takes 1 parameter which represents the token you want checked for eligibility (to be used by this contract).

In the function, we use the ToucanContractRegistry (a contract that knows all TCO2 contracts) to check if the given token is a TCO2.

Then we check if the token address matches the BaseCarbonTonne address.

If either of these are true, the method returns true signifying that the token is eligible.

Otherwise, we return false.

## deposit()

```solidity
using SafeERC20 for IERC20;

// user => (token => amount)
mapping(address => mapping(address => uint256)) public balances;

// @description deposit tokens from use to this contract
// @param _erc20Address token to be deposited
// @param _amount amount to be deposited
function deposit(address _erc20Address, uint256 _amount) public {
// update footprint to account for this function and its transactions
addFootprint(2);

bool eligibility = checkTokenEligibility(_erc20Address);
require(eligibility, "Can't deposit this token");

// use token's contract to do a safe transfer from the user to this contract
// remember that the user has to approve this in the frontend
IERC20(_erc20Address).safeTransferFrom(msg.sender, address(this), _amount);

// add amount of said token to balance of this user in this contract
balances[msg.sender][_erc20Address] += _amount;

emit Deposited(msg.sender, _erc20Address, _amount);
}
```

In this section of the code, we have a nested mapping used to hold a balance sheet of each user's token balance within this contract.

Simpler terms? Each user (the first address) has a mapping of the token address and the amount he holds in this pool.

You can access it like `balances[user_address][token_address]` and it would return the amount of [insert token] that [insert user] has within this contract.

Next up, the deposit function. This is used so that you, as a user, can deposit tokens to this pool. As params it takes the address of the token you want to deposit and the amount you want deposited.

Let's see how it does that.

We first update the footprint (knowing that this method will have 2 transactions).

We check the eligibility of the token (we discussed how this works above).

And we do a `safeTransferFrom()`. This is a method from the `SafeERC20.sol` contract and it takes in as parameters a from address, a to address and a uint256 representing the value to transfer.

**VERY IMPORTANT!** You should know that for the safeTransferFrom method to work, you need to approve this contract to use your token on the frontend. This is how it could look on the frontend (JS):

```javascript
await (
  await tokenContract.approve(cop.address, ethers.utils.parseEther(amount))
).wait();
```

`tokenContract` being the contract of the token you want to deposit, `cop` being the Contract Offsetter POC, and the `amount` is the amount you want to approve.

Another thing that should be of note is that, in the very beggining I had this line `using SafeERC20 for IERC20;` which I didn't yet explain. This (and importing the contract) is what gives us the safeTransferFrom method.

_Side note_: I'll talk about all the imported contracts later. Don't worry yet.

Once the transfer happens, we update the balance sheet of this contract in this line `balances[msg.sender][_erc20Address] += _amount;` and we emit an event. (I'll also walk through the events later)

## redeemBCT()

```solidity
// @description redeems some BCT from contract balance for a chosen TCO2 token
// @param _desiredTCO2 the address of the TCO2 you want to receive
// @param _amount the amount of BCT you want to redeem for TCO2
function redeemBCT(address _desiredTCO2, uint256 _amount) public {
  // update footprint to account for this function and its transactions
  addFootprint(3);

  require(
    _amount <= balances[msg.sender][bctAddress],
    "You don't have enough BCT in this contract."
  );

  bool eligibility = checkTokenEligibility(_desiredTCO2);
  require(eligibility, "Can't redeem BCT for this token.");

  // prepare/format params for BCT.retireMany() method
  address[] memory tco2Addresses = new address[](1);
  uint256[] memory amounts = new uint256[](1);
  tco2Addresses[0] = _desiredTCO2;
  amounts[0] = _amount;

  // send BCT, receive TCO2
  BaseCarbonTonne(bctAddress).redeemMany(tco2Addresses, amounts);

  // modify balance sheets of this contract
  balances[msg.sender][bctAddress] -= _amount;
  balances[msg.sender][_desiredTCO2] += _amount;

  emit Redeemed(msg.sender, _desiredTCO2, _amount);
}
```

This method is supposed to take the BCT you deposited (an amount of your choice), burn it and give you back (in the contract's balance sheet) TCO2 tokens.

That's called redeeming BCT for TCO2. I think my colleagues at Toucan do a good job of explaining how all the process [here](https://docs.toucan.earth/protocol/pool/pools).

Back to the method, it takes in the address of the TCO2 you want to receive & the amount of BCT you want to redeem as parameters.

Half of this method you'll already understand if you read the rest of the article with attention. You know what `addFootprint()` does, you know how checking token eligibility works and the line requiring that the user has enough BCT in this contract is pretty self explanatory (the person has to deposit BCT first, in order to redeem it).

So, let's explain what's new.

This method takes the parameters and formats them in arrays so they may be passed on to the `redeemMany()` method of the BaseCarbonTonne contract.

We call the `redeemMany()` method to redeem your deposited BCT for the TCO2 of your choice.

_Side note_: Technically, you could adapt `redeemBCT()` of the `ContractOffsetterPOC` contract to be able to redeem BCT for multiple TCO2s types at the same time.

Lastly we update the balance sheet and emit an event.

## selfOffset()

```solidity
// @description retire TCO2 so that you offset ALL the carbon used by this contract
// @param _tco2Address address of the TCO2 you want to retire
function selfOffset(address _tco2Address) public {
  // update footprint to account for this function and its transactions
  addFootprint(2);

  bool eligibility = checkTokenEligibility(_tco2Address);
  require(eligibility, "Can't retire this token.");

  require(
    footprints[msg.sender] <= balances[msg.sender][_tco2Address],
    "You don't have enough of this TCO2 (in the contract)."
  );

  // use the TCO contract to retire TCO2
  ToucanCarbonOffsets(_tco2Address).retire(footprints[msg.sender]);

  // reduce amount of TCO2 in the balance sheet
  balances[msg.sender][_tco2Address] -= footprints[msg.sender];

  uint256 amountOffset = footprints[msg.sender];

  // reset the footprint
  footprints[msg.sender] = 0;

  emit Offset(msg.sender, _tco2Address, amountOffset, footprints[msg.sender]);
}

// @description retire TCO2 so that you offset a certain amount of the carbon used by this contract
// @param _tco2Address address of the TCO2 you want to retire
// @param _amount how much CO2 you want to offset
function selfOffset(address _tco2Address, uint256 _amount) public {
  // update footprint to account for this function and its transactions
  addFootprint(2);

  bool eligibility = checkTokenEligibility(_tco2Address);
  require(eligibility, "Can't retire this token.");

  require(
    _amount <= balances[msg.sender][_tco2Address],
    "You don't have enough of this TCO2 (in the contract)."
  );

  require(
    _amount <= footprints[msg.sender],
    "You can't offset more than your footprint."
  );

  // use the TCO contract to retire TCO2
  ToucanCarbonOffsets(_tco2Address).retire(_amount);

  // reduce amount of TCO2 in the balance sheet
  balances[msg.sender][_tco2Address] -= _amount;

  // reduce the footprint
  footprints[msg.sender] -= _amount;

  emit Offset(msg.sender, _tco2Address, _amount, footprints[msg.sender]);
}
```

The `selfOffset()` method is made to use the `retire()` method of the `ToucanCarbonOffsets` so that it burns TCO2 tokens which equates to offseting CO2 emmissions.

Now, you are seeing 2 methods here because we want the `selfOffset()` to be able to do 2 things:

1. if you only provide a tco2 address and no amount, it will attempt to offset the whole footprint.
2. if you do provide an amount, it will attempt to offset the amount of your choice instead.

Both add to the footprint initially (to account for the footprint you generate when you do these transactions), then they check token eligibility and other basic things like the user having enough TCO2 on the balance sheet or the user not attempting to offset more than his footprint.

Once the checks are passed, the method retires the TCO2 chosen by the user, changes the balance sheet AND resets the footprint.

## imports

These right here are all the contracts used, one way or another, in the making of this contract.

```solidity
import "hardhat/console.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "./CO2KEN_contracts/ToucanCarbonOffsets.sol";
import "./CO2KEN_contracts/pools/BaseCarbonTonne.sol";
import "./CO2KEN_contracts/IToucanContractRegistry.sol";
```

## events

And, to finish up, these are the events.

```solidity

  event Deposited(
    address depositor,
    address erc20Address,
    uint256 amountDeposited
  );
  event Redeemed(
    address redeemer,
    address receivedTCO2,
    uint256 amountRedeemed
  );
  event Offset(
    address offsetter,
    address retiredTCO2,
    uint256 amountOffset,
    uint256 remainingFootprint
  );
```

# Conclusion

This is about how it all works.

You can interact with this contract to offset your use of it. You can re-use the code from it in your own contracts, or, even, extend your contracts with this one to help you offset them.

As I mentioned in the beginning, I will make a contract + dapp (and an article) that will make it amazingly easy for you to offset other (your) contracts or even the footprint of your wallet.

What you see here is more of a proof of concept than a fully perfect solution.



A while ago I wanted to contribute to [Toucan.earth](https://toucan.earth) in a hope that my contribution will show enough skill to get me [a full-time position](/posts/why-i-quit-freelancing).

The team thought it would be cool if I built a discord bot that rewards users with our own "Praise Token". They also pointed me to [Collab.land](https://collab.land)

## What is Collab.land?

Collab.land is a bot that you can hook up to your discord channel, it requests the users to connect their crypto wallet then, based on the admin's config, it assigns roles based on the user's balance of the currency/token of your choice.

This means that you can make collab.land give admin roles to anyone that has over 10 ETH or you can have it give access to a private channel in the server to anyone that has over 100 of a token made by _you_.

So I got to making my first token. And I used ERC20 as a base.

## What is ERC20? 🪙

I'm assuming you are a programmer.

So, you know that if you code a Class you can have your Class extend another Class. This way it inherits all the properties and methods of the parent Class.

Well, every token you see out there is a smart contract which essentially is a Class. And a LOT of them extend [ERC20](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol).

Including, but not limited to:

- LINK
- USDT
- SHIB
- and the token I've made

Why do this? For the same reason we extend classes in normal programming. To not reinvent the wheel.

## I did have to customise my token a bit 🧙🏻‍♂️

The contract for the [token I have created](https://github.com/lazaralex98/toucan-discord-praise-bot/blob/main/protocol/contracts/ToucanPraiseToken.sol) is largely quite simple. This token's name is TPT (Toucan Praise Token).

And, we can see the code right here:

```solidity
//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract ToucanPraiseToken is ERC20 {
    uint public constant _INITIAL_SUPPLY = 30 * (10**18);
    constructor() ERC20("ToucanPraiseToken", "TPT") {
        _mint(msg.sender, _INITIAL_SUPPLY);
    }

    /**
    * @param _from the address that praises
    * @param _to the address to praise
    * @return true upon success
    *
    * Mints & sends praiseTokens to an address based on the senders balance
    */
    function praise(address _from, address _to) public returns (bool) {
        /**
         * Just making sure ppl can't praise themselves.
         */
        require(_from != _to, "Can't praise yourself");

        /**
        * It's important to think of your praiseToken balance as your reputation.
        */
        uint256 reputation = balanceOf(_from);

        /**
        * This makes the praise have a worth based on who praised.
        * If someone more reputable praises, then the praise will be worth more.
        * But I have also implement a minimum praiseWorth of 1 in case the person that praises has 0 balance.
        */
        uint256 praiseWorth;
        if (reputation < (10 * (10**18))) {
            praiseWorth = 1 * (10**18);
        } else {
            praiseWorth = reputation / 10;
        }


        /**
        * We make sure the person that praises doesn't lose any reputation.
        * Minting more, also lowers the value of each individual token, adding an element similar to 'decaying'
        */
        _mint(_to, praiseWorth);

        // TODO emit an event
        return true;
    }
}
```

I'd like to think that I made a pretty good job of commenting the code (and you also have [the GitHub link where you actually have colored code](https://github.com/lazaralex98/toucan-discord-praise-bot/blob/main/protocol/contracts/ToucanPraiseToken.sol)).

But, the basic idea of what is happening is: I have a token that has one extra custom method.

This method is named `praise()`. It takes 2 parameters (the address that praises and the address that is praised).

Side note: In crypto, your address is like your ID number or your IBAN. It looks like this `0x721F6f7A29b99CbdE1F18C4AA7D7AEb31eb2923B`.

The `praise()` method mints new TPT tokens based on how many the praiser has in his balance and sends them to the praise target.

I [deployed the token with Alchemy and Hardhat](https://docs.alchemy.com/alchemy/tutorials/deploy-your-own-erc20-token) on the Rinkeby Test Network, and that was that.

Now I had to dive deep into discord.js to actually build the discord bot that would call that `praise()` method.

## Building a Discord Bot 101 🤖

You can actually see [the code for the bot in its final form right here](https://github.com/lazaralex98/toucan-discord-praise-bot/tree/main/bot).

I'll explain the basics of building a discord bot, but not every nook and cranny of my bot. This way, you should be able to organize the code as you wish and create the commands you wish to have.

You first need to go the [Discord Dev Portal](https://discord.com/developers/applications). You click on "New Application", give it a name and BAM.

You have a bot. Kinda. There's still a lot to do...

If you go to the Bot tab, you'll see a "Copy" and a "Regenerate" button.

![Discord Bot Token](/discord-bot-token.png)

The "Copy" button will give you your a token which you will use in your code to actually do stuff.

Now you need to invite your bot to your server. I suggest you make a test server first to play with your bot before you deploy it live.

You got to the OAuth2 > URL Generator tab. In the "scopes" area you check "bot" and then you have all these options:

![Discord Bot Permissions](/discord-bot-permissions.png)

Pick the ones that make sense for your bot (depends on what you want the bot to do), but 2 you will most likely need are:

- Read Messages/View Channels
- Send Messages

This will give you a URL that you can use to authorise the bot on your server.

## Now, we can finally start coding this bot 👨🏻‍💻

The one library you will need is [Discord.js](https://discord.js.org/) (or the equivalent for your programming language).

This is the most basic bot you could probably make:

```javascript
const Discord = require("discord.js");
const client = new Discord.Client();
require("dotenv").config();

client.on("ready", () => {
  console.log(`Logged in as ${client.user.tag}!`);
});

client.on("message", (msg) => {
  if (msg.content === "Hey bot") {
    msg.reply("Hey friend!");
  }
});

client.login(process.env.TOKEN);
```

It just replies with "Hey friend!" whenever someone says "Hey bot".

Every "client.on()" is an event listener that you can use to have your bot run code.

Another library you probably want to use is [discord-command-parser](https://openbase.com/js/discord-command-parser/documentation).

It helps you parse commands like "!help". This is a basic example:

```javascript
import { parse, ParsedMessage } from "discord-command-parser";
const Discord = require("discord.js");
const client = new Discord.Client();
require("dotenv").config();

const PREFIX = "!";

client.on("ready", () => {
  console.log(`Logged in as ${client.user.tag}!`);
});

client.on("message", (msg) => {
  const parsed = parse(msg, PREFIX);
  if (!parsed.success) return;

  if (parsed.command === "help") {
    msg.reply("I'm here to help");
  }
});

client.login(process.env.TOKEN);
```

But you could use it to parse a more complex command like `!praise @Alex for making this bot` (which is [exactly what I did](https://github.com/lazaralex98/toucan-discord-praise-bot/blob/main/bot/src/commandHandlers/handlePraiseCommand.ts)).

You'll have to dive into the DOCS, but you can write code where the bot will take this message, understand it's a praise command, extract the praise target (@Alex) and understand the praise reason (for making this bot).

## The first real issue I ran into 💣

After I've coded the bot such that it's able to understand when a praise is happening I had to code the smart contract interaction where the bot would call the praise() method we talked about earlier.

There is a problem though. I thought that after someone connects their wallet to Collab.land I can share their address from that to my bot so I know where to mint & transfer the new tokens upon a praise.

Nope...

After consulting with the guys at Toucan.earth I've decided to simply do away with Collab.land and create [my own auth & wallet connection system](https://github.com/lazaralex98/toucan-discord-praise-bot/tree/main/client).

It's not a very complex thing. It's a Next.js app that uses [Supabase](https://supabase.com/docs) to offer Discord-based authentication.

Then I use [ethers.js](https://docs.ethers.io/v5/) to connect to the users wallet and I save the discord_id - wallet_address connection in a Supabase dB table called "discordToWalletConnections" with the following schema:

![Discord To Wallet Connections Schema](/discordToWalletConnectionSchema.png)

It's all deployed on Vercel.

Side note: [I really like TypeScript + Next.js + Vercel + Supabase](https://www.youtube.com/watch?v=TW6llXub8h4). It makes so many things so easy, especially compared to my days of coding in plain PHP. But you could have used anything else.

## With authentication out of the way

The idea is that people will use the !help or the !connect commands in the discord chat, which will have the bot direct them to [my auth system](https://toucan-discord-praise-bot.vercel.app/).

There they will connect their discord and their wallet, and now my bot can use the Supabase client to access these connections.

Obviously there is a lot of error handling implemented, like:

- you can't praise yourself
- you can't praise if either you or the target haven't connected your wallets/discords
- you haven't used the correct format for the command
- any unexpected errors when querying Supabase, using Discord.js

Side note: Obviously all this is easier said then done as seen by some of my commit messages which include "FML", "x" and even some reverted commits. 😅

But if everything is fine the bot will attempt to call the `praise()` method from the smart contract.

## My second big issue...

... happened when trying to implement [the smart contract interaction](https://github.com/lazaralex98/toucan-discord-praise-bot/blob/main/bot/src/utils/callPraise.ts).

You can take a look at the link above, or here:

```javascript
import { Message, User } from "discord.js";
import { ethers } from "ethers";
import discordToWalletConnection from "./ifcDiscordtoWalletConnection";
import * as artifact from "../utils/ToucanPraiseToken.json";
require("dotenv").config();

/**
 * @param msg will be used for the success console.log
 * @param target will be used for the success console.log
 * @param praiserWalletConnection will be used for the address of the praiser
 * @param praiseTargetWalletConnection will be used for the address of the praiseTarget
 * @returns the praiseTxn object (which should have a status === 1 if successful), or null if some error happened
 */
const callPraise = async (
  msg: Message,
  target: User,
  praiserWalletConnection: discordToWalletConnection,
  praiseTargetWalletConnection: discordToWalletConnection
) => {
  try {
    const provider = new ethers.providers.JsonRpcProvider(
      process.env.INFURA_RINKEBY_URL,
      4
    );
    let wallet = new ethers.Wallet(
      process.env.RINKEBY_PRIVATE_KEY || "",
      provider
    );
    const signer = provider.getSigner(process.env.OWNER_ADDRESS_RINKEBY);
    wallet = wallet.connect(provider);

    const tptContract = new ethers.Contract(
      process.env.RINKEBY_CONTRACT_ADDRESS || "",
      artifact.abi,
      wallet
    );

    const praiserAddress = praiserWalletConnection.wallet_address;
    const praiseTargetAddress = praiseTargetWalletConnection.wallet_address;
    const praiseTxn = await tptContract.praise(
      praiserAddress,
      praiseTargetAddress,
      {
        value: ethers.utils.parseEther("0"),
        gasLimit: 300000,
      }
    );
    console.log(
      `Sending praise (${msg.author.id} to ${target.id})(these are discord IDs) with transaction hash:`,
      praiseTxn.hash
    );
    return await praiseTxn.wait();
  } catch (error) {
    console.error(`Error interacting with the contract, callPraise():`, error);
    return null;
  }
};

export default callPraise;
```

In it's final form the function uses a JsonRpcProvider with an [Infura](https://infura.io) endpoint.

You see, I was used to interacting with smart contracts on the frontend with ethers which is fairly straight forward.

I never have interacted with a smart contract on the backend before. But after thoroughly reading the [ethers.js documentation](https://docs.ethers.io/v5/), googling around for other people that had similar issues and, just generally, banging my head on the wall...

I figured out how to actually implement a JsonRpcProvider with Infura and interact with the smart contract on the backend.

In hindsight, it's not that complex tbh. 🤷🏻‍♂️

## Where we are at today

After all this (again, easier said than done 😂) I had a real bot with a real token where you could connect your wallet, call "!praise @alex for building this bot" and the target would receive some freshly-minted TPT (Toucan Praise Token).

BTW: I have deployed the bot on [Heroku](https://heroku.com).

I have created my very first, actually used in production (soon), crypto token 🤯😱.

What's next?

Well, the app is well tested and we're soon to deploy it on Polygon for the whole server to actually use which is going to be nice.

Among a bunch of small TODOs (which you can find in the codebase), one bigger thing I'd like to do is have the Discord bot reward people with nicknames, roles or access to private channels based on their TPT balance.

But, we'll see.

The very good thing for me is that the guys at Toucan really liked what I did and I have a call with them tomorrow to discuss a full-time position.

Sooo, the goal I set [here](/posts/why-i-quit-freelancing) might have come to fruition by the time you read this article.

Yay! 🎉



Check it out [here](https://css-tricks.com/fixed-background-effect/).



Before we dive in the discussion, fun fact, see that bridge in the image on the right? It's in my college town.

It's much longer than it seems in the image. Wind makes it dwindle and I've only crossed it once because I'm genuinely afraid of heights.

Back to the topic, the software engineering field is an amazing [field to be in](https://www.bls.gov/ooh/computer-and-information-technology/software-developers.htm).

The demand for good engineers is high and going up. The average income is high, the unemployment is low, you can work remote, you can freelance/contract.

Also, it’s a field that allows for a lot of pivoting either within it (full-stack to frontend) or to other engineering fields (sysadmin, network, cybersecurity, web3).

But, one thing I questioned once was...

> What if we were in an economical crisis?

There hasn't been any data looking at software engineers (avg income, unemployment) in a real crisis. I'm talking the bad kind, not like 2008.

I'm thinking something like the 1930s depression era.

We can't see how **software** engineers would fare in such a crisis, but we can see how engineers in general have done in that era.

## Life as an engineer in the Great Depression

I have aggregated data from quite a few places (including a book!) and this blog post has lived in my iCloud notes for a while now, so you will have to take my word with these numbers. Sorry 🤷🏻‍♂️.

Anyways...

In 1929 to 1934 (worst of the depression), engineer unemployment was at most 10,1%. Whereas the general average unemployment reached a peak of 24,9% at one point.

So, if you were an engineer you were doing observably better than the average person from this regard.

Also, I'm sure at least some of that 10,1% were unemployed by choice.

The ones that weren't unemployed by choice, I'm willing to assume that at least some of them weren't that greatly skilled to begin with.

My point? **If you were good at your skill & willing to work, you'd likely have kept your job or found another.**

Let's talk about average income as well:

The average yearly income in the 1930s was $1.368, whereas an average engineer with 2 years of experience would earn around an average of $2.000 per year.

Adjusted to official inflation, that today would have been [$22.235](https://www.in2013dollars.com/us/inflation/1929?amount=1368) and [$32.508](https://www.in2013dollars.com/us/inflation/1929?amount=2000) respectively.

Side note: I urge you to [reconsider the validity of official inflation numbers](https://inflationchart.com/spx-in-m3).

## My conclusion?

Even in a major economical crisis, if you are an engineer you will be ok. Even more so if you are a software engineer, I recon.

If you are in tech, you are in an amazing position. You will likely always have a good income so long as you are willing to work.



I've been wanting to make a case study of this website for a while now.

It's, I believe, a good piece of proof that I can handle decently large production projects.

And when I say large I mean high six figures in revenue and about 1,400 people actively using the membership side of the website.

## Short Recap of the project

Generally, I believe my client's words are worth more than mine regarding our work together, so [here's a link to Stirling's video testimonial + my recap of the project](https://youtu.be/OpHEtX50HHc).

That said, if you prefer reading, here's the cliffnotes:

- We started working in December 2020, launched the brochure + membership site successfuly in January 2021
- I was a bit under time pressure since Stirling pre-sold his course that needed the website's membership area to be delivered to users
- We kept on building on the website throughout the year (admin dashboard which allowed Stirling to add/remove users, functionality to host more than 1 course)
- I've built this with PHP on a Linode VPS, altough now I've transitioned to Typescript and Next.js as my favorite stack
- I was supposed to build Stirling's new site, but I quit freelancing since I'm transitioning to a new field

Why did I quit freelancing? [Read here](https://alexlazar.dev/posts/why-i-quit-freelancing).

## What have I learned from this website?

Over the 1 year I've worked on this website, I have learnt 2 major things.

1. Stick to a framework (welcome Next.js 🥰)
2. Whenever time allows, implement testing

It's unfortunate that we've had a few situations where I've deployed with bugs solely because I was inexperienced and didn't know anything about TDD.

Stirling was super understanding and I evidently worked overtime to fix it all.

I remember at one point, when we were adding functionality to host more than 1 course, I went to sleep only to wake up at midnight to a bug report and fix it, half asleep, in 1 hour 🤯😂.

Needless to say, that was very stressful for me.

That's why now, especially since I'm making the transition to the crypto world where bugs can result in BIG money losses, I want to focus more on testing.

## About Stirling

He doesn't know I'm writing this & I'm not sure if he will ever read this, but I wanted to dedicate a section to him.

He is an amazing client. Super easy to work with, always has his copy & assets ready before I even need them, pays on time, knows what he wants and listens to expert advice.

I'll be honest, he's my best client yet. If I had 5 guys like him, I might not be [quitting freelancing](https://alexlazar.dev/posts/why-i-quit-freelancing) 😂.

To whomever works with him, if you do a good job and are serious about your work, I'm sure you'll find yourself very happy to have him as a client.

P.S.: He already has a new web developer so don't try that angle 😂

P.P.S.: While you're here, check out some of [my other articles](https://alexlazar.dev) or, even, check out [my YouTube channel](https://www.youtube.com/channel/UCBTlMP2ODwm0_Apy4wMoy5g).



## I made almost $20k this year and I'm quitting 🤯

If you've read [this article](https://alexlazar.dev/posts/about-me) you already know a bit about how I got here and you know that I made almost $20k in 2021 freelancing as a web developer.

Which is shit if you live in New York, but it's pretty cool if you are a 24y old in Romania were the average person earns like $12k.

_Yes, I know on paper Romania's average income is $5,7k but that's just wrong. A lot of people in this country do not report their income or pay taxes._

There's a few caveats though:

1. I spent some of that $20k on business stuff (a new macbook, programming courses, software, referral commissions, etc)
2. I didn't work full time. I had about 3 months where I didn't actually get ANY paid work.

That said, it was a pretty good year, and I had good prospects/leads for next year.

So...

## Why did I choose to quit freelancing? 🧐

There's a few reasons. Let's recap them at first, and then dive into each of them.

- There are higher paid fields than web, like crypto & web3;
- It's a grind to find new clients and negociate rates with them;
- It kinda gets boring to build the same landing pages & blogs time and time again.

## I can make more in web3 💸

Probably the first reason to quit freelancing is that I could earn more as a software engineer in the crypto/web3 field.

And it's very important to note that, unlike web development, the crypto field has more opportunities for employees or long-term contractors than for freelancers.

According to [CryptoCurrencyJobs a Solidity dev earns $80k a year on the low end](https://cryptocurrencyjobs.co/salaries/solidity-developer/).

Isn't that great?

The reality is, even if I'd work full time as a web dev freelancer, I'd probably still fall short of that. Unless I'd hire people and scale, but then you have the issue of finding enough work to keep them all busy.

Marketing & sales **IS NOT EASY**...

## Finding clients & negociating deals is a grind, especially when...

Especially when you also need to fulfill the work.

It's far easier to do one or two things within your business than to handle: web design, frontend development, backend development, deployment, sales, marketing, lead generation, creating content, etc.

By getting a job, I can focus on far fewer things and it makes my life easier & less stressful.

## I'm bored 🥱

Web3 problems are novel to me. Therefore, more interesting than building a landing page or blog or eCom store.

These are things that I have done already quite a few times and it really does get boring.

## Drawbacks?

Freelancing obviously gives me the most freedom & flexibility in terms of how much I work, when I work, how I work, etc.

A job can be more restrictive, but it's not necessarily that way.

In fact, in the world of crypto where most companies are DAOs (decentralised autonomous organisations) there's a lot of freedom.

It's a bit like the wild west. They don't ask for a college degree, they don't require you to be available 9-5 within a certain timezone and there is little bureaucracy.

So long as you get your work done, you're more or less good in most crypto companies.

Which means there isn't that much of a freedom drawback IF I stick to crypto/web3 companies.

Which is what I intend to do.

## Conclusion?

More money, more stability, funner challenges and similar freedom.

In theory it sounds great, right?

That's why I'm giving it a shot. I'm in the middle of learning & building a web3 portfolio and DMing companies.

There is, of course, a chance I might not like working as an employee in a DAO and I end up coming back to freelancing. That's fine, I still feel I need to take this shot.

**Fun fact:** I am actually DMing these guys. The primary means of communication in the crypto world is Discord. No email or anything corporate.

P.S.: Check out [my first ever smart contract right here](https://github.com/lazaralex98/voting-contract).



## My first PC 👨🏻‍💻

I remember having my first PC when I was 5 and the internet when I was 7. This was back in the early 2000s in Romania when most people didn't yet have a PC nor an internet connection.

(Thanks mom & dad!)

While I was primarily using it only to entertain myself or my friends, I believe that becoming 'computer literate' is the first prerequisite towards becoming a software engineer.

Having a PC & an internet connection was also the start of me learning English. Which is also a major part of me being where I am at today.

## My first encounter with computer programming

I remember first coding back in 7th grade in school. Our IT professor was supposed to teach us a bit of PASCAL, among other IT skills like Excel and whatnot.

I had an inclination for it and was first in my class at it. It was super fun to create logical sequences of if/else statements which would make the terminal do what I wanted it to do.

What happened though is my family, which was pretty wealthy **at the time**, pulled me out of school for a few weeks so we could go on a ❄️ winter vacation.

We went to Dubai ✈️ for a week and then we visited a few ⛰ mountainous cities/towns in north Romania.

_As a side note, I was as priviliged & spoiled as you could be in Romania at the time. Altough my parents were very strict regarding my school grades, I was given everything I wanted._

The point is, by the time I got back to school, the class was so far ahead on PASCAL that I couldn't catch up to them.

My little flame of interest towards programming estinguished and I took up boxing.

## Years passed, the wealth was lost & I had to figure something out

Over the years my father was imprisoned, my family lost a big chunk of its wealth and I found myself in my early twenties not knowing what to do next.

I was 'groomed' to inherit and take over the familiy businessess, but these businessess did not exist anymore.

So, I had to set out & blaze my own path.

I've wandered a bit. A few things happened:

- a car crash where I caused the death of a person (it's a hard topic for me still and it's also what got me on probation)
- I quit boxing for the most part
- many drunken parties & a lot of wasted time
- a short stay in the UK where I hoped I would find better opportunities
- a layman job in construction job under my father's company (what was left of it)

Eventually, in October 2019, I happened upon my now good friend [Abuamerican](https://twitter.com/abuamerican). We were strangers, he mentioned on Twitter that he needed a website & I emailed him saying I could do it for him.

I didn't know much besides being able to set up a basic WordPress website. But I figured that was still better then the broken Wix website he used to have at the time.

And that's how I got into web development...

## Being a web freelancer 🤑

At this point, I figured that for the first time in my life I'm onto something. I had the hope that I might be able to build a business of my own.

So, I started doing 2 things:

1. I learned more about building websites
2. I emailed more people to offer my services

In my first 12 months I made like $2-3k. Which is kinda shit, but I saw progress so I stuck with it.

_It's important to note that, even with my family being far poorer, I still didn't have to worry about rent, utilities or food. For the most part, I could spend most of my money on my desires._

In my second year I made somewhere around $20k, but I also learned a ton from a technical aspect.

It's also of note that I never really worked full time... at least not for long periods.

Whereas at the beginning of my career I was a WordPress 'developer' after 1 year I was building custom web apps with plain PHP. And by now, December 2021, I have already graduated to Next.js, testing and Github 🤯.

I can only now honestly call myself a real software engineer to be honest.

## What's next?

I'm learning Solidity and web3 and I'm looking to break into this industry and have my first real job. 👨🏻‍💼

Wish me luck! 🍀



I've put in a good 3 days into building this .md file based blog, and I actually really like it.

I'm too spent to write anything right now though.

But... **hello world**, welcome to my blog.

Cheers!

P.S.: I actually still need to integrate ConvertKit in that newsletter form you see, but whatever. Aaaand I need to deploy to my domain which I'm having transfer issues with 😅🤯


I'm Alex