Blockchain Technology Lab Manual

lOMoARcPSD|19222644
Blockchain Technology Lab manual
Information technology (Savitribai Phule Pune University)
Scan to open on Studocu
Studocu is not sponsored or endorsed by any college or university

Downloaded by Apeksha Mane (apekshasanjay13@gmail.com)
lOMoARcPSD|19222644

lOMoARcPSD|19222644
DEPARTMENT OF INFORMATION TECHNOLOGY
VISION
 To achieve high quality in technical education that provides the skills

andattitudeto adapt to the global needs of the Information Technology sector,
through academic and research excellence.
MISSION
 To equip the students with the cognizance for problem solving and
toimprove the teaching pedagogy by using innovative techniques.
 To strengthen the knowledge base of the faculty and students with

motivation towards possession of effective academic skills and relevant
research experience
 To promote the necessary moral and ethical values among the engineers,
for the betterment of the society

lOMoARcPSD|19222644
PROGRAMME EDUCATIONAL OBJECTIVES (PEOs)
PEO1: PROFESSIONALISM & CITIZENSHIP

To create and sustain a community of learning in which students acquire knowledge
and learn to apply it professionally with due consideration for ethical, ecological and
economic issues.
PEO2: TECHNICAL ACCOMPLISHMENTS
To provide knowledge based services to satisfy the needs of society and the industry
byproviding hands on experience in various technologies in core field.
PEO3: INVENTION, INNOVATION AND CREATIVITY
To make the students to design, experiment, analyze, interpret in the core field
withthe help of other multi disciplinary concepts wherever applicable.
PEO4: PROFESSIONAL DEVELOPMENT
To educate the students to disseminate research findings with good soft skills and
become a successful entrepreneur.
PEO5: HUMAN RESOURCE DEVELOPMENT
To graduate the students in building national capabilities in technology, education and
research.

lOMoARcPSD|19222644
PROGRAM SPECIFIC OUTCOMES (PSOs)
After the completion of the course, B. Tech Information Technology, the

graduateswill havethe following Program Specific Outcomes:
1. Fundamentals and critical knowledge of the Computer System:-

Able to Understand the working principles of the computer System and
its components , Apply the knowledge to build, asses, and analyze the
softwareand hardware aspects of it .
2. The comprehensive and Applicative knowledge of Software

Development: Comprehensive skills of Programming Languages,
Softwareprocess models, methodologies, and able to plan, develop, test,
analyze, and manage the software and hardware intensive systems in
heterogeneous platforms individually or working in teams.
Applications of Computing Domain & Research: Able to use the

professional, managerial, interdisciplinary skill set, and domain specific tools in
development processes, identify the research gaps, and provide innovative
solutions to them.

lOMoARcPSD|19222644
PROGRAM OUTCOMES (POs)
Engineering Graduates should possess the following:

1. Engineering knowledge: Apply the knowledge of mathematics, science,
engineering fundamentals, and an engineering specialization to the solution of
complex engineering problems.
2. Problem analysis: Identify, formulate, review research literature, and analyze
complex engineering problems reaching substantiated conclusions using first
principles of mathematics, natural sciences, and engineering sciences.
3. Design / development of solutions: Design solutions for complex engineering
problems and design system components or processes that meet the specified
needs with appropriate consideration for the public health and safety, and the
cultural, societal, and environmental considerations.
4. Conduct investigations of complex problems: Use research-based knowledge
and research methods including design of experiments, analysis and interpretation
of data,and synthesis of the information to provide valid conclusions.
5. Modern tool usage: Create, select, and apply appropriate techniques, resources,
and modern engineering and IT tools including prediction and modeling to
complex engineering activities with an understanding of the limitations.
6. The engineer and society: Apply reasoning informed by the contextual
knowledge to assess societal, health, safety, legal and cultural issues and the
consequent responsibilities relevant to the professional engineering practice.
7. Environment and sustainability: Understand the impact of the professional
engineering solutions in societal and environmental contexts, and demonstrate the
knowledge of, and need for sustainable development.
8. Ethics: Apply ethical principles and commit to professional ethics and
responsibilitiesand norms of the engineering practice.
9. Individual and team work: Function effectively as an individual, and as a
member or leader in diverse teams, and in multidisciplinary settings.
10. Communication: Communicate effectively on complex engineering activities
with the engineering community and with society at large, such as, being able to
comprehend and write effective reports and design documentation, make effective
presentations, and give and receive clear instructions.
11. Project management and finance: Demonstrate knowledge and understanding of
theengineering and management principles and apply these to one’s own work, as
a member and leader in a team, to manage projects and in multi-disciplinary
environments.
12. Life- long learning: Recognize the need for, and have the preparation and ability
to engage in independent and life-long learning in the broadest context of
technological change.

lOMoARcPSD|19222644
MALLA REDDY COLLEGE OF ENGINEERING & TECHNOLOGY

Maisammaguda, Dhulapally Post, Via Hakimpet, Secunderabad – 500100
DEPARTMENT OF INFORMATION TECHNOLOGY

GENERAL LABORATORY INSTRUCTIONS
1. Students are advised to come to the laboratory atleast 5 minutes before (to the starting
time), those who come after 5minutes will not be allowed into the lab.
2. Plan your task properly much before to the commencement, come prepared to the lab
with the synopsis / program / experiment details.
3. Student should enter into the laboratory with:
a) Laboratory observation notes with all the details (Problem statement, Aim, Algorithm,
Procedure, Program, Expected Output, etc.,) filled in for the lab session.
b) Laboratory Record updated upto the last session experiments and other utensils (if
any) needed in the lab.
c) Proper Dress code and Identity card.
4. Sign in the laboratory login register, write the TIME-IN, and occupy the computer system
allotted to you by the faculty.
5. Execute your task in the laboratory, and record the results/output in the lab observation
notebook, and get certified by the concerned faculty.
6. All the students should be polite and cooperative with the laboratory staff, must maintainthe
discipline and decency in the laboratory.
7. Computerlabsareestablishedwithsophisticatedandhighendbrandedsystems, which should be
utilized properly.
8. Students / Faculty must keep their mobile phones in SWITCHED OFF mode during the lab
sessions. Misuse of the equipment, misbehaviors with the staff and systems etc., will attract severe
punishment.
9. Students must take the permission of the faculty in case of any urgency to go out; if anybody
found loitering outside the lab / class without permission during working hours will be treated
seriously and punished appropriately.
10. Students should LOG OFF/ SHUT DOWN the computer system before he/she leaves the lab
after completing the task (experiment) in all aspects. He/she must ensure the system / seat iskept properly.
HEAD OF THE DEPARTMENT PRINCIPAL

lOMoARcPSD|19222644
BCT Lab 2023-24
MALLAREDDY COLLEGE OF ENGINEERING AND TECHNOLOGY

IV Year B.Tech. IT- I Sem L/T/P/C
-/-/3/1.5
(R20A0591)BLOCKCHAIN TECHNOLOGY LAB
COURSE OBJECTIVES
This course will enable the students:
1. Understanding Block chain Fundamentals and creating basic blocks.

2. Able to Develop Block chain Applications in a structured manner
3. Ability to createown crypto currency and get familiarity with future currencies.
4. Able to Evaluate and AnalyzeBlock chain Systems
LIST OF EXPERIMENTS
Week 1: Creating Merkle tree

Week 2: Creation of Block
Week 3: Block chain Implementation Programming code
Week 4: Creating ERC20 token
Week 5: Java code to implement blockchain in Merkle Trees
Week 6: Java Code to implement Mining using block chain
Week 7: Java Code to implement peer-to-peer using block chain
Week 8: Creating a Crypto-currency Wallet
COURSE OUTCOMES
1. Knowledge of Blockchain Concepts and creating basic blocks.
2. Proficiency in Blockchain Development.
3. Ability to Design and Implement Blockchain Applications.
4. Evaluation and Analysis of Blockchain Systems.
5. Knowledge of crypto currency and creating a basic form of it.

lOMoARcPSD|19222644
BCT Lab 2023-24
TABLE OF CONTENTS
Name of the Program

S.No Page no
Creating Merkle tree
1 1
Creation of Block
2 6
Blockchain implementation
3 11
Creating ERC20 token

4 16
Blockchain implementation using Merkle Trees

5 20
Mining in Blockchain
6 25
Peer-to-Peer implementation using Blockchain

7 32
Creating Crypto-currency Wallet

8 40

lOMoARcPSD|19222644
BCT Lab 2023-24
WEEK: 1
AIM: Creating Merkle tree
Merkle Tree
Merkle tree is a tree data structure with leaf nodes and non leaf nodes. It also known as Hash tree.
The reason behind it is it only stores the hashes in its nodes instead of data. In its leaf nodes, it will
store the hash of the data. Non leaf nodes contain the hash of its children.
Bit coin’s merkle-tree implementation works the following way:
1.split the transactions in the block up into pairs

2.byte-swap the txids
3.concatenate the txids
4.double hash the concatenated pairs
SOURCE CODE:
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.List;
public class MerkleTree {
private List<String> transactions;
private List<String> merkleTree;
public MerkleTree(List<String> transactions) {
this.transactions = transactions;
this.merkleTree = buildMerkleTree(transactions);
}
private String calculateHash(String data) {
try {
MessageDigest digest = MessageDigest.getInstance("SHA-256");
byte[] hashBytes = digest.digest(data.getBytes(StandardCharsets.UTF_8));
StringBuilder hexString = new StringBuilder();
for (byte hashByte : hashBytes) {
String hex = Integer.toHexString(0xff &hashByte);
if (hex.length() == 1) {
Department of IT Page 1

lOMoARcPSD|19222644
BCT Lab 2023-24
hexString.append('0');
}
hexString.append(hex);
}
return hexString.toString();
}
catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return null;
}
private List<String> buildMerkleTree(List<String> transactions) {
List<String> merkleTree = new ArrayList<>(transactions);
int levelOffset = 0;
for (int levelSize = transactions.size(); levelSize> 1; levelSize = (levelSize + 1) / 2) {
for (int left = 0; left <levelSize; left += 2) {
int right = Math.min(left + 1, levelSize - 1);
String leftHash = merkleTree.get(levelOffset + left);
String rightHash = merkleTree.get(levelOffset + right);
String parentHash = calculateHash(leftHash + rightHash);
merkleTree.add(parentHash);
}
levelOffset += levelSize;
}
return merkleTree;
}
public List<String>getMerkleTree() {
return merkleTree;
}
public static void main(String[] args) {
List<String> transactions = new ArrayList<>();
transactions.add("Transaction 1");

lOMoARcPSD|19222644
BCT Lab 2023-24
MerkleTree merkleTree = new MerkleTree(transactions);

List<String> tree = merkleTree.getMerkleTree();
for (String hash : tree) {
System.out.println(hash);
}}}
EXPECTED OUTPUT:
OUTPUT:

lOMoARcPSD|19222644
BCT Lab 2023-24
Record Notes:

lOMoARcPSD|19222644
BCT Lab 2023-24

lOMoARcPSD|19222644
BCT Lab 2023-24
WEEK : 2
AIM : Creation of Block
Blocks are data structures within the blockchain database, where transaction data in a
cryptocurrency blockchain are permanently recorded. A block records some or all of the most recent
transactions not yet validated by the network. Once the data are validated, the block is closed. Then,
a new block is created for new transactions to be entered into and validated.
Blocks are created when miners or block validators successfully validate the encrypted
information in the blockheader, which prompts the creation of a new block.
SOURCE CODE:
import java.util.Date;
public class Block {
private int index;
private long timestamp;
private String previousHash;
private String hash;
private String data;
private int nonce;
public Block(int index, String previousHash, String data) {
this.index = index;
this.timestamp = new Date().getTime();
this.previousHash = previousHash;
this.data = data;
this.nonce = 0;
this.hash = calculateHash();
}
public String calculateHash() {
try {
String input = index + timestamp + previousHash + data + nonce;
byte[] hashBytes = digest.digest(input.getBytes());

lOMoARcPSD|19222644
BCT Lab 2023-24

if (hex.length() == 1) {
}
}
}
}
return null;
}
public void mineBlock(int difficulty) {
String target = new String(new char[difficulty]).replace('\0', '0');
while (!hash.substring(0, difficulty).equals(target)) {
nonce++;
hash = calculateHash();
}
System.out.println("Block mined: " + hash);
}
public int getIndex() {
return index;
}
public long getTimestamp() {
return timestamp;
}
public String getPreviousHash() {
return previousHash;
}
public String getHash() {
return hash;
}
public String getData() {

lOMoARcPSD|19222644
BCT Lab 2023-24
return data;
}
public static void main(String args[]){
Block b=new
Block(1,"3a42c503953909637f78dd8c99b3b85ddde362415585afc11901bdefe8349102","hai");
b.calculateHash();
b.mineBlock(1);
b.getIndex();
b.getTimestamp();
b.getPreviousHash();
b.getHash();
b.getData();
}}
EXPECTED OUTPUT:
OUTPUT:

lOMoARcPSD|19222644
BCT Lab 2023-24
Record Notes:

lOMoARcPSD|19222644
BCT Lab 2023-24

lOMoARcPSD|19222644
BCT Lab 2023-24
WEEK:3
AIM : Block chain Implementation Programming code
Block chain programming fundamentals:
In order to understand Blockchain deeply, the concept of a Digital Signature or a Hash is important.
Digital Signature is basically a function that takes a string as input and returns a fixed-size
alphanumeric string. The output string is known as the Digital Signature or the Hash of the input
message. The important point is that the function via which we obtain the Digital Signature is
“irreversible” in that given an input string, it can compute the Hash. However, given the Hash, it is
virtually impossible to compute the input string. Further, it is also virtually impossible to find 2
values that have the same Hash.
Hash1=hash(input1)
Hash2=hash(input2)
It is easy to compute hash1 from input1 and hash2 from input2.
It is virtually impossible to compute input1 given the value of hash1. Similarly for input2 and hash2.
It is virtually impossible to find distinct input1 and input2 such that hash1 = hash2.
SOURCE CODE:
public class Blockchain {
private List<Block> chain;
private int difficulty;
public Blockchain(int difficulty) {
this.chain = new ArrayList<>();
this.difficulty = difficulty;
// Create the genesis block
createGenesisBlock();
}
private void createGenesisBlock() {
Block genesisBlock = new Block(0, "0", "Genesis Block");
genesisBlock.mineBlock(difficulty);
chain.add(genesisBlock);
}

lOMoARcPSD|19222644
BCT Lab 2023-24
public Block getLatestBlock() {

return chain.get(chain.size() - 1);
}
public void addBlock(Block newBlock) {
newBlock.mineBlock(difficulty);
chain.add(newBlock);
}
public boolean isChainValid() {
for (int i = 1; i <chain.size(); i++) {
Block currentBlock = chain.get(i);
Block previousBlock = chain.get(i - 1);
if (!currentBlock.getHash().equals(currentBlock.calculateHash())) {
System.out.println("Invalid hash for Block " + currentBlock.getIndex());
return false;
}
if (!previousBlock.getHash().equals(currentBlock.getPreviousHash())) {
System.out.println("Invalid previous hash for Block " + currentBlock.getIndex());
return false;
}}
return true;
}
Blockchain blockchain = new Blockchain(4);
Block block1 = new Block(1, blockchain.getLatestBlock().getHash(), "Data 1");
blockchain.addBlock(block1);
System.out.println("Blockchain is valid: " + blockchain.isChainValid());
}
}

lOMoARcPSD|19222644
BCT Lab 2023-24
EXPECTED OUTPUT:
OUTPUT:

lOMoARcPSD|19222644
BCT Lab 2023-24
Record Notes:

lOMoARcPSD|19222644
BCT Lab 2023-24

lOMoARcPSD|19222644
BCT Lab 2023-24
WEEK:4
AIM : CreatingERC20 token
An ERC20 token is a standard used for creating and issuing smart contracts on the
Ethereumblockchain. Smart contracts can then be used to create smart property or tokenized assets
that people can invest in. ERC stands for "Ethereum request for comment," and the ERC20 standard
was implemented in 2015
SOURCE CODE:
import java.util.HashMap;
import java.util.Map;
public class ERC20Token {
private String name;
private String symbol;
private int decimals;
private Map<String, Integer> balances;
public ERC20Token(String name, String symbol, int decimals) {
this.name = name;
this.symbol = symbol;
this.decimals = decimals;
this.balances = new HashMap<>();
}
public void transfer(String from, String to, int amount) {
int balance = balances.getOrDefault(from, 0);
if (balance < amount) {
System.out.println("Insufficient balance");
return;
}
balances.put(from, balance - amount);
balances.put(to, balances.getOrDefault(to, 0) + amount);
System.out.println("Transfer successful");
}
public int balanceOf(String address) {
return balances.getOrDefault(address, 0);
}

lOMoARcPSD|19222644
BCT Lab 2023-24
public String getName() {

return name; }
public String getSymbol() {
return symbol; }
public int getDecimals() {
return decimals; }
ERC20Token token = new ERC20Token("MyToken", "MTK", 18);
// Set initial balances
token.balances.put("Alice", 1000);
token.balances.put("Bob", 500);
token.balances.put("Charlie", 200);
// Perform some transfers
token.transfer("Alice", "Bob", 200);
token.transfer("Charlie", "Alice", 100);
token.transfer("Bob", "Charlie", 50);
// Print final balances
System.out.println("Alice balance: " + token.balanceOf("Alice"));
System.out.println("Bob balance: " + token.balanceOf("Bob"));
System.out.println("Charlie balance: " + token.balanceOf("Charlie"));
}}
EXPECTED OUTPUT:
OUTPUT:

lOMoARcPSD|19222644
BCT Lab 2023-24
Record Notes:

lOMoARcPSD|19222644
BCT Lab 2023-24

lOMoARcPSD|19222644
BCT Lab 2023-24
WEEK:5
AIM: Java code to implement blockchain in Merkle Trees
Merkle trees is an implementation of binary trees where each non-leaf node is a hash of the two
child nodes. The leaves can either be the data itself or a hash/signature of the data.
Usages:
Merkle tree(Hash tree) is used to verify any kind of data stored, handled and transferred in and
between computers.
Currently, the main use of Merkle tree is to make sure that data blocks received from other peers in a
peer-to-peer network are received undamaged and unaltered, and even to check that the other peers
do not lie and send fake blocks.
Merkle tree is used in git, Amazon's Dynamo, Cassandra as well as BitCoin.
SOURCE CODE:
class MerkleTree {
private List<String> transactions;
private String root;
public MerkleTree(List<String> transactions) {
this.root = buildTree();
}
private String buildTree() {
List<String> level = new ArrayList<>(transactions);
while (level.size() > 1) {
List<String>nextLevel = new ArrayList<>();
for (int i = 0; i <level.size(); i += 2) {
String left = level.get(i);
String right = (i + 1 <level.size()) ? level.get(i + 1) : "";
String combined = left + right;
String hash = calculateHash(combined);
nextLevel.add(hash);
}

lOMoARcPSD|19222644
BCT Lab 2023-24
level = nextLevel;
}
return level.get(0);
}
private String calculateHash(String input) {
try {
byte[] hashBytes = digest.digest(input.getBytes());
if (hex.length() == 1)
}
}
return null;
}}
public String getRoot() {
return root;
}}
public class Blockchain1 {
private List<MerkleTree> blocks;
public Blockchain1() {
this.blocks = new ArrayList<>();
}
public void addBlock(List<String> transactions) {
MerkleTree merkleTree = new MerkleTree(transactions);
blocks.add(merkleTree);
}
public String getBlockRoot(int blockIndex) {
if (blockIndex>= 0 &&blockIndex<blocks.size()) {

lOMoARcPSD|19222644
BCT Lab 2023-24
MerkleTree merkleTree = blocks.get(blockIndex);

return merkleTree.getRoot();
}
return null;
}
Blockchain1 blockchain = new Blockchain1();
List<String> transactions1 = new ArrayList<>();
transactions1.add("Transaction 1");
blockchain.addBlock(transactions1);
List<String> transactions2 = new ArrayList<>();
blockchain.addBlock(transactions2);
String root1 = blockchain.getBlockRoot(0);
System.out.println("Block 1 Root: " + root1);
String root2 = blockchain.getBlockRoot(1);
System.out.println("Block 2 Root: " + root2);
}
}
EXPECTED OUTPUT:
OUTPUT:

lOMoARcPSD|19222644
BCT Lab 2023-24
Record Notes:

lOMoARcPSD|19222644
BCT Lab 2023-24

lOMoARcPSD|19222644
BCT Lab 2023-24
WEEK:6
AIM: Java Code to implement Mining using block chain
Blockchain is a budding technology that has tremendous scope in the coming years. Blockchain is
the modern technology that stores data in the form of block data connected through cryptography
and cryptocurrencies such as Bitcoin. It was introduced by Stuart Haber and W. Scott Tornetta in
1991. It is a linked list where the nodes are the blocks in the Blockchain, and the references are
hashes of the previous block in the chain. References are cryptographic hashes when dealing with
link lists. The references are just basically objects. So every single node will store another node
variable, and it will be the reference to the next node. In this case, the references are cryptographic
hashes.
Blockchain uses hash pointers to reference the previous node in a long list. We assign a hash to every
single node because this is how we can identify them
SOURCE CODE:
class Block {
private int index;
private int nonce;
private List<Transaction> transactions;
public Block(int index, long timestamp, String previousHash, List<Transaction> transactions) {
this.index = index;
this.timestamp = timestamp;
this.nonce = 0;
}

lOMoARcPSD|19222644
BCT Lab 2023-24
try {
String data = index + timestamp + previousHash + nonce + transactions.toString();
}
}
}
return null;
}
nonce++;
}
}
return hash;
}
}}
class Transaction {
private String from;
private String to;

lOMoARcPSD|19222644
BCT Lab 2023-24
private double amount;

public Transaction(String from, String to, double amount) {
this.from = from;
this.to = to;
this.amount = amount;
}
@Override
public String toString() {
return from + "->" + to + ": " + amount;
}}
class Blockchain {
}
List<Transaction> transactions = new ArrayList<>();
transactions.add(new Transaction("Genesis", "Alice", 100));
Block genesisBlock = new Block(0, System.currentTimeMillis(), "0", transactions);
}
public void addBlock(Block block) {
block.mineBlock(difficulty);
chain.add(block);
}
if (!currentBlock.getHash().equals(currentBlock.calculateHash()))
return false;

lOMoARcPSD|19222644
BCT Lab 2023-24
if (!currentBlock.getPreviousHash().equals(previousBlock.getHash()))
return false;
}
return true;
}
public Block getLastBlock() {
}}
public class BlockchainMiningExample {
// Create a blockchain with difficulty 4
// Create some transactions and add them to a block
transactions.add(new Transaction("Alice", "Bob", 10.0));
transactions.add(new Transaction("Charlie", "Alice", 5.0));
Block block1 = new Block(1, System.currentTimeMillis(), blockchain.getLastBlock().getHash(),
transactions);
// Add the block to the blockchain
// Create another block with different transactions
List<Transaction> transactions2 = new ArrayList<>();
transactions2.add(new Transaction("Bob", "Charlie", 3.0));
transactions2.add(new Transaction("Alice", "Bob", 2.0));
Block block2 = new Block(2, System.currentTimeMillis(), blockchain.getLastBlock().getHash(),
transactions2);
// Add the second block to the blockchain
// Validate the blockchain
System.out.println("Is blockchain valid? " + blockchain.isChainValid());
}}

lOMoARcPSD|19222644
BCT Lab 2023-24
EXPECTED OUTPUT:
OUTPUT:

lOMoARcPSD|19222644
BCT Lab 2023-24
Record Notes:

lOMoARcPSD|19222644
BCT Lab 2023-24

lOMoARcPSD|19222644
BCT Lab 2023-24
WEEK:7
AIM: Java Code to implement peer-to-peer using block chain
Earlier, we made a single blockchain. Now we’re going to make a set of them and get them talking to
one another. The real point of the blockchain is a distributed system of verification. We can add
blocks from any nodes and eventually it gets to peer nodes so everyone agrees on what the
blockchain looks like. There is one problem that comes up right away: Each node is two services,
plus a MongoDB and a Kafka message bus that all need to talk to one another. We’ll be working on
a node service that will allow the nodes to work with one another. This will get input from two
places, a restful interface that allows you to add and list the nodes connected, and a message bus
provided by Kafka that notifies the node service of changes in the local blockchain that need to be
broadcast to the peer nodes.
SOURCE CODE:
class Block {
private int index;
private int nonce;
private List<Transaction> transactions;
public Block(int index, long timestamp, String previousHash, List<Transaction> transactions) {
this.index = index;
this.timestamp = timestamp;
this.nonce = 0;
}
try {

lOMoARcPSD|19222644
BCT Lab 2023-24

String data = index + timestamp + previousHash + nonce + transactions.toString();
}
} catch (NoSuchAlgorithmException e) {
}
return null;
}
nonce++;
}
}
public int getIndex() {
return index;
}
public long getTimestamp() {
return timestamp;
}
}
return hash;

lOMoARcPSD|19222644
BCT Lab 2023-24
}
public int getNonce() {
return nonce;
}
public List<Transaction>getTransactions() {
return transactions;
}}
class Transaction {
private String from;
private String to;
private double amount;
public Transaction(String from, String to, double amount) {
this.from = from;
this.to = to;
this.amount = amount;
}
public String getFrom() {
return from;
}
public String getTo() {
return to;
}
public double getAmount() {
return amount;
}
@Override
public String toString() {
return from + "->" + to + ": " + amount;
}}
class Blockchain {

lOMoARcPSD|19222644
BCT Lab 2023-24
}
transactions.add(new Transaction("Genesis", "Alice", 100));
Block genesisBlock = new Block(0, System.currentTimeMillis(), "0", transactions);
}
public void addBlock(Block block) {
block.mineBlock(difficulty);
chain.add(block);
}
if (!currentBlock.getHash().equals(currentBlock.calculateHash()))
return false;
if (!currentBlock.getPreviousHash().equals(previousBlock.getHash()))
return false;
}
return true;
}
public List<Block>getChain() {
return chain;
}
public Block getLastBlock() {
}}
class Node {
private Blockchain blockchain;
private List<Transaction>pendingTransactions;
public Node(Blockchain blockchain) {
this.blockchain = blockchain;

lOMoARcPSD|19222644
BCT Lab 2023-24
this.pendingTransactions = new ArrayList<>();

}
public void minePendingTransactions() {
Block newBlock = new Block(
blockchain.getLastBlock().getIndex() + 1,
System.currentTimeMillis(),
blockchain.getLastBlock().getHash(),pendingTransactions);
blockchain.addBlock(newBlock);
pendingTransactions.clear();
}
public void createTransaction(Transaction transaction) {
pendingTransactions.add(transaction);
}
public Blockchain getBlockchain() {
return blockchain;
}
public List<Transaction>getPendingTransactions() {
return pendingTransactions;
}}
public class PeerToPeerBlockchain {
// Create a blockchain with difficulty 4
// Create two nodes
Node node1 = new Node(blockchain);
Node node2 = new Node(blockchain);
// Node 1 creates a transaction
Transaction transaction1 = new Transaction("Alice", "Bob", 10.0);
node1.createTransaction(transaction1);
// Node 2 creates a transaction
Transaction transaction2 = new Transaction("Bob", "Charlie", 5.0);
node2.createTransaction(transaction2);
// Node 1 mines the pending transactions
node1.minePendingTransactions();
// Node 2 mines the pending transactions

lOMoARcPSD|19222644
BCT Lab 2023-24
node2.minePendingTransactions();
// Validate the blockchain
System.out.println("Is blockchain valid? " + blockchain.isChainValid());
}}
EXPECTED OUTPUT:
OUTPUT:

lOMoARcPSD|19222644
BCT Lab 2023-24
Record Notes:

lOMoARcPSD|19222644
BCT Lab 2023-24

lOMoARcPSD|19222644
BCT Lab 2023-24
WEEK:8
AIM: creating a Crypto-currency Wallet.
There are four basic steps.

1. Choose the type of wallet.
2. Sign up for an account, buy the device or download the software needed.
3. Set up security features, including a recovery phrase.
4. Purchase cryptocurrency or transfer coins from another wallet or exchange.
Types of crypto wallets:
There are three basic types of wallets for virtual currency.
One option is a software wallet or hot wallet that stores your crypto on an internet-connected device
that you own.
Another option to consider with added security is a cold wallet, a specialized piece of hardware that
keeps your crypto offline.
Custodial wallets, which leave your crypto in the control of a company you trust, such as a crypto
exchange, are another storage method to consider.
SOURCE CODE:
import java.security.*;
import java.security.spec.ECGenParameterSpec;
public class CryptoWallet {
private PrivateKey privateKey;
private PublicKey publicKey;
public CryptoWallet() {
generateKeyPair();
}
public void generateKeyPair() {
try {
KeyPairGenerator keyGen = KeyPairGenerator.getInstance("EC");
SecureRandom random = SecureRandom.getInstanceStrong();
ECGenParameterSpec ecSpec = new ECGenParameterSpec("spec256k1");
keyGen.initialize(ecSpec, random);
KeyPair keyPair = keyGen.generateKeyPair();
privateKey = keyPair.getPrivate();
publicKey = keyPair.getPublic();
} catch (Exception e) {

lOMoARcPSD|19222644
BCT Lab 2023-24
}}
CryptoWallet wallet = new CryptoWallet();
System.out.println("Private Key: " + wallet.privateKey);
System.out.println("Public Key: " + wallet.publicKey);
}}
EXPECTED OUTPUT:
OUTPUT:

lOMoARcPSD|19222644
BCT Lab 2023-24
Record Notes:

lOMoARcPSD|19222644
BCT Lab 2023-24

Blockchain Technology Lab Manual

Uploaded by

Copyright:

Available Formats

Blockchain Technology Lab Manual

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Blockchain Technology Lab Manual

Uploaded by

Copyright:

Available Formats

lOMoARcPSD|19222644

Blockchain Technology Lab manual

Information technology (Savitribai Phule Pune University)

Scan to open on Studocu

Studocu is not sponsored or endorsed by any college or university

Downloaded by Apeksha Mane (apekshasanjay13@gmail.com)

DEPARTMENT OF INFORMATION TECHNOLOGY

 To achieve high quality in technical education that provides the skills

 To strengthen the knowledge base of the faculty and students with

Downloaded by Apeksha Mane (apekshasanjay13@gmail.com)

PROGRAMME EDUCATIONAL OBJECTIVES (PEOs)

PEO1: PROFESSIONALISM & CITIZENSHIP

Downloaded by Apeksha Mane (apekshasanjay13@gmail.com)

PROGRAM SPECIFIC OUTCOMES (PSOs)

After the completion of the course, B. Tech Information Technology, the

1. Fundamentals and critical knowledge of the Computer System:-

2. The comprehensive and Applicative knowledge of Software

Applications of Computing Domain & Research: Able to use the

Downloaded by Apeksha Mane (apekshasanjay13@gmail.com)

PROGRAM OUTCOMES (POs)

Engineering Graduates should possess the following:

Downloaded by Apeksha Mane (apekshasanjay13@gmail.com)

MALLA REDDY COLLEGE OF ENGINEERING & TECHNOLOGY

DEPARTMENT OF INFORMATION TECHNOLOGY

HEAD OF THE DEPARTMENT PRINCIPAL

Downloaded by Apeksha Mane (apekshasanjay13@gmail.com)

BCT Lab 2023-24

MALLAREDDY COLLEGE OF ENGINEERING AND TECHNOLOGY

1. Understanding Block chain Fundamentals and creating basic blocks.

Week 1: Creating Merkle tree

Downloaded by Apeksha Mane (apekshasanjay13@gmail.com)

BCT Lab 2023-24

Name of the Program

Creating ERC20 token

Blockchain implementation using Merkle Trees

Peer-to-Peer implementation using Blockchain

Creating Crypto-currency Wallet

Downloaded by Apeksha Mane (apekshasanjay13@gmail.com)

BCT Lab 2023-24

AIM: Creating Merkle tree

Bit coin’s merkle-tree implementation works the following way:

1.split the transactions in the block up into pairs

Downloaded by Apeksha Mane (apekshasanjay13@gmail.com)

BCT Lab 2023-24

Downloaded by Apeksha Mane (apekshasanjay13@gmail.com)

BCT Lab 2023-24

MerkleTree merkleTree = new MerkleTree(transactions);

Downloaded by Apeksha Mane (apekshasanjay13@gmail.com)

BCT Lab 2023-24

Downloaded by Apeksha Mane (apekshasanjay13@gmail.com)

BCT Lab 2023-24

Downloaded by Apeksha Mane (apekshasanjay13@gmail.com)

BCT Lab 2023-24

AIM : Creation of Block

Downloaded by Apeksha Mane (apekshasanjay13@gmail.com)

BCT Lab 2023-24

for (byte hashByte : hashBytes) {

Downloaded by Apeksha Mane (apekshasanjay13@gmail.com)

BCT Lab 2023-24