Show the world the most gas-optimized,secure contract it has ever seen(Just Kidding,It's beginner friendly)
3 |
285 |
286 |
--------------------------------------------------------------------------------
/contracts/Auction/DutchAuction.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 |
3 | pragma solidity ^0.8.7;
4 |
5 | interface IERC721 {
6 | function transferFrom(
7 | address _from,
8 | address _to,
9 | uint256 _nftId
10 | ) external;
11 | }
12 |
13 | contract DutchAuction {
14 | event Buy(address winner, uint256 amount);
15 |
16 | IERC721 public immutable nft;
17 | uint256 public immutable nftId;
18 |
19 | address payable public seller;
20 | uint256 public startingPrice;
21 | uint256 public startAt;
22 | uint256 public expiresAt;
23 | uint256 public priceDeductionRate;
24 | address public winner;
25 |
26 | constructor(
27 | uint256 _startingPrice,
28 | uint256 _priceDeductionRate,
29 | address _nft,
30 | uint256 _nftId
31 | ) {
32 | seller = payable(msg.sender);
33 | startingPrice = _startingPrice;
34 | startAt = block.timestamp;
35 | expiresAt = block.timestamp + 7 days; //Expires in week from the start
36 | priceDeductionRate = _priceDeductionRate;
37 |
38 | nft = IERC721(_nft);
39 | nftId = _nftId;
40 | }
41 |
42 | function buy() external payable {
43 | // Check for the timestamp before buy
44 | require(block.timestamp < expiresAt, "auction expired");
45 |
46 | require(winner == address(0), "auction finished");
47 |
48 | uint256 timeElapsed = block.timestamp - startAt;
49 | uint256 deduction = priceDeductionRate * timeElapsed;
50 | uint256 price = startingPrice - deduction;
51 |
52 | require(msg.value >= price, "ETH < price");
53 |
54 | winner = msg.sender;
55 | nft.transferFrom(seller, msg.sender, nftId);
56 | seller.transfer(msg.value);
57 |
58 | emit Buy(msg.sender, msg.value);
59 | }
60 | }
61 |
--------------------------------------------------------------------------------
/contracts/Auction/EnglishAuction.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 |
3 | pragma solidity ^0.8.7;
4 |
5 | interface IERC721 {
6 | function transfer(address, uint) external;
7 |
8 | function transferFrom(
9 | address,
10 | address,
11 | uint
12 | ) external;
13 | }
14 |
15 | //Seller of NFT deploys this contract.
16 | //Auction lasts for 7 days.
17 | //Participants can bid by depositing ETH greater than the current highest bidder.
18 |
19 | contract Auction {
20 | event Start();
21 | event End(address highestBidder, uint highestBid);
22 | event Bid(address indexed sender, uint amount);
23 | event Withdraw(address indexed bidder, uint amount);
24 |
25 | address payable public seller;
26 |
27 | bool public started;
28 | bool public ended;
29 | uint public endAt;
30 |
31 | IERC721 public nft;
32 | uint public nftId;
33 |
34 | uint public highestBid;
35 | address public highestBidder;
36 | mapping(address => uint) public bids;
37 |
38 | constructor () {
39 | seller = payable(msg.sender);
40 | }
41 |
42 | function start(IERC721 _nft, uint _nftId, uint startingBid) external {
43 | require(!started, "Already started!");
44 | require(msg.sender == seller, "You did not start the auction!");
45 | highestBid = startingBid;
46 |
47 | nft = _nft;
48 | nftId = _nftId;
49 | nft.transferFrom(msg.sender, address(this), nftId);
50 |
51 | started = true;
52 | endAt = block.timestamp + 7 days;
53 |
54 | emit Start();
55 | }
56 |
57 | function bid() external payable {
58 | require(started, "Not started.");
59 | require(block.timestamp < endAt, "Ended!");
60 | require(msg.value > highestBid);
61 |
62 | if (highestBidder != address(0)) {
63 | bids[highestBidder] += highestBid;
64 | }
65 |
66 | highestBid = msg.value;
67 | highestBidder = msg.sender;
68 |
69 | emit Bid(highestBidder, highestBid);
70 | }
71 |
72 | function withdraw() external payable {
73 | uint bal = bids[msg.sender];
74 | bids[msg.sender] = 0;
75 | (bool sent, bytes memory data) = payable(msg.sender).call{value: bal}("");
76 | require(sent, "Could not withdraw");
77 |
78 | emit Withdraw(msg.sender, bal);
79 | }
80 |
81 | function end() external {
82 | require(started, "You need to start first!");
83 | require(block.timestamp >= endAt, "Auction is still ongoing!");
84 | require(!ended, "Auction already ended!");
85 |
86 | if (highestBidder != address(0)) {
87 | nft.transfer(highestBidder, nftId);
88 | (bool sent, bytes memory data) = seller.call{value: highestBid}("");
89 | require(sent, "Could not pay seller!");
90 | } else {
91 | nft.transfer(seller, nftId);
92 | }
93 |
94 | ended = true;
95 | emit End(highestBidder, highestBid);
96 | }
97 | }
--------------------------------------------------------------------------------
/contracts/Auction/SimpleAuction.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: GPL-3.0
2 | pragma solidity ^0.8.4;
3 |
4 | contract SimpleAuction {
5 | // Parameters of the auction. Times are either
6 | // absolute unix timestamps (seconds since 1970-01-01)
7 | // or time periods in seconds.
8 | address payable public beneficiary;
9 | uint256 public auctionEndTime;
10 |
11 | // Current state of the auction.
12 | address public highestBidder;
13 | uint256 public highestBid;
14 |
15 | // Allowed withdrawals of previous bids
16 | mapping(address => uint256) pendingReturns;
17 |
18 | // Set to true at the end, disallows any change.
19 | // By default initialized to `false`.
20 | bool ended;
21 |
22 | // Events that will be emitted on changes.
23 | event HighestBidIncreased(address bidder, uint256 amount);
24 | event AuctionEnded(address winner, uint256 amount);
25 |
26 | // Errors that describe failures.
27 | /// The auction has already ended.
28 | error AuctionAlreadyEnded();
29 | /// There is already a higher or equal bid.
30 | error BidNotHighEnough(uint256 highestBid);
31 | /// The auction has not ended yet.
32 | error AuctionNotYetEnded();
33 | /// The function auctionEnd has already been called.
34 | error AuctionEndAlreadyCalled();
35 |
36 | /// Create a simple auction with `biddingTime`
37 | /// seconds bidding time on behalf of the
38 | /// beneficiary address `beneficiaryAddress`.
39 | constructor(uint256 biddingTime, address payable beneficiaryAddress) {
40 | beneficiary = beneficiaryAddress;
41 | auctionEndTime = block.timestamp + biddingTime;
42 | }
43 |
44 | /// Bid on the auction with the value sent
45 | /// together with this transaction.
46 | /// The value will only be refunded if the
47 | /// auction is not won.
48 | function bid() external payable {
49 | // Revert the call if the bidding
50 | // period is over.
51 | if (block.timestamp > auctionEndTime) revert AuctionAlreadyEnded();
52 |
53 | // If the bid is not higher, send the
54 | // money back (the revert statement
55 | // will revert all changes in this
56 | // function execution including
57 | // it having received the money).
58 | if (msg.value <= highestBid) revert BidNotHighEnough(highestBid);
59 |
60 | if (highestBid != 0) {
61 | // Sending back the money by simply using
62 | // highestBidder.send(highestBid) is a security risk
63 | // because it could execute an untrusted contract.
64 | // It is always safer to let the recipients
65 | // withdraw their money themselves.
66 | pendingReturns[highestBidder] += highestBid;
67 | }
68 | highestBidder = msg.sender;
69 | highestBid = msg.value;
70 | emit HighestBidIncreased(msg.sender, msg.value);
71 | }
72 |
73 | /// Withdraw a bid that was overbid.
74 | function withdraw() external returns (bool) {
75 | uint256 amount = pendingReturns[msg.sender];
76 | if (amount > 0) {
77 | // It is important to set this to zero because the recipient
78 | // can call this function again as part of the receiving call
79 | // before `send` returns.
80 | pendingReturns[msg.sender] = 0;
81 |
82 | // msg.sender is not of type `address payable` and must be
83 | // explicitly converted using `payable(msg.sender)` in order
84 | // use the member function `send()`.
85 | if (!payable(msg.sender).send(amount)) {
86 | // No need to call throw here, just reset the amount owing
87 | pendingReturns[msg.sender] = amount;
88 | return false;
89 | }
90 | }
91 | return true;
92 | }
93 |
94 | /// End the auction and send the highest bid
95 | /// to the beneficiary.
96 | function auctionEnd() external {
97 | // 1. Conditions
98 | if (block.timestamp < auctionEndTime) revert AuctionNotYetEnded();
99 | if (ended) revert AuctionEndAlreadyCalled();
100 |
101 | // 2. Effects
102 | ended = true;
103 | emit AuctionEnded(highestBidder, highestBid);
104 |
105 | // 3. Interaction
106 | beneficiary.transfer(highestBid);
107 | }
108 | }
109 |
--------------------------------------------------------------------------------
/contracts/Banking/BankingSystem.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | pragma solidity ^0.8.0;
3 |
4 | contract BankingSystem {
5 |
6 | mapping(address => uint256) public balanceOf; // balanceOf, indexed by addresses
7 |
8 | function deposit() public payable {
9 | balanceOf[msg.sender] += msg.value;
10 | }
11 |
12 | function withdraw(uint _amount) public {
13 | require (balanceOf[msg.sender] >= _amount, "Insufficent Funds");
14 | balanceOf[msg.sender] -= _amount;
15 | (bool sent,) = msg.sender.call{value: _amount}("Sent");
16 | require(sent, "Failed to Complete");
17 | }
18 |
19 | // transferAmt function transfers ether from one account to another
20 | function transferAmt(address payable _address, uint _amount) public {
21 | require (balanceOf[msg.sender] >= _amount, "Insufficent Funds");
22 | _address.transfer(_amount);
23 | }
24 |
25 | }
26 |
--------------------------------------------------------------------------------
/contracts/Blog/Blog.sol:
--------------------------------------------------------------------------------
1 | //SPDX-License-Identifier: Unlicense
2 | pragma solidity ^0.8.7;
3 |
4 | import "hardhat/console.sol";
5 | import "@openzeppelin/contracts/access/Ownable.sol";
6 |
7 | //Using inheritance
8 | contract Blog is Ownable {
9 | //creating an event to create a post
10 | event PostCreated(uint id, string title, string _hash);
11 | //creating an event to update a post
12 | event PostUpdated(uint id, string title, string _hash, bool published);
13 |
14 | // creating a struct of post which to define all the propeties a post should hvae
15 | struct Post {
16 | uint id;
17 | string title;
18 | string content;
19 | address publisher;
20 | bool published;
21 | }
22 |
23 | string public name;
24 | uint private latestPostId;
25 |
26 | //creating a mapping
27 | mapping(uint => Post) private idToPost;
28 | mapping(string => Post) private hashToPost;
29 |
30 | // defining a contructor so that while deploying it would show the deployer's name
31 | constructor(string memory _name) {
32 | console.log("Deploy with name: ", name);
33 | name = _name;
34 | }
35 |
36 | //function to update name
37 | function updateName(string memory _name) public onlyOwner {
38 | name = _name;
39 | }
40 | // function to get a Post
41 | function getPost(string memory _hash) public view returns (Post memory) {
42 | return hashToPost[_hash];
43 | }
44 | // function to create a post
45 | function createPost(string memory title, string memory _hash) public {
46 | Post memory post = Post({
47 | id: ++latestPostId,
48 | title: title,
49 | content: _hash,
50 | publisher: msg.sender,
51 | published: true
52 | });
53 | hashToPost[_hash] = post;
54 | idToPost[latestPostId] = post;
55 |
56 | emit PostCreated(latestPostId, title, _hash);
57 | }
58 |
59 | //function to update the post
60 | function updatePost(uint id, string memory title, string memory _hash, bool published) public {
61 | require(idToPost[id].publisher == msg.sender, "forbidden");
62 | Post storage post = idToPost[id];
63 | post.title = title;
64 | post.content = _hash;
65 | post.published = published;
66 | hashToPost[_hash] = post;
67 |
68 | emit PostUpdated(id, title, _hash, published);
69 | }
70 | // funciton to get the updated post
71 | function getPosts() public view returns (Post[] memory posts) {
72 | posts = new Post[](latestPostId);
73 |
74 | for(uint i=1; i<=latestPostId; i++) {
75 | posts[i-1] = idToPost[i];
76 | }
77 |
78 | return posts;
79 | }
80 | }
--------------------------------------------------------------------------------
/contracts/Coins/erc20std.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | pragma solidity ^0.8.4;
3 |
4 | import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
5 | import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
6 | import "@openzeppelin/contracts/access/Ownable.sol";
7 |
8 | // constructor with token name and symbol
9 | contract AdvaitaCoin is ERC20, ERC20Burnable, Ownable {
10 | constructor() ERC20("Advaita Coin", "ADV") {
11 | _mint(msg.sender, 10000 * 10 ** decimals());
12 | }
13 |
14 | function mint(address to, uint256 amount) public onlyOwner {
15 | _mint(to, amount);
16 | }
17 | }
--------------------------------------------------------------------------------
/contracts/DAO/metadao.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | pragma solidity ^0.8.9;
3 |
4 | contract MetaDAO {
5 |
6 | event PostCreated (bytes32 indexed postId, address indexed postOwner, bytes32 indexed parentId, bytes32 contentId, bytes32 categoryId);
7 | event ContentAdded (bytes32 indexed contentId, string contentUri);
8 | event CategoryCreated (bytes32 indexed categoryId, string category);
9 | event Voted (bytes32 indexed postId, address indexed postOwner, address indexed voter, uint80 reputationPostOwner, uint80 reputationVoter, int40 postVotes, bool up, uint8 reputationAmount);
10 |
11 | struct post {
12 | address postOwner;
13 | bytes32 parentPost;
14 | bytes32 contentId;
15 | int40 votes;
16 | bytes32 categoryId;
17 | }
18 |
19 | mapping (address => mapping (bytes32 => uint80)) reputationRegistry;
20 | mapping (bytes32 => string) categoryRegistry;
21 | mapping (bytes32 => string) contentRegistry;
22 | mapping (bytes32 => post) postRegistry;
23 | mapping (address => mapping (bytes32 => bool)) voteRegistry;
24 |
25 | function createPost(bytes32 _parentId, string calldata _contentUri, bytes32 _categoryId) external {
26 | address _owner = msg.sender;
27 | bytes32 _contentId = keccak256(abi.encode(_contentUri));
28 | bytes32 _postId = keccak256(abi.encodePacked(_owner,_parentId, _contentId));
29 | contentRegistry[_contentId] = _contentUri;
30 | postRegistry[_postId].postOwner = _owner;
31 | postRegistry[_postId].parentPost = _parentId;
32 | postRegistry[_postId].contentId = _contentId;
33 | postRegistry[_postId].categoryId = _categoryId;
34 | emit ContentAdded(_contentId, _contentUri);
35 | emit PostCreated (_postId, _owner,_parentId,_contentId,_categoryId);
36 | }
37 |
38 | function voteUp(bytes32 _postId, uint8 _reputationAdded) external {
39 | address _voter = msg.sender;
40 | bytes32 _category = postRegistry[_postId].categoryId;
41 | address _contributor = postRegistry[_postId].postOwner;
42 | require (postRegistry[_postId].postOwner != _voter, "you cannot vote your own posts");
43 | require (voteRegistry[_voter][_postId] == false, "Sender already voted in this post");
44 | require (validateReputationChange(_voter,_category,_reputationAdded)==true, "This address cannot add this amount of reputation points");
45 | postRegistry[_postId].votes += 1;
46 | reputationRegistry[_contributor][_category] += _reputationAdded;
47 | voteRegistry[_voter][_postId] = true;
48 | emit Voted(_postId, _contributor, _voter, reputationRegistry[_contributor][_category], reputationRegistry[_voter][_category], postRegistry[_postId].votes, true, _reputationAdded);
49 | }
50 |
51 | function voteDown(bytes32 _postId, uint8 _reputationTaken) external {
52 | address _voter = msg.sender;
53 | bytes32 _category = postRegistry[_postId].categoryId;
54 | address _contributor = postRegistry[_postId].postOwner;
55 | require (voteRegistry[_voter][_postId] == false, "Sender already voted in this post");
56 | require (validateReputationChange(_voter,_category,_reputationTaken)==true, "This address cannot take this amount of reputation points");
57 | postRegistry[_postId].votes >= 1 ? postRegistry[_postId].votes -= 1: postRegistry[_postId].votes = 0;
58 | reputationRegistry[_contributor][_category] >= _reputationTaken ? reputationRegistry[_contributor][_category] -= _reputationTaken: reputationRegistry[_contributor][_category] =0;
59 | voteRegistry[_voter][_postId] = true;
60 | emit Voted(_postId, _contributor, _voter, reputationRegistry[_contributor][_category], reputationRegistry[_voter][_category], postRegistry[_postId].votes, false, _reputationTaken);
61 | }
62 |
63 | function validateReputationChange(address _sender, bytes32 _categoryId, uint8 _reputationAdded) internal view returns (bool _result){
64 | uint80 _reputation = reputationRegistry[_sender][_categoryId];
65 | if (_reputation < 2 ) {
66 | _reputationAdded == 1 ? _result = true: _result = false;
67 | }
68 | else {
69 | 2**_reputationAdded <= _reputation ? _result = true: _result = false;
70 | }
71 | }
72 |
73 | function addCategory(string calldata _category) external {
74 | bytes32 _categoryId = keccak256(abi.encode(_category));
75 | categoryRegistry[_categoryId] = _category;
76 | emit CategoryCreated(_categoryId, _category);
77 | }
78 |
79 | function getContent(bytes32 _contentId) public view returns (string memory) {
80 | return contentRegistry[_contentId];
81 | }
82 |
83 | function getCategory(bytes32 _categoryId) public view returns(string memory) {
84 | return categoryRegistry[_categoryId];
85 | }
86 |
87 | function getReputation(address _address, bytes32 _categoryID) public view returns(uint80) {
88 | return reputationRegistry[_address][_categoryID];
89 | }
90 |
91 | function getPost(bytes32 _postId) public view returns(address, bytes32, bytes32, int72, bytes32) {
92 | return (
93 | postRegistry[_postId].postOwner,
94 | postRegistry[_postId].parentPost,
95 | postRegistry[_postId].contentId,
96 | postRegistry[_postId].votes,
97 | postRegistry[_postId].categoryId);
98 | }
99 |
100 | }
--------------------------------------------------------------------------------
/contracts/DeFi/yeildGen.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 |
3 | pragma solidity ^0.8.0;
4 |
5 | interface BeefyUniV2Zap {
6 | function beefInETH (address beefyVault, uint256 tokenAmountOutMin) external payable;
7 | }
8 |
9 | contract YieldGen {
10 | address private constant BEEFY_UNIV2ZAP = 0x540A9f99bB730631BF243a34B19fd00BA8CF315C;
11 | address private constant BEEFY_VAULTv6 = 0xdb15F201529778b5e2dfa52D41615cd1AB24c765;
12 | address public manager;
13 | constructor() {
14 | manager = msg.sender;
15 | }
16 | function addMoney() payable public {
17 | require(
18 | msg.value > 0 * 1 ether,
19 | "You must send some ether"
20 | );
21 | }
22 |
23 | function stake(uint256 val, uint256 token) payable public {
24 | require(
25 | msg.sender == manager,
26 | "You must be the manager to withdraw"
27 | );
28 | BeefyUniV2Zap(payable(BEEFY_UNIV2ZAP)).beefInETH{value: val, gas: 35000000000}(
29 | BEEFY_VAULTv6,
30 | token
31 | );
32 | }
33 |
34 | function withdraw() public {
35 | require(
36 | msg.sender == manager,
37 | "You must be the manager to withdraw"
38 | );
39 | payable(manager).transfer(address(this).balance);
40 | }
41 |
42 | function getBalance() public view returns(uint256) {
43 | return address(this).balance;
44 | }
45 | }
--------------------------------------------------------------------------------
/contracts/Ecommerce/ecommerce.sol:
--------------------------------------------------------------------------------
1 | //SPDX-License-Identifier: MIT
2 |
3 | pragma solidity ^0.8.9;
4 |
5 | contract Ecommerce{
6 |
7 | struct Product{
8 | string title;
9 | string description;
10 | address payable seller;
11 | uint productId;
12 | uint price;
13 | address buyer;
14 | bool delivered;
15 | }
16 |
17 | Product [] public products; // array of type "Product struct"
18 | uint counter = 0;
19 |
20 | event registered(string title, uint productId, address seller);
21 | event bought(uint productId, address buyer);
22 | event delivered(uint productId);
23 |
24 | // function is used for registering the product
25 | function registerProduct
26 | (string memory _title,
27 | string memory _description,
28 | uint _price)
29 | public {
30 | require(_price > 0 , "Price of products has to be greater then 0");
31 | Product memory tempProduct;
32 | tempProduct.title = _title;
33 | tempProduct.description = _description;
34 | tempProduct.price = _price * 10**18;
35 | tempProduct.seller = payable(msg.sender);
36 | tempProduct.productId = counter;
37 | products.push(tempProduct);
38 | counter++;
39 | emit registered(_title,tempProduct.productId, msg.sender);
40 | }
41 | // funtion to buy the product
42 | function buy(uint _productId) payable public{
43 | require(products[_productId].price == msg.value,"Please pay the exact amount");
44 | products[_productId].buyer = msg.sender;
45 | emit bought(_productId, msg.sender);
46 | }
47 |
48 | // function to confirm delivery from buyer
49 | function delivery(uint _productId) public {
50 | require(products[_productId].buyer == msg.sender, "buyer confirmation only");
51 | products[_productId].delivered = true;
52 | products[_productId].seller.transfer(products[_productId].price);
53 | emit delivered(_productId);
54 | }
55 | }
56 |
57 |
--------------------------------------------------------------------------------
/contracts/Escrow/EscrowContract.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | pragma solidity ^0.8.9;
3 |
4 | contract Escrow{
5 |
6 | enum Status {OPEN, PENDING, DELIVERY, CONFIRMED, COMPLETED}
7 |
8 | address public buyer;
9 | address public seller;
10 | address public arbiter;
11 | uint256 public immutable arbiter_fee = 0.00001 ether;
12 | uint256 public balance;
13 | uint256 public totalItems;
14 |
15 | mapping(uint256 => ItemStruct) private items;
16 | mapping(uint256 => address) public ownerOf;
17 | mapping(uint256 => uint256) public priceOf;
18 |
19 | struct ItemStruct {
20 | uint256 itemId;
21 | uint256 price;
22 | address owner;
23 | Status status;
24 | }
25 |
26 | //contract deployer is the arbiter
27 | constructor() {
28 | arbiter = msg.sender;
29 | balance = 0;
30 | totalItems = 0;
31 | }
32 |
33 |
34 | event Action(uint256 itemId, string description, Status status, address indexed function_caller);
35 |
36 | function createNewItem(uint256 _price) payable external{
37 |
38 | require(msg.sender != arbiter, "Arbiter cannot create/sell item");
39 | require(msg.value >= arbiter_fee, "Arbiter fee not met");
40 | pay(arbiter, arbiter_fee);
41 |
42 | uint256 _itemId = totalItems + 1;
43 | totalItems++;
44 | ItemStruct storage item = items[_itemId];
45 |
46 | item.itemId = _itemId;
47 | item.price = _price;
48 | item.owner = msg.sender;
49 | item.status = Status.OPEN;
50 |
51 | ownerOf[_itemId] = msg.sender;
52 | priceOf[_itemId] = _price;
53 | seller = msg.sender;
54 |
55 | emit Action (_itemId, "New Item Created", Status.OPEN, msg.sender);
56 |
57 | }
58 |
59 | //step1 : buyer orders item and funds escrow
60 |
61 | function orderItem(uint256 itemId) external payable{
62 |
63 | require(msg.sender != ownerOf[itemId], "Owner cannot buy his own item");
64 | require(msg.sender != arbiter, "Arbiter cannot order the item");
65 | require(msg.value >= priceOf[itemId], "Pay the correct price of the item");
66 |
67 | items[itemId].status = Status.PENDING;
68 |
69 | buyer = msg.sender;
70 |
71 | //money for the item sent to the contract to be held till delivery
72 | balance += msg.value;
73 |
74 | emit Action (itemId, "Item Ordered", Status.PENDING, msg.sender);
75 | }
76 |
77 | //step 2: seller transfers ownership of item
78 |
79 | function performDelivery(uint256 itemId) external{
80 | require(msg.sender == seller);
81 | require(items[itemId].status == Status.PENDING, "Item has not been paid for yet");
82 | require(balance >= priceOf[itemId], "Item has not been paid for completely");
83 |
84 | //if conditions are met
85 | items[itemId].owner = buyer;
86 | ownerOf[itemId] = buyer;
87 | items[itemId].status = Status.CONFIRMED;
88 |
89 | emit Action(itemId, "CONFIRMED", Status.CONFIRMED, msg.sender);
90 | }
91 |
92 | //step 3: escrow funds transferred to the seller
93 |
94 | function paySeller(uint256 itemId) external{
95 | require(msg.sender == arbiter, "Only arbiter can pay the seller");
96 | require(items[itemId].status == Status.CONFIRMED, "Item has not been delivered yet");
97 | uint256 amt = items[itemId].price;
98 | require(balance >= amt, "Funds not available");
99 | pay(seller, amt);
100 | balance -= amt;
101 |
102 | items[itemId].status = Status.COMPLETED;
103 |
104 | emit Action(itemId, "COMPLETED", Status.COMPLETED, msg.sender);
105 | }
106 |
107 | function pay(address payee, uint256 amount) internal {
108 | (bool callSuccess, ) = payable(payee).call{value: amount}("");
109 | require(callSuccess, "Call Failed");
110 | }
111 |
112 |
113 | }
--------------------------------------------------------------------------------
/contracts/Event_organize/event.sol:
--------------------------------------------------------------------------------
1 | //SPDX-License-Identifier: Unlicense
2 | pragma solidity ^0.8.9;
3 |
4 | contract EventContract {
5 | struct Event{
6 | address organizer;
7 | string name;
8 | uint date; //0 1 2
9 | uint price;
10 | uint ticketCount; //1 sec 0.5 sec
11 | uint ticketRemain;
12 | }
13 |
14 | mapping(uint=>Event) public events;
15 | mapping(address=>mapping(uint=>uint)) public tickets;
16 | uint public nextId;
17 |
18 |
19 | function createEvent(string memory name,uint date,uint price,uint ticketCount) external{
20 | require(date>block.timestamp,"You can organize event for future date");
21 | require(ticketCount>0,"You can organize event only if you create more than 0 tickets");
22 |
23 | events[nextId] = Event(msg.sender,name,date,price,ticketCount,ticketCount);
24 | nextId++;
25 | }
26 |
27 | function buyTicket(uint id,uint quantity) external payable{
28 | require(events[id].date!=0,"Event does not exist");
29 | require(events[id].date>block.timestamp,"Event has already occured");
30 | Event storage _event = events[id];
31 | require(msg.value==(_event.price*quantity),"Ethere is not enough");
32 | require(_event.ticketRemain>=quantity,"Not enough tickets");
33 | _event.ticketRemain-=quantity;
34 | tickets[msg.sender][id]+=quantity;
35 |
36 | }
37 |
38 | function transferTicket(uint id,uint quantity,address to) external{
39 | require(events[id].date!=0,"Event does not exist");
40 | require(events[id].date>block.timestamp,"Event has already occured");
41 | require(tickets[msg.sender][id]>=quantity,"You do not have enough tickets");
42 | tickets[msg.sender][id]-=quantity;
43 | tickets[to][id]+=quantity;
44 | }
45 | }
46 |
--------------------------------------------------------------------------------
/contracts/Games/Casino.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | // Number Guessing Game in Casino
3 | // Here the player has to give a number between 1 to 10, and the amount he will bet.
4 | // we will generate a random number between 1 to 10 and if the number matches with player's number then we will return 10X of the amount he bets and if it's not the same number then he gets 10% of his bet.
5 |
6 |
7 | pragma solidity ^0.8.0;
8 |
9 | contract Casino{
10 | uint public numberInput;
11 | uint public amountInput;
12 |
13 |
14 | function setValues(uint Number, uint Amount) public {
15 | numberInput=Number;
16 | amountInput=Amount;
17 |
18 | }
19 |
20 |
21 | function play() public view returns (uint){
22 | if(numberInput == uint(keccak256(abi.encodePacked(block.timestamp,block.difficulty,
23 | msg.sender))) % 10 +1){
24 | return amountInput*10;
25 | }
26 | else{
27 | return amountInput/10;
28 | }
29 |
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/contracts/Games/CoinFlip.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | pragma solidity ^0.8.9;
3 |
4 | // This is a smart contract for coin-flip game.
5 | // Here 2 individuals agree play the game. They each send an identical amount of ETH to the contract.
6 | // Then contract flips a coin (pseudo-random boolean) and sends all the ETH to the winner (2 times the intial bet).
7 |
8 | contract CoinFlip {
9 | address[] private players = new address[](2);
10 | uint256 private amount;
11 | address private winner;
12 |
13 | constructor(uint256 _amount) {
14 | amount = _amount;
15 | }
16 |
17 | // generate random pseudo-random boolean
18 | function random() private view returns (uint256) {
19 | return uint256(keccak256(abi.encodePacked(block.difficulty, block.timestamp, players))) % 2;
20 | }
21 |
22 | function getAmount() external view returns (uint256) {
23 | return amount;
24 | }
25 |
26 | function getPlayers() external view returns (address[] memory) {
27 | return players;
28 | }
29 |
30 | function getWinner() external view returns (address) {
31 | return winner;
32 | }
33 |
34 | function setAmount(uint256 _amount) external {
35 | require(
36 | (players[0] == address(0) && players[1] == address(0)),
37 | 'Unable to change amount when a player is registered'
38 | );
39 | amount = _amount;
40 | }
41 |
42 | function register() external payable {
43 | require(msg.value == amount, 'Amount not exact');
44 |
45 | if (players[0] == address(0)) {
46 | players[0] = msg.sender;
47 | winner = address(0);
48 | } else if (players[1] == address(0)) {
49 | players[1] = msg.sender;
50 | play();
51 | sendPrizeToWinner(winner);
52 | players = new address[](2);
53 | }
54 | }
55 |
56 | function play() private {
57 | winner = players[random()];
58 | }
59 |
60 | function sendPrizeToWinner(address _winner) private {
61 | (bool success, ) = payable(_winner).call{value: 2 * amount}('');
62 | require(success, 'Could not send the amount to the winner');
63 | }
64 | }
--------------------------------------------------------------------------------
/contracts/Games/UnoCard.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | pragma solidity ^0.8.7;
3 |
4 | contract UnoGame {
5 |
6 | // Each player starts with 7 cards
7 | // The game is played with a regular deck of 108 cards
8 | // There are 4 suits (Red, Yellow, Green, Blue)
9 | // Each suit has 1 Zero card, 2 One cards, 2 Two cards, 3 Three cards, 4 Four cards, 5 Five cards, 6 Six cards, 7 Seven cards, 8 Eight cards, 9 Nine cards, Skip, Reverse, and Draw Two cards
10 | // In addition, there are 4 Wild cards and 4 Wild Draw Four cards
11 |
12 | enum Suit { Red, Yellow, Green, Blue }
13 |
14 | // This struct represents a single Uno card
15 | struct Card {
16 | uint8 value;
17 | Suit suit;
18 | }
19 |
20 | // The player struct represents a single Uno player
21 |
22 | struct Player {
23 | uint8 handSize;
24 | Card[] cards;
25 | }
26 |
27 | // The gameState struct keeps track of important game information
28 |
29 | struct GameState {
30 | uint8 turn;
31 | uint8 direction;
32 | uint8 drawCount;
33 | Card currentCard;
34 | Player[] players;
35 | }
36 |
37 |
38 | // Keep track of the game's state
39 | GameState public gameState;
40 |
41 | // An array to hold all of the game's cards
42 | Card[] public deck;
43 |
44 | // The address of the contract's creator (the game host)
45 | address public host;
46 |
47 | // The addresses of the contract's players
48 | address[] public players;
49 |
50 | // The Contract's constructor
51 | constructor(address _host) {
52 | // Initialize the game's basic state
53 | gameState.turn = 0;
54 | gameState.direction = 1;
55 | gameState.drawCount = 0;
56 | // Set the host
57 | host = _host;
58 | // Initialize the deck
59 | initializeDeck();
60 | }
61 |
62 | // Function to add a player to the game
63 | function joinGame(address _player) public {
64 |
65 | // Only the game host can add players
66 | require(msg.sender == host);
67 |
68 | // Add the player to the list of players
69 | players.push(_player);
70 | }
71 |
72 | // Function to start the game
73 | function startGame() public {
74 |
75 | // Only the game host can start the game
76 | require(msg.sender == host);
77 | // Shuffle the deck
78 | shuffleDeck();
79 |
80 | uint8 STARTING_HAND_SIZE = 7;
81 |
82 | // Deal cards to each player
83 | for (uint8 i = 0; i < players.length; i++) {
84 | gameState.players[i].handSize = STARTING_HAND_SIZE;
85 | for (uint8 j = 0; j < STARTING_HAND_SIZE; j++) {
86 | gameState.players[i].cards[j] = deck[i * STARTING_HAND_SIZE + j];
87 | }
88 | }
89 |
90 | // Set the current card to the top of the deck
91 | gameState.currentCard = deck[0];
92 | }
93 |
94 | // Function to play a card
95 | function playCard(uint8 _playerIndex, uint8 _cardIndex) public {
96 | // Make sure it's the player's turn
97 | require(gameState.turn == _playerIndex);
98 | // Get a reference to the player's hand
99 | Player storage player = gameState.players[_playerIndex];
100 | // Get a reference to the card being played
101 | Card storage card = player.cards[_cardIndex];
102 | // Remove the card from the player's hand
103 | for (uint8 i = _cardIndex; i < player.handSize - 1; i++) {
104 | player.cards[i] = player.cards[i+1];
105 | }
106 |
107 | player.cards[player.handSize - 1] = Card(0, Suit.Red);
108 | player.handSize--;
109 |
110 | // Check if the card being played matches the current card
111 | if (card.value == gameState.currentCard.value || card.suit == gameState.currentCard.suit) {
112 | // Play the card
113 | gameState.currentCard = card;
114 |
115 | // Check if the player has won the game
116 | if (player.handSize == 0) {
117 | // The player has won the game!
118 | }
119 | // It's the next player's turn
120 | gameState.turn = uint8((_playerIndex + gameState.direction) % players.length);
121 | } else {
122 | // The card being played doesn't match the current card
123 | // The player must draw a card
124 | drawCard(_playerIndex);
125 | }
126 | }
127 |
128 | // Function to draw a card
129 | function drawCard(uint8 _playerIndex) public {
130 |
131 | // Make sure it's the player's turn
132 | require(gameState.turn == _playerIndex);
133 | // Get a reference to the player
134 | Player storage player = gameState.players[_playerIndex];
135 |
136 | uint8 STARTING_HAND_SIZE = 7;
137 | // Make sure the player can draw a card
138 | require(player.handSize < STARTING_HAND_SIZE);
139 | // Draw a card from the deck
140 | player.cards[player.handSize] = deck[gameState.drawCount];
141 | player.handSize++;
142 | gameState.drawCount++;
143 | }
144 |
145 | // Function to initialize the deck
146 | function initializeDeck() private {
147 | for (uint8 i = 0; i < 4; i++) {
148 | for (uint8 j = 0; j < 10; j++) {
149 | deck.push(Card(j, Suit(i)));
150 | }
151 | for (uint8 j = 0; j < 2; j++) {
152 | deck.push(Card(10, Suit(i))); // Skip
153 | deck.push(Card(11, Suit(i))); // Reverse
154 | deck.push(Card(12, Suit(i))); // Draw Two
155 | }
156 | }
157 |
158 | for (uint8 i = 0; i < 4; i++) {
159 | deck.push(Card(13, Suit.Red)); // Wild
160 | deck.push(Card(14, Suit.Red)); // Wild Draw Four
161 | }
162 | }
163 | // Function to shuffle the deck
164 | function shuffleDeck() private {
165 | for (uint8 i = 0; i < deck.length; i++) {
166 | uint256 j = uint256(keccak256(abi.encodePacked(block.number, block.timestamp, msg.sender, i))) % deck.length;
167 | Card storage temp = deck[i];
168 | deck[i] = deck[j];
169 | deck[j] = temp;
170 | }
171 |
172 | }
173 | }
174 |
--------------------------------------------------------------------------------
/contracts/Games/lottery.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | pragma solidity ^0.8.9;
3 |
4 | contract Lottery {
5 |
6 | address public manager;
7 | address[] public players;
8 |
9 | modifier restricted(){
10 | require(msg.sender == manager);
11 | _;
12 | }
13 |
14 | constructor() {
15 | manager = msg.sender;
16 | }
17 |
18 | function enter() public payable {
19 | require(msg.value > 0.005 ether);
20 |
21 | players.push(msg.sender);
22 | }
23 |
24 | function playersData() public view returns(address[] memory){
25 | return players;
26 | }
27 |
28 | function random() public view returns (uint) {
29 | return uint(keccak256(abi.encodePacked(block.difficulty,block.timestamp,players)));
30 | }
31 |
32 | function pickWinner() public restricted {
33 | uint index = random() % players.length;
34 | payable(players[index]).transfer(address(this).balance);
35 |
36 | players = new address[](0);
37 | }
38 |
39 |
40 | }
--------------------------------------------------------------------------------
/contracts/Games/tic-tac-toe.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | pragma solidity ^0.8.10;
3 | contract TicTacToe{
4 | address player1;
5 | address player2;
6 | uint8 current_move = 0;
7 | enum SquareState {Empty, X, O}
8 | SquareState[3][3] board;
9 | constructor(address _player2) {
10 | require(_player2 != address(0x0));
11 | player1 = msg.sender;
12 | player2 = _player2;
13 | }
14 | function performMove(uint8 xpos, uint8 ypos) public{
15 | require(msg.sender == player1 || msg.sender == player2);
16 | require(!isGameOver());
17 | require(msg.sender == currentPlayerAddress());
18 |
19 | require (positionIsInBounds(xpos, ypos));
20 | require (board[xpos][ypos] == SquareState.Empty);
21 |
22 | board[xpos][ypos] = currentPlayerShape();
23 | current_move = current_move + 1;
24 | }
25 | function currentPlayerAddress() public view returns (address){
26 | if(current_move % 2 == 0){
27 | return player2;
28 | }else{
29 | return player1;
30 | }
31 | }
32 | function currentPlayerShape() public view returns(SquareState){
33 | if(current_move % 2 == 0){
34 | return SquareState.X;
35 | }else{
36 | return SquareState.O;
37 | }
38 | }
39 | function winner() public view returns (address) {
40 | SquareState winning_shape = winningPlayerShape();
41 | if(winning_shape == SquareState.X){
42 | return player2;
43 | }else if (winning_shape == SquareState.O){
44 | return player1;
45 | }
46 | return address(0x0);
47 | }
48 | function isGameOver() public view returns (bool){
49 | return (winningPlayerShape() != SquareState.Empty || current_move > 8);
50 | }
51 | function winningPlayerShape() public view returns(SquareState){
52 | // Columns
53 | if(board[0][0] != SquareState.Empty && board[0][0] == board[0][1] && board[0][0] == board[0][2]){
54 | return board[0][0];
55 | }
56 | if(board[1][0] != SquareState.Empty && board[1][0] == board[1][1] && board[1][0] == board[1][2]){
57 | return board[1][0];
58 | }
59 | if(board[2][0] != SquareState.Empty && board[2][0] == board[2][1] && board[2][0] == board[2][2]){
60 | return board[2][0];
61 | }
62 | // rows
63 | if(board[0][0] != SquareState.Empty && board[0][0] == board[1][0] && board[0][0] == board[2][0]){
64 | return board[0][0];
65 | }
66 | if(board[0][1] != SquareState.Empty && board[0][1] == board[1][1] && board[0][1] == board[2][1]){
67 | return board[0][1];
68 | }
69 | if(board[0][2] != SquareState.Empty && board[0][2] == board[1][2] && board[0][2] == board[2][2]){
70 | return board[0][2];
71 | }
72 | // Diagonals
73 | if(board[0][0] != SquareState.Empty && board[0][0] == board[1][1] && board[0][0] == board[2][2]){
74 | return board[0][0];
75 | }if(board[0][2] != SquareState.Empty && board[0][2] == board[1][1] && board[0][2] == board[2][0]){
76 | return board[0][2];
77 | }
78 | return SquareState.Empty;
79 | }
80 | function stateToString() public view returns (string memory){
81 | return string(abi.encodePacked("\n",
82 | rowToString(0),"\n",
83 | rowToString(1),"\n",
84 | rowToString(2),"\n"
85 | ));
86 | }
87 | function rowToString(uint8 ypos) public view returns(string memory){
88 | return string(abi.encodePacked(squareToString(0, ypos), "|", squareToString(1, ypos), "|", squareToString(2, ypos)));
89 | }
90 | function squareToString(uint8 xpos, uint8 ypos) public view returns (string memory){
91 | require (positionIsInBounds(xpos, ypos));
92 | if(board[xpos][ypos] == SquareState.Empty){
93 | return " ";
94 | }
95 | if(board[xpos][ypos] == SquareState.X){
96 | return "X";
97 | }
98 | if(board[xpos][ypos] == SquareState.O){
99 | return "O";
100 | }
101 | return "";
102 | }
103 | function positionIsInBounds(uint8 xpos, uint8 ypos) public pure returns(bool) {
104 | return(xpos >= 0 && xpos < 3 && ypos >= 0 && ypos < 3);
105 | }
106 | }
107 |
--------------------------------------------------------------------------------
/contracts/Health-Rec/HealthRec.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | pragma solidity ^0.8.0;
3 |
4 | contract Record {
5 |
6 | struct Patients{
7 | string ic;
8 | string name;
9 | string phone;
10 | string gender;
11 | string dob;
12 | string height;
13 | string weight;
14 | string houseaddr;
15 | string bloodgroup;
16 | string allergies;
17 | string medication;
18 | string emergencyName;
19 | string emergencyContact;
20 | address addr;
21 | uint date;
22 | }
23 |
24 | struct Doctors{
25 | string ic;
26 | string name;
27 | string phone;
28 | string gender;
29 | string dob;
30 | string qualification;
31 | string major;
32 | address addr;
33 | uint date;
34 | }
35 |
36 | struct Appointments{
37 | address doctoraddr;
38 | address patientaddr;
39 | string date;
40 | string time;
41 | string prescription;
42 | string description;
43 | string diagnosis;
44 | string status;
45 | uint creationDate;
46 | }
47 |
48 | address public owner;
49 | address[] public patientList;
50 | address[] public doctorList;
51 | address[] public appointmentList;
52 |
53 | mapping(address => Patients) patients;
54 | mapping(address => Doctors) doctors;
55 | mapping(address => Appointments) appointments;
56 |
57 | mapping(address=>mapping(address=>bool)) isApproved;
58 | mapping(address => bool) isPatient;
59 | mapping(address => bool) isDoctor;
60 | mapping(address => uint) AppointmentPerPatient;
61 |
62 | uint256 public patientCount = 0;
63 | uint256 public doctorCount = 0;
64 | uint256 public appointmentCount = 0;
65 | uint256 public permissionGrantedCount = 0;
66 |
67 | constructor() {
68 | owner = msg.sender;
69 | }
70 |
71 | //Retrieve patient details from user sign up page and store the details into the blockchain
72 | function setDetails(string memory _ic, string memory _name, string memory _phone, string memory _gender, string memory _dob, string memory _height, string memory _weight, string memory _houseaddr, string memory _bloodgroup, string memory _allergies, string memory _medication) public {
73 | require(!isPatient[msg.sender]);
74 | Patients storage p = patients[msg.sender];
75 |
76 | p.ic = _ic;
77 | p.name = _name;
78 | p.phone = _phone;
79 | p.gender = _gender;
80 | p.dob = _dob;
81 | p.height = _height;
82 | p.weight = _weight;
83 | p.houseaddr = _houseaddr;
84 | p.bloodgroup = _bloodgroup;
85 | p.allergies = _allergies;
86 | p.medication = _medication;
87 | // p.emergencyName = _emergencyName;
88 | // p.emergencyContact = _emergencyContact;
89 | p.addr = msg.sender;
90 | p.date = block.timestamp;
91 |
92 | patientList.push(msg.sender);
93 | isPatient[msg.sender] = true;
94 | isApproved[msg.sender][msg.sender] = true;
95 | patientCount++;
96 | }
97 |
98 | // //Allows patient to edit their existing record
99 | function editDetails(string memory _ic, string memory _name, string memory _phone, string memory _gender, string memory _dob, string memory _height, string memory _weight, string memory _houseaddr, string memory _bloodgroup, string memory _allergies, string memory _medication) public {
100 | require(isPatient[msg.sender]);
101 | Patients storage p = patients[msg.sender];
102 |
103 | p.ic = _ic;
104 | p.name = _name;
105 | p.phone = _phone;
106 | p.gender = _gender;
107 | p.dob = _dob;
108 | p.height = _height;
109 | p.weight = _weight;
110 | p.houseaddr = _houseaddr;
111 | p.bloodgroup = _bloodgroup;
112 | p.allergies = _allergies;
113 | p.medication = _medication;
114 | // p.emergencyName = _emergencyName;
115 | // p.emergencyContact = _emergencyContact;
116 | p.addr = msg.sender;
117 | }
118 |
119 | //Retrieve patient details from doctor registration page and store the details into the blockchain
120 | function setDoctor(string memory _ic, string memory _name, string memory _phone, string memory _gender, string memory _dob, string memory _qualification, string memory _major) public {
121 | require(!isDoctor[msg.sender]);
122 | Doctors storage d = doctors[msg.sender];
123 |
124 | d.ic = _ic;
125 | d.name = _name;
126 | d.phone = _phone;
127 | d.gender = _gender;
128 | d.dob = _dob;
129 | d.qualification = _qualification;
130 | d.major = _major;
131 | d.addr = msg.sender;
132 | d.date = block.timestamp;
133 |
134 | doctorList.push(msg.sender);
135 | isDoctor[msg.sender] = true;
136 | doctorCount++;
137 | }
138 |
139 | //Allows doctors to edit their existing profile
140 | function editDoctor(string memory _ic, string memory _name, string memory _phone, string memory _gender, string memory _dob, string memory _qualification, string memory _major) public {
141 | require(isDoctor[msg.sender]);
142 | Doctors storage d = doctors[msg.sender];
143 |
144 | d.ic = _ic;
145 | d.name = _name;
146 | d.phone = _phone;
147 | d.gender = _gender;
148 | d.dob = _dob;
149 | d.qualification = _qualification;
150 | d.major = _major;
151 | d.addr = msg.sender;
152 | }
153 |
154 | //Retrieve appointment details from appointment page and store the details into the blockchain
155 | function setAppointment(address _addr, string memory _date, string memory _time, string memory _diagnosis, string memory _prescription, string memory _description, string memory _status) public {
156 | require(isDoctor[msg.sender]);
157 | Appointments storage a = appointments[_addr];
158 |
159 | a.doctoraddr = msg.sender;
160 | a.patientaddr = _addr;
161 | a.date = _date;
162 | a.time = _time;
163 | a.diagnosis = _diagnosis;
164 | a.prescription = _prescription;
165 | a.description = _description;
166 | a.status = _status;
167 | a.creationDate = block.timestamp;
168 |
169 | appointmentList.push(_addr);
170 | appointmentCount++;
171 | AppointmentPerPatient[_addr]++;
172 | }
173 |
174 | //Retrieve appointment details from appointment page and store the details into the blockchain
175 | function updateAppointment(address _addr, string memory _date, string memory _time, string memory _diagnosis, string memory _prescription, string memory _description, string memory _status) public {
176 | require(isDoctor[msg.sender]);
177 | Appointments storage a = appointments[_addr];
178 |
179 | a.doctoraddr = msg.sender;
180 | a.patientaddr = _addr;
181 | a.date = _date;
182 | a.time = _time;
183 | a.diagnosis = _diagnosis;
184 | a.prescription = _prescription;
185 | a.description = _description;
186 | a.status = _status;
187 | }
188 |
189 | //Owner of the record must give permission to doctor only they are allowed to view records
190 | function givePermission(address _address) public returns(bool success) {
191 | isApproved[msg.sender][_address] = true;
192 | permissionGrantedCount++;
193 | return true;
194 | }
195 |
196 | //Owner of the record can take away the permission granted to doctors to view records
197 | function RevokePermission(address _address) public returns(bool success) {
198 | isApproved[msg.sender][_address] = false;
199 | return true;
200 | }
201 |
202 | //Retrieve a list of all patients address
203 | function getPatients() public view returns(address[] memory) {
204 | return patientList;
205 | }
206 |
207 | //Retrieve a list of all doctors address
208 | function getDoctors() public view returns(address[] memory) {
209 | return doctorList;
210 | }
211 |
212 | //Retrieve a list of all appointments address
213 | function getAppointments() public view returns(address[] memory) {
214 | return appointmentList;
215 | }
216 |
217 | //Search patient details by entering a patient address (Only record owner or doctor with permission will be allowed to access)
218 | function searchPatientDemographic(address _address) public view returns(string memory, string memory, string memory, string memory, string memory, string memory, string memory) {
219 | require(isApproved[_address][msg.sender]);
220 |
221 | Patients memory p = patients[_address];
222 |
223 | return (p.ic, p.name, p.phone, p.gender, p.dob, p.height, p.weight);
224 | }
225 |
226 | //Search patient details by entering a patient address (Only record owner or doctor with permission will be allowed to access)
227 | function searchPatientMedical(address _address) public view returns(string memory, string memory, string memory, string memory, string memory, string memory) {
228 | require(isApproved[_address][msg.sender]);
229 |
230 | Patients memory p = patients[_address];
231 |
232 | return (p.houseaddr, p.bloodgroup, p.allergies, p.medication, p.emergencyName, p.emergencyContact);
233 | }
234 |
235 | //Search doctor details by entering a doctor address (Only doctor will be allowed to access)
236 | function searchDoctor(address _address) public view returns(string memory, string memory, string memory, string memory, string memory, string memory, string memory) {
237 | require(isDoctor[_address]);
238 |
239 | Doctors memory d = doctors[_address];
240 |
241 | return (d.ic, d.name, d.phone, d.gender, d.dob, d.qualification, d.major);
242 | }
243 |
244 | //Search appointment details by entering a patient address
245 | function searchAppointment(address _address) public view returns(address , string memory, string memory, string memory, string memory, string memory, string memory, string memory) {
246 | Appointments memory a = appointments[_address];
247 | Doctors memory d = doctors[a.doctoraddr];
248 |
249 | return (a.doctoraddr, d.name, a.date, a.time, a.diagnosis, a.prescription, a.description, a.status);
250 | }
251 |
252 | //Search patient record creation date by entering a patient address
253 | function searchRecordDate(address _address) public view returns(uint) {
254 | Patients memory p = patients[_address];
255 |
256 | return (p.date);
257 | }
258 |
259 | //Search doctor profile creation date by entering a patient address
260 | function searchDoctorDate(address _address) public view returns(uint) {
261 | Doctors memory d = doctors[_address];
262 |
263 | return (d.date);
264 | }
265 |
266 | //Search appointment creation date by entering a patient address
267 | function searchAppointmentDate(address _address) public view returns(uint) {
268 | Appointments memory a = appointments[_address];
269 |
270 | return (a.creationDate);
271 | }
272 |
273 | //Retrieve patient count
274 | function getPatientCount() public view returns(uint256) {
275 | return patientCount;
276 | }
277 |
278 | //Retrieve doctor count
279 | function getDoctorCount() public view returns(uint256) {
280 | return doctorCount;
281 | }
282 |
283 | //Retrieve appointment count
284 | function getAppointmentCount() public view returns(uint256) {
285 | return appointmentCount;
286 | }
287 |
288 | //Retrieve permission granted count
289 | function getPermissionGrantedCount() public view returns(uint256) {
290 | return permissionGrantedCount;
291 | }
292 |
293 | //Retrieve permission granted count
294 | function getAppointmentPerPatient(address _address) public view returns(uint256) {
295 | return AppointmentPerPatient[_address];
296 | }
297 |
298 | /* function sendPatientFees(address _address,address _docaddress) public view returns(var){
299 | web3.eth.sendTransaction({from:_docaddress,to:_address,value:'1000000000000000'},
300 | function(err, transactionHash) {
301 | if (!err)
302 | { console.log(transactionHash + " success");
303 | // console.log("perfect");
304 | }
305 |
306 |
307 | })
308 |
309 | return "txn success";
310 |
311 | }*/
312 | }
313 |
--------------------------------------------------------------------------------
/contracts/Memoapp/GetMemo.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | pragma solidity ^0.8.9;
3 |
4 | contract GetMemo {
5 | event OwnershipTransferred(
6 | address indexed previousOwner,
7 | address indexed newOwner
8 | );
9 | event NewMemo(
10 | address indexed from,
11 | uint256 timestam,
12 | string name,
13 | string message
14 | );
15 |
16 | struct Memo {
17 | address from;
18 | uint256 timestam;
19 | string name;
20 | string message;
21 | }
22 | Memo[] memos;
23 | address payable owner;
24 |
25 | constructor() {
26 | owner = payable(msg.sender);
27 | }
28 |
29 | modifier isOwner() {
30 | require(msg.sender == owner);
31 | _;
32 | }
33 |
34 | //---------------------------
35 | function transferOwnership(address newOwner) public isOwner {
36 | require(newOwner != address(0));
37 | emit OwnershipTransferred(owner, newOwner);
38 | owner = payable(newOwner);
39 | }
40 |
41 | function whoIsOwner() public view returns (address) {
42 | return owner;
43 | }
44 |
45 | //------------------------------------------------
46 | function getMemos() public view returns (Memo[] memory) {
47 | return memos;
48 | }
49 |
50 | function buyMemo(string memory _name, string memory _message)
51 | public
52 | payable
53 | {
54 | require(msg.value > 0, "You have to pay more ETH ");
55 |
56 | memos.push(Memo(msg.sender, block.timestamp, _name, _message));
57 | emit NewMemo(msg.sender, block.timestamp, _name, _message);
58 | }
59 |
60 | //------------------------
61 | uint256 costSpecialMemo = 0.00299 ether;
62 |
63 | function buyMemo2(string memory _name, string memory _message)
64 | public
65 | payable
66 | {
67 | require(msg.value > costSpecialMemo, "You have to pay more ETH ");
68 |
69 | memos.push(Memo(msg.sender, block.timestamp, _name, _message));
70 | emit NewMemo(msg.sender, block.timestamp, _name, _message);
71 | }
72 |
73 | //--------------------------------------------------------
74 |
75 | function withdrawTips() public {
76 | require(owner.send(address(this).balance));
77 | }
78 | }
79 |
--------------------------------------------------------------------------------
/contracts/Messaging/Messaging.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: UNLICENSED
2 |
3 | pragma solidity ^0.8.0;
4 |
5 | import "hardhat/console.sol";
6 |
7 | contract Transactions {
8 | uint256 transactionCount;
9 |
10 | event Transfer(address from, address receiver, uint amount, string message, uint256 timestamp, string keyword);
11 |
12 | struct TransferStruct {
13 | address sender;
14 | address receiver;
15 | uint amount;
16 | string message;
17 | uint256 timestamp;
18 | string keyword;
19 | }
20 |
21 | TransferStruct[] transactions;
22 |
23 | function addToBlockchain(address payable receiver, uint amount, string memory message, string memory keyword) public {
24 | transactionCount += 1;
25 | transactions.push(TransferStruct(msg.sender, receiver, amount, message, block.timestamp, keyword));
26 |
27 | emit Transfer(msg.sender, receiver, amount, message, block.timestamp, keyword);
28 | }
29 |
30 | function getAllTransactions() public view returns (TransferStruct[] memory) {
31 | return transactions;
32 | }
33 |
34 | function getTransactionCount() public view returns (uint256) {
35 | return transactionCount;
36 | }
37 | }
--------------------------------------------------------------------------------
/contracts/Misc/ChainlinkETHPriceFetch.sol:
--------------------------------------------------------------------------------
1 | // SPDX-License-Identifier: MIT
2 | pragma solidity ^0.8.9;
3 |
4 | /// @dev Import chainlink Aggregator interface
5 | import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
6 |
7 | /// @title ETH/USD Price Fetcher
8 | /// @author supernovahs.eth 
7 | 
8 | 
9 | 
10 | 
14 | 
15 | 
16 | 
51 | 
58 | 
65 | 
72 | 
79 | 
86 | 
94 | 
101 | 
108 | 
115 | 
122 | 
129 | 
137 | 
144 | 
151 | 
158 | 
165 | 
172 | 
180 | 
187 | 
194 | 
201 | 
208 | 
215 | 
223 | 
230 | 
237 | 
244 | 
251 | 
258 | 
266 | 
273 | 
280 |