You can use Scaffold-ETH to learn about Solidity by taking the initial YourContract.sol smart contract & start iterating on it by adding more complex concepts onto it. Below are some quests to follow along.

You can also check out the BG Labs video on Solidity Deep Dive over here. 👇

1. Getting started with Scaffold-ETH: Add totalCounter

• Spin up Scaffold-ETH. Check out the Burner wallet, get funds for your wallet, and try out the example UI and contract component page.

Exercise: Add a counter called 'totalCounter' to your smart Contract that keeps track of how many times the purpose changes.

uint256 public totalCounter;

function setPurpose(string memory newPurpose) public payable {
    totalCounter += 1;
    // ....
}

2. Array of Structs

Structs: Structs are a data type that allows you to group related data together. Mappings: A mapping is a data type that associates values with keys and stores them. Mappings cannot be looped over. Here's how you can iterate through a mapping.

Exercise: We want to store all the purposes sent by a given address and the block timestamp. We need a Struct & a mapping with an array of those structs. Go to Solidity by example, copy/paste and modify.

struct PurposeSubmission {
    string text;
    uint256 timestamp;
}

mapping(address => PurposeSubmission[]) public userSubmissions;

function setPurpose(string memory newPurpose) public payable {
    userSubmissions[msg.sender].push(PurposeSubmission(newPurpose, block.timestamp));
    // ....
}

3. Inheritance

Inheritance allows us to override or extend the behavior of the original contract. The most common use case is inheriting from battle-tested 3rd party contracts (like OpenZeppelin); these are audited and commonly used contracts.

Exercise: Inherit the OpenZeppelin Ownable Contract. Check all the new functions/variables that appear in the UI.

contract YourContract is Ownable {...}

We'll come back to the owner that comes with the Ownable contract.

Exercise: Solidity supports multiple inheritances. On the same Contract, inherit the OpenZeppelin Pausable contract as well.

import "@openzeppelin/contracts/security/Pausable.sol";

contract YourContract is Ownable, Pausable {...}

4. Deploy script

The deploy script is where we prepare our contract for deployment (arguments, one-time tx after deploy, etc). You can edit your deployment scripts in packages/hardhat/deploy

Exercise: Call transferOwnership from the deploy script.

await YourContract.transferOwnership(
  "FRONTEND_ADDRESS_HERE"
);

Exercise: transferOwnership from the constructor.

// contract
constructor(address _initialOwner) payable {
    Ownable._transferOwnership(_initialOwner);
}

// deploy script
await deploy("YourContract", {
  //..
  args: ["FRONTEND_ADDRESS_HERE"],
  //..
});

5. New Contract + Contract Interaction

You can have multiple contracts on your project and look into contract to contract interaction.

Exercise: Create a new contract called WithdrawerContract to get money from our PurposeContract.

1. Create the Contract

   pragma solidity >=0.8.0 <0.9.0;
   //SPDX-License-Identifier: MIT
   
   // Create a blueprint first
   contract WithdrawerContract {
       function withdrawFrom(address _contractAddress) public {
           //
       }
   
       // to support receiving ETH by default
       receive() external payable {}
       fallback() external payable {}
   }
   

2. Create a new deploy script to deploy the Withdrawer Contract.

   module.exports = async ({ getNamedAccounts, deployments }) => {
     const { deploy } = deployments;
     const { deployer } = await getNamedAccounts();
   
     await deploy("WithdrawerContract", {
       from: deployer,
       log: true,
       waitConfirmations: 5,
     });
   };
   module.exports.tags = ["withdrawFrom"];
   

3. Add the Withdrawer Contract to the UI on `App.jsx`

     < Contract
       name="WithdrawerContract"
       price={price}
       signer={userSigner}
       provider={localProvider}
       address={address}
       blockExplorer={blockExplorer}
       contractConfig={contractConfig}
     />
   

4. Implement a withdraw function on the Purpose contract & try to call it from the UI.

   function withdraw() public {
       require(msg.sender != tx.origin, "Not a contract");
   
       (bool sent,) = msg.sender.call{value: address(this).balance}("");
       require(sent, "Failed to send Ether");
   }
   

5. Contract to Contract call on WithdrawerContract

   interface IYourContract {
       function withdraw() external;
   }
   
   contract WithdrawerContract {
       function withdrawFrom(address _contractAddress) public {
           IYourContract(_contractAddress).withdraw();
       }
   
       // ...
   }
   

Hope this was helpful! These were some sample tasks & you can continue to try out new concepts from Solidity by example with Scaffold-ETH. Next up, why not take on SpeedRunEthereum! 😉

What projects are built by the BuidlGuidl?

It's all about building forkable components with Scaffold-ETH. You can make a new voting system component, work on the open issues, make a new challenge for SpeedRunEthereum, etc. Make sure to have a well-written README so anyone can easily set it up.

In other words, builders have the flexibility to choose the projects they want to work on. There isn't a specific job description or app to complete; it's really up to your interest and creativity. For example, if you're interested in Ceramic, you can integrate Ceramic and Scaffold-ETH; if you want to work on a new SVG NFT game, you can do that.

How to join the BuidlGuidl?

You can join BuidlGuidl after completing the first 4 challenges on SpeedRunEthereum.

After building forkable Scaffold-ETH components, submitting them to your Builder profile, and being active in the BuidlGuidl Telegram groups, you can also get the opportunity of a BuidlGuidl Stream.

What is a BuidlGuidl Stream?

Active contributors can get a BuidlGuidl stream to earn money for building cool things.

This is a smart contract where the builder can withdraw ETH after submitting some work. The stream is set to a certain amount of ETH per 30 days. This is the total amount the builder can withdraw in a time period of 30 days. The amount is unlocked during the month, and the streams are re-filled periodically.

You can see all the builder profiles on buidlguidl.com; you'll find there the projects builders have submitted and how much they withdrew from the steam.

How to get a BuidlGuidl Stream?

Start by completing the first 4 challenges on speedrunethereum.com, which allows you to join the BuidlGuidl. From there, start building!

Create your own projects to help the ecosystem, start helping on the Github repositories, and/or help others in the BuidlGuidl Telegram channels. Help enough and you may get some small scholarships paid in ETH. Do enough good work and you'll get your own stream!

You can see all the builders with an active stream on the BG website.

How to withdraw from your stream?

First, once you've done some work, you can submit the project details on your profile page on buidlguidl.com.

Then you can withdraw some ETH from your stream. When you click “withdraw,“ you are asked to state the reason & provide relative links for the work.

How much should I withdraw from my stream for my work/build?

It can feel weird to price your work as a builder, but looking at other builder profiles can be very helpful. For example, you can look at similar projects and how much the builders have withdrawn. Also, feel free to reach out to the core team for similar projects to understand how much to withdraw.

How can I choose/decide what to work on?

If you have a project in mind, for example, a protocol you're interested in, you can go ahead and build your idea. There are also lots of opportunities to learn about new ideas and join projects looking for builders.

Where can I ask for help?

Make sure to join the BG Townhall Telegram group, each SpeedRunEthereum challenge also has its telegram group for specific questions about the challenge. When you join the BuidlGuidl, you also gain access to other developer groups.

Where can I follow BuidlGuidl?

Here are the resources to keep up to date:

• Buidlguidl.com

• Speedrunethereum.com

• BG Townhall Telegram

• Newsletter

• BG Twitter