1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

package com.zxh;

import java.security.*;

import java.security.spec.ECGenParameterSpec;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Map;

public class Wallet {

    public PrivateKey privateKey;

    public PublicKey publicKey;

    public HashMap<String,TransactionOutput> UTXOs = new HashMap<String,TransactionOutput>();

    public Wallet() {

        generateKeyPair();

    }

    public void generateKeyPair() {

        try {

            KeyPairGenerator keyGen = KeyPairGenerator.getInstance("ECDSA","BC");

            SecureRandom random = SecureRandom.getInstance("SHA1PRNG");

            ECGenParameterSpec ecSpec = new ECGenParameterSpec("prime192v1");

            // Initialize the key generator and generate a KeyPair

            keyGen.initialize(ecSpec, random); //256

            KeyPair keyPair = keyGen.generateKeyPair();

            // Set the public and private keys from the keyPair

            privateKey = keyPair.getPrivate();

            publicKey = keyPair.getPublic();

        }catch(Exception e) {

            throw new RuntimeException(e);

        }

    }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

import java.security.*;import java.util.ArrayList;public class Transaction {

    public String transactionId; // this is also the hash of the transaction.

    public PublicKey sender; // senders address/public key.

    public PublicKey reciepient; // Recipients address/public key.

    public float value;

    public byte[] signature; // this is to prevent anybody else from spending funds in our wallet.

    public ArrayList<TransactionInput> inputs = new ArrayList<TransactionInput>();

    public ArrayList<TransactionOutput> outputs = new ArrayList<TransactionOutput>();

    private static int sequence = 0; // a rough count of how many transactions have been generated. 

    // Constructor: 

    public Transaction(PublicKey from, PublicKey to, float value,  ArrayList<TransactionInput> inputs) {

        this.sender = from;

        this.reciepient = to;

        this.value = value;

        this.inputs = inputs;

    }

    // This Calculates the transaction hash (which will be used as its Id)

    private String calulateHash() {

        sequence++; //increase the sequence to avoid 2 identical transactions having the same hash

        return StringUtil.applySha256(

                StringUtil.getStringFromKey(sender) +

                StringUtil.getStringFromKey(reciepient) +

                Float.toString(value) + sequence

                );

    }}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

public static byte[] applyECDSASig(PrivateKey privateKey, String input) {

        Signature dsa;

        byte[] output = new byte[0];

        try {

            dsa = Signature.getInstance("ECDSA", "BC");

            dsa.initSign(privateKey);

            byte[] strByte = input.getBytes();

            dsa.update(strByte);

            byte[] realSig = dsa.sign();

            output = realSig;

        } catch (Exception e) {

            throw new RuntimeException(e);

        }

        return output;

    }

    //Verifies a String signature 

    public static boolean verifyECDSASig(PublicKey publicKey, String data, byte[] signature) {

        try {

            Signature ecdsaVerify = Signature.getInstance("ECDSA", "BC");

            ecdsaVerify.initVerify(publicKey);

            ecdsaVerify.update(data.getBytes());

            return ecdsaVerify.verify(signature);

        }catch(Exception e) {

            throw new RuntimeException(e);

        }

    }

    public static String getStringFromKey(Key key) {

        return Base64.getEncoder().encodeToString(key.getEncoded());

    }

1

2

3

4

5

6

7

//Signs all the data we dont wish to be tampered with.public void generateSignature(PrivateKey privateKey) {

    String data = StringUtil.getStringFromKey(sender) + StringUtil.getStringFromKey(reciepient) + Float.toString(value)  ;

    signature = StringUtil.applyECDSASig(privateKey,data);        }

    //Verifies the data we signed hasnt been tampered withpublic boolean verifiySignature() {

    String data = StringUtil.getStringFromKey(sender) + StringUtil.getStringFromKey(reciepient) + Float.toString(value)  ;

    return StringUtil.verifyECDSASig(sender, data, signature);}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

import java.security.Security;import java.util.ArrayList;import java.util.Base64;import com.google.gson.GsonBuilder;public class NoobChain {

    public static ArrayList<Block> blockchain = new ArrayList<Block>();

    public static int difficulty = 5;

    public static Wallet walletA;

    public static Wallet walletB;

    public static void main(String[] args) {  

        //Setup Bouncey castle as a Security Provider

        Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider()); 

        //Create the new wallets

        walletA = new Wallet();

        walletB = new Wallet();

        //Test public and private keys

        System.out.println("Private and public keys:");

        System.out.println(StringUtil.getStringFromKey(walletA.privateKey));

        System.out.println(StringUtil.getStringFromKey(walletA.publicKey));

        //Create a test transaction from WalletA to walletB 

        Transaction transaction = new Transaction(walletA.publicKey, walletB.publicKey, 5, null);

        transaction.generateSignature(walletA.privateKey);

        //Verify the signature works and verify it from the public key

        System.out.println("Is signature verified");

        System.out.println(transaction.verifiySignature());

    }

1

Connected to the target VM, address: '127.0.0.1:55757', transport: 'socket'Private and public keys:MHsCAQAwEwYHKoZIzj0CAQYIKoZIzj0DAQEEYTBfAgEBBBiJzZiesBnBWwwB+uog+fJX84mx4lPUTUagCgYIKoZIzj0DAQGhNAMyAAQfPzad0zqBUGQAany2rRZE1+2ml5IOCZST8LywjBQT8ux+3UPVbr2u0+LaExxz1WI=MEkwEwYHKoZIzj0CAQYIKoZIzj0DAQEDMgAEHz82ndM6gVBkAGp8tq0WRNftppeSDgmUk/C8sIwUE/Lsft1D1W69rtPi2hMcc9ViIs signature verifiedtrue

1

2

3

4

5

6

7

public class TransactionInput {

    public String transactionOutputId; //Reference to TransactionOutputs -> transactionId

    public TransactionOutput UTXO; //Contains the Unspent transaction output

    public TransactionInput(String transactionOutputId) {

        this.transactionOutputId = transactionOutputId;

    }}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

import java.security.PublicKey;public class TransactionOutput {

    public String id;

    public PublicKey reciepient; //also known as the new owner of these coins.

    public float value; //the amount of coins they own

    public String parentTransactionId; //the id of the transaction this output was created in

    //Constructor

    public TransactionOutput(PublicKey reciepient, float value, String parentTransactionId) {

        this.reciepient = reciepient;

        this.value = value;

        this.parentTransactionId = parentTransactionId;

        this.id = StringUtil.applySha256(StringUtil.getStringFromKey(reciepient)+Float.toString(value)+parentTransactionId);

    }

    //Check if coin belongs to you

    public boolean isMine(PublicKey publicKey) {

        return (publicKey == reciepient);

    }

    }

1

2

3

4

5

6

7

8

9

public class NoobChain {

    public static ArrayList<Block> blockchain = new ArrayList<Block>();

    public static HashMap<String,TransactionOutputs> UTXOs = new HashMap<String,TransactionOutputs>(); //list of all unspent transactions. 

    public static int difficulty = 5;

    public static Wallet walletA;

    public static Wallet walletB;

    public static void main(String[] args) {  

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

//Returns true if new transaction could be created.  public boolean processTransaction() {

        if(verifiySignature() == false) {

            System.out.println("#Transaction Signature failed to verify");

            return false;

        }

        //gather transaction inputs (Make sure they are unspent):

        for(TransactionInput i : inputs) {

            i.UTXO = NoobChain.UTXOs.get(i.transactionOutputId);

        }

        //check if transaction is valid:

        if(getInputsValue() < NoobChain.minimumTransaction) {

            System.out.println("#Transaction Inputs to small: " + getInputsValue());

            return false;

        }

        //generate transaction outputs:

        float leftOver = getInputsValue() - value; //get value of inputs then the left over change:

        transactionId = calulateHash();

        outputs.add(new TransactionOutput( this.reciepient, value,transactionId)); //send value to recipient

        outputs.add(new TransactionOutput( this.sender, leftOver,transactionId)); //send the left over 'change' back to sender      

        //add outputs to Unspent list

        for(TransactionOutput o : outputs) {

            NoobChain.UTXOs.put(o.id , o);

        }

        //remove transaction inputs from UTXO lists as spent:

        for(TransactionInput i : inputs) {

            if(i.UTXO == null) continue; //if Transaction can't be found skip it 

            NoobChain.UTXOs.remove(i.UTXO.id);

        }

        return true;

    }

    //returns sum of inputs(UTXOs) values

    public float getInputsValue() {

        float total = 0;

        for(TransactionInput i : inputs) {

            if(i.UTXO == null) continue; //if Transaction can't be found skip it 

            total += i.UTXO.value;

        }

        return total;

    }//returns sum of outputs:

    public float getOutputsValue() {

        float total = 0;

        for(TransactionOutput o : outputs) {

            total += o.value;

        }

        return total;

    }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

import java.security.*;import java.security.spec.ECGenParameterSpec;import java.util.ArrayList;import java.util.HashMap;import java.util.Map;public class Wallet {

    public PrivateKey privateKey;

    public PublicKey publicKey;

    public HashMap<String,TransactionOutput> UTXOs = new HashMap<String,TransactionOutput>(); //only UTXOs owned by this wallet.

    public Wallet() {...

    public void generateKeyPair() {...

  //returns balance and stores the UTXO's owned by this wallet in this.UTXOs

    public float getBalance() {

        float total = 0;

        for (Map.Entry<String, TransactionOutput> item: NoobChain.UTXOs.entrySet()){

            TransactionOutput UTXO = item.getValue();

            if(UTXO.isMine(publicKey)) { //if output belongs to me ( if coins belong to me )

                UTXOs.put(UTXO.id,UTXO); //add it to our list of unspent transactions.

                total += UTXO.value ; 

            }

        }  

        return total;

    }

    //Generates and returns a new transaction from this wallet.

    public Transaction sendFunds(PublicKey _recipient,float value ) {

        if(getBalance() < value) { //gather balance and check funds.

            System.out.println("#Not Enough funds to send transaction. Transaction Discarded.");

            return null;

        }

    //create array list of inputs

        ArrayList<TransactionInput> inputs = new ArrayList<TransactionInput>();

        float total = 0;

        for (Map.Entry<String, TransactionOutput> item: UTXOs.entrySet()){

            TransactionOutput UTXO = item.getValue();

            total += UTXO.value;

            inputs.add(new TransactionInput(UTXO.id));

            if(total > value) break;

        }

        Transaction newTransaction = new Transaction(publicKey, _recipient , value, inputs);

        newTransaction.generateSignature(privateKey);

        for(TransactionInput input: inputs){

            UTXOs.remove(input.transactionOutputId);

        }

        return newTransaction;

    }

    }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

//Tacks in array of transactions and returns a merkle root.public static String getMerkleRoot(ArrayList<Transaction> transactions) {

        int count = transactions.size();

        ArrayList<String> previousTreeLayer = new ArrayList<String>();

        for(Transaction transaction : transactions) {

            previousTreeLayer.add(transaction.transactionId);

        }

        ArrayList<String> treeLayer = previousTreeLayer;

        while(count > 1) {

            treeLayer = new ArrayList<String>();

            for(int i=1; i < previousTreeLayer.size(); i++) {

                treeLayer.add(applySha256(previousTreeLayer.get(i-1) + previousTreeLayer.get(i)));

            }

            count = treeLayer.size();

            previousTreeLayer = treeLayer;

        }

        String merkleRoot = (treeLayer.size() == 1) ? treeLayer.get(0) : "";

        return merkleRoot;

    }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

import java.util.ArrayList;import java.util.Date;public class Block {

    public String hash;

    public String previousHash; 

    public String merkleRoot;

    public ArrayList<Transaction> transactions = new ArrayList<Transaction>(); //our data will be a simple message.

    public long timeStamp; //as number of milliseconds since 1/1/1970.

    public int nonce;

    //Block Constructor.  

    public Block(String previousHash ) {

        this.previousHash = previousHash;

        this.timeStamp = new Date().getTime();

        this.hash = calculateHash(); //Making sure we do this after we set the other values.

    }

    //Calculate new hash based on blocks contents

    public String calculateHash() {

        String calculatedhash = StringUtil.applySha256( 

                previousHash +

                Long.toString(timeStamp) +

                Integer.toString(nonce) + 

                merkleRoot

                );

        return calculatedhash;

    }

    //Increases nonce value until hash target is reached.

    public void mineBlock(int difficulty) {

        merkleRoot = StringUtil.getMerkleRoot(transactions);

        String target = StringUtil.getDificultyString(difficulty); //Create a string with difficulty * "0" 

        while(!hash.substring( 0, difficulty).equals(target)) {

            nonce ++;

            hash = calculateHash();

        }

        System.out.println("Block Mined!!! : " + hash);

    }

    //Add transactions to this block

    public boolean addTransaction(Transaction transaction) {

        //process transaction and check if valid, unless block is genesis block then ignore.

        if(transaction == null) return false;      

        if((previousHash != "0")) {

            if((transaction.processTransaction() != true)) {

                System.out.println("Transaction failed to process. Discarded.");

                return false;

            }

        }

        transactions.add(transaction);

        System.out.println("Transaction Successfully added to Block");

        return true;

    }

    }