COMP3221代做、Java程序调试、代写Java设计、代做CS Blockchain
代做R语言编程|代写Web开发
COMP3221 Assignment 1: CS Blockchain
The goal of this project is to implement a Client-Server (CS) Blockchain application in Java
which could be able to store messages and detect tampering.
1 Submission Details
The assignment comprises 3 tasks, each can be submitted separately. The final version of
your assignment should be submitted electronically via PASTA by 11:59PM on the Tuesday of
Week 4 (Hard Deadline). The project is an individual project, and each student has to submit
his/her own version.
1.1 Program structure
For task 1, three java files must be submitted. It is recommended to submit by 11:59 PM on
the Friday of Week 2 (Soft Deadline).
A Blockchain.java file.
A Block.java file.
A Transaction.java file.
For task 2, four java files must be submitted. It is recommended to submit by 11:59 PM on
the Sunday of Week 2 (Soft Deadline).
A Blockchain.java file.
A Block.java file.
A Transaction.java file.
A BlockchainServer.java file.
For task 3, five java files must be submitted. It is recommended to submit by 11:59 PM on
the Sunday of Week 3 (Soft Deadline).
A Blockchain.java file.
A Block.java file.
1COMP3221 Client-Server Blockchain
A Transaction.java file.
A BlockchainServer.java file.
A BlockchainClient.java file.
All classes will be stored in the same default package (no package header in java files), and
all files should be located in the same src folder with no subfolders. All present .java files
should be correct and do not forget to remove any dummy files that do not count as source
files (E.g. junit test cases, class files). Please zip the src folder and submit the resulting
archive src.zip by the deadline given above. The program should compile with Java 8. No
optional packages that are not part of the default Java 8 JDK can be used.
1.2 Submission system
PASTA will be used to assess that your program correctly implements the Client-Server Blockchain
protocol. The archive src.zip should be submitted at https://pastpd01191.srv.
sydney.edu.au/PASTA. To access this website, you will have to be connected to the network
of the University of Sydney (physically on campus or through VPN).
PASTA stands for “Programming Assessment Submission and Testing Application” and is a
web-based application that automates the compilation, execution and testing of your program.
When you submit your src.zip archive in PASTA, the system enqueues your submission
in the shared queue of all assignments to be tested. It may take more time close to the
deadline as many students will try to submit at the same time.
1.3 Academic Honesty / Plagiarism
By uploading your submission to PASTA you implicitly agree to abide by the University policies
regarding academic honesty, and in particular that all the work is original and not plagiarised
from the work of others. If you believe that part of your submission is not your work you
must bring this to the attention of your tutor or lecturer immediately. See the policy slides
released in Week 1 for further details.
In assessing a piece of submitted work, the School of IT may reproduce it entirely, may
provide a copy to another member of faculty, and/or communicate a copy of this assignment
to a plagiarism checking service or in-house computer program. A copy of the assignment
may be maintained by the service or the School of IT for the purpose of future plagiarism
checking.
2 Marking
This assignment is worth 10% of your final grade for this unit of study.
The first category of tasks, called Blockchain: Data Structure, assesses the quality of the
message being stored in the block chain. If you could pass all tests, 4 marks are given.
Distributed Systems Page 2COMP3221 Client-Server Blockchain
Maximum 1 mark for rejecting invalid transactions.
Maximum 1 mark for storing transaction into pool properly.
Maximum 2 mark for committing transactions from pool to blockchain correctly.
The second category, called Blockchain: Server, assesses the behaviour of the server with
respect to protocol requirements. If you could pass all tests, 3 marks are given.
Maximum 1 mark for server listening to connections continuously.
Maximum 1 mark for server replying to add transaction request correctly.
Maximum 1 mark for server replying to print blockchain request correctly.
The third category, called Blockchain: Client, assesses the behaviour of the client with respect
to protocol requirements. If you could pass all tests, 3 marks are given.
Maximum 1 mark for client connecting to the server properly.
Maximum 1 mark for client forwarding requests to the server correctly.
Maximum 1 mark for client printing replies correctly.
Please make sure previous tasks are implemented correctly, before moving to next task. You
may face cascading failures due to improper implementation of previous tasks.
2.1 Feedback
PASTA provides feedback about each individual submission, one at a time. It will output a list
of tests and outcomes indicating whether your program passed each visible test successfully
or failed. The feedback provided is indicative, intentionally high-level and will not precisely
identify the nature of any bug of your program. Please write your personal test cases and
thoroughly test all your code before submission.
3 Functionalities of a Client-Server Blockchain
The goal of this project is to implement a Client-Server (CS) Blockchain application. While
the original blockchain operates in a distributed and P2P mode, your current CS Blockchain
program will only require one client and one server running at the same time. The following
tasks indicate the features that should be implemented, one solution for each task is expected
to be submitted.
Distributed Systems Page 3COMP3221 Client-Server Blockchain
Task 1 Blockchain: Data Structure
In task 1, you are required to build the Blockchain’s core data structure, which is a linked list
of blocks of transactions. If you would like to have a better view of what we are trying to
build, please have a look at Assignment 0.
Transaction. A transaction is defined as the container to store a single message (sender +
content).
Message sender, e.g., test0001
Message content, e.g., welcome to comp2121!
You should perform some checks before you consider a message as a valid transaction. The
message sender must present and should match a unikey-like form (regex: [a-z]{4}[0-9]{4}).
The message content cannot have more than 70 English characters or contain a ‘|’ character.
(| is used as delimiter later). If a transaction violates those rules, it should be considered as
an invalid transaction.
Please use the skeleton code below to implement your Transaction class.
1 public class Transaction {
2 private String sender;
3 private String content;
4
5 // getters and setters
6 public void setSender(String sender) { this.sender = sender; }
7 public void setContent(String content) { this.content = content; }
8 public String getSender() { return sender; }
9 public String getContent() { return content; }
10
11 public String toString() {
12 return String.format("|%s|%70s|\n", sender, content);
13 }
14
15 // implement helper functions here if you need any
16 }
Block. A block contains a list of transactions and a hash value of the previous block as the
pointer:
? a list of transactions contains the messages;
? a hash pointer stores the hash value of the previous block.
The important thing here is to calculate the hash precisely. The hash function is SHA-
256. The first thing gets hashed is the previous block’s hash value using dos.write()
method, then each transaction in the list gets hashed using the dos.writeUTF() method.
writeUTF() method expects string as input. Therefore, you should convert each transaction
to tx|| string format (E.g. tx|test0001|welcome to comp2121!) before
writing to DataOutputStream. If you do not know how to achieve this, please have a
look at Assignment 0 of this course. The hashing algorithm is shown as follows.
Distributed Systems Page 4COMP3221 Client-Server Blockchain
1 H = SHA-256(H,tx1,tx2,tx3)
Please use the skeleton code below to implement your Block class.
1 public class Block {
2
3 private Block previousBlock;
4 private byte[] previousHash;
5 private ArrayList transactions;
6
7 public Block() { transactions = new ArrayList<>(); }
8
9 // getters and setters
10 public Block getPreviousBlock() { return previousBlock; }
11 public byte[] getPreviousHash() { return previousHash; }
12 public ArrayList getTransactions() { return transactions; }
13 public void setPreviousBlock(Block previousBlock) { this.previousBlock = previousBlock; }
14 public void setPreviousHash(byte[] previousHash) { this.previousHash = previousHash; }
15 public void setTransactions(ArrayList transactions) {
16 this.transactions = transactions;
17 }
18
19 public String toString() {
20 String cutOffRule = new String(new char[81]).replace("\0", "-") + "\n";
21 String prevHashString = String.format("|PreviousHash:|%65s|\n",
22 Base64.getEncoder().encodeToString(previousHash));
23 String hashString = String.format("|CurrentHash:|%66s|\n",
24 Base64.getEncoder().encodeToString(calculateHash()));
25 String transactionsString = "";
26 for (Transaction tx : transactions) {
27 transactionsString += tx.toString();
28 }
29 return "Block:\n"
30 + cutOffRule
31 + hashString
32 + cutOffRule
33 + transactionsString
34 + cutOffRule
35 + prevHashString
36 + cutOffRule;
37 }
38
39 // to calculate the hash of current block.
40 public byte[] calculateHash() {
41 // implement your code here.
42 }
43
44 // implement helper functions here if you need any.
45 }
Blockchain. A blockchain contains the blockchain itself to store committed transactions and
Distributed Systems Page 5COMP3221 Client-Server Blockchain
a pool to store uncommitted transactions. More precisely, it contains:
a list of uncommitted transactions as a pool;
the head (latest block) of the blockchain;
the length of the blockchain.
The blockchain has a public int addTransaction(String txString) method for the
user to add a transaction. The txString is in tx|| format. You need
to check each part of the txString following the standard as suggested before. Only valid
txString is converted into a transaction and then added to the pool. Adding invalid transaction
will cause this method to terminate and return 0. The pool should have an upper
limit of 3. Once the limit is reached, all uncommitted transactions in the pool are committed
to a new block, and that block is added to the blockchain (it becomes the new head of the
blockchain). If adding a new transaction causes a new block being generated, the length of
the blockchain should increase by 1 and this method should return 2. Otherwise, it returns
1. The root hash value is 0, this means the genesis block’s hash pointer has value 0.
Please use the skeleton code below to implement your Blockchain class.
1 public class Blockchain {
2
3 private Block head;
4 private ArrayList pool;
5 private int length;
6
7 private final int poolLimit = 3;
8
9 public Blockchain() {
10 pool = new ArrayList<>();
11 length = 0;
12 }
13
14 // getters and setters
15 public Block getHead() { return head; }
16 public ArrayList getPool() { return pool; }
17 public int getLength() { return length; }
18 public void setHead(Block head) { this.head = head; }
19 public void setPool(ArrayList pool) { this.pool = pool; }
20 public void setLength(int length) { this.length = length; }
21
22 // add a transaction
23 public int addTransaction(String txString) {
24 // implement you code here.
25 }
26
27 public String toString() {
28 String cutOffRule = new String(new char[81]).replace("\0", "-") + "\n";
29 String poolString = "";
30 for (Transaction tx : pool) {
Distributed Systems Page 6COMP3221 Client-Server Blockchain
31 poolString += tx.toString();
32 }
33
34 String blockString = "";
35 Block bl = head;
36 while (bl != null) {
37 blockString += bl.toString();
38 bl = bl.getPreviousBlock();
39 }
40
41 return "Pool:\n"
42 + cutOffRule
43 + poolString
44 + cutOffRule
45 + blockString;
46 }
47
48 // implement helper functions here if you need any.
49 }
Task 2 Blockchain: Server
The Blockchain server should build a ServerSocket that keeps listening to a specific port
provided by the user. Once a client connects, the server should accept the connection, and
pass the InputStream and OutputStream of the accepted socket to the serverHandler()
function. serverHandler() method implements the core logic about how to interact with
user requests. Your server should keep listening for connections unless you terminated the
process explicitly like "kill -9 ". There are three types of requests.
tx request. "tx||"
pb request. "pb"
cc request. "cc"
For tx (Transaction) request, the server should try to add the transaction message to the
blockchain and reply whether the transaction is in correct format. If the transaction is valid,
server should reply with "Accepted\n\n". Otherwise, it should reply with "Rejected\n\n".
Note, since Mac, Windows and Linux all utilizes different newline characters, In this assignment,
if there is no special indication, print() method is used by default rather than
println() method, and we manually add "\n" when a new line is required.
For pb (Print Blockchain) request, the server should reply with string representation of the
blockchain with an additional "\n". (blockchain.toString() + "\n").
For cc (Close Connection) request, the server should not reply anything and close socket
gracefully. (Note, only end the connection, don’t terminate the server).
Distributed Systems Page 7COMP3221 Client-Server Blockchain
For any other unrecognized request, the server should reply with "Error\n\n".
Please use the skeleton code below to implement your BlockchainServer class.
1 public class BlockchainServer {
2
3 private Blockchain blockchain;
4
5 public BlockchainServer() { blockchain = new Blockchain(); }
6
7 // getters and setters
8 public void setBlockchain(Blockchain blockchain) { this.blockchain = blockchain; }
9 public Blockchain getBlockchain() { return blockchain; }
10
11 public static void main(String[] args) {
12 if (args.length != 1) {
13 return;
14 }
15 int portNumber = Integer.parseInt(args[0]);
16 BlockchainServer bcs = new BlockchainServer();
17
18 // implement your code here.
19 }
20
21 public void serverHandler(InputStream clientInputStream, OutputStream clientOutputStream) {
22
23 BufferedReader inputReader = new BufferedReader(
24 new InputStreamReader(clientInputStream));
25 PrintWriter outWriter = new PrintWriter(clientOutputStream, true);
26
27 // implement your code here.
28
29 }
30
31 // implement helper functions here if you need any.
32 }
You should test this part using Linux telnet program as taught in the tutorial before.
For example, if you choose to use command line to compile your code, please issue command
"javac -d bin src/*.java" for compilation.
To start up your server, please issue command "java -cp bin BlockchainServer 8333 &",
and then start a connection to your server with command "telnet localhost 8333" in the
terminal.
Make sure you can reproduce the transcript below.
1 Trying ::1...
2 Connected to localhost.
3 Escape character is '^]'.
Distributed Systems Page 8COMP3221 Client-Server Blockchain
4 pb
5 Pool:
6 ---------------------------------------------------------------------------------
7 ---------------------------------------------------------------------------------
8
9 tx|test0000|1
10 Accepted
11
12 pb
13 Pool:
14 ---------------------------------------------------------------------------------
15 |test0000| 1|
16 ---------------------------------------------------------------------------------
17
18 tx|test0000|2
19 Accepted
20
21 pb
22 Pool:
23 ---------------------------------------------------------------------------------
24 |test0000| 1|
25 |test0000| 2|
26 ---------------------------------------------------------------------------------
27
28 tx|test0000|3
29 Accepted
30
31 pb
32 Pool:
33 ---------------------------------------------------------------------------------
34 ---------------------------------------------------------------------------------
35 Block:
36 ---------------------------------------------------------------------------------
37 |CurrentHash:| jWuaYc5TOawKJew+B+tYuLZT0NDsTo6NDKEJdmgJyBk=|
38 ---------------------------------------------------------------------------------
39 |test0000| 1|
40 |test0000| 2|
41 |test0000| 3|
42 ---------------------------------------------------------------------------------
43 |PreviousHash:| AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=|
44 ---------------------------------------------------------------------------------
45
46 tx|test0000|4
47 Accepted
48
49 pb
50 Pool:
51 ---------------------------------------------------------------------------------
52 |test0000| 4|
53 ---------------------------------------------------------------------------------
Distributed Systems Page 9COMP3221 Client-Server Blockchain
54 Block:
55 ---------------------------------------------------------------------------------
56 |CurrentHash:| jWuaYc5TOawKJew+B+tYuLZT0NDsTo6NDKEJdmgJyBk=|
57 ---------------------------------------------------------------------------------
58 |test0000| 1|
59 |test0000| 2|
60 |test0000| 3|
61 ---------------------------------------------------------------------------------
62 |PreviousHash:| AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=|
63 ---------------------------------------------------------------------------------
64
65 tx|test0000|5
66 Accepted
67
68 pb
69 Pool:
70 ---------------------------------------------------------------------------------
71 |test0000| 4|
72 |test0000| 5|
73 ---------------------------------------------------------------------------------
74 Block:
75 ---------------------------------------------------------------------------------
76 |CurrentHash:| jWuaYc5TOawKJew+B+tYuLZT0NDsTo6NDKEJdmgJyBk=|
77 ---------------------------------------------------------------------------------
78 |test0000| 1|
79 |test0000| 2|
80 |test0000| 3|
81 ---------------------------------------------------------------------------------
82 |PreviousHash:| AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=|
84
85 tx|test0000|6
86 Accepted
87
88 pb
89 Pool:
90 ---------------------------------------------------------------------------------
91 ---------------------------------------------------------------------------------
92 Block:
93 ---------------------------------------------------------------------------------
94 |CurrentHash:| Lakir/jIQFUGnf+UUnRbiuYsNDOcGXekM+2cKXVmyRw=|
95 ---------------------------------------------------------------------------------
96 |test0000| 4|
97 |test0000| 5|
98 |test0000| 6|
99 ---------------------------------------------------------------------------------
100 |PreviousHash:| jWuaYc5TOawKJew+B+tYuLZT0NDsTo6NDKEJdmgJyBk=|
101 ---------------------------------------------------------------------------------
102 Block:
103 ---------------------------------------------------------------------------------
Distributed Systems Page 10COMP3221 Client-Server Blockchain
104 |CurrentHash:| jWuaYc5TOawKJew+B+tYuLZT0NDsTo6NDKEJdmgJyBk=|
105 ---------------------------------------------------------------------------------
106 |test0000| 1|
107 |test0000| 2|
108 |test0000| 3|
109 ---------------------------------------------------------------------------------
110 |PreviousHash:| AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=|
111 ---------------------------------------------------------------------------------
112
113 tx|test0000|7
114 Accepted
115
116 pb
117 Pool:
118 ---------------------------------------------------------------------------------
119 |test0000| 7|
120 ---------------------------------------------------------------------------------
121 Block:
122 ---------------------------------------------------------------------------------
123 |CurrentHash:| Lakir/jIQFUGnf+UUnRbiuYsNDOcGXekM+2cKXVmyRw=|
124 ---------------------------------------------------------------------------------
125 |test0000| 4|
126 |test0000| 5|
127 |test0000| 6|
128 ---------------------------------------------------------------------------------
129 |PreviousHash:| jWuaYc5TOawKJew+B+tYuLZT0NDsTo6NDKEJdmgJyBk=|
130 ---------------------------------------------------------------------------------
131 Block:
132 ---------------------------------------------------------------------------------
133 |CurrentHash:| jWuaYc5TOawKJew+B+tYuLZT0NDsTo6NDKEJdmgJyBk=|
134 ---------------------------------------------------------------------------------
135 |test0000| 1|
136 |test0000| 2|
137 |test0000| 3|
138 ---------------------------------------------------------------------------------
139 |PreviousHash:| AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=|
140 ---------------------------------------------------------------------------------
141
142 tx|wrong|wrong
143 Rejected
144
145 pb
146 Pool:
147 ---------------------------------------------------------------------------------
148 |test0000| 7|
149 ---------------------------------------------------------------------------------
150 Block:
151 ---------------------------------------------------------------------------------
152 |CurrentHash:| Lakir/jIQFUGnf+UUnRbiuYsNDOcGXekM+2cKXVmyRw=|
153 ---------------------------------------------------------------------------------
Distributed Systems Page 11COMP3221 Client-Server Blockchain
154 |test0000| 4|
155 |test0000| 5|
156 |test0000| 6|
157 ---------------------------------------------------------------------------------
158 |PreviousHash:| jWuaYc5TOawKJew+B+tYuLZT0NDsTo6NDKEJdmgJyBk=|
159 ---------------------------------------------------------------------------------
160 Block:
161 ---------------------------------------------------------------------------------
162 |CurrentHash:| jWuaYc5TOawKJew+B+tYuLZT0NDsTo6NDKEJdmgJyBk=|
163 ---------------------------------------------------------------------------------
164 |test0000| 1|
165 |test0000| 2|
166 |test0000| 3|
167 ---------------------------------------------------------------------------------
168 |PreviousHash:| AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=|
169 ---------------------------------------------------------------------------------
170
171 cc
172 Connection closed by foreign host.
Task 3 Blockchain: Client
The last task is to build the client program. It should try to create a socket to connect to the
specific server and port number, and pass socket’s InputStream and OutputStream to the
clientHandler() method. The clientHandler() method implements the core logic of the
client, which uses a scanner to listen to user inputs, and forward user requests to the server.
If the request is "cc", the client should terminate. Otherwise, it keeps waiting for new user
inputs. All server replies should be correctly printed on the screen. The client program should
work exactly the same as the telnet program does, except for lines like
1 Trying ::1...
2 Connected to localhost.
3 Escape character is '^]'.
4 Connection closed by foreign host.
Please use the skeleton code below to implement your BlockchainClient class.
1 public class BlockchainClient {
2
3 public static void main(String[] args) {
4
5 if (args.length != 2) {
6 return;
7 }
8 String serverName = args[0];
9 int portNumber = Integer.parseInt(args[1]);
10 BlockchainClient bcc = new BlockchainClient();
11
12 // implement your code here.
Distributed Systems Page 12COMP3221 Client-Server Blockchain
13 }
14
15 public void clientHandler(InputStream serverInputStream, OutputStream serverOutputStream) {
16 BufferedReader inputReader = new BufferedReader(
17 new InputStreamReader(serverInputStream));
18 PrintWriter outWriter = new PrintWriter(serverOutputStream, true);
19
20 Scanner sc = new Scanner(System.in);
21 while (sc.hasNextLine()) {
22 // implement your code here
23 }
24 }
25
26 // implement helper functions here if you need any.
27 }
While no code should be shared, note that you are allowed to test with others after you have
finished your assignment.