PRASAD AROTE B21 ROLL NO - 77
Lab Assignment 1
AIM: To study implementation of Blockchain Technology.
LO1: Develop and test smart contract on local blockchain.
Theory:
Introduction
It demonstrates two key aspects of blockchain technology:
1. Smart Contract Development: A Solidity-based smart contract for transferring funds
between accounts on the Ethereum blockchain.
2. Blockchain Implementation: A simple blockchain implementation using Python to
understand the underlying concepts of blockchain technology.
Part 1: Smart Contract for Fund Transfer
Code Explanation
The smart contract, named FinancialContract, is written in Solidity and consists of the
following key components:
1. Mapping for Balances:
o A mapping is used to store the balance of each address:
o This allows the contract to manage funds for multiple accounts.
2. Constructor:
o The constructor initializes the deployer’s balance to 25000:
3. getBalance Function:
o This function returns the balance of a specific account:
4. deposit Function:
o Users can deposit funds into their own account:
5. transfer Function:
o This function transfers funds from the sender to a recipient:
o It includes a require statement to ensure the sender has sufficient funds and
emits a Transfer event to log the transaction.
6. Event:
o The Transfer event logs the details of each transfer:
Testing the Contract
The contract was tested using the Remix IDE. Below is the workflow:
PRASAD AROTE B21 ROLL NO - 77
1. Deployment:
o The contract was deployed, and the deployer’s address was initialized with a
balance of 25000.
2. Deposit:
o The deposit function was called with an amount of 1000. The deployer’s
balance increased to 26000.
3. Transfer:
o The transfer function was called to send 500 to a recipient address. The
deployer’s balance decreased to 25500, and the recipient’s balance increased
to 500.
4. Balance Check:
o The getBalance function was used to verify the balances of both the deployer
and the recipient.
Part 2: Blockchain Implementation Using Python
Code Explanation
A simple blockchain was implemented using Python to demonstrate the core concepts of
blockchain technology. The implementation includes the following components:
1. Blockchain Class:
o Manages the chain, transactions, and proof-of-work.
PRASAD AROTE B21 ROLL NO - 77
o Key methods:
▪ new_block: Creates a new block and adds it to the chain.
▪ new_transaction: Adds a new transaction to the list of pending
transactions.
▪ proof_of_work: Implements a simple proof-of-work algorithm.
▪ valid_proof: Validates the proof-of-work.
2. Flask API:
o Provides endpoints to interact with the blockchain:
▪ /mine: Mines a new block.
▪ /transactions/new: Adds a new transaction.
▪ /chain: Returns the full blockchain.
import hashlib
import json
from time import time
from uuid import uuid4
from flask import Flask, jsonify, request
class Blockchain:
def __init__(self):
[Link] = []
self.current_transactions = []
self.new_block(previous_hash='1', proof=100) # Genesis block
def new_block(self, proof, previous_hash=None):
block = {
'index': len([Link]) + 1,
'timestamp': time(),
'transactions': self.current_transactions,
'proof': proof,
'previous_hash': previous_hash or [Link]([Link][-1]),
PRASAD AROTE B21 ROLL NO - 77
}
self.current_transactions = []
[Link](block)
return block
def new_transaction(self, sender, recipient, amount):
self.current_transactions.append({
'sender': sender,
'recipient': recipient,
'amount': amount,
})
return self.last_block['index'] + 1
@staticmethod
def hash(block):
block_string = [Link](block, sort_keys=True).encode()
return hashlib.sha256(block_string).hexdigest()
@property
def last_block(self):
return [Link][-1]
def proof_of_work(self, last_proof):
proof = 0
while self.valid_proof(last_proof, proof) is False:
proof += 1
return proof
@staticmethod
def valid_proof(last_proof, proof):
PRASAD AROTE B21 ROLL NO - 77
guess = f'{last_proof}{proof}'.encode()
guess_hash = hashlib.sha256(guess).hexdigest()
return guess_hash[:4] == "0000"
app = Flask(__name__)
node_identifier = str(uuid4()).replace('-', '')
blockchain = Blockchain()
@[Link]('/mine', methods=['GET'])
def mine():
last_block = blockchain.last_block
last_proof = last_block['proof']
proof = blockchain.proof_of_work(last_proof)
blockchain.new_transaction(
sender="0",
recipient=node_identifier,
amount=1,
)
block = blockchain.new_block(proof)
response = {
'message': "New Block Forged",
'index': block['index'],
'transactions': block['transactions'],
'proof': block['proof'],
'previous_hash': block['previous_hash'],
}
return jsonify(response), 200
PRASAD AROTE B21 ROLL NO - 77
@[Link]('/transactions/new', methods=['POST'])
def new_transaction():
values = request.get_json()
required = ['sender', 'recipient', 'amount']
if not all(k in values for k in required):
return 'Missing values', 400
index = blockchain.new_transaction(values['sender'], values['recipient'], values['amount'])
response = {'message': f'Transaction will be added to Block {index}'}
return jsonify(response), 201
@[Link]('/chain', methods=['GET'])
def full_chain():
response = {
'chain': [Link],
'length': len([Link]),
}
return jsonify(response), 200
if __name__ == '__main__':
[Link](host='[Link]', port=5000)
Testing the Blockchain
1. Run the Python Script:
o Start the Flask server by running the script.
o The blockchain will be accessible at [Link]
2. Interact with the API:
o Use tools like Postman or cURL to:
▪ Add a transaction: POST to /transactions/new with JSON data.
PRASAD AROTE B21 ROLL NO - 77
▪ Mine a block: GET /mine.
▪ View the chain: GET /chain.
Conclusion:
This assignment successfully demonstrates:
Smart Contract Development: A Solidity-based contract for fund transfer.
Blockchain Implementation: A Python-based blockchain with mining and transaction
capabilities.
Together, these components provide a comprehensive understanding of blockchain technology
and its applications.
