Solidity Development 101

hvbjubjknklnkjbkjbkjbkjbjkh

The smart contract I developed is aim for the insurance industry, mainly for small-time insurance like premium Watches and Gadgets.

Solidity smart contract named Mintify, implements an ERC721 token with minting functionality. It allows users to mint NFTs by paying a specified price per NFT. The contract also supports whitelisting functionality, where whitelisted users can mint tokens at a different price. The contract owner can set various parameters such as the base URI, mint price, whitelist price, maximum supply, and maximum tokens per wallet. ## Features - Price tiers for minting: `mintPrice` and `whitelistPrice` - Maximum supply limit: `maxSupply` - Maximum mints per wallet limit: `maxPerWallet` - Base URI for token metadata: `baseURI` - Whitelist for certain addresses: `whitelisted`

The provided code implements a Solidity smart contract for managing non-fungible tokens (NFTs) on the Ethereum blockchain. Here's a brief explanation of what the code does: 1. Contract Initialization: The contract is initialized with the name "MyNFT" and the symbol "MNFT". 2. Minting Tokens: The contract owner can mint new NFTs and assign them to specific recipients. Each token has a unique identifier (token ID) that increments with each minting. 3. Burning Tokens: The contract owner can burn (delete) existing NFTs by their token IDs. This removes the tokens from circulation. 4. Total Supply: The contract provides a function to query the total number of tokens minted. Overall, this contract provides basic functionality for minting, burning, and querying NFTs. It can be deployed on the Ethereum network and interacted with using Ethereum wallets like MetaMask. To set up and test this contract using Hardhat: 1. Install Hardhat and initialize a new project: bash Copy code npm install --save-dev hardhat npx hardhat 2. Install the required dependencies: bash Copy code npm install @openzeppelin/contracts 3. Replace the content of contracts/MyNFT.sol in your Hardhat project with the provided contract code. 4. Write tests in the test/ directory to verify the functionality of the contract. 5. Compile the contract: bash Copy code npx hardhat compile 6. Test the contract: bash Copy code npx hardhat test 7. Deploy the contract to a testnet or local Ethereum network: bash Copy code npx hardhat run scripts/deploy.js Make sure to replace the placeholder content in deploy.js with the actual deployment logic.

blockchain blood bank management system This is a smart contract for a Blood Bank Management System implemented on the Ethereum blockchain. The system allows users to register as donors, patients, and hospitals, facilitating the donation and request of blood.

Welcome to ArtMintify, where creativity meets the blockchain! ArtMintify is a cutting-edge platform that empowers artists, creators, and enthusiasts to turn their digital art into unique and tradable assets known as Non-Fungible Tokens (NFTs). Our user-friendly interface makes the minting process a breeze, allowing you to effortlessly upload your favorite images and transform them into one-of-a-kind NFTs. ArtMintify supports a variety of file formats, giving you the flexibility to express your artistic vision. Customize your NFTs with metadata, set royalties, and explore different editions to make your creations truly stand out. Powered by secure and audited smart contracts on the Ethereum blockchain, ArtMintify ensures the integrity of your digital assets. Join our vibrant ArtMintify community, where artists and collectors connect. Whether you're an experienced NFT creator or a newcomer to the space, our platform provides the tools and resources you need to thrive. Dive into the world of decentralized digital art ownership with ArtMintify – where every upload is a masterpiece and every NFT tells a unique story. Unlock the potential of your creativity. Mint it with ArtMintify! Feel free to adjust the name and description based on your vision and the specific features of your platform.

The purpose of the "Charity Donation NFT" contract is to facilitate charitable donations with NFT rewards. Donors receive unique NFTs for their contributions, enhancing transparency and engagement. The contract includes a voting system, allowing NFT holders to influence charity project decisions. It tracks donations, donors, and project details, promoting accountability. This contract enhances donor engagement and trust, as NFTs serve as a tangible recognition of contributions, and the voting mechanism deepens donor involvement in charitable activities. Additionally, the transparent record-keeping of donations and projects can boost confidence in the charity's operations.

A decentralized agricultural platform that bridges the gap between investors with farming capital to farmers in need and facilitates connections between farmers and available arable land.

This Solidity smart contract manages package logistics. It uses enums to represent package statuses, includes a package data structure, and allows sending packages to recipients. The contract enables updating status by the sender, recipient, or carrier and assigning carriers by the sender. Events log package actions on the blockchain. It applies the concept of blockchain in supply chain management through product supply, carriage and delivery.

The "Carpooling" smart contract enables decentralized carpooling on the Ethereum blockchain. Users can register, create rides with specific details, view available rides, and book seats. Ride owners can cancel rides, triggering refunds for booked seats. The contract includes basic refund logic using the transfer function and logs important actions through events. It serves as a foundation for a decentralized carpooling platform, facilitating transparent and secure ride-sharing interactions on the blockchain.

This is an CELO blockchain Name service and market place that allows users reserve, select background color of the nft, list and sell there favorite names. basically names are sold as nfts. Its like a domain service but for the celo blockchain. the concept is inspired by the ENS(ethereum name service).

the purpose of our contract captures key information about each crop, including its ID, name, and status (harvested, distributed, consumed). This information can be used for quality control purposes, helping to identify and address issues in the supply chain that may impact the quality of the crops. Consumer Confidence: Consumers can use the information recorded on the blockchain to verify the authenticity and origin of the crops they purchase. This increased transparency can lead to greater consumer confidence in the quality and safety of the agricultural products. Reduced Fraud and Counterfeiting: The immutability of the blockchain ensures that once information is recorded, it cannot be altered or tampered with. This reduces the risk of fraud and counterfeiting in the supply chain, as the history of each crop is securely stored on the blockchain. Smart Contract Automation: The use of smart contracts automates certain processes, such as updating the status of a crop or triggering events based on specific conditions. This automation can lead to increased efficiency and reduced administrative overhead in managing the agricultural supply chain.

//patient and treatment registry // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; contract PatientRegistry { // Struct to represent a treatment struct Treatment { string description; uint256 cost; uint256 timestamp; address doctorAddress; } // Struct to represent a doctor struct Doctor { string name; bool isRegistered; } // Struct to represent a patient struct Patient { string name; uint256 age; address walletAddress; bool isRegistered; Treatment[] treatments; } // Mapping to store doctors mapping(address => Doctor) public doctors; // Mapping to store patients mapping(address => Patient) public patients; // Event to notify when a new patient is registered event PatientRegistered(address indexed patientAddress, string name, uint256 age); // Event to notify when a treatment is recorded event TreatmentRecorded(address indexed patientAddress, address indexed doctorAddress, string description, uint256 cost, uint256 timestamp); // Modifier to ensure that only registered patients can access certain functions modifier onlyRegisteredPatients() { require(patients[msg.sender].isRegistered, "Patient not registered"); _; } // Modifier to ensure that only registered doctors can access certain functions modifier onlyRegisteredDoctors() { require(doctors[msg.sender].isRegistered, "Access denied!"); _; } // Function to register a new patient function registerPatient(string memory _name, uint256 _age) external { require(!patients[msg.sender].isRegistered, "Patient already registered"); Patient storage newPatient = patients[msg.sender]; newPatient.name = _name; newPatient.age = _age; newPatient.walletAddress = msg.sender; newPatient.isRegistered = true; emit PatientRegistered(msg.sender, _name, _age); } // Function to register a new doctor function registerDoctor(string memory _name) external { require(!doctors[msg.sender].isRegistered, "Doctor already registered"); Doctor storage newDoctor = doctors[msg.sender]; newDoctor.name = _name; newDoctor.isRegistered = true; } // Function to record a treatment for a patient function recordTreatment(address _patientAddress, string memory _description, uint256 _cost) external onlyRegisteredDoctors { Treatment memory newTreatment = Treatment({ description: _description, cost: _cost, timestamp: block.timestamp, doctorAddress: msg.sender }); patients[_patientAddress].treatments.push(newTreatment); emit TreatmentRecorded(_patientAddress, msg.sender, _description, _cost, block.timestamp); } // Function to get patient details including treatments function getPatientDetails() external view onlyRegisteredPatients returns (string memory, uint256, address, Treatment[] memory) { Patient storage patient = patients[msg.sender]; return (patient.name, patient.age, patient.walletAddress, patient.treatments); } // Function to get patient records for a single patient function getPatientRecords(address _patientAddress) external view returns (string memory, uint256, address, Treatment[] memory) { require( msg.sender == _patientAddress || doctors[msg.sender].isRegistered, "Caller is not the patient or a registered doctor" ); Patient storage patient = patients[_patientAddress]; return (patient.name, patient.age, patient.walletAddress, patient.treatments); } }

// SPDX-License-Identifier: MIT pragma solidity ^0.8.3; contract Lottery { address public owner; address payable[] public players; uint public lotteryId; mapping (uint => address payable) public lotteryHistory; constructor() { owner = msg.sender; lotteryId = 1; } function getWinnerByLottery(uint lottery) public view returns (address payable) { return lotteryHistory[lottery]; } function getBalance() public view returns (uint) { return address(this).balance; } function getPlayers() public view returns (address payable[] memory) { return players; } function enter() public payable { require(msg.value > .01 ether); players.push(payable(msg.sender)); } function getRandomNumber() public view returns (uint) { return uint(keccak256(abi.encodePacked(owner, block.timestamp))); } function pickWinner() public onlyowner { uint index = getRandomNumber() % players.length; players[index].transfer(address(this).balance); lotteryHistory[lotteryId] = players[index]; lotteryId++; players = new address payable[](0); } modifier onlyowner() { require(msg.sender == owner); _; } }

The project is a blockchain-based system within a smart contract named "Hospital" that manages patient data, allowing recording and retrieval of medical information such as medical history, test results, prescribed drugs, and doctor's name using unique patient IDs.

here is my submission

The "WarrantyNFT" contract is a powerful Ethereum smart contract that manages warranties for NFTs. It allows retailers to mint NFTs with warranties, control warranty status, and document repair history. Ownership and access control are flexible, and users can check warranty validity. It also ensures safe NFT transfers and inherits standard NFT functions. This contract enhances NFT asset protection and transparency, making it a valuable addition to the NFT ecosystem.

Here is different use case of NFTs, a decentralized digital art marketplace with bidding and royalty features

Introducing FootballNFT, a user-friendly Solidity contract that brings the excitement of football to the world of non-fungible tokens. With FootballNFT, users can effortlessly create their own personalized football player NFTs, capturing the essence of their favorite players with customizable attributes like name, number, and position.

This Contract provides a way for a barber shop to handle their customer appointments. There is a set fee for each service rendered(Hair Cut, Hair Treatment, e.t.c) and customer priority(Home Service, VIP, Regular) in the smart contract. Each Customer is identified by their address(msg.sender) and their transactions are stored using their address as key.

This is a dynamic NFT marketplace, where users can mint, list(for selling), and buy NFTs. It is dynamic because it is not meant for only one NFT contract. it can interact with any NFT contract.

This a simple Bounty platform contract. It can provide guarantee for the bounty content. But there is no guarantee that the funder would choose you tobe the winner. Anyone can post a bounty. Anyone can apply for a valid bounty and strive for rewards.

Trustfund is a smart contract that locks both ERC20 and ERC721 tokens for a specified duration. On contract deployment the addresses of the benefactor and spender are collected in order to restrict access to the contracts withdrawal functions. The benefactor is able to set a new spender address. The lock duration of the contract can be increased as well.

That's a project built with Hardhat. You must run "npx hardhat run scripts/deploy.js --network goerli" to create your collection. You can change the name of the collection and interact with the contract. On root folder create a .env file and add the next info: QUICKNODE_API_KEY_URL= GOERLI_PRIVATE_KEY=

TicketSub is a simple ticketing system for air travellers. This smart contract allows airlines to issue tickets. Every time a ticket is purchased, an NFT will be sent to the user. Users can by ticket using token which will be sent to the admin wallet. The user signs using their wallet to redeem the ticket for the actual flight. This confirms the possession of the ticket. This also prevents the administrator from redeeming user's ticket without their consent. The admin can delete an unsold ticket. Users can also transfer the NFT to other user but not the actual ticket.

Collab is a blockchain based solution to end to end group conversations and collaboration between groups and teams. It is a platform where businesses and individuals come to have conversations for free of charge. Collab contract was built using the latest version of the solidity programming language. It's features are listed in the READM file on GitHub.

The contract create Minting to users with specified Price. The contract's conditions required are: 1- contract should be toggled to enable minting. 2- total suplly should be less than max supply. 3- provided value should equal nft price 4- user should not minted before

This is an NFT Collection DApps deployed on Mumbai testnet where user can mint NFT. Project build in NextJs and Hardhat and already deployed on Vercel https://nft-collection-ipfs-taupe.vercel.app/ Some of the key requirements when building this projects are - Total of 10 NFT can be minted and each one of them is unique - User can mint one nft with one transaction - User need to connect their wallet before mint the NFT - The NFT metadata are stored in IPFS

I've created a smart contract where users can Create, Update and Delete Todos list. It will keep track of all the todos of each user separately. Kindly review it.

Simple Smart Contract to Stake Tokens Backend https://github.com/Kron1749/Full-Defi-App-Hardhat Frontend https://github.com/Kron1749/full-defi-app-hardhat-frontend