Create a Crowdfunding Smart Contract using Solidity
Tags: blockchain, web3, webdev, programming
Published: 2022-05-24 10:16:38


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/havgruz64nd1mj6nz205.jpg)

This post was originally posted on [Hackmamba](https://hackmamba.io/blog/2022/05/create-a-crowdfunding-smart-contract-using-solidity/)

Smart contracts are resilient and highly secured applications deployed on the blockchain.

We are going to build a smart campaign contracts used to crowdsource projects and keep track of the spending habit of the `crowdsourcer`.

PREREQUISITE

- 
Remix
- 
Little or no knowledge of solidity

CASE STUDY
Before we begin, let’s take a case study of [Kickstarter](https://www.kickstarter.com/). Kickstarter is a crowdsourcing website where anyone can drop their idea for people to crowdsource to enable them to finish their project.

While it is a beautiful idea, we would encounter issues on Web3 if we build this kind of contract using blockchain technology.

ISSUES

- 
Who sanctions the release of the funds inside the pool?

- 
What if the owner swindles everyone and runs away with the whole funds after crowdsourcing?

- 
How do we cross-check the project to see if the crowdsourcer is making progress?


While this might feel like a big task, we will create a smart contract that takes all of this into account and ensures the contributor’s funds are utilized based on the agreement.

How?

First, take a look at this diagram of what we intend to build.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/4utwgzuc0v7bftceqrar.png)

The manager calls a contract to request funds which the contributors all come together to crowdsource. After crowdsourcing, the manager calls a spending request that more than 50% of the contributor must approve, but what if the manager calls a request to his wallet.

How do we remedy such an instance?

The vendor account is filled in the struct when requesting a spending request and, once approved, sent to that vendor and not the manager.

The accountability and security of contributors’ funds are guaranteed.

We will be using Remix IDE to write our smart contract, so click [here](https://remix.ethereum.org/#optimize=false&runs=200&evmVersion=null&version=soljson-v0.4.17+commit.bdeb9e52.js&language=Solidity) to begin.

    

```solidity 
//SPDX-License-Identifier: MIT
    pragma solidity ^0.4.17;
```
The first line tells us the license we are working with, MIT free license. If we do not have this, our code will throw an error.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/7rmeqb6azweg9su59y5m.png)



`Pragma solidity` tells us the version we are working on; note this version must match our compiler, or we will get an error sign.

In this article, we will be using version `0.4.17`.

    

```solidity 
contract CrowdSource{
     address public manager;
     uint public MinimumContribution;
     address[] public approvals;
```

We can create the contract by calling the function `contract` and giving `**CrowdSource**`. Use the curly brace to open it.

We call the variable called manager as this is the `crowdsourcer` and the contract caller.

`Uint` is an unsigned variable similar to `uint256`; we make this function public as we want anyone to call it when contributing the `MinimumContribution`.

We created another function called `address approvals`, but with `[ ]`, everyone who made the `MinimumContribution` will be saved in the approvals list. We would remove this soon as it is expensive and gas-intensive to run.

    

```solidity 
function campaign(uint minimum)public{
        manager = msg.sender;
        MinimumContribution = minimum;
      }
```
The constructor function
The `Constructor` or `function` campaign is the first function to run as we want to make sure only the manager can call the contract.

Note that we made it `public` to see the caller of the contract.

`msg.sender` is a universal variable that we assign to the manager, `manager = msg.sender`; whenever the contract is called so, whoever calls the contract is the manager.

We called `(uint minimum)public{` which is an unsigned integer for the amount of money required to become a contributor, we can have a different minimum or create a static amount.

Then we can call in the function `MinimumContribution = minimum;` so whoever contributes to the contract is added here `uint public MinimumContribution;`

The approval process
The approvals function is called when a contributor pays `payable` a minimum amount to the contract.

    

```solidity 
function contribute() public payable{
        require(msg.value > MinimumContribution);
        approvals.push(msg.sender);
      }
```
The `require` function kicks out anyone that has not added value to the `minimumContribution` and pushes a contributor to the approvals list.

Next, we introduce the payable function and the approval variable, and we will see why they play a significant role in the smart contract.

Requesting funds
Contributors can send funds into our contract, but we can not pull money out of the request function, leading us to create a struct. `Struct` is a collection of key-value pairs that have different types.

    

```solidity 
contract CrowdSource{
      struct request{
        string description;
        uint value;
        address recipiant;
        bool complete;
    }

```
- 
**Description**: string: the purpose of the request.

- 
**Value**: Uint: the amount of money needed.

- 
**Recipient**: address: the address of the vendor
We create a struct as a request that the contributors approve before sending it to the vendor, which is also a struct type.

Struct is not an instance but a definition of a type we can use multiple times across the project.

Testing the contract
We’ll test the contract right in the IDE.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/2wwt85qb5vln0xqpkblg.png)



Running a test on Remix is straightforward. We can see the DEPLOY AND RUN TRANSACTIONS on the left-hand side.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ssnv47kdpuucwwj5khc0.png)

Environment
There are about four different environments, but most times will use just two `javascript VM (London)` and `Injected Web3`.



- 
Account
Remix gives 15 free accounts that we can use to deploy contracts and test our deployment.


- 
Gas Limit Gas limit replicates the actual gas fees when deploying a contract. Each deployment or change in the contract will cost us a gas fee, and we will review the gas fee later on.

- 
Value The value is the fund we put into the contract when deploying it. `Wei` is the smallest unit, while ether is the highest unit of the currency used on Ethereum.

- 
Contract The name of the contract, which in this case is `new.sol`. `.sol` is a file format for solidity contracts.

``Deploy Deploys the contract into the blockchain network so we can interact with the network.

Compile the contract and click on deploy, a contract will be created below.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/18sv1ozcdxn2zh91abg9.png)

Click on the drop-down button by the left, and see the full deployment.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/x2luhzi7anapmvi1id9q.png)


In our contract, we have the campaign which reads `uint256`, which is an unsigned integer; this is the part we input our contribution into the contract, so whoever puts any funds is added to the contract.

Let’s test it.

We will put a `100wei` into the campaign input space but remember to change the account above, so we do not make the contract manager a contributor.

Use another account and input `100wei`.




Click on the campaign, and notice a panel on the right that turns green, it means funds has been sent to the contract.



Number 1 is the deployed contract by the manager; notice the address begins with 0X746.. while number 2 is the new contributor to the contract.

Number 3 tells us that a contributor joined the contract.

Conclusion
We have created a crowd-funding smart contract that allows users to crowd-fund together, and we can deploy this contract on the blockchain network.

Resource
[Solidity Zero to Hero Course](https://www.codiesalert.com/courses/free-solidity-course/)
[Ethereum and Solidity: The Complete Developer's Guide](https://www.udemy.com/join/login-popup/?next=/course/ethereum-and-solidity-the-complete-developers-guide/learn/lecture/9020750%3Fstart%3D75#overview)