Activity - 1

Problem Statement: Hello World Contract

Create a simple Solidity smart contract that prints "Hello, World!"

Pre-Requisites:

1. Remix Engine
2. Solidity Compiler

Program:

// SPDX-License-Identi er: MIT

pragma solidity ^0.8.0;

contract HelloWorld {
string public greeting = "Hello, World!";

function getGreeting() public view returns (string memory) {

return greeting;
}
}

Output:
fi
 Activity - 2
Problem Statement: Token Creation

Develop a basic ERC-20 token smart contract, including functions for transfer,
balance, and approval.

Pre-Requisites:

1. Remix Engine
2. Solidity Compiler

Program:

// SPDX-License-Identi er: MIT

pragma solidity ^0.8.0;

contract SimpleToken {
string public name = "Simple Token";
string public symbol = "ST";
uint8 public decimals = 18;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;

event Transfer(address indexed from, address indexed to, uint256 value);

constructor(uint256 initialSupply) {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
}

function transfer(address to, uint256 value) public returns (bool success) {

require(to != address(0), "Invalid address");
require(balanceOf[msg.sender] >= value, "Insu cient balance");

balanceOf[msg.sender] -= value;
balanceOf[to] += value;

emit Transfer(msg.sender, to, value);

return true;
}
}
fi
ffi
Output:
 Activity - 3
Problem Statement: ICO Crowdsale

Design a simple ICO (Initial Coin O ering) contract that allows users to buy tokens
and the owner to withdraw funds.

Pre-Requisites:

1. Remix Engine
2. Solidity Compiler

Program:

// SPDX-License-Identi er: MIT

pragma solidity ^0.8.0;

contract SimpleICO {
address public owner;
uint256 public tokenPrice;
uint256 public totalTokens;
uint256 public tokensSold;
mapping(address => uint256) public balances;

event TokensPurchased(address indexed buyer, uint256 amount);

event FundsWithdrawn(address owner, uint256 amount);

constructor(uint256 _tokenPrice, uint256 _totalTokens) {

owner = msg.sender;
tokenPrice = _tokenPrice;
totalTokens = _totalTokens;
tokensSold = 0;
}

function buyTokens(address buyer, uint256 value) public {

require(tokensSold + value / tokenPrice <= totalTokens, "Not enough tokens
available");
uint256 numberOfTokens = value / tokenPrice;
balances[buyer] += numberOfTokens;
tokensSold += numberOfTokens;
emit TokensPurchased(buyer, numberOfTokens);
}

function withdrawFunds() public {

require(msg.sender == owner, "Only the owner can withdraw funds");
uint256 balance = address(this).balance;
payable(owner).transfer(balance);
emit FundsWithdrawn(owner, balance);
}
}
fi
ff
Output:
 Activity - 4
Problem Statement: Voting Contract

Build a voting contract where users can submit and vote on proposals. Implement
safeguards to prevent double voting.

Pre-Requisites:

1. Remix Engine
2. Solidity Compiler

Program:

// SPDX-License-Identi er: MIT

pragma solidity ^0.8.0;

contract SimpleVoting {
mapping(address => bool) public hasVoted;
mapping(string => uint256) public proposalVotes;
string[] public proposals;
event Voted(address indexed voter, string proposal);

function addProposal(string memory proposal) public {

proposals.push(proposal);
}

function vote(string memory proposal) public {

require(!hasVoted[msg.sender], "You have already voted.");
require(proposalExists(proposal), "Invalid proposal.");
proposalVotes[proposal]++;
hasVoted[msg.sender] = true;

emit Voted(msg.sender, proposal);

}

function getProposalVotes(string memory proposal) public view returns (uint256) {

return proposalVotes[proposal];
}

function proposalExists(string memory proposal) internal view returns (bool) {

for (uint256 i = 0; i < proposals.length; i++) {
if (keccak256(abi.encodePacked(proposals[i])) ==
keccak256(abi.encodePacked(proposal))) {
return true;
}
}
return false;
}
}
fi
Output:
 Activity - 5
Problem Statement: Escrow Contract

Create an escrow smart contract that holds funds until prede ned conditions are met.

Pre-Requisites:

1. Remix Engine
2. Solidity Compiler

Program:

// SPDX-License-Identi er: MIT

pragma solidity ^0.8.0;

contract SimpleEscrow {
address public payer;
address public payee;
uint256 public amount;
bool public released;

event FundsDeposited(address indexed payer, uint256 amount);

event FundsReleased(address indexed payee, uint256 amount);

constructor(address _payee) {
payer = msg.sender;
payee = _payee;
}

function deposit() public payable {

require(msg.sender == payer, "Only the payer can deposit funds");
amount += msg.value;
emit FundsDeposited(payer, msg.value);
}

function release() public {

require(msg.sender == payee, "Only the payee can release funds");
require(amount > 0, "No funds to release");
require(!released, "Funds already released");

released = true;
(bool success, ) = payable(payee).call{value: amount}("");
require(success, "Transfer failed");
emit FundsReleased(payee, amount);
}
}
fi
fi
Output:
 Activity - 6
Problem Statement: Wallet Contract

Construct a wallet contract that allows funds to be locked until a speci ed time.

Pre-Requisites:

1. Remix Engine
2. Solidity Compiler

Program:

// SPDX-License-Identi er: MIT

pragma solidity ^0.8.0;

contract TimelockWallet {
address public owner;
uint256 public releaseTime;
uint256 public balance;

event FundsDeposited(address indexed from, uint256 amount);

event FundsWithdrawn(address indexed to, uint256 amount);

constructor(uint256 _releaseTime) {
owner = msg.sender;
releaseTime = _releaseTime;
}

modi er onlyOwner() {
require(msg.sender == owner, "Only the owner can perform this action");
_;
}

modi er onlyAfter(uint256 _time) {

require(block.timestamp >= _time, "Action can only be performed after the speci ed
time");
_;
}

function deposit() public payable {

require(msg.value > 0, "Must send Ether with the deposit");
balance += msg.value;
emit FundsDeposited(msg.sender, msg.value);
}

function withdraw() public onlyOwner onlyAfter(releaseTime) {

require(balance > 0, "No funds to withdraw");
uint256 amountToWithdraw = balance;
balance = 0;
fi
fi
fi
fi
fi
 (bool success, ) = payable(owner).call{value: amountToWithdraw}("");
require(success, "Transfer failed");
emit FundsWithdrawn(owner, amountToWithdraw);
}
}

Output:
 Activity - 7
Problem Statement: Multi Signature Wallet

Implement a multi-signature wallet that requires multiple parties to approve

transactions.

Pre-Requisites:

1. Remix Engine
2. Solidity Compiler

Program:

// SPDX-License-Identi er: MIT

pragma solidity ^0.8.0;

contract MultiSigWallet {
address public owner;
address public signer1;
address public signer2;
address public signer3;

event Deposit(address indexed sender, uint256 value);

event Transfer(address indexed to, uint256 value);

constructor(address _signer1, address _signer2, address _signer3) {

owner = msg.sender;
signer1 = _signer1;
signer2 = _signer2;
signer3 = _signer3;
}

receive() external payable {

emit Deposit(msg.sender, msg.value);
}

function transfer(address payable to, uint256 value) public {

require(msg.sender == owner || msg.sender == signer1 || msg.sender == signer2 ||
msg.sender == signer3, "Not authorized");
require(address(this).balance >= value, "Insu cient balance");

to.transfer(value);
emit Transfer(to, value);
}
}
fi
ffi
Output:
 Activity - 8
Problem Statement: Decentralised Exchange

Design a simpli ed decentralised exchange where users can trade tokens.

Pre-Requisites:

1. Remix Engine
2. Solidity Compiler

Program:

// SPDX-License-Identi er: MIT

pragma solidity ^0.8.0;

contract SimpleDecentralizedExchange {
address public owner;
uint256 public tokenBalance;

event TokensPurchased(address indexed buyer, uint256 ethValue, uint256

tokenAmount);
event TokensSold(address indexed seller, uint256 ethValue, uint256 tokenAmount);

constructor() {
owner = msg.sender;
}

modi er onlyOwner() {
require(msg.sender == owner, "Only the owner can perform this action");
_;
}

function buyTokens() public payable {

uint256 ethValue = msg.value;
uint256 tokenAmount = ethValue; // 1 Ether = 1 Token (simpli ed rate)

tokenBalance += tokenAmount;
emit TokensPurchased(msg.sender, ethValue, tokenAmount);
}

function sellTokens(uint256 _tokenAmount) public {

require(_tokenAmount > 0, "Invalid token amount");
uint256 ethValue = _tokenAmount; // 1 Token = 1 Ether (simpli ed rate)

require(tokenBalance >= _tokenAmount, "Insu cient token balance");

tokenBalance -= _tokenAmount;

payable(msg.sender).transfer(ethValue);
fi
fi
fi
ffi
fi
fi
 emit TokensSold(msg.sender, ethValue, _tokenAmount);
}

function depositTokens(uint256 _tokenAmount) public onlyOwner {

tokenBalance += _tokenAmount;
}

function withdrawTokens(uint256 _tokenAmount) public onlyOwner {

require(tokenBalance >= _tokenAmount, "Insu cient token balance");
tokenBalance -= _tokenAmount;
}

function getContractBalance() public view returns (uint256) {

return address(this).balance;
}

function getContractTokenBalance() public view returns (uint256) {

return tokenBalance;
}
}

Output:
ffi
 Activity - 9
Problem Statement: NFT Contract

Create a basic NFT contract, allowing the minting and transferring of unique
tokens.

Pre-Requisites:

1. Remix Engine
2. Solidity Compiler

Program:

// SPDX-License-Identi er: MIT

pragma solidity ^0.8.0;

contract BasicNFT {
string public name;
string public symbol;

struct Token {
address owner;
string tokenURI;
}

Token[] public tokens;

mapping(uint256 => address) public tokenOwners;

constructor(string memory _name, string memory _symbol) {

name = _name;
symbol = _symbol;
}

function mint(string memory _tokenURI) public {

uint256 tokenId = tokens.length;
tokens.push(Token(msg.sender, _tokenURI));
tokenOwners[tokenId] = msg.sender;
}

function transfer(address _to, uint256 _tokenId) public {

require(tokenOwners[_tokenId] == msg.sender, "You don't own this token");
tokenOwners[_tokenId] = _to;
}

function getTokenURI(uint256 _tokenId) public view returns (string memory) {

return tokens[_tokenId].tokenURI;
}
}
fi
Output:
 Activity - 10
Problem Statement: Lottery Contract

Develop a lottery contract with an entry fee and randomised winner selection.

Pre-Requisites:

1. Remix Engine
2. Solidity Compiler

Program:

// SPDX-License-Identi er: MIT

pragma solidity ^0.8.0;

contract Lottery {
address public manager;
address[] public players;

event LotteryStarted();
event WinnerSelected(address winner);

constructor() {
manager = msg.sender;
}

function enter() public payable {

require(msg.value > 0.01 ether, "Entry fee is at least 0.01 Ether");
players.push(msg.sender);
}

function random() private view returns (uint) {

return uint(keccak256(abi.encodePacked(block.di culty, block.timestamp, players)));
}

function pickWinner() public restricted {

require(players.length > 0, "No players in the lottery");

uint index = random() % players.length;

address winner = players[index];
emit WinnerSelected(winner);

// Transfer the entire contract balance to the winner

payable(winner).transfer(address(this).balance);

// Reset the player array for the next round

players = new address[](0);
}
fi
ffi
 modi er restricted() {
require(msg.sender == manager, "Only the manager can call this function");
_;
}

function getPlayers() public view returns (address[] memory) {

return players;
}
}

Output:
fi
 Activity - 11
Problem Statement: Supply Chain Contract

Build a supply chain contract that tracks the movement of goods from producer to
consumer.

Pre-Requisites:

1. Remix Engine
2. Solidity Compiler

Program:

// SPDX-License-Identi er: MIT

pragma solidity ^0.8.0;

contract SimpleSupplyChain {
address public producer;
address public consumer;
bool public delivered;

event ProductProduced();
event ProductShipped();
event ProductDelivered();

constructor() {
producer = msg.sender;
delivered = false;
}

modi er onlyProducer() {
require(msg.sender == producer, "Only the producer can perform this action");
_;
}

modi er onlyConsumer() {
require(msg.sender == consumer, "Only the consumer can perform this action");
_;
}

function produceProduct() public onlyProducer {

emit ProductProduced();
}

function shipProduct(address _consumer) public onlyProducer {

consumer = _consumer;
emit ProductShipped();
}
fi
fi
fi
 function con rmDelivery() public onlyConsumer {
delivered = true;
emit ProductDelivered();
}
}

Output:
fi
 Activity - 12
Problem Statement: KYC Contract

Build a contract that veri es user identity using KYC (Know Your Customer)
principles.

Pre-Requisites:

1. Remix Engine
2. Solidity Compiler

Program:

// SPDX-License-Identi er: MIT

pragma solidity ^0.8.0;

contract KYC {
address public owner;

enum KYCStatus { NotSubmitted, Pending, Approved, Rejected }

struct KYCData {
KYCStatus status;
string data; // In a real KYC system, this would be more detailed user data
}

mapping(address => KYCData) public kycRecords;

event KYCSubmitted(address user);

event KYCApproved(address user);
event KYCRejected(address user);

constructor() {
owner = msg.sender;
}

modi er onlyOwner() {
require(msg.sender == owner, "Only the owner can perform this action");
_;
}

function submitKYC(string memory _data) public {

require(kycRecords[msg.sender].status == KYCStatus.NotSubmitted, "KYC already
submitted");
kycRecords[msg.sender] = KYCData(KYCStatus.Pending, _data);
emit KYCSubmitted(msg.sender);
}

function approveKYC(address _user) public onlyOwner {

fi
fi
fi
 require(kycRecords[_user].status == KYCStatus.Pending, "KYC is not pending");
kycRecords[_user].status = KYCStatus.Approved;
emit KYCApproved(_user);
}

function rejectKYC(address _user) public onlyOwner {

require(kycRecords[_user].status == KYCStatus.Pending, "KYC is not pending");
kycRecords[_user].status = KYCStatus.Rejected;
emit KYCRejected(_user);
}
}

Output:
 Activity - 13
Problem Statement: Subscription Contract

Develop a contract for subscription-based services, enabling users to pay on a

recurring basis.

Pre-Requisites:

1. Remix Engine
2. Solidity Compiler

Program:

// SPDX-License-Identi er: MIT

pragma solidity ^0.8.0;

contract SubscriptionService {
address public owner;
uint256 public subscriptionPrice;
uint256 public nextPaymentDue;

event SubscriptionRenewed(address user, uint256 nextPaymentDue);

constructor(uint256 _subscriptionPrice) {
owner = msg.sender;
subscriptionPrice = _subscriptionPrice;
nextPaymentDue = block.timestamp + 30 days; // Initial subscription is for 30 days
}

modi er onlyOwner() {
require(msg.sender == owner, "Only the owner can perform this action");
_;
}

modi er subscriptionDue() {
require(block.timestamp >= nextPaymentDue, "Subscription payment is due");
_;
}

function setSubscriptionPrice(uint256 _newPrice) public onlyOwner {

subscriptionPrice = _newPrice;
}

function renewSubscription() public payable subscriptionDue {

require(msg.value >= subscriptionPrice, "Insu cient payment for subscription
renewal");

uint256 extraAmount = msg.value - subscriptionPrice;

if (extraAmount > 0) {
fi
fi
fi
ffi
 payable(msg.sender).transfer(extraAmount); // Refund extra payment
}

nextPaymentDue = nextPaymentDue + 30 days; // Renew for another 30 days

emit SubscriptionRenewed(msg.sender, nextPaymentDue);
}
}

Output:
 Activity - 14
Problem Statement: Stake Contract

Design a contract that allows users to stake tokens in return for rewards.

Pre-Requisites:

1. Remix Engine
2. Solidity Compiler

Program:

// SPDX-License-Identi er: MIT

pragma solidity ^0.8.0;

contract SimpleStaking {
address public owner;
uint256 public rewardRate;
uint256 public totalStaked;

mapping(address => uint256) public stakedBalances;

mapping(address => uint256) public rewards;

event Staked(address staker, uint256 amount);

event Unstaked(address staker, uint256 amount);
event RewardClaimed(address staker, uint256 amount);

constructor(uint256 _rewardRate) {
owner = msg.sender;
rewardRate = _rewardRate;
}

modi er onlyOwner() {
require(msg.sender == owner, "Only the owner can perform this action");
_;
}

function stake() public payable {

require(msg.value > 0, "Amount must be greater than 0");
stakedBalances[msg.sender] += msg.value;
totalStaked += msg.value;
emit Staked(msg.sender, msg.value);
}

function unstake(uint256 _amount) public {

require(stakedBalances[msg.sender] >= _amount, "Insu cient staked balance");
stakedBalances[msg.sender] -= _amount;
totalStaked -= _amount;
payable(msg.sender).transfer(_amount);
fi
fi
ffi
 emit Unstaked(msg.sender, _amount);
}

function claimReward() public {

uint256 reward = (stakedBalances[msg.sender] * rewardRate) / 100;
require(reward > 0, "No rewards to claim");
rewards[msg.sender] += reward;
emit RewardClaimed(msg.sender, reward);
}

function withdrawRewards() public {

uint256 reward = rewards[msg.sender];
require(reward > 0, "No rewards to withdraw");
rewards[msg.sender] = 0;
payable(msg.sender).transfer(reward);
}
}

Output:
 Activity - 15
Problem Statement: Pet Shop Contract

Design a contract that allows users to purchase pets from the shop.

Pre-Requisites:

1. Remix Engine
2. Solidity Compiler

Program:

pragma solidity 0.5.16;

contract Adoption {
address[16] public adopters;

function adopt(uint petId) public returns (uint) {

require(petId>=0 && petId<=15);
adopters[petId]=msg.sender;
return petId;
}

function getAdopters() public view returns(address[16] memory) {

return adopters;
}
}

Output: