Code Examples

Here are 10 code samples in Solidity demonstrating various concepts and functionalities.

1. Simple Storage Contract

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

contract SimpleStorage {
    uint256 storedData;

    function set(uint256 x) public {
        storedData = x;
    }

    function get() public view returns (uint256) {
        return storedData;
    }
}

2. Basic ERC20 Token

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

contract BasicERC20Token {
    string public name = "BasicToken";
    string public symbol = "BTK";
    uint8 public decimals = 18;
    uint256 public totalSupply;

    mapping(address => uint256) balances;
    mapping(address => mapping(address => uint256)) allowed;

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

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

    function balanceOf(address owner) public view returns (uint256) {
        return balances[owner];
    }

    function transfer(address to, uint256 value) public returns (bool) {
        require(to != address(0), "Invalid address");
        require(value <= balances[msg.sender], "Insufficient balance");

        balances[msg.sender] -= value;
        balances[to] += value;
        emit Transfer(msg.sender, to, value);
        return true;
    }

    function approve(address spender, uint256 value) public returns (bool) {
        allowed[msg.sender][spender] = value;
        emit Approval(msg.sender, spender, value);
        return true;
    }

    function transferFrom(address from, address to, uint256 value) public returns (bool) {
        require(to != address(0), "Invalid address");
        require(value <= balances[from], "Insufficient balance");
        require(value <= allowed[from][msg.sender], "Allowance exceeded");

        balances[from] -= value;
        balances[to] += value;
        allowed[from][msg.sender] -= value;
        emit Transfer(from, to, value);
        return true;
    }

    function allowance(address owner, address spender) public view returns (uint256) {
        return allowed[owner][spender];
    }
}

3. Voting Contract

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

contract Voting {
    struct Voter {
        bool voted;
        uint8 vote;
        uint256 weight;
    }

    struct Proposal {
        uint256 voteCount;
    }

    address public chairperson;
    mapping(address => Voter) public voters;
    Proposal[] public proposals;

    constructor(uint8 _numProposals) {
        chairperson = msg.sender;
        voters[chairperson].weight = 1;
        for (uint8 i = 0; i < _numProposals; i++) {
            proposals.push(Proposal({voteCount: 0}));
        }
    }

    function register(address toVoter) public {
        require(msg.sender == chairperson, "Only chairperson can register voters");
        require(!voters[toVoter].voted, "Voter already registered");
        voters[toVoter].weight = 1;
    }

    function vote(uint8 toProposal) public {
        Voter storage sender = voters[msg.sender];
        require(sender.weight != 0, "Has no right to vote");
        require(!sender.voted, "Already voted");
        require(toProposal < proposals.length, "Invalid proposal");

        sender.voted = true;
        sender.vote = toProposal;
        proposals[toProposal].voteCount += sender.weight;
    }

    function winningProposal() public view returns (uint8 _winningProposal) {
        uint256 winningVoteCount = 0;
        for (uint8 p = 0; p < proposals.length; p++) {
            if (proposals[p].voteCount > winningVoteCount) {
                winningVoteCount = proposals[p].voteCount;
                _winningProposal = p;
            }
        }
    }
}

4. Simple Auction Contract

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

contract SimpleAuction {
    address public beneficiary;
    uint256 public auctionEndTime;

    address public highestBidder;
    uint256 public highestBid;

    mapping(address => uint256) pendingReturns;
    bool ended;

    event HighestBidIncreased(address bidder, uint256 amount);
    event AuctionEnded(address winner, uint256 amount);

    constructor(
        uint256 _biddingTime,
        address _beneficiary
    ) {
        beneficiary = _beneficiary;
        auctionEndTime = block.timestamp + _biddingTime;
    }

    function bid() public payable {
        require(block.timestamp <= auctionEndTime, "Auction already ended");
        require(msg.value > highestBid, "There already is a higher bid");

        if (highestBid != 0) {
            pendingReturns[highestBidder] += highestBid;
        }
        highestBidder = msg.sender;
        highestBid = msg.value;
        emit HighestBidIncreased(msg.sender, msg.value);
    }

    function withdraw() public returns (bool) {
        uint256 amount = pendingReturns[msg.sender];
        if (amount > 0) {
            pendingReturns[msg.sender] = 0;
            if (!payable(msg.sender).send(amount)) {
                pendingReturns[msg.sender] = amount;
                return false;
            }
        }
        return true;
    }

    function auctionEnd() public {
        require(block.timestamp >= auctionEndTime, "Auction not yet ended");
        require(!ended, "auctionEnd has already been called");

        ended = true;
        emit AuctionEnded(highestBidder, highestBid);

        payable(beneficiary).transfer(highestBid);
    }
}

5. Crowdfunding Contract

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

contract Crowdfunding {
    struct Campaign {
        address payable beneficiary;
        uint256 fundingGoal;
        uint256 amountRaised;
        uint256 deadline;
        mapping(address => uint256) contributions;
    }

    mapping(uint256 => Campaign) public campaigns;
    uint256 public numCampaigns;

    function startCampaign(uint256 fundingGoal, uint256 duration) public {
        numCampaigns++;
        Campaign storage c = campaigns[numCampaigns];
        c.beneficiary = payable(msg.sender);
        c.fundingGoal = fundingGoal;
        c.deadline = block.timestamp + duration;
    }

    function contribute(uint256 campaignID) public payable {
        Campaign storage c = campaigns[campaignID];
        require(block.timestamp < c.deadline, "Campaign has ended");
        c.contributions[msg.sender] += msg.value;
        c.amountRaised += msg.value;
    }

    function withdraw(uint256 campaignID) public {
        Campaign storage c = campaigns[campaignID];
        require(block.timestamp >= c.deadline, "Campaign is still ongoing");
        require(msg.sender == c.beneficiary, "Only the beneficiary can withdraw");

        if (c.amountRaised >= c.fundingGoal) {
            c.beneficiary.transfer(c.amountRaised);
        } else {
            payable(msg.sender).transfer(c.contributions[msg.sender]);
            c.contributions[msg.sender] = 0;
        }
    }
}

6. Multi-Signature Wallet

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

contract MultiSigWallet {
    address[] public owners;
    uint256 public required;

    struct Transaction {
        address destination;
        uint256 value;
        bool executed;
        mapping(address => bool) confirmations;
    }

    mapping(uint256 => Transaction) public transactions;
    uint256 public transactionCount;

    modifier onlyOwner() {
        require(isOwner(msg.sender), "Not owner");
        _;
    }

    modifier confirmed(uint256 transactionId, address owner) {
        require(transactions[transactionId].confirmations[owner], "Not confirmed");
        _;
    }

    modifier notConfirmed(uint256 transactionId, address owner) {
        require(!transactions[transactionId].confirmations[owner], "Already confirmed");
        _;
    }

    modifier notExecuted(uint256 transactionId) {
        require(!transactions[transactionId].executed, "Already executed");
        _;
    }

    constructor(address[] memory _owners, uint256 _required) {
        require(_owners.length > 0, "Owners required");
        require(_required > 0 && _required <= _owners.length, "Invalid required number of owners");

        for (uint256 i = 0; i < _owners.length; i++) {
            require(!isOwner(_owners[i]) && _owners[i] != address(0), "Invalid owner");
            owners.push(_owners[i]);
        }
        required = _required;
    }

    function isOwner(address addr) public view returns (bool) {
        for (uint256 i = 0; i < owners.length; i++) {
            if (owners[i] == addr) {
                return true;
            }
        }
        return false;
    }

    function submitTransaction(address destination, uint256 value) public onlyOwner {
        transactionCount++;
        Transaction storage t = transactions[transactionCount];
        t.destination = destination;
        t.value = value;
    }

    function confirmTransaction(uint256 transactionId) public onlyOwner notConfirmed(transactionId, msg.sender) {
        transactions[transactionId].confirmations[msg.sender] = true;
        if (isConfirmed(transactionId)) {
            executeTransaction(transactionId);
        }
    }

    function executeTransaction(uint256 transactionId) public onlyOwner notExecuted(transactionId) {
        if (isConfirmed(transactionId)) {
            Transaction storage t = transactions[transactionId];
            t.executed = true;
            payable(t.destination).transfer(t.value);
        }
    }

    function isConfirmed(uint256 transactionId) public view returns (bool) {
        uint256 count = 0;
        for (uint256 i = 0; i < owners.length; i++) {
            if (transactions[transactionId].confirmations[owners[i]]) {
                count += 1;
            }
            if (count == required) {
                return true;
            }
        }
        return false;
    }
}

7. Lottery Contract

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

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

    constructor() {
        manager = msg.sender;
    }

    function enter() public payable {
        require(msg.value > .01 ether, "Minimum ether not met");
        players.push(msg.sender);
    }

    function random() private view returns (uint256) {
        return uint256(keccak256(abi.encodePacked(block.difficulty, block.timestamp, players)));
    }

    function pickWinner() public restricted {
        uint256 index = random() % players.length;
        payable(players[index]).transfer(address(this).balance);
        players = new address ;
    }

    modifier restricted() {
        require(msg.sender == manager, "Not manager");
        _;
    }

    function getPlayers() public view returns (address[] memory) {
        return players;
    }
}

8. Time-Locked Wallet

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

contract TimeLockedWallet {
    address public creator;
    address public owner;
    uint256 public unlockTime;

    constructor(
        address _creator,
        address _owner,
        uint256 _unlockTime
    ) payable {
        creator = _creator;
        owner = _owner;
        unlockTime = _unlockTime;
    }

    function withdraw() public {
        require(block.timestamp >= unlockTime, "Funds are locked");
        require(msg.sender == owner, "Only owner can withdraw");
        payable(owner).transfer(address(this).balance);
    }

    function info() public view returns (address, address, uint256, uint256) {
        return (creator, owner, unlockTime, address(this).balance);
    }
}

9. Decentralized Marketplace

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

contract Marketplace {
    struct Product {
        uint256 id;
        string name;
        uint256 price;
        address payable seller;
        address buyer;
        bool delivered;
    }

    uint256 public productCount;
    mapping(uint256 => Product) public products;

    function listProduct(string memory _name, uint256 _price) public {
        require(_price > 0, "Price must be greater than zero");
        productCount++;
        products[productCount] = Product(productCount, _name, _price, payable(msg.sender), address(0), false);
    }

    function buyProduct(uint256 _id) public payable {
        Product storage product = products[_id];
        require(msg.value == product.price, "Incorrect amount sent");
        require(product.seller != msg.sender, "Seller cannot buy their own product");
        require(product.buyer == address(0), "Product already sold");

        product.buyer = msg.sender;
        product.seller.transfer(msg.value);
    }

    function markAsDelivered(uint256 _id) public {
        Product storage product = products[_id];
        require(msg.sender == product.buyer, "Only buyer can mark as delivered");
        product.delivered = true;
    }

    function getProduct(uint256 _id) public view returns (Product memory) {
        return products[_id];
    }
}

10. Decentralized Library

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

contract DecentralizedLibrary {
    struct Book {
        uint256 id;
        string title;
        string author;
        address currentHolder;
    }

    uint256 public bookCount;
    mapping(uint256 => Book) public books;

    function addBook(string memory _title, string memory _author) public {
        bookCount++;
        books[bookCount] = Book(bookCount, _title, _author, msg.sender);
    }

    function borrowBook(uint256 _id) public {
        Book storage book = books[_id];
        require(book.currentHolder != msg.sender, "You already have this book");
        book.currentHolder = msg.sender;
    }

    function returnBook(uint256 _id) public {
        Book storage book = books[_id];
        require(book.currentHolder == msg.sender, "You do not have this book");
        book.currentHolder = address(0);
    }

    function getBook(uint256 _id) public view returns (Book memory) {
        return books[_id];
    }
}

These examples cover a range of functionalities, including simple storage, tokens, voting, auctions, crowdfunding, multi-signature wallets, lotteries, time-locked wallets, decentralized marketplaces, and libraries. Each contract demonstrates key Solidity concepts and patterns.