They've raised $15M in funding rounds and are backed by top VCs like @BinanceLabs. Additionally, 10% of the supply is allocated to the community.

This is the continuation of the Twitter post.

I believe you have already downloaded the Terminus app or software, and your VPS is ready.

Open the Terminus app or software and click on "new host". Paste the IP address you obtained from pq hosting in the “IP or Hostname“ box, then enter "root" as the username. Use the password you set in the PQ hosting dashboard when you were getting your VPS.

If you're confused about your VPS password, navigate to your dashboard and click on the three dots next to the purchased VPS. Then, select "to panel."

You will be taken to the next page. Once there, click on the three dots and select "Change password." This will allow you to change your VPS password.

Once you are connected to your VPS, you will see something similar to this on your screen.

Now, 50% of the work is completed, All you need to do is paste each command individually, and your node will be operational.

First, let install docker using following command.

# Update APT package index
sudo apt update

# Install Docker
sudo apt install -y docker-ce

You can verify if docker is installed or not by:

sudo docker --version

You will see output similar to the following, Docker version 27.5.1, build 9f9e405. This indicates that the installation was successful.

Now, start and enable docker service in your VPS using following command:

sudo systemctl start docker 
sudo systemctl enable docker

Now, After this paste this code:

docker pull privasea/acceleration-node-beta:latest

Let’s create directory and navigate to it now:

mkdir -p ~/privasea/config && cd ~/privasea

Then run the following command and the program will prompt you to enter a password, please remember this password for future use.

docker run --rm -it -v "$HOME/privasea/config:/app/config" privasea/acceleration-node-beta:latest ./node-calc new_keystore

Now, we need to move keystore file to a new file.

mv $HOME/privasea/config/UTC--* $HOME/privasea/config/wallet_keystore

Then simply go over here and connect your wallet and click on “set one up now!”

Once you reach to next page, enter your unique name, set commission as 1% and enter your node address that we got in last step and told you to save somewhere safe.

READ THIS CAREFULLY: In the command below, replace "YOUR_KEYSTONE_PASSWORD" with the password you set earlier.

docker run -d --name privanetix-node -v "$HOME/privasea/config:/app/config" -e KEYSTORE_PASSWORD=YOUR_KEYSTONE_PASSWORD privasea/acceleration-node-beta:latest

That's it. Our node setup is complete, and your node will start running.

After a moment, your status will change from "Offline" to "Online."

Once your node status is online, you can stake your $TPRAI by going here.

Note: You can get 1 $TPRAI from the faucet by clicking on “Privasea DeepSea Beta faucet” in the top right.

If you’re not seeing $TPRAI in your wallet, add it to your wallet using this CA:

If you're receiving a "stake failed" error, set the gas fee as indicated below, and it should succeed.

Keep your node running and you will be able to claim rewards once in a while.

That’s all for now!

Since it’s on the testnet, they’re testing various things. Yesterday, a huge gas spike caused many of us to lose BRN in gas fees.

Don’t worry, they’ll compensate us for the lost BRN. They also have an update we need to install on our VPS to run the node perfectly.

To access your VPS, enter the VPS screen. Press “CTRL + C” if your node is running to stop it.

You will find yourself in the “executor/executor/bin” directory. We need to navigate to the home directory to begin.

To go to the home directory, use the following command; remember, you only need to copy and paste the commands.

cd ../../..

Now that you’re in the home directory let’s remove the outdated folder from our VPS by using the command below:

rm -r executor

Again, following immediately with this command.

rm -r executor-linux-v0.27.0.tar.gz

Now that both outdated folders have been removed let’s install the new version using the command below.

wget https://github.com/t3rn/executor-release/releases/download/v0.28.0/executor-linux-v0.28.0.tar.gz

Then copy and paste this command to unzip the folder:

tar -xvzf executor-linux-v0.28.0.tar.gz

Followed by:

cd executor/executor/bin

Just like this.

Next, copy and paste the following:

export NODE_ENV=testnet

Immediately followed by (Copy the two codes below at once and paste):

export LOG_LEVEL=debug

export LOG_PRETTY=false

Immediately followed by (Copy the two codes below at once and paste):

export EXECUTOR_PROCESS_ORDERS=true

export EXECUTOR_PROCESS_CLAIMS=true

Then immediately followed by:

export EXECUTOR_MAX_L3_GAS_PRICE=50

This command, introduced in the latest guide, sets a GWEI limit to prevent issues with our node during gas price spikes.

Just like this.

Now, read this carefully, obtain the private key of the wallet you wish to use, or have testnet funds in any wallet you have been using, such as metamask.

Now you see the code below; see where it says =YOUR_PRIVATE_KEY your private key should be what is there, so remove that YOUR_PRIVATE_KEY and put your private key there before you paste the code into your VPS

export PRIVATE_KEY_LOCAL=YOUR_PRIVATE_KEY

After you have done that, copy and paste the following:

export ENABLED_NETWORKS='arbitrum-sepolia,base-sepolia,optimism-sepolia,l1rn'

Immediately followed by:

export EXECUTOR_PROCESS_PENDING_ORDERS_FROM_API=false

And finally,

./executor

Your NODE is running perfectly.

Press CTRL + A + D together as usual to exit your screen.

That will be all for now.

We will elevate our efforts by running the node to earn $BRN directly.

This is the continuation of the Twitter post.

I believe you have already downloaded the Terminus app or software, as well as your VPS is ready.

open the Terminus app or software and click on "new host". Paste the IP address you obtained from pq hosting in the “IP or Hostname“ box, then enter "root" as the username. Use the password you set in the PQ hosting dashboard when you were getting your VPS.

If you're confused about your VPS password, navigate to your dashboard and click on the three dots next to the purchased VPS. Then, select "to panel."

You will be taken to the next page. Once there, click on the three dots and select "Change password." This will allow you to change your VPS password.

Once you are connected to your VPS, you will see something similar to this on your screen.

Now, 50% of the work is completed, All you need to do is paste each command individually, and your node will be operational.

So, copy the following codes (The three of them at once) and paste them into your VPS:

sudo apt update

sudo apt install build-essential

sudo apt install git -y

Once it has finished running, you will see something similar to root@t3rn: It indicates that the next command can now be pasted. So, copy and paste:

sudo apt install screen

Immediately followed by:

screen -S t3rn

So, now copy and paste:

wget https://github.com/t3rn/executor-release/releases/download/v0.27.0/executor-linux-v0.27.0.tar.gz

So, copy and paste:

tar -xvzf executor-linux-v0.27.0.tar.gz

Followed by:

cd executor/executor/bin

Next, copy and paste the following:

export NODE_ENV=testnet

Immediately followed by (Copy the two codes below at once and paste):

export LOG_LEVEL=debug

export LOG_PRETTY=false

Immediately followed by (Copy the two codes below at once and paste):

export EXECUTOR_PROCESS_ORDERS=true

export EXECUTOR_PROCESS_CLAIMS=true

Now, read this carefully, obtain the private key of the wallet you wish to use, or have testnet funds in any wallet you have been using, such as metamask.

Now you see the code below; see where it says =YOUR_PRIVATE_KEY your private key should be what is there, so remove that YOUR_PRIVATE_KEY and put your private key there before you paste the code into your VPS

export PRIVATE_KEY_LOCAL=YOUR_PRIVATE_KEY

After you have done that, copy and paste the following:

export ENABLED_NETWORKS='arbitrum-sepolia,base-sepolia,optimism-sepolia,l1rn'

Immediately followed by:

export EXECUTOR_PROCESS_PENDING_ORDERS_FROM_API=false

And finally,

./executor

Press CTRL + A + D together as usual to exit your screen.

That’s all the easy steps you need to do to run the node.

With everything ready, connect to your VPS using Termius on your mobile phone or laptop while PuTTY works best on your laptop.

Then, follow these commands step by step:

1. sudo apt install screen

2. screen -S nillion

You will then be redirected to an empty screen, as intended by this code.

3. snap install docker

4. docker pull nillion/retailtoken-accuser:v1.0.0

5. mkdir -p nillion/accuser

6. docker run -v ./nillion/accuser:/var/tmp nillion/retailtoken-accuser:v1.0.0 initialise

After this command, you will see a screen with codes, including "AccountID" and "public key." Safely save these details and paste them into the respective fields on the Nillion Verifier website.

Revisit https://faucet.testnet.nillion.com/ and get the faucet for the address you obtained from the VPS and saved in your notes earlier.

Wait at least 30-60 minutes before running the following command.

7. `docker run -v ./nillion/accuser:/var/tmp nillion/retailtoken-accuser:v1.0.0 accuse --rpc-endpoint "https://testnet-nillion-rpc.lavenderfive.com" --block-start 5352894`

Your node will start running smoothly and appear as "pending" on the verifier page. Due to a known bug, the team is fixing, it may stay "pending" for a few moments.

Then, to detach from the screen, press “CTRL + A + D” simultaneously, and you're done.

Do not worry about this delay. If you encounter any more problems, feel free to comment on my X post or join my Telegram channel:

Chase's linktree | Twitter | Linktree

Sharing strategies on Airdrops and DeFi.

https://linktr.ee

Only 11k completed the task. That’s a huge edge for us! 🔥

Gonna be a bit of a long one, not everyone’s going to vibe with it, but hey, that’s where we shine.

First of all, last year we minted this builder NFT when the base hit testnet. Now? You can totally claim your builder NFT on Mainnet right here: https://www.base.org/builder-anniversary-nft

No coding skills? No worries. Just cruise through this guide. You’ll bump into some code snippets to copy-paste. I know X will mess up my tweet, so, as always, catch the full guide on here.

First, you need to open up some websites. I’ll name them to make our journey easier.

1. Base developer page: here.

2. Remix page: here.

3. Testnet page: here.

4. Guild page: here.

Now, on the developer page, you can connect your wallet. It will prompt you to add the “base sepolia” network where all the tasks will be carried out.

After adding network in your wallet, let’s get some faucet by going here.

Next, navigate to the remix tool and locate the “owner.sol” file under the contracts folder. Click on the file, and on the left sidebar, you will find the “Solidity compiler” tab. Click on “compile.”

Next, go to the deploy tab and choose the environment as “Injected provider — Metamask”. Once your wallet is connected, click on deploy.

Great! Now, let’s deploy another contract. On the remix page, go to the contracts folder and create a new file following the example in the image below.

Next, name the file “BasicMath.” Simply copy the name and paste it in the required location. The file name should remain unchanged.

Next, the console will open on the right side of the screen. Paste the following code in it.

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

contract BasicMath {
    uint256 constant MAX_INT = type(uint256).max;    function adder(uint256 _a, uint256 _b) external pure returns (uint256 sum, bool error) {
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
    }    function subtractor(uint256 _a, uint256 _b) external pure returns (uint256 difference, bool error) {
        if (_b > _a) {
            return (0, true); // Underflow occurred
        }
        return (_a - _b, false);
    }
}//CHASE

Then on the left sidebar, click on “Solidity Compiler” and then compile BasicMath.sol

Once the contract has been successfully deployed, navigate to the left sidebar and scroll down to view the BasicMath contract code. Copy it and go to the developer page.

You should see something similar after selecting “Submit.”

Great, the first deployment is complete. We have 13 more contracts to deploy, and the process will be similar. Let’s keep going.

Contract 2: Control Structures

Make a new file called “Control Structures” in the contracts folder.

Next, insert the code below on the code panel’s right side.

// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;

contract ControlStructures {
    // Define custom errors for use within the contract
    error AfterHours(uint256 time);
    error AtLunch();    // Function to determine the response based on the input number
    function fizzBuzz(uint256 _number) public pure returns (string memory response) {
        // Check if the number is divisible by both 3 and 5
        if (_number % 3 == 0 && _number % 5 == 0) {
            return "FizzBuzz"; // Return "FizzBuzz" if divisible by both 3 and 5
        } 
        // Check if the number is divisible by 3
        else if (_number % 3 == 0) {
            return "Fizz"; // Return "Fizz" if divisible by 3
        } 
        // Check if the number is divisible by 5
        else if (_number % 5 == 0) {
            return "Buzz"; // Return "Buzz" if divisible by 5
        } 
        // If none of the above conditions are met
        else {
            return "Splat"; // Return "Splat" if none of the conditions are met
        }
    }    // Function to determine the response based on the input time
    function doNotDisturb(uint256 _time) public pure returns (string memory result) {
        // Ensure the input time is within valid bounds (less than 2400)
        assert(_time < 2400);        // Check different time ranges and return appropriate responses or revert with errors
        if (_time > 2200 || _time < 800) {
            revert AfterHours(_time); // Revert with custom error if it's after 10:00 PM or before 8:00 AM
        } 
        else if (_time >= 1200 && _time <= 1299) {
            revert AtLunch(); // Revert with custom error if it's between 12:00 PM and 1:00 PM
        } 
        else if (_time >= 800 && _time <= 1199) {
            return "Morning!"; // Return "Morning!" if it's between 8:00 AM and 11:59 AM
        } 
        else if (_time >= 1300 && _time <= 1799) {
            return "Afternoon!"; // Return "Afternoon!" if it's between 1:00 PM and 5:59 PM
        } 
        else if (_time >= 1800 && _time <= 2200) {
            return "Evening!"; // Return "Evening!" if it's between 6:00 PM and 10:00 PM
        }
    }
}//CHASE

Next, in the same manner, compile the file, deploy the contract and validate the metamask transaction.

Then copy the contract code by scrolling down on the left sidebar.

Then go over here and paste your contract code, and click on “Submit.”

Contract 3: Storage

Make a new file called “Storage” in the contracts folder.

Next, insert the code below on the code panel’s right side.

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

contract EmployeeStorage {
    // Declare private state variables to store employee data
    uint16 private shares; // Number of shares owned by the employee (private to contract)
    uint32 private salary; // Monthly salary of the employee (private to contract)
    uint256 public idNumber; // Unique identification number of the employee (publicly accessible)
    string public name; // Name of the employee (publicly accessible)    // Constructor to initialize employee data when contract is deployed
    constructor(uint16 _shares, string memory _name, uint32 _salary, uint _idNumber) {
        shares = _shares; // Initialize shares
        name = _name; // Initialize name
        salary = _salary; // Initialize salary
        idNumber = _idNumber; // Initialize idNumber
    }    // View function to retrieve the number of shares owned by the employee
    function viewShares() public view returns (uint16) {
        return shares;
    }
    
    // View function to retrieve the monthly salary of the employee
    function viewSalary() public view returns (uint32) {
        return salary;
    }    // Custom error declaration
    error TooManyShares(uint16 _shares);
    
    // Function to grant additional shares to the employee
    function grantShares(uint16 _newShares) public {
        // Check if the requested shares exceed the limit
        if (_newShares > 5000) {
            revert("Too many shares"); // Revert with error message
        } else if (shares + _newShares > 5000) {
            revert TooManyShares(shares + _newShares); // Revert with custom error message
        }
        shares += _newShares; // Grant the new shares
    }    // Function used for testing packing of storage variables (not relevant to main functionality)
    function checkForPacking(uint _slot) public view returns (uint r) {
        assembly {
            r := sload (_slot)
        }
    }    // Function to reset shares for debugging purposes (not relevant to main functionality)
    function debugResetShares() public {
        shares = 1000; // Reset shares to 1000
    }
}//CHASE

Now on the deploy tab, we need to make some changes.

Select the dropdown menu as indicated by the picture. Then fill out the details.

• shares - 1000

• name - Pat

• salary - 50000

• idNumber - 112358132134

Then click on “Transact” and confirm the metamask popup.

Then copy the contract code by scrolling down on the left sidebar.

Then go over here paste your contract code, and click on “Submit.”

Contract 4: Arrays

Make a new file called “Arrays” in the contracts folder.

Next, insert the code below on the code panel’s right side.

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

contract ArraysExercise {
    // Declare state variables to store arrays of numbers, timestamps, and senders
    uint[] numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; // Array of numbers initialized with values
    uint[] timestamps; // Dynamic array to store timestamps
    address[] senders; // Dynamic array to store sender addresses    uint256 constant Y2K = 946702800; // Constant representing the Unix timestamp for the year 2000    // Function to retrieve the array of numbers
    function getNumbers() external view returns (uint[] memory) {
        // Create a memory array to hold the numbers
        uint[] memory results = new uintUnsupported embed;        // Copy the numbers from the state array to the memory array
        for(uint i=0; i<numbers.length; i++) {
            results[i] = numbers[i];
        }        // Return the memory array
        return results;
    }    // Function to reset the numbers array to its initial values
    function resetNumbers() public {
        numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    }    // Function to append new numbers to the numbers array
    function appendToNumbers(uint[] calldata _toAppend) public {
        // Iterate through the array to be appended
        for (uint i = 0; i < _toAppend.length; i++) {
            // Push each element of the array to be appended to the numbers array
            numbers.push(_toAppend[i]);
        }
    }    // Function to save a timestamp along with the sender's address
    function saveTimestamp(uint _unixTimestamp) public {
        // Push the timestamp and sender's address to their respective arrays
        timestamps.push(_unixTimestamp);
        senders.push(msg.sender);
    }    // Function to retrieve timestamps and senders after the year 2000
    function afterY2K() public view returns (uint256[] memory, address[] memory) {
        // Initialize counter for timestamps after Y2K
        uint256 counter = 0;        // Count the number of timestamps after Y2K
        for (uint i = 0; i < timestamps.length; i++) {
            if (timestamps[i] > Y2K) {
                counter++;
            }
        }        // Initialize memory arrays to hold timestamps and senders after Y2K
        uint256[] memory timestampsAfterY2K = new uint256Unsupported embed;
        address[] memory sendersAfterY2K = new addressUnsupported embed;        // Initialize index for inserting elements into memory arrays
        uint256 index = 0;        // Iterate through timestamps and senders arrays to extract elements after Y2K
        for (uint i = 0; i < timestamps.length; i++) {
            if (timestamps[i] > Y2K) {
                timestampsAfterY2K[index] = timestamps[i];
                sendersAfterY2K[index] = senders[i];
                index++;
            }
        }        // Return timestamps and senders after Y2K
        return (timestampsAfterY2K, sendersAfterY2K);
    }    // Function to reset the senders array
    function resetSenders() public {
        delete senders;
    }    // Function to reset the timestamps array
    function resetTimestamps() public {
        delete timestamps;
    }
}//CHASE

Next, in the same manner, compile the file, deploy the contract, and validate the metamask transaction.

Then copy the contract code by scrolling down on the left sidebar.

Then go over here and paste your contract code, and click on “Submit.”

Contract 5: Mapping

Make a new file called “Mapping” in the contracts folder.

Next, insert the code below on the code panel’s right side.

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

/**
 * @title FavoriteRecords
 * @dev Contract to manage a list of approved music records and allow users to add them to their favorites
 */
contract FavoriteRecords {
    // Mapping to store whether a record is approved
    mapping(string => bool) private approvedRecords;
    // Array to store the index of approved records
    string[] private approvedRecordsIndex;    // Mapping to store user's favorite records
    mapping(address => mapping(string => bool)) public userFavorites;
    // Mapping to store the index of user's favorite records
    mapping(address => string[]) private userFavoritesIndex;    // Custom error to handle unapproved records
    error NotApproved(string albumName);    /**
     * @dev Constructor that initializes the approved records list
     */
    constructor() {
        // Predefined list of approved records
        approvedRecordsIndex = [
            "Thriller", 
            "Back in Black", 
            "The Bodyguard", 
            "The Dark Side of the Moon", 
            "Their Greatest Hits (1971-1975)", 
            "Hotel California", 
            "Come On Over", 
            "Rumours", 
            "Saturday Night Fever"
        ];
        // Initialize the approved records mapping
        for (uint i = 0; i < approvedRecordsIndex.length; i++) {
            approvedRecords[approvedRecordsIndex[i]] = true;
        }
    }    /**
     * @dev Returns the list of approved records
     * @return An array of approved record names
     */
    function getApprovedRecords() public view returns (string[] memory) {
        return approvedRecordsIndex;
    }    /**
     * @dev Adds an approved record to the user's favorites
     * @param _albumName The name of the album to be added
     */
    function addRecord(string memory _albumName) public {
        // Check if the record is approved
        if (!approvedRecords[_albumName]) {
            revert NotApproved({albumName: _albumName});
        }
        // Check if the record is not already in the user's favorites
        if (!userFavorites[msg.sender][_albumName]) {
            // Add the record to the user's favorites
            userFavorites[msg.sender][_albumName] = true;
            // Add the record to the user's favorites index
            userFavoritesIndex[msg.sender].push(_albumName);
        }
    }    /**
     * @dev Returns the list of a user's favorite records
     * @param _address The address of the user
     * @return An array of user's favorite record names
     */
    function getUserFavorites(address _address) public view returns (string[] memory) {
        return userFavoritesIndex[_address];
    }    /**
     * @dev Resets the caller's list of favorite records
     */
    function resetUserFavorites() public {
        // Iterate through the user's favorite records
        for (uint i = 0; i < userFavoritesIndex[msg.sender].length; i++) {
            // Delete each record from the user's favorites mapping
            delete userFavorites[msg.sender][userFavoritesIndex[msg.sender][i]];
        }
        // Delete the user's favorites index
        delete userFavoritesIndex[msg.sender];
    }
}//CHASE

Next, in the same manner, compile the file, deploy the contract, and validate the metamask transaction.

Then copy the contract code by scrolling down on the left sidebar.

Then go over here and paste your contract code, and click on “Submit.”

Contract 6: Structs

Make a new file called “Structs” in the contracts folder.

Next, insert the code below on the code panel’s right side.

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

/**
 * @title GarageManager
 * @dev Contract to manage a garage of cars for each user
 */
contract GarageManager {
    // Mapping to store the garage of cars for each user
    mapping(address => Car[]) private garages;    // Struct to represent a car
    struct Car {
        string make; // Make of the car
        string model; // Model of the car
        string color; // Color of the car
        uint numberOfDoors; // Number of doors of the car
    }    // Custom error for handling invalid car index
    error BadCarIndex(uint256 index);    /**
     * @dev Adds a new car to the caller's garage
     * @param _make The make of the car
     * @param _model The model of the car
     * @param _color The color of the car
     * @param _numberOfDoors The number of doors of the car
     */
    function addCar(string memory _make, string memory _model, string memory _color, uint _numberOfDoors) external {
        // Push a new car struct with the provided details to the caller's garage
        garages[msg.sender].push(Car(_make, _model, _color, _numberOfDoors));
    }    /**
     * @dev Retrieves the caller's array of cars
     * @return An array of `Car` structs
     */
    function getMyCars() external view returns (Car[] memory) {
        // Return the array of cars stored in the caller's garage
        return garages[msg.sender];
    }    /**
     * @dev Retrieves a specific user's array of cars
     * @param _user The address of the user
     * @return An array of `Car` structs
     */
    function getUserCars(address _user) external view returns (Car[] memory) {
        // Return the array of cars stored in the garage of the specified user
        return garages[_user];
    }    /**
     * @dev Updates a specific car in the caller's garage
     * @param _index The index of the car in the garage array
     * @param _make The new make of the car
     * @param _model The new model of the car
     * @param _color The new color of the car
     * @param _numberOfDoors The new number of doors of the car
     */
    function updateCar(uint256 _index, string memory _make, string memory _model, string memory _color, uint _numberOfDoors) external {
        // Check if the provided index is valid
        if (_index >= garages[msg.sender].length) {
            revert BadCarIndex({index: _index}); // Revert with custom error if the index is invalid
        }
        // Update the specified car with the new details
        garages[msg.sender][_index] = Car(_make, _model, _color, _numberOfDoors);
    }    /**
     * @dev Deletes all cars in the caller's garage
     */
    function resetMyGarage() external {
        // Delete all cars from the caller's garage
        delete garages[msg.sender];
    }
}//CHASE

Next, in the same manner, compile the file, deploy the contract, and validate the metamask transaction.

Then copy the contract code by scrolling down on the left sidebar.

Then go over here and paste your contract code, and click on “Submit.”

Contract 7: Inheritance

Make a new file called “Inheritance” in the contracts folder.

Next, insert the code below on the code panel’s right side.

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;/**
 * @title Employee
 * @dev Abstract contract defining common properties and behavior for employees.
 */
abstract contract Employee {
    uint public idNumber; // Unique identifier for the employee
    uint public managerId; // Identifier of the manager overseeing the employee    /**
     * @dev Constructor to initialize idNumber and managerId.
     * @param _idNumber The unique identifier for the employee.
     * @param _managerId The identifier of the manager overseeing the employee.
     */
    constructor(uint _idNumber, uint _managerId) {
        idNumber = _idNumber;
        managerId = _managerId;
    }    /**
     * @dev Abstract function to be implemented by derived contracts to get the annual cost of the employee.
     * @return The annual cost of the employee.
     */
    function getAnnualCost() public virtual returns (uint);
}/**
 * @title Salaried
 * @dev Contract representing employees who are paid an annual salary.
 */
contract Salaried is Employee {
    uint public annualSalary; // The annual salary of the employee    /**
     * @dev Constructor to initialize the Salaried contract.
     * @param _idNumber The unique identifier for the employee.
     * @param _managerId The identifier of the manager overseeing the employee.
     * @param _annualSalary The annual salary of the employee.
     */
    constructor(uint _idNumber, uint _managerId, uint _annualSalary) Employee(_idNumber, _managerId) {
        annualSalary = _annualSalary;
    }    /**
     * @dev Overrides the getAnnualCost function to return the annual salary of the employee.
     * @return The annual salary of the employee.
     */
    function getAnnualCost() public override view returns (uint) {
        return annualSalary;
    }
}/**
 * @title Hourly
 * @dev Contract representing employees who are paid an hourly rate.
 */
contract Hourly is Employee {
    uint public hourlyRate; // The hourly rate of the employee    /**
     * @dev Constructor to initialize the Hourly contract.
     * @param _idNumber The unique identifier for the employee.
     * @param _managerId The identifier of the manager overseeing the employee.
     * @param _hourlyRate The hourly rate of the employee.
     */
    constructor(uint _idNumber, uint _managerId, uint _hourlyRate) Employee(_idNumber, _managerId) {
        hourlyRate = _hourlyRate;
    }    /**
     * @dev Overrides the getAnnualCost function to calculate the annual cost based on the hourly rate.
     * Assuming a full-time workload of 2080 hours per year.
     * @return The annual cost of the employee.
     */
    function getAnnualCost() public override view returns (uint) {
        return hourlyRate * 2080;
    }
}/**
 * @title Manager
 * @dev Contract managing a list of employee IDs.
 */
contract Manager {
    uint[] public employeeIds; // List of employee IDs    /**
     * @dev Function to add a new employee ID to the list.
     * @param _reportId The ID of the employee to be added.
     */
    function addReport(uint _reportId) public {
        employeeIds.push(_reportId);
    }    /**
     * @dev Function to reset the list of employee IDs.
     */
    function resetReports() public {
        delete employeeIds;
    }
}/**
 * @title Salesperson
 * @dev Contract representing salespeople who are paid hourly.
 */
contract Salesperson is Hourly {
    /**
     * @dev Constructor to initialize the Salesperson contract.
     * @param _idNumber The unique identifier for the employee.
     * @param _managerId The identifier of the manager overseeing the employee.
     * @param _hourlyRate The hourly rate of the employee.
     */
    constructor(uint _idNumber, uint _managerId, uint _hourlyRate) 
        Hourly(_idNumber, _managerId, _hourlyRate) {}
}/**
 * @title EngineeringManager
 * @dev Contract representing engineering managers who are paid an annual salary and have managerial responsibilities.
 */
contract EngineeringManager is Salaried, Manager {
    /**
     * @dev Constructor to initialize the EngineeringManager contract.
     * @param _idNumber The unique identifier for the employee.
     * @param _managerId The identifier of the manager overseeing the employee.
     * @param _annualSalary The annual salary of the employee.
     */
    constructor(uint _idNumber, uint _managerId, uint _annualSalary) 
        Salaried(_idNumber, _managerId, _annualSalary) {}
}/**
 * @title InheritanceSubmission
 * @dev Contract for deploying instances of Salesperson and EngineeringManager.
 */
contract InheritanceSubmission {
    address public salesPerson; // Address of the deployed Salesperson instance
    address public engineeringManager; // Address of the deployed EngineeringManager instance    /**
     * @dev Constructor to initialize the InheritanceSubmission contract.
     * @param _salesPerson Address of the deployed Salesperson instance.
     * @param _engineeringManager Address of the deployed EngineeringManager instance.
     */
    constructor(address _salesPerson, address _engineeringManager) {
        salesPerson = _salesPerson;
        engineeringManager = _engineeringManager;
    }
}//CHASE

Compile the file again in the same way, and during deployment, make some changes. In the contract drop-down, choose the “Salesperson” option.

Next, select the “Deploy” dropdown menu and enter the information as it appears in the figure.

Id Number: 55555

Manager id: 12345

Salary: 20

Then click on “Transact” and confirm the metamask transaction.

Now, on the next step, change the contract to “EngineeringManager.”

Fill in the following details on the unit detail after that.

Id Number: 54321

Manager id: 11111

Annual salary: 200000

Then click on “Transact” and confirm the metamask transaction.

Now, on the next step, change the contract to “Inheritance Submission.”

You must copy the contract code and paste it into this field.

Then click on “Transact” and confirm the metamask transaction.

Then copy the contract code by scrolling down on the left sidebar.

Then go over here and paste your contract code, and click on “Submit.”

Contract 8: SillyStringUtils/Imports

Make a new file called “SillyStringUtils” in the contracts folder.

Next, insert the code below on the code panel’s right side.

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.17;

library SillyStringUtils {    

struct Haiku {
        string line1;
        string line2;
        string line3;
    }    function shruggie(string memory _input) internal pure returns (string memory) {
        return string.concat(_input, unicode" 🤷");
    }
}//CHASE

Again, Make a new file called “Imports” in the contracts folder.

// SPDX-License-Identifier: MIT

// Importing the SillyStringUtils library
import "./SillyStringUtils.sol";pragma solidity 0.8.17;contract ImportsExercise {
    // Using the SillyStringUtils library for string manipulation
    using SillyStringUtils for string;    // Declaring a public variable to store a Haiku
    SillyStringUtils.Haiku public haiku;    // Function to save a Haiku
    function saveHaiku(string memory _line1, string memory _line2, string memory _line3) public {
        haiku.line1 = _line1;
        haiku.line2 = _line2;
        haiku.line3 = _line3;
    }    // Function to retrieve the saved Haiku
    function getHaiku() public view returns (SillyStringUtils.Haiku memory) {
        return haiku;
    }    // Function to append a shrugging emoji to the third line of the Haiku
    function shruggieHaiku() public view returns (SillyStringUtils.Haiku memory) {
        // Creating a copy of the Haiku
        SillyStringUtils.Haiku memory newHaiku = haiku;
        // Appending the shrugging emoji to the third line using the shruggie function from the SillyStringUtils library
        newHaiku.line3 = newHaiku.line3.shruggie();
        return newHaiku;
    }
}//CHASE

Next, in the same manner, compile the file, deploy the contract, and validate the metamask transaction.

Then copy the contract code by scrolling down on the left sidebar.

Then go over here and paste your contract code, and click on “Submit.”

Contract 9: Errors

Make a new file called “Errors” in the contracts folder.

Next, insert the code below on the code panel’s right side.

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.17;contract ErrorTriageExercise {
    /**
     * @dev Finds the difference between each uint with its neighbor (a to b, b to c, etc.)
     * and returns a uint array with the absolute integer difference of each pairing.
     * 
     * @param _a The first unsigned integer.
     * @param _b The second unsigned integer.
     * @param _c The third unsigned integer.
     * @param _d The fourth unsigned integer.
     * 
     * @return results An array containing the absolute differences between each pair of integers.
     */
    function diffWithNeighbor(
        uint _a,
        uint _b,
        uint _c,
        uint _d
    ) public pure returns (uint[] memory) {
        // Initialize an array to store the differences
        uint[] memory results = new uintUnsupported embed;        // Calculate the absolute difference between each pair of integers and store it in the results array
        results[0] = _a > _b ? _a - _b : _b - _a;
        results[1] = _b > _c ? _b - _c : _c - _b;
        results[2] = _c > _d ? _c - _d : _d - _c;        // Return the array of differences
        return results;
    }    /**
     * @dev Changes the base by the value of the modifier. Base is always >= 1000. Modifiers can be
     * between positive and negative 100.
     * 
     * @param _base The base value to be modified.
     * @param _modifier The value by which the base should be modified.
     * 
     * @return returnValue The modified value of the base.
     */
    function applyModifier(
        uint _base,
        int _modifier
    ) public pure returns (uint returnValue) {
        // Apply the modifier to the base value
        if(_modifier > 0) {
            return _base + uint(_modifier);
        }
        return _base - uint(-_modifier);
    }
    uint[] arr;    function popWithReturn() public returns (uint returnNum) {
        if(arr.length > 0) {
            uint result = arr[arr.length - 1];
            arr.pop();
            return result;
        }
    }    // The utility functions below are working as expected
    function addToArr(uint _num) public {
        arr.push(_num);
    }    function getArr() public view returns (uint[] memory) {
        return arr;
    }    function resetArr() public {
        delete arr;
    }
}//CHASE

Next, in the same manner, compile the file, deploy the contract, and validate the metamask transaction.

Then copy the contract code by scrolling down on the left sidebar.

Then go over here and paste your contract code, and click on “Submit.”

Contract 10: AddressBook

Make a new file called “AddressBook” in the contracts folder.

Next, insert the code below on the code panel’s right side.

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

import "@openzeppelin/contracts/access/Ownable.sol";contract AddressBook is Ownable(msg.sender) {
    // Define a private salt value for internal use
    string private salt = "value";     // Define a struct to represent a contact
    struct Contact {
        uint id; // Unique identifier for the contact
        string firstName; // First name of the contact
        string lastName; // Last name of the contact
        uint[] phoneNumbers; // Array to store multiple phone numbers for the contact
    }    // Array to store all contacts
    Contact[] private contacts;    // Mapping to store the index of each contact in the contacts array using its ID
    mapping(uint => uint) private idToIndex;    // Variable to keep track of the ID for the next contact
    uint private nextId = 1;    // Custom error for when a contact is not found
    error ContactNotFound(uint id);    // Function to add a new contact
    function addContact(string calldata firstName, string calldata lastName, uint[] calldata phoneNumbers) external onlyOwner {
        // Create a new contact with the provided details and add it to the contacts array
        contacts.push(Contact(nextId, firstName, lastName, phoneNumbers));
        // Map the ID of the new contact to its index in the array
        idToIndex[nextId] = contacts.length - 1;
        // Increment the nextId for the next contact
        nextId++;
    }    // Function to delete a contact by its ID
    function deleteContact(uint id) external onlyOwner {
        // Get the index of the contact to be deleted
        uint index = idToIndex[id];
        // Check if the index is valid and if the contact with the provided ID exists
        if (index >= contacts.length || contacts[index].id != id) revert ContactNotFound(id);        // Replace the contact to be deleted with the last contact in the array
        contacts[index] = contacts[contacts.length - 1];
        // Update the index mapping for the moved contact
        idToIndex[contacts[index].id] = index;
        // Remove the last contact from the array
        contacts.pop();
        // Delete the mapping entry for the deleted contact ID
        delete idToIndex[id];
    }    // Function to retrieve a contact by its ID
    function getContact(uint id) external view returns (Contact memory) {
        // Get the index of the contact
        uint index = idToIndex[id];
        // Check if the index is valid and if the contact with the provided ID exists
        if (index >= contacts.length || contacts[index].id != id) revert ContactNotFound(id);
        // Return the contact details
        return contacts[index];
    }    // Function to retrieve all contacts
    function getAllContacts() external view returns (Contact[] memory) {
        // Return the array of all contacts
        return contacts;
    }
}//CHASE

Again, Make a new file called “Other Contracts” in the contracts folder.

Next, insert the code below on the code panel’s right side.

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

// Import the AddressBook contract to interact with it
import "./AddressBook.sol";// Contract for creating new instances of AddressBook
contract AddressBookFactory {
    // Define a private salt value for internal use
    string private salt = "value";    // Function to deploy a new instance of AddressBook
    function deploy() external returns (AddressBook) {
        // Create a new instance of AddressBook
        AddressBook newAddressBook = new AddressBook();        // Transfer ownership of the new AddressBook contract to the caller of this function
        newAddressBook.transferOwnership(msg.sender);        // Return the newly created AddressBook contract
        return newAddressBook;
    }
}//CHASE

Next, in the same manner while compiling the contract, change the “compiler” to 0.8.20 version, deploy contract and validate the metamask transaction.

Then copy the contract code by scrolling down on the left sidebar.

Then go over here and paste your contract code, and click on “Submit.”

Contract 11: Minimal token

Make a new file called “Minimal Token” in the contracts folder.

Next, insert the code below on the code panel’s right side.

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

// Contract for an unburnable token
contract UnburnableToken {
    string private salt = "value"; // A private string variable    // Mapping to track token balances of addresses
    mapping(address => uint256) public balances;    uint256 public totalSupply; // Total supply of tokens
    uint256 public totalClaimed; // Total number of tokens claimed
    mapping(address => bool) private claimed; // Mapping to track whether an address has claimed tokens    // Custom errors
    error TokensClaimed(); // Error for attempting to claim tokens again
    error AllTokensClaimed(); // Error for attempting to claim tokens when all are already claimed
    error UnsafeTransfer(address _to); // Error for unsafe token transfer    // Constructor to set the total supply of tokens
    constructor() {
        totalSupply = 100000000; // Set the total supply of tokens
    }    // Public function to claim tokens
    function claim() public {
        // Check if all tokens have been claimed
        if (totalClaimed >= totalSupply) revert AllTokensClaimed();
        
        // Check if the caller has already claimed tokens
        if (claimed[msg.sender]) revert TokensClaimed();        // Update balances and claimed status
        balances[msg.sender] += 1000;
        totalClaimed += 1000;
        claimed[msg.sender] = true;
    }    // Public function for safe token transfer
    function safeTransfer(address _to, uint256 _amount) public {
        // Check for unsafe transfer conditions, including if the target address has a non-zero ether balance
        if (_to == address(0) || _to.balance == 0) revert UnsafeTransfer(_to);        // Ensure the sender has enough balance to transfer
        require(balances[msg.sender] >= _amount, "Insufficient balance");        // Perform the transfer
        balances[msg.sender] -= _amount;
        balances[_to] += _amount;
    }
}//CHASE

Then change the values into “1234.”

Next, in the same manner, compile the file, deploy the contract, and validate the metamask transaction.

Then copy the contract code by scrolling down on the left sidebar.

Then go over here and paste your contract code, and click on “Submit.”

Contract 12: ERC20

Make a new file called “ERC20” in the contracts folder.

Next, insert the code below on the code panel’s right side.

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

// Importing OpenZeppelin contracts for ERC20 and EnumerableSet functionalities
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";// Contract for weighted voting using ERC20 token
contract WeightedVoting is ERC20 {
    string private salt = "value"; // A private string variable
    using EnumerableSet for EnumerableSet.AddressSet; // Importing EnumerableSet for address set functionality    // Custom errors
    error TokensClaimed(); // Error for attempting to claim tokens again
    error AllTokensClaimed(); // Error for attempting to claim tokens when all are already claimed
    error NoTokensHeld(); // Error for attempting to perform an action without holding tokens
    error QuorumTooHigh(); // Error for setting a quorum higher than total supply
    error AlreadyVoted(); // Error for attempting to vote more than once
    error VotingClosed(); // Error for attempting to vote on a closed issue    // Struct to represent an issue
    struct Issue {
        EnumerableSet.AddressSet voters; // Set of voters
        string issueDesc; // Description of the issue
        uint256 quorum; // Quorum required to close the issue
        uint256 totalVotes; // Total number of votes casted
        uint256 votesFor; // Total number of votes in favor
        uint256 votesAgainst; // Total number of votes against
        uint256 votesAbstain; // Total number of abstained votes
        bool passed; // Flag indicating if the issue passed
        bool closed; // Flag indicating if the issue is closed
    }    // Struct to represent a serialized issue
    struct SerializedIssue {
        address[] voters; // Array of voters
        string issueDesc; // Description of the issue
        uint256 quorum; // Quorum required to close the issue
        uint256 totalVotes; // Total number of votes casted
        uint256 votesFor; // Total number of votes in favor
        uint256 votesAgainst; // Total number of votes against
        uint256 votesAbstain; // Total number of abstained votes
        bool passed; // Flag indicating if the issue passed
        bool closed; // Flag indicating if the issue is closed
    }    // Enum to represent different vote options
    enum Vote {
        AGAINST,
        FOR,
        ABSTAIN
    }    // Array to store all issues
    Issue[] internal issues;    // Mapping to track if tokens are claimed by an address
    mapping(address => bool) public tokensClaimed;    uint256 public maxSupply = 1000000; // Maximum supply of tokens
    uint256 public claimAmount = 100; // Amount of tokens to be claimed    string saltt = "any"; // Another string variable    // Constructor to initialize ERC20 token with a name and symbol
    constructor(string memory _name, string memory _symbol)
        ERC20(_name, _symbol)
    {
        issues.push(); // Pushing an empty issue to start from index 1
    }    // Function to claim tokens
    function claim() public {
        // Check if all tokens have been claimed
        if (totalSupply() + claimAmount > maxSupply) {
            revert AllTokensClaimed();
        }
        // Check if the caller has already claimed tokens
        if (tokensClaimed[msg.sender]) {
            revert TokensClaimed();
        }
        // Mint tokens to the caller
        _mint(msg.sender, claimAmount);
        tokensClaimed[msg.sender] = true; // Mark tokens as claimed
    }    // Function to create a new voting issue
    function createIssue(string calldata _issueDesc, uint256 _quorum)
        external
        returns (uint256)
    {
        // Check if the caller holds any tokens
        if (balanceOf(msg.sender) == 0) {
            revert NoTokensHeld();
        }
        // Check if the specified quorum is higher than total supply
        if (_quorum > totalSupply()) {
            revert QuorumTooHigh();
        }
        // Create a new issue and return its index
        Issue storage _issue = issues.push();
        _issue.issueDesc = _issueDesc;
        _issue.quorum = _quorum;
        return issues.length - 1;
    }    // Function to get details of a voting issue
    function getIssue(uint256 _issueId)
        external
        view
        returns (SerializedIssue memory)
    {
        Issue storage _issue = issues[_issueId];
        return
            SerializedIssue({
                voters: _issue.voters.values(),
                issueDesc: _issue.issueDesc,
                quorum: _issue.quorum,
                totalVotes: _issue.totalVotes,
                votesFor: _issue.votesFor,
                votesAgainst: _issue.votesAgainst,
                votesAbstain: _issue.votesAbstain,
                passed: _issue.passed,
                closed: _issue.closed
            });
    }    // Function to cast a vote on a voting issue
    function vote(uint256 _issueId, Vote _vote) public {
        Issue storage _issue = issues[_issueId];        // Check if the issue is closed
        if (_issue.closed) {
            revert VotingClosed();
        }
        // Check if the caller has already voted
        if (_issue.voters.contains(msg.sender)) {
            revert AlreadyVoted();
        }        uint256 nTokens = balanceOf(msg.sender);
        // Check if the caller holds any tokens
        if (nTokens == 0) {
            revert NoTokensHeld();
        }        // Update vote counts based on the vote option
        if (_vote == Vote.AGAINST) {
            _issue.votesAgainst += nTokens;
        } else if (_vote == Vote.FOR) {
            _issue.votesFor += nTokens;
        } else {
            _issue.votesAbstain += nTokens;
        }        // Add the caller to the list of voters and update total votes count
        _issue.voters.add(msg.sender);
        _issue.totalVotes += nTokens;        // Close the issue if quorum is reached and determine if it passed
        if (_issue.totalVotes >= _issue.quorum) {
            _issue.closed = true;
            if (_issue.votesFor > _issue.votesAgainst) {
                _issue.passed = true;
            }
        }
    }
}//CHASE

Then change the values into “CHASE.”

Then, compile the file in the same way, deploy the contract, fill in the following details, and validate the metamask transaction.

Then click on “Transact.”

Then copy the contract code by scrolling down on the left sidebar.

Then go over here and paste your contract code, and click on “Submit.”

Contract 13: ERC721

Make a new file called “ERC721” in the contracts folder.

Next, insert the code below on the code panel’s right side.

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

// Importing OpenZeppelin ERC721 contract
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/ERC721.sol";// Interface for interacting with a submission contract
interface ISubmission {
    // Struct representing a haiku
    struct Haiku {
        address author; // Address of the haiku author
        string line1; // First line of the haiku
        string line2; // Second line of the haiku
        string line3; // Third line of the haiku
    }    // Function to mint a new haiku
    function mintHaiku(
        string memory _line1,
        string memory _line2,
        string memory _line3
    ) external;    // Function to get the total number of haikus
    function counter() external view returns (uint256);    // Function to share a haiku with another address
    function shareHaiku(uint256 _id, address _to) external;    // Function to get haikus shared with the caller
    function getMySharedHaikus() external view returns (Haiku[] memory);
}// Contract for managing Haiku NFTs
contract HaikuNFT is ERC721, ISubmission {
    Haiku[] public haikus; // Array to store haikus
    mapping(address => mapping(uint256 => bool)) public sharedHaikus; // Mapping to track shared haikus
    uint256 public haikuCounter; // Counter for total haikus minted    // Constructor to initialize the ERC721 contract
    constructor() ERC721("HaikuNFT", "HAIKU") {
        haikuCounter = 1; // Initialize haiku counter
    }    string salt = "value"; // A private string variable    // Function to get the total number of haikus
    function counter() external view override returns (uint256) {
        return haikuCounter;
    }    // Function to mint a new haiku
    function mintHaiku(
        string memory _line1,
        string memory _line2,
        string memory _line3
    ) external override {
        // Check if the haiku is unique
        string[3] memory haikusStrings = [_line1, _line2, _line3];
        for (uint256 li = 0; li < haikusStrings.length; li++) {
            string memory newLine = haikusStrings[li];
            for (uint256 i = 0; i < haikus.length; i++) {
                Haiku memory existingHaiku = haikus[i];
                string[3] memory existingHaikuStrings = [
                    existingHaiku.line1,
                    existingHaiku.line2,
                    existingHaiku.line3
                ];
                for (uint256 eHsi = 0; eHsi < 3; eHsi++) {
                    string memory existingHaikuString = existingHaikuStrings[
                        eHsi
                    ];
                    if (
                        keccak256(abi.encodePacked(existingHaikuString)) ==
                        keccak256(abi.encodePacked(newLine))
                    ) {
                        revert HaikuNotUnique();
                    }
                }
            }
        }        // Mint the haiku NFT
        _safeMint(msg.sender, haikuCounter);
        haikus.push(Haiku(msg.sender, _line1, _line2, _line3));
        haikuCounter++;
    }    // Function to share a haiku with another address
    function shareHaiku(uint256 _id, address _to) external override {
        require(_id > 0 && _id <= haikuCounter, "Invalid haiku ID");        Haiku memory haikuToShare = haikus[_id - 1];
        require(haikuToShare.author == msg.sender, "NotYourHaiku");        sharedHaikus[_to][_id] = true;
    }    // Function to get haikus shared with the caller
    function getMySharedHaikus()
        external
        view
        override
        returns (Haiku[] memory)
    {
        uint256 sharedHaikuCount;
        for (uint256 i = 0; i < haikus.length; i++) {
            if (sharedHaikus[msg.sender][i + 1]) {
                sharedHaikuCount++;
            }
        }        Haiku[] memory result = new HaikuUnsupported embed;
        uint256 currentIndex;
        for (uint256 i = 0; i < haikus.length; i++) {
            if (sharedHaikus[msg.sender][i + 1]) {
                result[currentIndex] = haikus[i];
                currentIndex++;
            }
        }        if (sharedHaikuCount == 0) {
            revert NoHaikusShared();
        }        return result;
    }    // Custom errors
    error HaikuNotUnique(); // Error for attempting to mint a non-unique haiku
    error NotYourHaiku(); // Error for attempting to share a haiku not owned by the caller
    error NoHaikusShared(); // Error for no haikus shared with the caller
}//CHASE

Then, compile the file in the same way, deploy the contract and validate the metamask transaction.

Then copy the contract code by scrolling down on the left sidebar.

Then go over here and paste your contract code, and click on “Submit.”

Congratulations! You’ve completed all the tasks, and you’re now a kind of developer. If you’ve made it this far, I’m proud of you.

Now that you’ve collected all the badges/NFTs, head to the guild page and verify all the roles.

Guild link: https://guild.xyz/base/base-camp

Great! You can now check these roles by messaging in the base server.

Congratulations on dedicating your time on this. Your efforts will surely pay off.

If you run into any trouble, leave a comment and I’ll assist you.