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

contract StudentCertificate {

string public studentName;
string public courseName;
string public grade;

function setCertificate(
    string memory _name,
    string memory _course,
    string memory _grade
) public {
    studentName = _name;
    courseName = _course;
    grade = _grade;
}

function getCertificate() public view returns(
    string memory,
    string memory,
    string memory
) {
    return (studentName, courseName, grade);
}

}

---

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

contract Bank {

uint public balance;

function deposit(uint amount) public {
    balance = balance + amount;
}

function withdraw(uint amount) public {
    require(balance >= amount, "Insufficient Balance");
    balance = balance - amount;
}

function getBalance() public view returns(uint) {
    return balance;
}

}

---

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

contract Certificate {

string public studentName;
string public degree;
string public university;
uint public year;

function setCertificate(
    string memory _name,
    string memory _degree,
    string memory _university,
    uint _year
) public {

    studentName = _name;
    degree = _degree;
    university = _university;
    year = _year;
}

function getCertificate() public view returns(
    string memory,
    string memory,
    string memory,
    uint
) {
    return (studentName, degree, university, year);
}

}

---

import hashlib
import datetime

Create Block Class

class Block:
def init(self, index, timestamp, data, previous_hash):
self.index = index
self.timestamp = timestamp
self.data = data
self.previous_hash = previous_hash
self.hash = self.calculate_hash()

# Function to generate hash
def calculate_hash(self):
    value = str(self.index) + str(self.timestamp) + self.data + self.previous_hash
    return hashlib.sha256(value.encode()).hexdigest()

Create Blockchain

blockchain = []

Genesis Block (First Block)

block1 = Block(1, str(datetime.datetime.now()), "First Block", "0")
blockchain.append(block1)

Second Block

block2 = Block(2, str(datetime.datetime.now()), "Second Block", block1.hash)
blockchain.append(block2)

Third Block

block3 = Block(3, str(datetime.datetime.now()), "Third Block", block2.hash)
blockchain.append(block3)

Display Blockchain

for block in blockchain:
print("Block Index:", block.index)
print("Timestamp:", block.timestamp)
print("Data:", block.data)
print("Previous Hash:", block.previous_hash)
print("Hash:", block.hash)
print("-" * 50)

---

import hashlib

Input text from user

text = input("Enter text: ")

Convert text to bytes

encoded_text = text.encode()

Generate SHA-256 hash

hash_result = hashlib.sha256(encoded_text)

Convert to hexadecimal

final_hash = hash_result.hexdigest()

Print result

print("SHA-256 Hash is:")
print(final_hash)

---

https://andersbrownworth.com/blockchain/

---

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

contract HelloWorld {

string public message = "Hello World";

}

---

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

contract IdentityManagement {

struct User {
    string name;
    uint age;
    string email;
    address userAddress;
}

User public user;

function setUser(
    string memory _name,
    uint _age,
    string memory _email
) public {

    user = User(
        _name,
        _age,
        _email,
        msg.sender
    );
}

function getUser() public view returns
(
    string memory,
    uint,
    string memory,
    address
)
{
    return (
        user.name,
        user.age,
        user.email,
        user.userAddress
    );
}

}

---

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

contract PropertyRegistry {

struct Property {
    uint id;
    string ownerName;
    string location;
    uint area;
    address ownerAddress;
}

mapping(uint => Property) public properties;

function registerProperty(
    uint _id,
    string memory _ownerName,
    string memory _location,
    uint _area
) public {

    properties[_id] = Property(
        _id,
        _ownerName,
        _location,
        _area,
        msg.sender
    );
}

function getProperty(uint _id) public view returns(
    uint,
    string memory,
    string memory,
    uint,
    address
) {
    Property memory p = properties[_id];

    return (
        p.id,
        p.ownerName,
        p.location,
        p.area,
        p.ownerAddress
    );
}

}

---

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

contract MedicalData {

struct Record {
    string patientName;
    string reportHash;
    uint timestamp;
}

mapping(address => Record[]) public records;

function addRecord(
    string memory _name,
    string memory _hash
) public {

    records[msg.sender].push(
        Record(_name, _hash, block.timestamp)
    );
}

function getRecord(address user, uint index)
public
view
returns(string memory, string memory, uint)
{
    Record memory r = records[user][index];

    return (
        r.patientName,
        r.reportHash,
        r.timestamp
    );
}

}