# Mega guide on snagging a spot for the potential base developer airdrop!

**Published by:** [Abraham Chase.](https://paragraph.com/@abraham-chase/)
**Published on:** 2024-05-04
**URL:** https://paragraph.com/@abraham-chase/mega-guide-on-snagging-a-spot-for-the-potential-base-developer-airdrop

## Content

Have you seen those recent airdrops? developers getting treated right. There’s a bunch of contract deployment tasks up for grabs on @base where you can bag all the badges for zero cost! 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. Base developer page: here. Remix page: here. Testnet page: here. 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.

## Publication Information

- [Abraham Chase.](https://paragraph.com/@abraham-chase/): Publication homepage
- [All Posts](https://paragraph.com/@abraham-chase/): More posts from this publication
- [RSS Feed](https://api.paragraph.com/blogs/rss/@abraham-chase): Subscribe to updates
- [Twitter](https://twitter.com/Abrahamchase09): Follow on Twitter