├── .gitignore
├── .travis.yml
├── src
    ├── main
    │   └── java
    │   │   └── one
    │   │       └── wangwei
    │   │           └── blockchain
    │   │               ├── cli
    │   │                   ├── Main.java
    │   │                   └── CLI.java
    │   │               ├── pow
    │   │                   ├── PowResult.java
    │   │                   └── ProofOfWork.java
    │   │               ├── transaction
    │   │                   ├── SpendableOutputResult.java
    │   │                   ├── TXInput.java
    │   │                   ├── TXOutput.java
    │   │                   ├── MerkleTree.java
    │   │                   ├── UTXOSet.java
    │   │                   └── Transaction.java
    │   │               ├── util
    │   │                   ├── SerializeUtils.java
    │   │                   ├── ByteUtils.java
    │   │                   ├── BtcAddressUtils.java
    │   │                   └── Base58Check.java
    │   │               ├── block
    │   │                   ├── Block.java
    │   │                   └── Blockchain.java
    │   │               ├── wallet
    │   │                   ├── Wallet.java
    │   │                   └── WalletUtils.java
    │   │               └── store
    │   │                   └── RocksDBUtils.java
    └── test
    │   └── java
    │       └── one
    │           └── wangwei
    │               └── blockchain
    │                   └── BlockchainTest.java
├── blockchain.sh
├── README.md
├── pom.xml
└── LICENSE


/.gitignore:
--------------------------------------------------------------------------------
1 | .idea/
2 | target/
3 | *.iml
4 | blockchain.db/
5 | wallet.dat


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: java
2 | sudo: false
3 | jdk:
4 |   - oraclejdk8
5 | notifications:
6 |   email: false


--------------------------------------------------------------------------------
/src/main/java/one/wangwei/blockchain/cli/Main.java:
--------------------------------------------------------------------------------
 1 | package one.wangwei.blockchain.cli;
 2 | 
 3 | public class Main {
 4 | 
 5 |     public static void main(String[] args) {
 6 |         CLI cli = new CLI(args);
 7 |         cli.parse();
 8 |     }
 9 | }
10 | 


--------------------------------------------------------------------------------
/blockchain.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | set -e
 4 | 
 5 | # Check if the jar has been built.
 6 | if [ ! -e target/blockchain-java-jar-with-dependencies.jar ]; then
 7 |   echo "Compiling blockchain project to a JAR"
 8 |   mvn package -DskipTests
 9 | fi
10 | 
11 | java -jar target/blockchain-java-jar-with-dependencies.jar "$@"


--------------------------------------------------------------------------------
/src/main/java/one/wangwei/blockchain/pow/PowResult.java:
--------------------------------------------------------------------------------
 1 | package one.wangwei.blockchain.pow;
 2 | 
 3 | import lombok.AllArgsConstructor;
 4 | import lombok.Data;
 5 | import lombok.NoArgsConstructor;
 6 | 
 7 | /**
 8 |  * <p> 工作量计算结果 </p>
 9 |  *
10 |  * @author wangwei
11 |  * @date 2018/02/04
12 |  */
13 | @Data
14 | @AllArgsConstructor
15 | @NoArgsConstructor
16 | public class PowResult {
17 | 
18 |     /**
19 |      * 计数器
20 |      */
21 |     private long nonce;
22 |     /**
23 |      * hash值
24 |      */
25 |     private String hash;
26 | 
27 | }
28 | 


--------------------------------------------------------------------------------
/src/main/java/one/wangwei/blockchain/transaction/SpendableOutputResult.java:
--------------------------------------------------------------------------------
 1 | package one.wangwei.blockchain.transaction;
 2 | 
 3 | import lombok.AllArgsConstructor;
 4 | import lombok.Data;
 5 | import lombok.NoArgsConstructor;
 6 | 
 7 | import java.util.Map;
 8 | 
 9 | /**
10 |  * 查询结果
11 |  *
12 |  * @author wangwei
13 |  * @date 2018/03/09
14 |  */
15 | @Data
16 | @AllArgsConstructor
17 | @NoArgsConstructor
18 | public class SpendableOutputResult {
19 | 
20 |     /**
21 |      * 交易时的支付金额
22 |      */
23 |     private int accumulated;
24 |     /**
25 |      * 未花费的交易
26 |      */
27 |     private Map<String, int[]> unspentOuts;
28 | 
29 | }
30 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ## 基于Java语言构建区块链
 2 | [![Build Status](https://travis-ci.org/wangweiX/blockchain-java.svg?branch=master)](https://travis-ci.org/wangweiX/blockchain-java)
 3 | 
 4 | > 本系列文章的思路均来自：https://github.com/Jeiwan/blockchain_go
 5 | 
 6 | ### 环境
 7 | 
 8 | - Maven 3.2.5
 9 | - JDK 1.7 +
10 | - IDEA 安装插件 Lombok. [详情](https://wangwei.one/posts/917fb1e0.html)
11 | 
12 | 
13 | ### 文章
14 | 
15 | - [基本原型](https://wangwei.one/posts/build-blockchain-in-java-base-prototype.html)
16 | - [工作量证明](https://wangwei.one/posts/build-blockchain-in-java-proof-of-work.html)
17 | - [持久化存储](https://wangwei.one/posts/build-blockchain-in-java-data-persistence.html)
18 | - [交易 - UTXO](https://wangwei.one/posts/build-blockchain-in-java-transaction-utxo.html)
19 | - [地址 - 钱包](https://wangwei.one/posts/build-blockchain-in-java-wallet-address.html)
20 | - [交易 - Merkle Tree](https://wangwei.one/posts/build-blockchain-in-java-transaction-merkle-tree.html)
21 | 
22 | 
23 | ### 反馈&提示
24 | - 由于本人水平有限，若代码或文章存在错误或不足，还望指正；
25 | - 如若[博客](https://wangwei.one/)网站无法打开，请开启翻墙代理全局模式；
26 | 


--------------------------------------------------------------------------------
/src/main/java/one/wangwei/blockchain/util/SerializeUtils.java:
--------------------------------------------------------------------------------
 1 | package one.wangwei.blockchain.util;
 2 | 
 3 | import com.esotericsoftware.kryo.Kryo;
 4 | import com.esotericsoftware.kryo.io.Input;
 5 | import com.esotericsoftware.kryo.io.Output;
 6 | 
 7 | /**
 8 |  * 序列化工具类
 9 |  *
10 |  * @author wangwei
11 |  * @date 2018/02/07
12 |  */
13 | public class SerializeUtils {
14 | 
15 |     /**
16 |      * 反序列化
17 |      *
18 |      * @param bytes 对象对应的字节数组
19 |      * @return
20 |      */
21 |     public static Object deserialize(byte[] bytes) {
22 |         Input input = new Input(bytes);
23 |         Object obj = new Kryo().readClassAndObject(input);
24 |         input.close();
25 |         return obj;
26 |     }
27 | 
28 |     /**
29 |      * 序列化
30 |      *
31 |      * @param object 需要序列化的对象
32 |      * @return
33 |      */
34 |     public static byte[] serialize(Object object) {
35 |         Output output = new Output(4096, -1);
36 |         new Kryo().writeClassAndObject(output, object);
37 |         byte[] bytes = output.toBytes();
38 |         output.close();
39 |         return bytes;
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/main/java/one/wangwei/blockchain/transaction/TXInput.java:
--------------------------------------------------------------------------------
 1 | package one.wangwei.blockchain.transaction;
 2 | 
 3 | import lombok.AllArgsConstructor;
 4 | import lombok.Data;
 5 | import lombok.NoArgsConstructor;
 6 | import one.wangwei.blockchain.util.BtcAddressUtils;
 7 | 
 8 | import java.util.Arrays;
 9 | 
10 | /**
11 |  * 交易输入
12 |  *
13 |  * @author wangwei
14 |  * @date 2017/03/04
15 |  */
16 | @Data
17 | @AllArgsConstructor
18 | @NoArgsConstructor
19 | public class TXInput {
20 | 
21 |     /**
22 |      * 交易Id的hash值
23 |      */
24 |     private byte[] txId;
25 |     /**
26 |      * 交易输出索引
27 |      */
28 |     private int txOutputIndex;
29 |     /**
30 |      * 签名
31 |      */
32 |     private byte[] signature;
33 |     /**
34 |      * 公钥
35 |      */
36 |     private byte[] pubKey;
37 | 
38 |     /**
39 |      * 检查公钥hash是否用于交易输入
40 |      *
41 |      * @param pubKeyHash
42 |      * @return
43 |      */
44 |     public boolean usesKey(byte[] pubKeyHash) {
45 |         byte[] lockingHash = BtcAddressUtils.ripeMD160Hash(this.getPubKey());
46 |         return Arrays.equals(lockingHash, pubKeyHash);
47 |     }
48 | 
49 | }
50 | 


--------------------------------------------------------------------------------
/src/test/java/one/wangwei/blockchain/BlockchainTest.java:
--------------------------------------------------------------------------------
 1 | package one.wangwei.blockchain;
 2 | 
 3 | import one.wangwei.blockchain.cli.CLI;
 4 | 
 5 | /**
 6 |  * 测试
 7 |  *
 8 |  * @author wangwei
 9 |  * @date 2018/02/05
10 |  */
11 | public class BlockchainTest {
12 | 
13 |     public static void main(String[] args) {
14 |         try {
15 | //            String[] argss = {"createwallet"};
16 | //            String[] argss = {"createblockchain", "-address", "1CceyiwYXh6vL6dLPw6WiNc5ihqVxwYHSA"};
17 |             // 1CceyiwYXh6vL6dLPw6WiNc5ihqVxwYHSA
18 |             // 1G9TkDEp9YTnGa6gS5zaWkwGQwKrRykXcf
19 |             // 1EKacQPNxTd8N7Y83VK11zoqm7bhUZiDHm
20 | //            String[] argss = {"printaddresses"};
21 | //            String[] argss = {"getbalance", "-address", "1G9TkDEp9YTnGa6gS5zaWkwGQwKrRykXcf"};
22 |             String[] argss = {"send", "-from", "1CceyiwYXh6vL6dLPw6WiNc5ihqVxwYHSA", "-to", "1EKacQPNxTd8N7Y83VK11zoqm7bhUZiDHm", "-amount", "5"};
23 |             CLI cli = new CLI(argss);
24 |             cli.parse();
25 |         } catch (Exception e) {
26 |             e.printStackTrace();
27 |         }
28 |     }
29 | 
30 | }
31 | 


--------------------------------------------------------------------------------
/src/main/java/one/wangwei/blockchain/util/ByteUtils.java:
--------------------------------------------------------------------------------
 1 | package one.wangwei.blockchain.util;
 2 | 
 3 | import org.apache.commons.codec.binary.Hex;
 4 | import org.apache.commons.lang3.ArrayUtils;
 5 | 
 6 | import java.nio.ByteBuffer;
 7 | import java.util.Arrays;
 8 | import java.util.stream.Stream;
 9 | 
10 | /**
11 |  * 字节数组工具类
12 |  *
13 |  * @author wangwei
14 |  * @date 2018/02/05
15 |  */
16 | public class ByteUtils {
17 | 
18 |     public static final byte[] EMPTY_ARRAY = new byte[0];
19 | 
20 |     public static final byte[] EMPTY_BYTES = new byte[32];
21 | 
22 |     public static final String ZERO_HASH = Hex.encodeHexString(EMPTY_BYTES);
23 | 
24 |     /**
25 |      * 将多个字节数组合并成一个字节数组
26 |      *
27 |      * @param bytes
28 |      * @return
29 |      */
30 |     public static byte[] merge(byte[]... bytes) {
31 |         Stream<Byte> stream = Stream.of();
32 |         for (byte[] b: bytes) {
33 |             stream = Stream.concat(stream, Arrays.stream(ArrayUtils.toObject(b)));
34 |         }
35 |         return ArrayUtils.toPrimitive(stream.toArray(Byte[]::new));
36 |     }
37 | 
38 |     /**
39 |      * long 类型转 byte[]
40 |      *
41 |      * @param val
42 |      * @return
43 |      */
44 |     public static byte[] toBytes(long val) {
45 |         return ByteBuffer.allocate(Long.BYTES).putLong(val).array();
46 |     }
47 | 
48 | }
49 | 


--------------------------------------------------------------------------------
/src/main/java/one/wangwei/blockchain/transaction/TXOutput.java:
--------------------------------------------------------------------------------
 1 | package one.wangwei.blockchain.transaction;
 2 | 
 3 | import lombok.AllArgsConstructor;
 4 | import lombok.Data;
 5 | import lombok.NoArgsConstructor;
 6 | import one.wangwei.blockchain.util.Base58Check;
 7 | 
 8 | import java.util.Arrays;
 9 | 
10 | /**
11 |  * 交易输出
12 |  *
13 |  * @author wangwei
14 |  * @date 2017/03/04
15 |  */
16 | @Data
17 | @AllArgsConstructor
18 | @NoArgsConstructor
19 | public class TXOutput {
20 | 
21 |     /**
22 |      * 数值
23 |      */
24 |     private int value;
25 |     /**
26 |      * 公钥Hash
27 |      */
28 |     private byte[] pubKeyHash;
29 | 
30 |     /**
31 |      * 创建交易输出
32 |      *
33 |      * @param value
34 |      * @param address
35 |      * @return
36 |      */
37 |     public static TXOutput newTXOutput(int value, String address) {
38 |         // 反向转化为 byte 数组
39 |         byte[] versionedPayload = Base58Check.base58ToBytes(address);
40 |         byte[] pubKeyHash = Arrays.copyOfRange(versionedPayload, 1, versionedPayload.length);
41 |         return new TXOutput(value, pubKeyHash);
42 |     }
43 | 
44 |     /**
45 |      * 检查交易输出是否能够使用指定的公钥
46 |      *
47 |      * @param pubKeyHash
48 |      * @return
49 |      */
50 |     public boolean isLockedWithKey(byte[] pubKeyHash) {
51 |         return Arrays.equals(this.getPubKeyHash(), pubKeyHash);
52 |     }
53 | 
54 | }
55 | 


--------------------------------------------------------------------------------
/src/main/java/one/wangwei/blockchain/util/BtcAddressUtils.java:
--------------------------------------------------------------------------------
 1 | package one.wangwei.blockchain.util;
 2 | 
 3 | import org.apache.commons.codec.digest.DigestUtils;
 4 | import org.bouncycastle.crypto.digests.RIPEMD160Digest;
 5 | import org.bouncycastle.util.Arrays;
 6 | 
 7 | /**
 8 |  * 地址工具类
 9 |  *
10 |  * @author wangwei
11 |  * @date 2018/03/21
12 |  */
13 | public class BtcAddressUtils {
14 |     
15 |     /**
16 |      * 双重Hash
17 |      *
18 |      * @param data
19 |      * @return
20 |      */
21 |     public static byte[] doubleHash(byte[] data) {
22 |         return DigestUtils.sha256(DigestUtils.sha256(data));
23 |     }
24 | 
25 |     /**
26 |      * 计算公钥的 RIPEMD160 Hash值
27 |      *
28 |      * @param pubKey 公钥
29 |      * @return ipeMD160Hash(sha256 ( pubkey))
30 |      */
31 |     public static byte[] ripeMD160Hash(byte[] pubKey) {
32 |         //1. 先对公钥做 sha256 处理
33 |         byte[] shaHashedKey = DigestUtils.sha256(pubKey);
34 |         RIPEMD160Digest ripemd160 = new RIPEMD160Digest();
35 |         ripemd160.update(shaHashedKey, 0, shaHashedKey.length);
36 |         byte[] output = new byte[ripemd160.getDigestSize()];
37 |         ripemd160.doFinal(output, 0);
38 |         return output;
39 |     }
40 | 
41 |     /**
42 |      * 生成公钥的校验码
43 |      *
44 |      * @param payload
45 |      * @return
46 |      */
47 |     public static byte[] checksum(byte[] payload) {
48 |         return Arrays.copyOfRange(doubleHash(payload), 0, 4);
49 |     }
50 | 
51 | }
52 | 


--------------------------------------------------------------------------------
/src/main/java/one/wangwei/blockchain/block/Block.java:
--------------------------------------------------------------------------------
 1 | package one.wangwei.blockchain.block;
 2 | 
 3 | import lombok.AllArgsConstructor;
 4 | import lombok.Data;
 5 | import lombok.NoArgsConstructor;
 6 | import lombok.ToString;
 7 | import one.wangwei.blockchain.pow.PowResult;
 8 | import one.wangwei.blockchain.pow.ProofOfWork;
 9 | import one.wangwei.blockchain.transaction.MerkleTree;
10 | import one.wangwei.blockchain.transaction.Transaction;
11 | import one.wangwei.blockchain.util.ByteUtils;
12 | 
13 | import java.time.Instant;
14 | 
15 | /**
16 |  * 区块
17 |  *
18 |  * @author wangwei
19 |  * @date 2018/02/02
20 |  */
21 | @Data
22 | @AllArgsConstructor
23 | @NoArgsConstructor
24 | @ToString
25 | public class Block {
26 | 
27 |     /**
28 |      * 区块hash值
29 |      */
30 |     private String hash;
31 |     /**
32 |      * 前一个区块的hash值
33 |      */
34 |     private String prevBlockHash;
35 |     /**
36 |      * 交易信息
37 |      */
38 |     private Transaction[] transactions;
39 |     /**
40 |      * 区块创建时间(单位:秒)
41 |      */
42 |     private long timeStamp;
43 |     /**
44 |      * 工作量证明计数器
45 |      */
46 |     private long nonce;
47 | 
48 |     /**
49 |      * <p> 创建创世区块 </p>
50 |      *
51 |      * @param coinbase
52 |      * @return
53 |      */
54 |     public static Block newGenesisBlock(Transaction coinbase) {
55 |         return Block.newBlock(ByteUtils.ZERO_HASH, new Transaction[]{coinbase});
56 |     }
57 | 
58 |     /**
59 |      * <p> 创建新区块 </p>
60 |      *
61 |      * @param previousHash
62 |      * @param transactions
63 |      * @return
64 |      */
65 |     public static Block newBlock(String previousHash, Transaction[] transactions) {
66 |         Block block = new Block("", previousHash, transactions, Instant.now().getEpochSecond(), 0);
67 |         ProofOfWork pow = ProofOfWork.newProofOfWork(block);
68 |         PowResult powResult = pow.run();
69 |         block.setHash(powResult.getHash());
70 |         block.setNonce(powResult.getNonce());
71 |         return block;
72 |     }
73 | 
74 |     /**
75 |      * 对区块中的交易信息进行Hash计算
76 |      *
77 |      * @return
78 |      */
79 |     public byte[] hashTransaction() {
80 |         byte[][] txIdArrays = new byte[this.getTransactions().length][];
81 |         for (int i = 0; i < this.getTransactions().length; i++) {
82 |             txIdArrays[i] = this.getTransactions()[i].hash();
83 |         }
84 |         return new MerkleTree(txIdArrays).getRoot().getHash();
85 |     }
86 | }
87 | 


--------------------------------------------------------------------------------
/src/main/java/one/wangwei/blockchain/pow/ProofOfWork.java:
--------------------------------------------------------------------------------
  1 | package one.wangwei.blockchain.pow;
  2 | 
  3 | import lombok.AllArgsConstructor;
  4 | import lombok.Data;
  5 | import lombok.NoArgsConstructor;
  6 | import lombok.extern.slf4j.Slf4j;
  7 | import one.wangwei.blockchain.block.Block;
  8 | import one.wangwei.blockchain.util.ByteUtils;
  9 | import org.apache.commons.codec.digest.DigestUtils;
 10 | import org.apache.commons.lang3.StringUtils;
 11 | 
 12 | import java.math.BigInteger;
 13 | 
 14 | /**
 15 |  * 工作量证明
 16 |  *
 17 |  * @author wangwei
 18 |  * @date 2018/02/04
 19 |  */
 20 | @Data
 21 | @AllArgsConstructor
 22 | @NoArgsConstructor
 23 | @Slf4j
 24 | public class ProofOfWork {
 25 | 
 26 |     /**
 27 |      * 难度目标位
 28 |      */
 29 |     public static final int TARGET_BITS = 16;
 30 | 
 31 |     /**
 32 |      * 区块
 33 |      */
 34 |     private Block block;
 35 |     /**
 36 |      * 难度目标值
 37 |      */
 38 |     private BigInteger target;
 39 | 
 40 | 
 41 |     /**
 42 |      * 创建新的工作量证明，设定难度目标值
 43 |      * <p>
 44 |      * 对1进行移位运算，将1向左移动 (256 - TARGET_BITS) 位，得到我们的难度目标值
 45 |      *
 46 |      * @param block
 47 |      * @return
 48 |      */
 49 |     public static ProofOfWork newProofOfWork(Block block) {
 50 |         BigInteger targetValue = BigInteger.valueOf(1).shiftLeft((256 - TARGET_BITS));
 51 |         return new ProofOfWork(block, targetValue);
 52 |     }
 53 | 
 54 |     /**
 55 |      * 运行工作量证明，开始挖矿，找到小于难度目标值的Hash
 56 |      *
 57 |      * @return
 58 |      */
 59 |     public PowResult run() {
 60 |         long nonce = 0;
 61 |         String shaHex = "";
 62 |         long startTime = System.currentTimeMillis();
 63 |         while (nonce < Long.MAX_VALUE) {
 64 |             log.info("POW running, nonce=" + nonce);
 65 |             byte[] data = this.prepareData(nonce);
 66 |             shaHex = DigestUtils.sha256Hex(data);
 67 |             if (new BigInteger(shaHex, 16).compareTo(this.target) == -1) {
 68 |                 log.info("Elapsed Time: {} seconds \n", new Object[]{(float) (System.currentTimeMillis() - startTime) / 1000});
 69 |                 log.info("correct hash Hex: {} \n", new Object[]{shaHex});
 70 |                 break;
 71 |             } else {
 72 |                 nonce++;
 73 |             }
 74 |         }
 75 |         return new PowResult(nonce, shaHex);
 76 |     }
 77 | 
 78 |     /**
 79 |      * 验证区块是否有效
 80 |      *
 81 |      * @return
 82 |      */
 83 |     public boolean validate() {
 84 |         byte[] data = this.prepareData(this.getBlock().getNonce());
 85 |         return new BigInteger(DigestUtils.sha256Hex(data), 16).compareTo(this.target) == -1;
 86 |     }
 87 | 
 88 |     /**
 89 |      * 准备数据
 90 |      * <p>
 91 |      * 注意：在准备区块数据时，一定要从原始数据类型转化为byte[]，不能直接从字符串进行转换
 92 |      *
 93 |      * @param nonce
 94 |      * @return
 95 |      */
 96 |     private byte[] prepareData(long nonce) {
 97 |         byte[] prevBlockHashBytes = {};
 98 |         if (StringUtils.isNoneBlank(this.getBlock().getPrevBlockHash())) {
 99 |             prevBlockHashBytes = new BigInteger(this.getBlock().getPrevBlockHash(), 16).toByteArray();
100 |         }
101 | 
102 |         return ByteUtils.merge(
103 |                 prevBlockHashBytes,
104 |                 this.getBlock().hashTransaction(),
105 |                 ByteUtils.toBytes(this.getBlock().getTimeStamp()),
106 |                 ByteUtils.toBytes(TARGET_BITS),
107 |                 ByteUtils.toBytes(nonce)
108 |         );
109 |     }
110 | 
111 | }
112 | 


--------------------------------------------------------------------------------
/src/main/java/one/wangwei/blockchain/wallet/Wallet.java:
--------------------------------------------------------------------------------
  1 | package one.wangwei.blockchain.wallet;
  2 | 
  3 | import lombok.AllArgsConstructor;
  4 | import lombok.Data;
  5 | import lombok.extern.slf4j.Slf4j;
  6 | import one.wangwei.blockchain.util.Base58Check;
  7 | import one.wangwei.blockchain.util.BtcAddressUtils;
  8 | import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;
  9 | import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey;
 10 | import org.bouncycastle.jce.ECNamedCurveTable;
 11 | import org.bouncycastle.jce.provider.BouncyCastleProvider;
 12 | import org.bouncycastle.jce.spec.ECParameterSpec;
 13 | 
 14 | import java.io.ByteArrayOutputStream;
 15 | import java.io.IOException;
 16 | import java.io.Serializable;
 17 | import java.security.KeyPair;
 18 | import java.security.KeyPairGenerator;
 19 | import java.security.SecureRandom;
 20 | import java.security.Security;
 21 | 
 22 | /**
 23 |  * 钱包
 24 |  *
 25 |  * @author wangwei
 26 |  * @date 2018/03/14
 27 |  */
 28 | @Data
 29 | @AllArgsConstructor
 30 | @Slf4j
 31 | public class Wallet implements Serializable {
 32 | 
 33 |     private static final long serialVersionUID = 166249065006236265L;
 34 | 
 35 |     /**
 36 |      * 校验码长度
 37 |      */
 38 |     private static final int ADDRESS_CHECKSUM_LEN = 4;
 39 |     /**
 40 |      * 私钥
 41 |      */
 42 |     private BCECPrivateKey privateKey;
 43 |     /**
 44 |      * 公钥
 45 |      */
 46 |     private byte[] publicKey;
 47 | 
 48 | 
 49 |     public Wallet() {
 50 |         initWallet();
 51 |     }
 52 | 
 53 |     /**
 54 |      * 初始化钱包
 55 |      */
 56 |     private void initWallet() {
 57 |         try {
 58 |             KeyPair keyPair = newECKeyPair();
 59 |             BCECPrivateKey privateKey = (BCECPrivateKey) keyPair.getPrivate();
 60 |             BCECPublicKey publicKey = (BCECPublicKey) keyPair.getPublic();
 61 | 
 62 |             byte[] publicKeyBytes = publicKey.getQ().getEncoded(false);
 63 | 
 64 |             this.setPrivateKey(privateKey);
 65 |             this.setPublicKey(publicKeyBytes);
 66 |         } catch (Exception e) {
 67 |             log.error("Fail to init wallet ! ", e);
 68 |             throw new RuntimeException("Fail to init wallet ! ", e);
 69 |         }
 70 |     }
 71 | 
 72 | 
 73 |     /**
 74 |      * 创建新的密钥对
 75 |      *
 76 |      * @return
 77 |      * @throws Exception
 78 |      */
 79 |     private KeyPair newECKeyPair() throws Exception {
 80 |         // 注册 BC Provider
 81 |         Security.addProvider(new BouncyCastleProvider());
 82 |         // 创建椭圆曲线算法的密钥对生成器，算法为 ECDSA
 83 |         KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("ECDSA", BouncyCastleProvider.PROVIDER_NAME);
 84 |         // 椭圆曲线（EC）域参数设定
 85 |         // bitcoin 为什么会选择 secp256k1，详见：https://bitcointalk.org/index.php?topic=151120.0
 86 |         ECParameterSpec ecSpec = ECNamedCurveTable.getParameterSpec("secp256k1");
 87 |         keyPairGenerator.initialize(ecSpec, new SecureRandom());
 88 |         return keyPairGenerator.generateKeyPair();
 89 |     }
 90 | 
 91 | 
 92 |     /**
 93 |      * 获取钱包地址
 94 |      *
 95 |      * @return
 96 |      */
 97 |     public String getAddress() {
 98 |         try {
 99 |             // 1. 获取 ripemdHashedKey
100 |             byte[] ripemdHashedKey = BtcAddressUtils.ripeMD160Hash(this.getPublicKey());
101 | 
102 |             // 2. 添加版本 0x00
103 |             ByteArrayOutputStream addrStream = new ByteArrayOutputStream();
104 |             addrStream.write((byte) 0);
105 |             addrStream.write(ripemdHashedKey);
106 |             byte[] versionedPayload = addrStream.toByteArray();
107 | 
108 |             // 3. 计算校验码
109 |             byte[] checksum = BtcAddressUtils.checksum(versionedPayload);
110 | 
111 |             // 4. 得到 version + paylod + checksum 的组合
112 |             addrStream.write(checksum);
113 |             byte[] binaryAddress = addrStream.toByteArray();
114 | 
115 |             // 5. 执行Base58转换处理
116 |             return Base58Check.rawBytesToBase58(binaryAddress);
117 |         } catch (IOException e) {
118 |             e.printStackTrace();
119 |         }
120 |         throw new RuntimeException("Fail to get wallet address ! ");
121 |     }
122 | 
123 | 
124 | }
125 | 


--------------------------------------------------------------------------------
/src/main/java/one/wangwei/blockchain/transaction/MerkleTree.java:
--------------------------------------------------------------------------------
  1 | package one.wangwei.blockchain.transaction;
  2 | 
  3 | import com.google.common.collect.Lists;
  4 | import lombok.Data;
  5 | import one.wangwei.blockchain.util.ByteUtils;
  6 | import org.apache.commons.codec.digest.DigestUtils;
  7 | 
  8 | import java.util.List;
  9 | 
 10 | /**
 11 |  * 默克尔树
 12 |  *
 13 |  * @author wangwei
 14 |  * @date 2018/04/15
 15 |  */
 16 | @Data
 17 | public class MerkleTree {
 18 | 
 19 |     /**
 20 |      * 根节点
 21 |      */
 22 |     private Node root;
 23 |     /**
 24 |      * 叶子节点Hash
 25 |      */
 26 |     private byte[][] leafHashes;
 27 | 
 28 |     public MerkleTree(byte[][] leafHashes) {
 29 |         constructTree(leafHashes);
 30 |     }
 31 | 
 32 |     /**
 33 |      * 从底部叶子节点开始往上构建整个Merkle Tree
 34 |      *
 35 |      * @param leafHashes
 36 |      */
 37 |     private void constructTree(byte[][] leafHashes) {
 38 |         if (leafHashes == null || leafHashes.length < 1) {
 39 |             throw new RuntimeException("ERROR:Fail to construct merkle tree ! leafHashes data invalid ! ");
 40 |         }
 41 |         this.leafHashes = leafHashes;
 42 |         List<Node> parents = bottomLevel(leafHashes);
 43 |         while (parents.size() > 1) {
 44 |             parents = internalLevel(parents);
 45 |         }
 46 |         root = parents.get(0);
 47 |     }
 48 | 
 49 |     /**
 50 |      * 构建一个层级节点
 51 |      *
 52 |      * @param children
 53 |      * @return
 54 |      */
 55 |     private List<Node> internalLevel(List<Node> children) {
 56 |         List<Node> parents = Lists.newArrayListWithCapacity(children.size() / 2);
 57 |         for (int i = 0; i < children.size() - 1; i += 2) {
 58 |             Node child1 = children.get(i);
 59 |             Node child2 = children.get(i + 1);
 60 | 
 61 |             Node parent = constructInternalNode(child1, child2);
 62 |             parents.add(parent);
 63 |         }
 64 | 
 65 |         // 内部节点奇数个，只对left节点进行计算
 66 |         if (children.size() % 2 != 0) {
 67 |             Node child = children.get(children.size() - 1);
 68 |             Node parent = constructInternalNode(child, null);
 69 |             parents.add(parent);
 70 |         }
 71 | 
 72 |         return parents;
 73 |     }
 74 | 
 75 |     /**
 76 |      * 底部节点构建
 77 |      *
 78 |      * @param hashes
 79 |      * @return
 80 |      */
 81 |     private List<Node> bottomLevel(byte[][] hashes) {
 82 |         List<Node> parents = Lists.newArrayListWithCapacity(hashes.length / 2);
 83 | 
 84 |         for (int i = 0; i < hashes.length - 1; i += 2) {
 85 |             Node leaf1 = constructLeafNode(hashes[i]);
 86 |             Node leaf2 = constructLeafNode(hashes[i + 1]);
 87 | 
 88 |             Node parent = constructInternalNode(leaf1, leaf2);
 89 |             parents.add(parent);
 90 |         }
 91 | 
 92 |         if (hashes.length % 2 != 0) {
 93 |             Node leaf = constructLeafNode(hashes[hashes.length - 1]);
 94 |             // 奇数个节点的情况，复制最后一个节点
 95 |             Node parent = constructInternalNode(leaf, leaf);
 96 |             parents.add(parent);
 97 |         }
 98 | 
 99 |         return parents;
100 |     }
101 | 
102 |     /**
103 |      * 构建叶子节点
104 |      *
105 |      * @param hash
106 |      * @return
107 |      */
108 |     private static Node constructLeafNode(byte[] hash) {
109 |         Node leaf = new Node();
110 |         leaf.hash = hash;
111 |         return leaf;
112 |     }
113 | 
114 |     /**
115 |      * 构建内部节点
116 |      *
117 |      * @param leftChild
118 |      * @param rightChild
119 |      * @return
120 |      */
121 |     private Node constructInternalNode(Node leftChild, Node rightChild) {
122 |         Node parent = new Node();
123 |         if (rightChild == null) {
124 |             parent.hash = leftChild.hash;
125 |         } else {
126 |             parent.hash = internalHash(leftChild.hash, rightChild.hash);
127 |         }
128 |         parent.left = leftChild;
129 |         parent.right = rightChild;
130 |         return parent;
131 |     }
132 | 
133 |     /**
134 |      * 计算内部节点Hash
135 |      *
136 |      * @param leftChildHash
137 |      * @param rightChildHash
138 |      * @return
139 |      */
140 |     private byte[] internalHash(byte[] leftChildHash, byte[] rightChildHash) {
141 |         byte[] mergedBytes = ByteUtils.merge(leftChildHash, rightChildHash);
142 |         return DigestUtils.sha256(mergedBytes);
143 |     }
144 | 
145 |     /**
146 |      * Merkle Tree节点
147 |      */
148 |     @Data
149 |     public static class Node {
150 |         private byte[] hash;
151 |         private Node left;
152 |         private Node right;
153 |     }
154 | 
155 | }
156 | 


--------------------------------------------------------------------------------
/src/main/java/one/wangwei/blockchain/util/Base58Check.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Bitcoin cryptography library
  3 |  * Copyright (c) Project Nayuki
  4 |  *
  5 |  * https://www.nayuki.io/page/bitcoin-cryptography-library
  6 |  * https://github.com/nayuki/Bitcoin-Cryptography-Library
  7 |  */
  8 | package one.wangwei.blockchain.util;
  9 | 
 10 | import java.io.ByteArrayOutputStream;
 11 | import java.io.IOException;
 12 | import java.math.BigInteger;
 13 | import java.util.Arrays;
 14 | 
 15 | /**
 16 |  * Base58 转化工具
 17 |  */
 18 | public final class Base58Check {
 19 | 
 20 |     /**
 21 |      * 添加校验码并转化为 Base58 字符串
 22 |      *
 23 |      * @param data
 24 |      * @return
 25 |      */
 26 |     public static String bytesToBase58(byte[] data) {
 27 |         return rawBytesToBase58(addCheckHash(data));
 28 |     }
 29 | 
 30 |     /**
 31 |      * 转化为 Base58 字符串
 32 |      *
 33 |      * @param data
 34 |      * @return
 35 |      */
 36 |     public static String rawBytesToBase58(byte[] data) {
 37 |         // Convert to base-58 string
 38 |         StringBuilder sb = new StringBuilder();
 39 |         BigInteger num = new BigInteger(1, data);
 40 |         while (num.signum() != 0) {
 41 |             BigInteger[] quotrem = num.divideAndRemainder(ALPHABET_SIZE);
 42 |             sb.append(ALPHABET.charAt(quotrem[1].intValue()));
 43 |             num = quotrem[0];
 44 |         }
 45 | 
 46 |         // Add '1' characters for leading 0-value bytes
 47 |         for (int i = 0; i < data.length && data[i] == 0; i++) {
 48 |             sb.append(ALPHABET.charAt(0));
 49 |         }
 50 |         return sb.reverse().toString();
 51 |     }
 52 | 
 53 | 
 54 |     /**
 55 |      * 添加校验码并返回待有校验码的原生数据
 56 |      *
 57 |      * @param data
 58 |      * @return
 59 |      */
 60 |     static byte[] addCheckHash(byte[] data) {
 61 |         try {
 62 |             byte[] hash = Arrays.copyOf(BtcAddressUtils.doubleHash(data), 4);
 63 |             ByteArrayOutputStream buf = new ByteArrayOutputStream();
 64 |             buf.write(data);
 65 |             buf.write(hash);
 66 |             return buf.toByteArray();
 67 |         } catch (IOException e) {
 68 |             throw new AssertionError(e);
 69 |         }
 70 |     }
 71 | 
 72 | 
 73 |     /**
 74 |      * 将 Base58Check 字符串转化为 byte 数组，并校验其校验码
 75 |      * 返回的byte数组带有版本号，但不带有校验码
 76 |      *
 77 |      * @param s
 78 |      * @return
 79 |      */
 80 |     public static byte[] base58ToBytes(String s) {
 81 |         byte[] concat = base58ToRawBytes(s);
 82 |         byte[] data = Arrays.copyOf(concat, concat.length - 4);
 83 |         byte[] hash = Arrays.copyOfRange(concat, concat.length - 4, concat.length);
 84 |         byte[] rehash = Arrays.copyOf(BtcAddressUtils.doubleHash(data), 4);
 85 |         if (!Arrays.equals(rehash, hash)) {
 86 |             throw new IllegalArgumentException("Checksum mismatch");
 87 |         }
 88 |         return data;
 89 |     }
 90 | 
 91 | 
 92 |     /**
 93 |      * 将 Base58Check 字符串反转为 byte 数组
 94 |      *
 95 |      * @param s
 96 |      * @return
 97 |      */
 98 |     static byte[] base58ToRawBytes(String s) {
 99 |         // Parse base-58 string
100 |         BigInteger num = BigInteger.ZERO;
101 |         for (int i = 0; i < s.length(); i++) {
102 |             num = num.multiply(ALPHABET_SIZE);
103 |             int digit = ALPHABET.indexOf(s.charAt(i));
104 |             if (digit == -1) {
105 |                 throw new IllegalArgumentException("Invalid character for Base58Check");
106 |             }
107 |             num = num.add(BigInteger.valueOf(digit));
108 |         }
109 |         // Strip possible leading zero due to mandatory sign bit
110 |         byte[] b = num.toByteArray();
111 |         if (b[0] == 0) {
112 |             b = Arrays.copyOfRange(b, 1, b.length);
113 |         }
114 |         try {
115 |             // Convert leading '1' characters to leading 0-value bytes
116 |             ByteArrayOutputStream buf = new ByteArrayOutputStream();
117 |             for (int i = 0; i < s.length() && s.charAt(i) == ALPHABET.charAt(0); i++) {
118 |                 buf.write(0);
119 |             }
120 |             buf.write(b);
121 |             return buf.toByteArray();
122 |         } catch (IOException e) {
123 |             throw new AssertionError(e);
124 |         }
125 |     }
126 | 
127 | 
128 |     /*---- Class constants ----*/
129 | 
130 |     private static final String ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
131 |     private static final BigInteger ALPHABET_SIZE = BigInteger.valueOf(ALPHABET.length());
132 | 
133 | 
134 |     /*---- Miscellaneous ----*/
135 | 
136 |     private Base58Check() {
137 |     }  // Not instantiable
138 | 
139 | }
140 | 


--------------------------------------------------------------------------------
/pom.xml:
--------------------------------------------------------------------------------
  1 | <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2 |          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3 |     <modelVersion>4.0.0</modelVersion>
  4 | 
  5 |     <groupId>one.wangwei.blockchain</groupId>
  6 |     <artifactId>blockchain-java</artifactId>
  7 |     <version>1.0-SNAPSHOT</version>
  8 |     <packaging>jar</packaging>
  9 | 
 10 |     <name>blockchain-java</name>
 11 |     <url>http://maven.apache.org</url>
 12 | 
 13 |     <properties>
 14 |         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 15 |     </properties>
 16 | 
 17 |     <dependencies>
 18 |         <dependency>
 19 |             <groupId>junit</groupId>
 20 |             <artifactId>junit</artifactId>
 21 |             <version>4.13.1</version>
 22 |             <scope>test</scope>
 23 |         </dependency>
 24 |         <dependency>
 25 |             <groupId>org.apache.commons</groupId>
 26 |             <artifactId>commons-lang3</artifactId>
 27 |             <version>3.7</version>
 28 |         </dependency>
 29 |         <dependency>
 30 |             <groupId>commons-codec</groupId>
 31 |             <artifactId>commons-codec</artifactId>
 32 |             <version>1.11</version>
 33 |         </dependency>
 34 |         <dependency>
 35 |             <groupId>commons-cli</groupId>
 36 |             <artifactId>commons-cli</artifactId>
 37 |             <version>1.4</version>
 38 |         </dependency>
 39 |         <dependency>
 40 |             <groupId>commons-io</groupId>
 41 |             <artifactId>commons-io</artifactId>
 42 |             <version>2.6</version>
 43 |         </dependency>
 44 |         <dependency>
 45 |             <groupId>com.google.guava</groupId>
 46 |             <artifactId>guava</artifactId>
 47 |             <version>24.1.1-jre</version>
 48 |         </dependency>
 49 |         <dependency>
 50 |             <groupId>org.projectlombok</groupId>
 51 |             <artifactId>lombok</artifactId>
 52 |             <version>1.16.20</version>
 53 |         </dependency>
 54 | 
 55 |         <!-- 对象序列化/反序列化框架 -->
 56 |         <dependency>
 57 |             <groupId>com.esotericsoftware</groupId>
 58 |             <artifactId>kryo</artifactId>
 59 |             <version>4.0.1</version>
 60 |         </dependency>
 61 | 
 62 |         <!-- rocksdb -->
 63 |         <dependency>
 64 |             <groupId>org.rocksdb</groupId>
 65 |             <artifactId>rocksdbjni</artifactId>
 66 |             <version>5.9.2</version>
 67 |         </dependency>
 68 | 
 69 |         <!-- 加密算法 -->
 70 |         <dependency>
 71 |             <groupId>org.bouncycastle</groupId>
 72 |             <artifactId>bcprov-jdk15on</artifactId>
 73 |             <version>1.59</version>
 74 |         </dependency>
 75 | 
 76 |         <!-- 引入日志框架 slf4j 和 logback  -->
 77 |         <dependency>
 78 |             <groupId>org.slf4j</groupId>
 79 |             <artifactId>slf4j-api</artifactId>
 80 |             <version>1.7.25</version>
 81 |         </dependency>
 82 |         <dependency>
 83 |             <groupId>ch.qos.logback</groupId>
 84 |             <artifactId>logback-core</artifactId>
 85 |             <version>1.2.3</version>
 86 |         </dependency>
 87 |         <dependency>
 88 |             <groupId>ch.qos.logback</groupId>
 89 |             <artifactId>logback-classic</artifactId>
 90 |             <version>1.2.3</version>
 91 |         </dependency>
 92 |     </dependencies>
 93 | 
 94 |     <build>
 95 |         <finalName>blockchain-java</finalName>
 96 |         <plugins>
 97 |             <plugin>
 98 |                 <groupId>org.apache.maven.plugins</groupId>
 99 |                 <artifactId>maven-compiler-plugin</artifactId>
100 |                 <version>3.7.0</version>
101 |                 <configuration>
102 |                     <source>1.8</source>
103 |                     <target>1.8</target>
104 |                 </configuration>
105 |             </plugin>
106 |             <plugin>
107 |                 <groupId>org.apache.maven.plugins</groupId>
108 |                 <artifactId>maven-assembly-plugin</artifactId>
109 |                 <version>3.1.0</version>
110 |                 <configuration>
111 |                     <archive>
112 |                         <manifest>
113 |                             <addClasspath>true</addClasspath>
114 |                             <classpathPrefix>lib/</classpathPrefix>
115 |                             <mainClass>one.wangwei.blockchain.cli.Main</mainClass>
116 |                         </manifest>
117 |                     </archive>
118 |                     <descriptorRefs>
119 |                         <descriptorRef>jar-with-dependencies</descriptorRef>
120 |                     </descriptorRefs>
121 |                 </configuration>
122 |                 <executions>
123 |                     <execution>
124 |                         <id>make-assembly</id> <!-- this is used for inheritance merges -->
125 |                         <phase>package</phase> <!-- 指定在打包节点执行jar包合并操作 -->
126 |                         <goals>
127 |                             <goal>single</goal>
128 |                         </goals>
129 |                     </execution>
130 |                 </executions>
131 |             </plugin>
132 |         </plugins>
133 |     </build>
134 | 
135 | </project>
136 | 


--------------------------------------------------------------------------------
/src/main/java/one/wangwei/blockchain/transaction/UTXOSet.java:
--------------------------------------------------------------------------------
  1 | package one.wangwei.blockchain.transaction;
  2 | 
  3 | import com.google.common.collect.Maps;
  4 | import lombok.AllArgsConstructor;
  5 | import lombok.NoArgsConstructor;
  6 | import lombok.Synchronized;
  7 | import lombok.extern.slf4j.Slf4j;
  8 | import one.wangwei.blockchain.block.Block;
  9 | import one.wangwei.blockchain.block.Blockchain;
 10 | import one.wangwei.blockchain.store.RocksDBUtils;
 11 | import one.wangwei.blockchain.util.SerializeUtils;
 12 | import org.apache.commons.codec.binary.Hex;
 13 | import org.apache.commons.lang3.ArrayUtils;
 14 | 
 15 | import java.util.Map;
 16 | 
 17 | /**
 18 |  * 未被花费的交易输出池
 19 |  *
 20 |  * @author wangwei
 21 |  * @date 2018/03/31
 22 |  */
 23 | @NoArgsConstructor
 24 | @AllArgsConstructor
 25 | @Slf4j
 26 | public class UTXOSet {
 27 | 
 28 |     private Blockchain blockchain;
 29 | 
 30 |     /**
 31 |      * 寻找能够花费的交易
 32 |      *
 33 |      * @param pubKeyHash 钱包公钥Hash
 34 |      * @param amount     花费金额
 35 |      */
 36 |     public SpendableOutputResult findSpendableOutputs(byte[] pubKeyHash, int amount) {
 37 |         Map<String, int[]> unspentOuts = Maps.newHashMap();
 38 |         int accumulated = 0;
 39 |         Map<String, byte[]> chainstateBucket = RocksDBUtils.getInstance().getChainstateBucket();
 40 |         for (Map.Entry<String, byte[]> entry : chainstateBucket.entrySet()) {
 41 |             String txId = entry.getKey();
 42 |             TXOutput[] txOutputs = (TXOutput[]) SerializeUtils.deserialize(entry.getValue());
 43 | 
 44 |             for (int outId = 0; outId < txOutputs.length; outId++) {
 45 |                 TXOutput txOutput = txOutputs[outId];
 46 |                 if (txOutput.isLockedWithKey(pubKeyHash) && accumulated < amount) {
 47 |                     accumulated += txOutput.getValue();
 48 | 
 49 |                     int[] outIds = unspentOuts.get(txId);
 50 |                     if (outIds == null) {
 51 |                         outIds = new int[]{outId};
 52 |                     } else {
 53 |                         outIds = ArrayUtils.add(outIds, outId);
 54 |                     }
 55 |                     unspentOuts.put(txId, outIds);
 56 |                     if (accumulated >= amount) {
 57 |                         break;
 58 |                     }
 59 |                 }
 60 |             }
 61 |         }
 62 |         return new SpendableOutputResult(accumulated, unspentOuts);
 63 |     }
 64 | 
 65 | 
 66 |     /**
 67 |      * 查找钱包地址对应的所有UTXO
 68 |      *
 69 |      * @param pubKeyHash 钱包公钥Hash
 70 |      * @return
 71 |      */
 72 |     public TXOutput[] findUTXOs(byte[] pubKeyHash) {
 73 |         TXOutput[] utxos = {};
 74 |         Map<String, byte[]> chainstateBucket = RocksDBUtils.getInstance().getChainstateBucket();
 75 |         if (chainstateBucket.isEmpty()) {
 76 |             return utxos;
 77 |         }
 78 |         for (byte[] value : chainstateBucket.values()) {
 79 |             TXOutput[] txOutputs = (TXOutput[]) SerializeUtils.deserialize(value);
 80 |             for (TXOutput txOutput : txOutputs) {
 81 |                 if (txOutput.isLockedWithKey(pubKeyHash)) {
 82 |                     utxos = ArrayUtils.add(utxos, txOutput);
 83 |                 }
 84 |             }
 85 |         }
 86 |         return utxos;
 87 |     }
 88 | 
 89 | 
 90 |     /**
 91 |      * 重建 UTXO 池索引
 92 |      */
 93 |     @Synchronized
 94 |     public void reIndex() {
 95 |         log.info("Start to reIndex UTXO set !");
 96 |         RocksDBUtils.getInstance().cleanChainStateBucket();
 97 |         Map<String, TXOutput[]> allUTXOs = blockchain.findAllUTXOs();
 98 |         for (Map.Entry<String, TXOutput[]> entry : allUTXOs.entrySet()) {
 99 |             RocksDBUtils.getInstance().putUTXOs(entry.getKey(), entry.getValue());
100 |         }
101 |         log.info("ReIndex UTXO set finished ! ");
102 |     }
103 | 
104 |     /**
105 |      * 更新UTXO池
106 |      * <p>
107 |      * 当一个新的区块产生时，需要去做两件事情：
108 |      * 1）从UTXO池中移除花费掉了的交易输出；
109 |      * 2）保存新的未花费交易输出；
110 |      *
111 |      * @param tipBlock 最新的区块
112 |      */
113 |     @Synchronized
114 |     public void update(Block tipBlock) {
115 |         if (tipBlock == null) {
116 |             log.error("Fail to update UTXO set ! tipBlock is null !");
117 |             throw new RuntimeException("Fail to update UTXO set ! ");
118 |         }
119 |         for (Transaction transaction : tipBlock.getTransactions()) {
120 | 
121 |             // 根据交易输入排查出剩余未被使用的交易输出
122 |             if (!transaction.isCoinbase()) {
123 |                 for (TXInput txInput : transaction.getInputs()) {
124 |                     // 余下未被使用的交易输出
125 |                     TXOutput[] remainderUTXOs = {};
126 |                     String txId = Hex.encodeHexString(txInput.getTxId());
127 |                     TXOutput[] txOutputs = RocksDBUtils.getInstance().getUTXOs(txId);
128 | 
129 |                     if (txOutputs == null) {
130 |                         continue;
131 |                     }
132 | 
133 |                     for (int outIndex = 0; outIndex < txOutputs.length; outIndex++) {
134 |                         if (outIndex != txInput.getTxOutputIndex()) {
135 |                             remainderUTXOs = ArrayUtils.add(remainderUTXOs, txOutputs[outIndex]);
136 |                         }
137 |                     }
138 | 
139 |                     // 没有剩余则删除，否则更新
140 |                     if (remainderUTXOs.length == 0) {
141 |                         RocksDBUtils.getInstance().deleteUTXOs(txId);
142 |                     } else {
143 |                         RocksDBUtils.getInstance().putUTXOs(txId, remainderUTXOs);
144 |                     }
145 |                 }
146 |             }
147 | 
148 |             // 新的交易输出保存到DB中
149 |             TXOutput[] txOutputs = transaction.getOutputs();
150 |             String txId = Hex.encodeHexString(transaction.getTxId());
151 |             RocksDBUtils.getInstance().putUTXOs(txId, txOutputs);
152 |         }
153 | 
154 |     }
155 | 
156 | 
157 | }
158 | 


--------------------------------------------------------------------------------
/src/main/java/one/wangwei/blockchain/wallet/WalletUtils.java:
--------------------------------------------------------------------------------
  1 | package one.wangwei.blockchain.wallet;
  2 | 
  3 | import com.google.common.collect.Maps;
  4 | import lombok.AllArgsConstructor;
  5 | import lombok.Cleanup;
  6 | import lombok.Data;
  7 | import lombok.NoArgsConstructor;
  8 | import lombok.extern.slf4j.Slf4j;
  9 | import one.wangwei.blockchain.util.Base58Check;
 10 | 
 11 | import javax.crypto.Cipher;
 12 | import javax.crypto.CipherInputStream;
 13 | import javax.crypto.CipherOutputStream;
 14 | import javax.crypto.SealedObject;
 15 | import javax.crypto.spec.SecretKeySpec;
 16 | import java.io.*;
 17 | import java.util.Map;
 18 | import java.util.Set;
 19 | 
 20 | 
 21 | /**
 22 |  * 钱包工具类
 23 |  *
 24 |  * @author wangwei
 25 |  * @date 2018/03/21
 26 |  */
 27 | @Slf4j
 28 | public class WalletUtils {
 29 | 
 30 |     /**
 31 |      * 钱包工具实例
 32 |      */
 33 |     private volatile static WalletUtils instance;
 34 | 
 35 |     public static WalletUtils getInstance() {
 36 |         if (instance == null) {
 37 |             synchronized (WalletUtils.class) {
 38 |                 if (instance == null) {
 39 |                     instance = new WalletUtils();
 40 |                 }
 41 |             }
 42 |         }
 43 |         return instance;
 44 |     }
 45 | 
 46 |     private WalletUtils() {
 47 |         initWalletFile();
 48 |     }
 49 | 
 50 |     /**
 51 |      * 钱包文件
 52 |      */
 53 |     private final static String WALLET_FILE = "wallet.dat";
 54 |     /**
 55 |      * 加密算法
 56 |      */
 57 |     private static final String ALGORITHM = "AES";
 58 |     /**
 59 |      * 密文
 60 |      */
 61 |     private static final byte[] CIPHER_TEXT = "2oF@5sC%DNf32y!TmiZi!tG9W5rLaniD".getBytes();
 62 | 
 63 |     /**
 64 |      * 初始化钱包文件
 65 |      */
 66 |     private void initWalletFile() {
 67 |         File file = new File(WALLET_FILE);
 68 |         if (!file.exists()) {
 69 |             this.saveToDisk(new Wallets());
 70 |         } else {
 71 |             this.loadFromDisk();
 72 |         }
 73 |     }
 74 | 
 75 |     /**
 76 |      * 获取所有的钱包地址
 77 |      *
 78 |      * @return
 79 |      */
 80 |     public Set<String> getAddresses() {
 81 |         Wallets wallets = this.loadFromDisk();
 82 |         return wallets.getAddresses();
 83 |     }
 84 | 
 85 |     /**
 86 |      * 获取钱包数据
 87 |      *
 88 |      * @param address 钱包地址
 89 |      * @return
 90 |      */
 91 |     public Wallet getWallet(String address) {
 92 |         Wallets wallets = this.loadFromDisk();
 93 |         return wallets.getWallet(address);
 94 |     }
 95 | 
 96 |     /**
 97 |      * 创建钱包
 98 |      *
 99 |      * @return
100 |      */
101 |     public Wallet createWallet() {
102 |         Wallet wallet = new Wallet();
103 |         Wallets wallets = this.loadFromDisk();
104 |         wallets.addWallet(wallet);
105 |         this.saveToDisk(wallets);
106 |         return wallet;
107 |     }
108 | 
109 |     /**
110 |      * 保存钱包数据
111 |      */
112 |     private void saveToDisk(Wallets wallets) {
113 |         try {
114 |             if (wallets == null) {
115 |                 log.error("Fail to save wallet to file ! wallets is null ");
116 |                 throw new Exception("ERROR: Fail to save wallet to file !");
117 |             }
118 |             SecretKeySpec sks = new SecretKeySpec(CIPHER_TEXT, ALGORITHM);
119 |             // Create cipher
120 |             Cipher cipher = Cipher.getInstance(ALGORITHM);
121 |             cipher.init(Cipher.ENCRYPT_MODE, sks);
122 |             SealedObject sealedObject = new SealedObject(wallets, cipher);
123 |             // Wrap the output stream
124 |             @Cleanup CipherOutputStream cos = new CipherOutputStream(
125 |                     new BufferedOutputStream(new FileOutputStream(WALLET_FILE)), cipher);
126 |             @Cleanup ObjectOutputStream outputStream = new ObjectOutputStream(cos);
127 |             outputStream.writeObject(sealedObject);
128 |         } catch (Exception e) {
129 |             log.error("Fail to save wallet to disk !", e);
130 |             throw new RuntimeException("Fail to save wallet to disk !");
131 |         }
132 |     }
133 | 
134 |     /**
135 |      * 加载钱包数据
136 |      */
137 |     private Wallets loadFromDisk() {
138 |         try {
139 |             SecretKeySpec sks = new SecretKeySpec(CIPHER_TEXT, ALGORITHM);
140 |             Cipher cipher = Cipher.getInstance(ALGORITHM);
141 |             cipher.init(Cipher.DECRYPT_MODE, sks);
142 |             @Cleanup CipherInputStream cipherInputStream = new CipherInputStream(
143 |                     new BufferedInputStream(new FileInputStream(WALLET_FILE)), cipher);
144 |             @Cleanup ObjectInputStream inputStream = new ObjectInputStream(cipherInputStream);
145 |             SealedObject sealedObject = (SealedObject) inputStream.readObject();
146 |             return (Wallets) sealedObject.getObject(cipher);
147 |         } catch (Exception e) {
148 |             log.error("Fail to load wallet from disk ! ", e);
149 |             throw new RuntimeException("Fail to load wallet from disk ! ");
150 |         }
151 |     }
152 | 
153 |     /**
154 |      * 钱包存储对象
155 |      */
156 |     @Data
157 |     @NoArgsConstructor
158 |     @AllArgsConstructor
159 |     public static class Wallets implements Serializable {
160 | 
161 |         private static final long serialVersionUID = -2542070981569243131L;
162 | 
163 |         private Map<String, Wallet> walletMap = Maps.newHashMap();
164 | 
165 |         /**
166 |          * 添加钱包
167 |          *
168 |          * @param wallet
169 |          */
170 |         private void addWallet(Wallet wallet) {
171 |             try {
172 |                 this.walletMap.put(wallet.getAddress(), wallet);
173 |             } catch (Exception e) {
174 |                 log.error("Fail to add wallet ! ", e);
175 |                 throw new RuntimeException("Fail to add wallet !");
176 |             }
177 |         }
178 | 
179 |         /**
180 |          * 获取所有的钱包地址
181 |          *
182 |          * @return
183 |          */
184 |         Set<String> getAddresses() {
185 |             if (walletMap == null) {
186 |                 log.error("Fail to get address ! walletMap is null ! ");
187 |                 throw new RuntimeException("Fail to get addresses ! ");
188 |             }
189 |             return walletMap.keySet();
190 |         }
191 | 
192 |         /**
193 |          * 获取钱包数据
194 |          *
195 |          * @param address 钱包地址
196 |          * @return
197 |          */
198 |         Wallet getWallet(String address) {
199 |             // 检查钱包地址是否合法
200 |             try {
201 |                 Base58Check.base58ToBytes(address);
202 |             } catch (Exception e) {
203 |                 log.error("Fail to get wallet ! address invalid ! address=" + address, e);
204 |                 throw new RuntimeException("Fail to get wallet ! ");
205 |             }
206 |             Wallet wallet = walletMap.get(address);
207 |             if (wallet == null) {
208 |                 log.error("Fail to get wallet ! wallet don`t exist ! address=" + address);
209 |                 throw new RuntimeException("Fail to get wallet ! ");
210 |             }
211 |             return wallet;
212 |         }
213 |     }
214 | }
215 | 


--------------------------------------------------------------------------------
/src/main/java/one/wangwei/blockchain/store/RocksDBUtils.java:
--------------------------------------------------------------------------------
  1 | package one.wangwei.blockchain.store;
  2 | 
  3 | import com.google.common.collect.Maps;
  4 | import lombok.Getter;
  5 | import lombok.extern.slf4j.Slf4j;
  6 | import one.wangwei.blockchain.block.Block;
  7 | import one.wangwei.blockchain.transaction.TXOutput;
  8 | import one.wangwei.blockchain.util.SerializeUtils;
  9 | import org.rocksdb.RocksDB;
 10 | import org.rocksdb.RocksDBException;
 11 | 
 12 | import java.util.Map;
 13 | 
 14 | /**
 15 |  * 存储工具类
 16 |  *
 17 |  * @author wangwei
 18 |  * @date 2018/02/27
 19 |  */
 20 | @Slf4j
 21 | public class RocksDBUtils {
 22 | 
 23 |     /**
 24 |      * 区块链数据文件
 25 |      */
 26 |     private static final String DB_FILE = "blockchain.db";
 27 |     /**
 28 |      * 区块桶Key
 29 |      */
 30 |     private static final String BLOCKS_BUCKET_KEY = "blocks";
 31 |     /**
 32 |      * 链状态桶Key
 33 |      */
 34 |     private static final String CHAINSTATE_BUCKET_KEY = "chainstate";
 35 | 
 36 |     /**
 37 |      * 最新一个区块
 38 |      */
 39 |     private static final String LAST_BLOCK_KEY = "l";
 40 | 
 41 |     private volatile static RocksDBUtils instance;
 42 | 
 43 |     public static RocksDBUtils getInstance() {
 44 |         if (instance == null) {
 45 |             synchronized (RocksDBUtils.class) {
 46 |                 if (instance == null) {
 47 |                     instance = new RocksDBUtils();
 48 |                 }
 49 |             }
 50 |         }
 51 |         return instance;
 52 |     }
 53 | 
 54 |     private RocksDB db;
 55 | 
 56 |     /**
 57 |      * block buckets
 58 |      */
 59 |     private Map<String, byte[]> blocksBucket;
 60 |     /**
 61 |      * chainstate buckets
 62 |      */
 63 |     @Getter
 64 |     private Map<String, byte[]> chainstateBucket;
 65 | 
 66 |     private RocksDBUtils() {
 67 |         openDB();
 68 |         initBlockBucket();
 69 |         initChainStateBucket();
 70 |     }
 71 | 
 72 |     /**
 73 |      * 打开数据库
 74 |      */
 75 |     private void openDB() {
 76 |         try {
 77 |             db = RocksDB.open(DB_FILE);
 78 |         } catch (RocksDBException e) {
 79 |             log.error("Fail to open db ! ", e);
 80 |             throw new RuntimeException("Fail to open db ! ", e);
 81 |         }
 82 |     }
 83 | 
 84 |     /**
 85 |      * 初始化 blocks 数据桶
 86 |      */
 87 |     private void initBlockBucket() {
 88 |         try {
 89 |             byte[] blockBucketKey = SerializeUtils.serialize(BLOCKS_BUCKET_KEY);
 90 |             byte[] blockBucketBytes = db.get(blockBucketKey);
 91 |             if (blockBucketBytes != null) {
 92 |                 blocksBucket = (Map) SerializeUtils.deserialize(blockBucketBytes);
 93 |             } else {
 94 |                 blocksBucket = Maps.newHashMap();
 95 |                 db.put(blockBucketKey, SerializeUtils.serialize(blocksBucket));
 96 |             }
 97 |         } catch (RocksDBException e) {
 98 |             log.error("Fail to init block bucket ! ", e);
 99 |             throw new RuntimeException("Fail to init block bucket ! ", e);
100 |         }
101 |     }
102 | 
103 |     /**
104 |      * 初始化 blocks 数据桶
105 |      */
106 |     private void initChainStateBucket() {
107 |         try {
108 |             byte[] chainstateBucketKey = SerializeUtils.serialize(CHAINSTATE_BUCKET_KEY);
109 |             byte[] chainstateBucketBytes = db.get(chainstateBucketKey);
110 |             if (chainstateBucketBytes != null) {
111 |                 chainstateBucket = (Map) SerializeUtils.deserialize(chainstateBucketBytes);
112 |             } else {
113 |                 chainstateBucket = Maps.newHashMap();
114 |                 db.put(chainstateBucketKey, SerializeUtils.serialize(chainstateBucket));
115 |             }
116 |         } catch (RocksDBException e) {
117 |             log.error("Fail to init chainstate bucket ! ", e);
118 |             throw new RuntimeException("Fail to init chainstate bucket ! ", e);
119 |         }
120 |     }
121 | 
122 |     /**
123 |      * 保存最新一个区块的Hash值
124 |      *
125 |      * @param tipBlockHash
126 |      */
127 |     public void putLastBlockHash(String tipBlockHash) {
128 |         try {
129 |             blocksBucket.put(LAST_BLOCK_KEY, SerializeUtils.serialize(tipBlockHash));
130 |             db.put(SerializeUtils.serialize(BLOCKS_BUCKET_KEY), SerializeUtils.serialize(blocksBucket));
131 |         } catch (RocksDBException e) {
132 |             log.error("Fail to put last block hash ! tipBlockHash=" + tipBlockHash, e);
133 |             throw new RuntimeException("Fail to put last block hash ! tipBlockHash=" + tipBlockHash, e);
134 |         }
135 |     }
136 | 
137 |     /**
138 |      * 查询最新一个区块的Hash值
139 |      *
140 |      * @return
141 |      */
142 |     public String getLastBlockHash() {
143 |         byte[] lastBlockHashBytes = blocksBucket.get(LAST_BLOCK_KEY);
144 |         if (lastBlockHashBytes != null) {
145 |             return (String) SerializeUtils.deserialize(lastBlockHashBytes);
146 |         }
147 |         return "";
148 |     }
149 | 
150 |     /**
151 |      * 保存区块
152 |      *
153 |      * @param block
154 |      */
155 |     public void putBlock(Block block) {
156 |         try {
157 |             blocksBucket.put(block.getHash(), SerializeUtils.serialize(block));
158 |             db.put(SerializeUtils.serialize(BLOCKS_BUCKET_KEY), SerializeUtils.serialize(blocksBucket));
159 |         } catch (RocksDBException e) {
160 |             log.error("Fail to put block ! block=" + block.toString(), e);
161 |             throw new RuntimeException("Fail to put block ! block=" + block.toString(), e);
162 |         }
163 |     }
164 | 
165 |     /**
166 |      * 查询区块
167 |      *
168 |      * @param blockHash
169 |      * @return
170 |      */
171 |     public Block getBlock(String blockHash) {
172 |         byte[] blockBytes = blocksBucket.get(blockHash);
173 |         if (blockBytes != null) {
174 |             return (Block) SerializeUtils.deserialize(blockBytes);
175 |         }
176 |         throw new RuntimeException("Fail to get block ! blockHash=" + blockHash);
177 |     }
178 | 
179 | 
180 |     /**
181 |      * 清空chainstate bucket
182 |      */
183 |     public void cleanChainStateBucket() {
184 |         try {
185 |             chainstateBucket.clear();
186 |         } catch (Exception e) {
187 |             log.error("Fail to clear chainstate bucket ! ", e);
188 |             throw new RuntimeException("Fail to clear chainstate bucket ! ", e);
189 |         }
190 |     }
191 | 
192 |     /**
193 |      * 保存UTXO数据
194 |      *
195 |      * @param key   交易ID
196 |      * @param utxos UTXOs
197 |      */
198 |     public void putUTXOs(String key, TXOutput[] utxos) {
199 |         try {
200 |             chainstateBucket.put(key, SerializeUtils.serialize(utxos));
201 |             db.put(SerializeUtils.serialize(CHAINSTATE_BUCKET_KEY), SerializeUtils.serialize(chainstateBucket));
202 |         } catch (Exception e) {
203 |             log.error("Fail to put UTXOs into chainstate bucket ! key=" + key, e);
204 |             throw new RuntimeException("Fail to put UTXOs into chainstate bucket ! key=" + key, e);
205 |         }
206 |     }
207 | 
208 | 
209 |     /**
210 |      * 查询UTXO数据
211 |      *
212 |      * @param key 交易ID
213 |      */
214 |     public TXOutput[] getUTXOs(String key) {
215 |         byte[] utxosByte = chainstateBucket.get(key);
216 |         if (utxosByte != null) {
217 |             return (TXOutput[]) SerializeUtils.deserialize(utxosByte);
218 |         }
219 |         return null;
220 |     }
221 | 
222 | 
223 |     /**
224 |      * 删除 UTXO 数据
225 |      *
226 |      * @param key 交易ID
227 |      */
228 |     public void deleteUTXOs(String key) {
229 |         try {
230 |             chainstateBucket.remove(key);
231 |             db.put(SerializeUtils.serialize(CHAINSTATE_BUCKET_KEY), SerializeUtils.serialize(chainstateBucket));
232 |         } catch (Exception e) {
233 |             log.error("Fail to delete UTXOs by key ! key=" + key, e);
234 |             throw new RuntimeException("Fail to delete UTXOs by key ! key=" + key, e);
235 |         }
236 |     }
237 | 
238 |     /**
239 |      * 关闭数据库
240 |      */
241 |     public void closeDB() {
242 |         try {
243 |             db.close();
244 |         } catch (Exception e) {
245 |             log.error("Fail to close db ! ", e);
246 |             throw new RuntimeException("Fail to close db ! ", e);
247 |         }
248 |     }
249 | }
250 | 


--------------------------------------------------------------------------------
/src/main/java/one/wangwei/blockchain/cli/CLI.java:
--------------------------------------------------------------------------------
  1 | package one.wangwei.blockchain.cli;
  2 | 
  3 | import lombok.extern.slf4j.Slf4j;
  4 | import one.wangwei.blockchain.block.Block;
  5 | import one.wangwei.blockchain.block.Blockchain;
  6 | import one.wangwei.blockchain.pow.ProofOfWork;
  7 | import one.wangwei.blockchain.store.RocksDBUtils;
  8 | import one.wangwei.blockchain.transaction.TXOutput;
  9 | import one.wangwei.blockchain.transaction.Transaction;
 10 | import one.wangwei.blockchain.transaction.UTXOSet;
 11 | import one.wangwei.blockchain.util.Base58Check;
 12 | import one.wangwei.blockchain.wallet.Wallet;
 13 | import one.wangwei.blockchain.wallet.WalletUtils;
 14 | import org.apache.commons.cli.*;
 15 | import org.apache.commons.lang3.StringUtils;
 16 | import org.apache.commons.lang3.math.NumberUtils;
 17 | 
 18 | import java.util.Arrays;
 19 | import java.util.Set;
 20 | 
 21 | /**
 22 |  * 命令行解析器
 23 |  *
 24 |  * @author wangwei
 25 |  * @date 2018/03/08
 26 |  */
 27 | @Slf4j
 28 | public class CLI {
 29 | 
 30 |     private String[] args;
 31 |     private Options options = new Options();
 32 | 
 33 |     public CLI(String[] args) {
 34 |         this.args = args;
 35 | 
 36 |         Option helpCmd = Option.builder("h").desc("show help").build();
 37 |         options.addOption(helpCmd);
 38 | 
 39 |         Option address = Option.builder("address").hasArg(true).desc("Source wallet address").build();
 40 |         Option sendFrom = Option.builder("from").hasArg(true).desc("Source wallet address").build();
 41 |         Option sendTo = Option.builder("to").hasArg(true).desc("Destination wallet address").build();
 42 |         Option sendAmount = Option.builder("amount").hasArg(true).desc("Amount to send").build();
 43 | 
 44 |         options.addOption(address);
 45 |         options.addOption(sendFrom);
 46 |         options.addOption(sendTo);
 47 |         options.addOption(sendAmount);
 48 |     }
 49 | 
 50 |     /**
 51 |      * 命令行解析入口
 52 |      */
 53 |     public void parse() {
 54 |         this.validateArgs(args);
 55 |         try {
 56 |             CommandLineParser parser = new DefaultParser();
 57 |             CommandLine cmd = parser.parse(options, args);
 58 |             switch (args[0]) {
 59 |                 case "createblockchain":
 60 |                     String createblockchainAddress = cmd.getOptionValue("address");
 61 |                     if (StringUtils.isBlank(createblockchainAddress)) {
 62 |                         help();
 63 |                     }
 64 |                     this.createBlockchain(createblockchainAddress);
 65 |                     break;
 66 |                 case "getbalance":
 67 |                     String getBalanceAddress = cmd.getOptionValue("address");
 68 |                     if (StringUtils.isBlank(getBalanceAddress)) {
 69 |                         help();
 70 |                     }
 71 |                     this.getBalance(getBalanceAddress);
 72 |                     break;
 73 |                 case "send":
 74 |                     String sendFrom = cmd.getOptionValue("from");
 75 |                     String sendTo = cmd.getOptionValue("to");
 76 |                     String sendAmount = cmd.getOptionValue("amount");
 77 |                     if (StringUtils.isBlank(sendFrom) ||
 78 |                             StringUtils.isBlank(sendTo) ||
 79 |                             !NumberUtils.isDigits(sendAmount)) {
 80 |                         help();
 81 |                     }
 82 |                     this.send(sendFrom, sendTo, Integer.valueOf(sendAmount));
 83 |                     break;
 84 |                 case "createwallet":
 85 |                     this.createWallet();
 86 |                     break;
 87 |                 case "printaddresses":
 88 |                     this.printAddresses();
 89 |                     break;
 90 |                 case "printchain":
 91 |                     this.printChain();
 92 |                     break;
 93 |                 case "h":
 94 |                     this.help();
 95 |                     break;
 96 |                 default:
 97 |                     this.help();
 98 |             }
 99 |         } catch (Exception e) {
100 |             log.error("Fail to parse cli command ! ", e);
101 |         } finally {
102 |             RocksDBUtils.getInstance().closeDB();
103 |         }
104 |     }
105 | 
106 |     /**
107 |      * 验证入参
108 |      *
109 |      * @param args
110 |      */
111 |     private void validateArgs(String[] args) {
112 |         if (args == null || args.length < 1) {
113 |             help();
114 |         }
115 |     }
116 | 
117 |     /**
118 |      * 创建区块链
119 |      *
120 |      * @param address
121 |      */
122 |     private void createBlockchain(String address) {
123 |         Blockchain blockchain = Blockchain.createBlockchain(address);
124 |         UTXOSet utxoSet = new UTXOSet(blockchain);
125 |         utxoSet.reIndex();
126 |         log.info("Done ! ");
127 |     }
128 | 
129 |     /**
130 |      * 创建钱包
131 |      *
132 |      * @throws Exception
133 |      */
134 |     private void createWallet() throws Exception {
135 |         Wallet wallet = WalletUtils.getInstance().createWallet();
136 |         log.info("wallet address : " + wallet.getAddress());
137 |     }
138 | 
139 |     /**
140 |      * 打印钱包地址
141 |      */
142 |     private void printAddresses() {
143 |         Set<String> addresses = WalletUtils.getInstance().getAddresses();
144 |         if (addresses == null || addresses.isEmpty()) {
145 |             log.info("There isn't address");
146 |             return;
147 |         }
148 |         for (String address : addresses) {
149 |             log.info("Wallet address: " + address);
150 |         }
151 |     }
152 | 
153 |     /**
154 |      * 查询钱包余额
155 |      *
156 |      * @param address 钱包地址
157 |      */
158 |     private void getBalance(String address) {
159 |         // 检查钱包地址是否合法
160 |         try {
161 |             Base58Check.base58ToBytes(address);
162 |         } catch (Exception e) {
163 |             log.error("ERROR: invalid wallet address", e);
164 |             throw new RuntimeException("ERROR: invalid wallet address", e);
165 |         }
166 | 
167 |         // 得到公钥Hash值
168 |         byte[] versionedPayload = Base58Check.base58ToBytes(address);
169 |         byte[] pubKeyHash = Arrays.copyOfRange(versionedPayload, 1, versionedPayload.length);
170 | 
171 |         Blockchain blockchain = Blockchain.createBlockchain(address);
172 |         UTXOSet utxoSet = new UTXOSet(blockchain);
173 | 
174 |         TXOutput[] txOutputs = utxoSet.findUTXOs(pubKeyHash);
175 |         int balance = 0;
176 |         if (txOutputs != null && txOutputs.length > 0) {
177 |             for (TXOutput txOutput : txOutputs) {
178 |                 balance += txOutput.getValue();
179 |             }
180 |         }
181 |         log.info("Balance of '{}': {}\n", new Object[]{address, balance});
182 |     }
183 | 
184 |     /**
185 |      * 转账
186 |      *
187 |      * @param from
188 |      * @param to
189 |      * @param amount
190 |      * @throws Exception
191 |      */
192 |     private void send(String from, String to, int amount) throws Exception {
193 |         // 检查钱包地址是否合法
194 |         try {
195 |             Base58Check.base58ToBytes(from);
196 |         } catch (Exception e) {
197 |             log.error("ERROR: sender address invalid ! address=" + from, e);
198 |             throw new RuntimeException("ERROR: sender address invalid ! address=" + from, e);
199 |         }
200 |         // 检查钱包地址是否合法
201 |         try {
202 |             Base58Check.base58ToBytes(to);
203 |         } catch (Exception e) {
204 |             log.error("ERROR: receiver address invalid ! address=" + to, e);
205 |             throw new RuntimeException("ERROR: receiver address invalid ! address=" + to, e);
206 |         }
207 |         if (amount < 1) {
208 |             log.error("ERROR: amount invalid ! amount=" + amount);
209 |             throw new RuntimeException("ERROR: amount invalid ! amount=" + amount);
210 |         }
211 |         Blockchain blockchain = Blockchain.createBlockchain(from);
212 |         // 新交易
213 |         Transaction transaction = Transaction.newUTXOTransaction(from, to, amount, blockchain);
214 |         // 奖励
215 |         Transaction rewardTx = Transaction.newCoinbaseTX(from, "");
216 |         Block newBlock = blockchain.mineBlock(new Transaction[]{transaction, rewardTx});
217 |         new UTXOSet(blockchain).update(newBlock);
218 |         log.info("Success!");
219 |     }
220 | 
221 |     /**
222 |      * 打印帮助信息
223 |      */
224 |     private void help() {
225 |         System.out.println("Usage:");
226 |         System.out.println("  createwallet - Generates a new key-pair and saves it into the wallet file");
227 |         System.out.println("  printaddresses - print all wallet address");
228 |         System.out.println("  getbalance -address ADDRESS - Get balance of ADDRESS");
229 |         System.out.println("  createblockchain -address ADDRESS - Create a blockchain and send genesis block reward to ADDRESS");
230 |         System.out.println("  printchain - Print all the blocks of the blockchain");
231 |         System.out.println("  send -from FROM -to TO -amount AMOUNT - Send AMOUNT of coins from FROM address to TO");
232 |         System.exit(0);
233 |     }
234 | 
235 |     /**
236 |      * 打印出区块链中的所有区块
237 |      */
238 |     private void printChain() {
239 |         Blockchain blockchain = Blockchain.initBlockchainFromDB();
240 |         for (Blockchain.BlockchainIterator iterator = blockchain.getBlockchainIterator(); iterator.hashNext(); ) {
241 |             Block block = iterator.next();
242 |             if (block != null) {
243 |                 boolean validate = ProofOfWork.newProofOfWork(block).validate();
244 |                 log.info(block.toString() + ", validate = " + validate);
245 |             }
246 |         }
247 |     }
248 | 
249 | }
250 | 


--------------------------------------------------------------------------------
/src/main/java/one/wangwei/blockchain/block/Blockchain.java:
--------------------------------------------------------------------------------
  1 | package one.wangwei.blockchain.block;
  2 | 
  3 | import com.google.common.collect.Maps;
  4 | import lombok.AllArgsConstructor;
  5 | import lombok.Data;
  6 | import lombok.NoArgsConstructor;
  7 | import lombok.extern.slf4j.Slf4j;
  8 | import one.wangwei.blockchain.store.RocksDBUtils;
  9 | import one.wangwei.blockchain.transaction.TXInput;
 10 | import one.wangwei.blockchain.transaction.TXOutput;
 11 | import one.wangwei.blockchain.transaction.Transaction;
 12 | import org.apache.commons.codec.binary.Hex;
 13 | import org.apache.commons.lang3.ArrayUtils;
 14 | import org.apache.commons.lang3.StringUtils;
 15 | import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;
 16 | 
 17 | import java.util.Arrays;
 18 | import java.util.Map;
 19 | 
 20 | /**
 21 |  * <p> 区块链 </p>
 22 |  *
 23 |  * @author wangwei
 24 |  * @date 2018/02/02
 25 |  */
 26 | @Data
 27 | @AllArgsConstructor
 28 | @NoArgsConstructor
 29 | @Slf4j
 30 | public class Blockchain {
 31 | 
 32 |     private String lastBlockHash;
 33 | 
 34 | 
 35 |     /**
 36 |      * 从 DB 中恢复区块链数据
 37 |      *
 38 |      * @return
 39 |      */
 40 |     public static Blockchain initBlockchainFromDB() {
 41 |         String lastBlockHash = RocksDBUtils.getInstance().getLastBlockHash();
 42 |         if (lastBlockHash == null) {
 43 |             throw new RuntimeException("ERROR: Fail to init blockchain from db. ");
 44 |         }
 45 |         return new Blockchain(lastBlockHash);
 46 |     }
 47 | 
 48 |     /**
 49 |      * <p> 创建区块链 </p>
 50 |      *
 51 |      * @param address 钱包地址
 52 |      * @return
 53 |      */
 54 |     public static Blockchain createBlockchain(String address) {
 55 |         String lastBlockHash = RocksDBUtils.getInstance().getLastBlockHash();
 56 |         if (StringUtils.isBlank(lastBlockHash)) {
 57 |             // 创建 coinBase 交易
 58 |             String genesisCoinbaseData = "The Times 03/Jan/2009 Chancellor on brink of second bailout for banks";
 59 |             Transaction coinbaseTX = Transaction.newCoinbaseTX(address, genesisCoinbaseData);
 60 |             Block genesisBlock = Block.newGenesisBlock(coinbaseTX);
 61 |             lastBlockHash = genesisBlock.getHash();
 62 |             RocksDBUtils.getInstance().putBlock(genesisBlock);
 63 |             RocksDBUtils.getInstance().putLastBlockHash(lastBlockHash);
 64 |         }
 65 |         return new Blockchain(lastBlockHash);
 66 |     }
 67 | 
 68 |     /**
 69 |      * 打包交易，进行挖矿
 70 |      *
 71 |      * @param transactions
 72 |      */
 73 |     public Block mineBlock(Transaction[] transactions) {
 74 |         // 挖矿前，先验证交易记录
 75 |         for (Transaction tx : transactions) {
 76 |             if (!this.verifyTransactions(tx)) {
 77 |                 log.error("ERROR: Fail to mine block ! Invalid transaction ! tx=" + tx.toString());
 78 |                 throw new RuntimeException("ERROR: Fail to mine block ! Invalid transaction ! ");
 79 |             }
 80 |         }
 81 |         String lastBlockHash = RocksDBUtils.getInstance().getLastBlockHash();
 82 |         if (lastBlockHash == null) {
 83 |             throw new RuntimeException("ERROR: Fail to get last block hash ! ");
 84 |         }
 85 | 
 86 |         Block block = Block.newBlock(lastBlockHash, transactions);
 87 |         this.addBlock(block);
 88 |         return block;
 89 |     }
 90 | 
 91 |     /**
 92 |      * <p> 添加区块  </p>
 93 |      *
 94 |      * @param block
 95 |      */
 96 |     private void addBlock(Block block) {
 97 |         RocksDBUtils.getInstance().putLastBlockHash(block.getHash());
 98 |         RocksDBUtils.getInstance().putBlock(block);
 99 |         this.lastBlockHash = block.getHash();
100 |     }
101 | 
102 | 
103 |     /**
104 |      * 区块链迭代器
105 |      */
106 |     public class BlockchainIterator {
107 | 
108 |         private String currentBlockHash;
109 | 
110 |         private BlockchainIterator(String currentBlockHash) {
111 |             this.currentBlockHash = currentBlockHash;
112 |         }
113 | 
114 |         /**
115 |          * 是否有下一个区块
116 |          *
117 |          * @return
118 |          */
119 |         public boolean hashNext() {
120 |             if (StringUtils.isBlank(currentBlockHash)) {
121 |                 return false;
122 |             }
123 |             Block lastBlock = RocksDBUtils.getInstance().getBlock(currentBlockHash);
124 |             if (lastBlock == null) {
125 |                 return false;
126 |             }
127 |             // 创世区块直接放行
128 |             if (lastBlock.getPrevBlockHash().length() == 0) {
129 |                 return true;
130 |             }
131 |             return RocksDBUtils.getInstance().getBlock(lastBlock.getPrevBlockHash()) != null;
132 |         }
133 | 
134 | 
135 |         /**
136 |          * 返回区块
137 |          *
138 |          * @return
139 |          */
140 |         public Block next() {
141 |             Block currentBlock = RocksDBUtils.getInstance().getBlock(currentBlockHash);
142 |             if (currentBlock != null) {
143 |                 this.currentBlockHash = currentBlock.getPrevBlockHash();
144 |                 return currentBlock;
145 |             }
146 |             return null;
147 |         }
148 |     }
149 | 
150 |     /**
151 |      * 获取区块链迭代器
152 |      *
153 |      * @return
154 |      */
155 |     public BlockchainIterator getBlockchainIterator() {
156 |         return new BlockchainIterator(lastBlockHash);
157 |     }
158 | 
159 |     /**
160 |      * 查找所有的 unspent transaction outputs
161 |      *
162 |      * @return
163 |      */
164 |     public Map<String, TXOutput[]> findAllUTXOs() {
165 |         Map<String, int[]> allSpentTXOs = this.getAllSpentTXOs();
166 |         Map<String, TXOutput[]> allUTXOs = Maps.newHashMap();
167 |         // 再次遍历所有区块中的交易输出
168 |         for (BlockchainIterator blockchainIterator = this.getBlockchainIterator(); blockchainIterator.hashNext(); ) {
169 |             Block block = blockchainIterator.next();
170 |             for (Transaction transaction : block.getTransactions()) {
171 | 
172 |                 String txId = Hex.encodeHexString(transaction.getTxId());
173 | 
174 |                 int[] spentOutIndexArray = allSpentTXOs.get(txId);
175 |                 TXOutput[] txOutputs = transaction.getOutputs();
176 |                 for (int outIndex = 0; outIndex < txOutputs.length; outIndex++) {
177 |                     if (spentOutIndexArray != null && ArrayUtils.contains(spentOutIndexArray, outIndex)) {
178 |                         continue;
179 |                     }
180 |                     TXOutput[] UTXOArray = allUTXOs.get(txId);
181 |                     if (UTXOArray == null) {
182 |                         UTXOArray = new TXOutput[]{txOutputs[outIndex]};
183 |                     } else {
184 |                         UTXOArray = ArrayUtils.add(UTXOArray, txOutputs[outIndex]);
185 |                     }
186 |                     allUTXOs.put(txId, UTXOArray);
187 |                 }
188 |             }
189 |         }
190 |         return allUTXOs;
191 |     }
192 | 
193 |     /**
194 |      * 从交易输入中查询区块链中所有已被花费了的交易输出
195 |      *
196 |      * @return 交易ID以及对应的交易输出下标地址
197 |      */
198 |     private Map<String, int[]> getAllSpentTXOs() {
199 |         // 定义TxId ——> spentOutIndex[]，存储交易ID与已被花费的交易输出数组索引值
200 |         Map<String, int[]> spentTXOs = Maps.newHashMap();
201 |         for (BlockchainIterator blockchainIterator = this.getBlockchainIterator(); blockchainIterator.hashNext(); ) {
202 |             Block block = blockchainIterator.next();
203 | 
204 |             for (Transaction transaction : block.getTransactions()) {
205 |                 // 如果是 coinbase 交易，直接跳过，因为它不存在引用前一个区块的交易输出
206 |                 if (transaction.isCoinbase()) {
207 |                     continue;
208 |                 }
209 |                 for (TXInput txInput : transaction.getInputs()) {
210 |                     String inTxId = Hex.encodeHexString(txInput.getTxId());
211 |                     int[] spentOutIndexArray = spentTXOs.get(inTxId);
212 |                     if (spentOutIndexArray == null) {
213 |                         spentOutIndexArray = new int[]{txInput.getTxOutputIndex()};
214 |                     } else {
215 |                         spentOutIndexArray = ArrayUtils.add(spentOutIndexArray, txInput.getTxOutputIndex());
216 |                     }
217 |                     spentTXOs.put(inTxId, spentOutIndexArray);
218 |                 }
219 |             }
220 |         }
221 |         return spentTXOs;
222 |     }
223 | 
224 | 
225 |     /**
226 |      * 依据交易ID查询交易信息
227 |      *
228 |      * @param txId 交易ID
229 |      * @return
230 |      */
231 |     private Transaction findTransaction(byte[] txId) {
232 |         for (BlockchainIterator iterator = this.getBlockchainIterator(); iterator.hashNext(); ) {
233 |             Block block = iterator.next();
234 |             for (Transaction tx : block.getTransactions()) {
235 |                 if (Arrays.equals(tx.getTxId(), txId)) {
236 |                     return tx;
237 |                 }
238 |             }
239 |         }
240 |         throw new RuntimeException("ERROR: Can not found tx by txId ! ");
241 |     }
242 | 
243 | 
244 |     /**
245 |      * 进行交易签名
246 |      *
247 |      * @param tx         交易数据
248 |      * @param privateKey 私钥
249 |      */
250 |     public void signTransaction(Transaction tx, BCECPrivateKey privateKey) throws Exception {
251 |         // 先来找到这笔新的交易中，交易输入所引用的前面的多笔交易的数据
252 |         Map<String, Transaction> prevTxMap = Maps.newHashMap();
253 |         for (TXInput txInput : tx.getInputs()) {
254 |             Transaction prevTx = this.findTransaction(txInput.getTxId());
255 |             prevTxMap.put(Hex.encodeHexString(txInput.getTxId()), prevTx);
256 |         }
257 |         tx.sign(privateKey, prevTxMap);
258 |     }
259 | 
260 |     /**
261 |      * 交易签名验证
262 |      *
263 |      * @param tx
264 |      */
265 |     private boolean verifyTransactions(Transaction tx) {
266 |         if (tx.isCoinbase()) {
267 |             return true;
268 |         }
269 |         Map<String, Transaction> prevTx = Maps.newHashMap();
270 |         for (TXInput txInput : tx.getInputs()) {
271 |             Transaction transaction = this.findTransaction(txInput.getTxId());
272 |             prevTx.put(Hex.encodeHexString(txInput.getTxId()), transaction);
273 |         }
274 |         try {
275 |             return tx.verify(prevTx);
276 |         } catch (Exception e) {
277 |             log.error("Fail to verify transaction ! transaction invalid ! ", e);
278 |             throw new RuntimeException("Fail to verify transaction ! transaction invalid ! ", e);
279 |         }
280 |     }
281 | }


--------------------------------------------------------------------------------
/src/main/java/one/wangwei/blockchain/transaction/Transaction.java:
--------------------------------------------------------------------------------
  1 | package one.wangwei.blockchain.transaction;
  2 | 
  3 | import lombok.AllArgsConstructor;
  4 | import lombok.Data;
  5 | import lombok.NoArgsConstructor;
  6 | import lombok.extern.slf4j.Slf4j;
  7 | import one.wangwei.blockchain.block.Blockchain;
  8 | import one.wangwei.blockchain.util.BtcAddressUtils;
  9 | import one.wangwei.blockchain.util.SerializeUtils;
 10 | import one.wangwei.blockchain.wallet.Wallet;
 11 | import one.wangwei.blockchain.wallet.WalletUtils;
 12 | import org.apache.commons.codec.binary.Hex;
 13 | import org.apache.commons.codec.digest.DigestUtils;
 14 | import org.apache.commons.lang3.ArrayUtils;
 15 | import org.apache.commons.lang3.StringUtils;
 16 | import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;
 17 | import org.bouncycastle.jce.ECNamedCurveTable;
 18 | import org.bouncycastle.jce.provider.BouncyCastleProvider;
 19 | import org.bouncycastle.jce.spec.ECParameterSpec;
 20 | import org.bouncycastle.jce.spec.ECPublicKeySpec;
 21 | import org.bouncycastle.math.ec.ECPoint;
 22 | 
 23 | import java.math.BigInteger;
 24 | import java.security.KeyFactory;
 25 | import java.security.PublicKey;
 26 | import java.security.Security;
 27 | import java.security.Signature;
 28 | import java.util.Arrays;
 29 | import java.util.Iterator;
 30 | import java.util.Map;
 31 | 
 32 | /**
 33 |  * 交易
 34 |  *
 35 |  * @author wangwei
 36 |  * @date 2017/03/04
 37 |  */
 38 | @Data
 39 | @AllArgsConstructor
 40 | @NoArgsConstructor
 41 | @Slf4j
 42 | public class Transaction {
 43 | 
 44 |     private static final int SUBSIDY = 10;
 45 | 
 46 |     /**
 47 |      * 交易的Hash
 48 |      */
 49 |     private byte[] txId;
 50 |     /**
 51 |      * 交易输入
 52 |      */
 53 |     private TXInput[] inputs;
 54 |     /**
 55 |      * 交易输出
 56 |      */
 57 |     private TXOutput[] outputs;
 58 |     /**
 59 |      * 创建日期
 60 |      */
 61 |     private long createTime;
 62 | 
 63 |     /**
 64 |      * 计算交易信息的Hash值
 65 |      *
 66 |      * @return
 67 |      */
 68 |     public byte[] hash() {
 69 |         // 使用序列化的方式对Transaction对象进行深度复制
 70 |         byte[] serializeBytes = SerializeUtils.serialize(this);
 71 |         Transaction copyTx = (Transaction) SerializeUtils.deserialize(serializeBytes);
 72 |         copyTx.setTxId(new byte[]{});
 73 |         return DigestUtils.sha256(SerializeUtils.serialize(copyTx));
 74 |     }
 75 | 
 76 |     /**
 77 |      * 创建CoinBase交易
 78 |      *
 79 |      * @param to   收账的钱包地址
 80 |      * @param data 解锁脚本数据
 81 |      * @return
 82 |      */
 83 |     public static Transaction newCoinbaseTX(String to, String data) {
 84 |         if (StringUtils.isBlank(data)) {
 85 |             data = String.format("Reward to '%s'", to);
 86 |         }
 87 |         // 创建交易输入
 88 |         TXInput txInput = new TXInput(new byte[]{}, -1, null, data.getBytes());
 89 |         // 创建交易输出
 90 |         TXOutput txOutput = TXOutput.newTXOutput(SUBSIDY, to);
 91 |         // 创建交易
 92 |         Transaction tx = new Transaction(null, new TXInput[]{txInput},
 93 |                 new TXOutput[]{txOutput}, System.currentTimeMillis());
 94 |         // 设置交易ID
 95 |         tx.setTxId(tx.hash());
 96 |         return tx;
 97 |     }
 98 | 
 99 |     /**
100 |      * 是否为 Coinbase 交易
101 |      *
102 |      * @return
103 |      */
104 |     public boolean isCoinbase() {
105 |         return this.getInputs().length == 1
106 |                 && this.getInputs()[0].getTxId().length == 0
107 |                 && this.getInputs()[0].getTxOutputIndex() == -1;
108 |     }
109 | 
110 | 
111 |     /**
112 |      * 从 from 向  to 支付一定的 amount 的金额
113 |      *
114 |      * @param from       支付钱包地址
115 |      * @param to         收款钱包地址
116 |      * @param amount     交易金额
117 |      * @param blockchain 区块链
118 |      * @return
119 |      */
120 |     public static Transaction newUTXOTransaction(String from, String to, int amount, Blockchain blockchain) throws Exception {
121 |         // 获取钱包
122 |         Wallet senderWallet = WalletUtils.getInstance().getWallet(from);
123 |         byte[] pubKey = senderWallet.getPublicKey();
124 |         byte[] pubKeyHash = BtcAddressUtils.ripeMD160Hash(pubKey);
125 | 
126 |         SpendableOutputResult result = new UTXOSet(blockchain).findSpendableOutputs(pubKeyHash, amount);
127 |         int accumulated = result.getAccumulated();
128 |         Map<String, int[]> unspentOuts = result.getUnspentOuts();
129 | 
130 |         if (accumulated < amount) {
131 |             log.error("ERROR: Not enough funds ! accumulated=" + accumulated + ", amount=" + amount);
132 |             throw new RuntimeException("ERROR: Not enough funds ! ");
133 |         }
134 |         Iterator<Map.Entry<String, int[]>> iterator = unspentOuts.entrySet().iterator();
135 | 
136 |         TXInput[] txInputs = {};
137 |         while (iterator.hasNext()) {
138 |             Map.Entry<String, int[]> entry = iterator.next();
139 |             String txIdStr = entry.getKey();
140 |             int[] outIds = entry.getValue();
141 |             byte[] txId = Hex.decodeHex(txIdStr);
142 |             for (int outIndex : outIds) {
143 |                 txInputs = ArrayUtils.add(txInputs, new TXInput(txId, outIndex, null, pubKey));
144 |             }
145 |         }
146 | 
147 |         TXOutput[] txOutput = {};
148 |         txOutput = ArrayUtils.add(txOutput, TXOutput.newTXOutput(amount, to));
149 |         if (accumulated > amount) {
150 |             txOutput = ArrayUtils.add(txOutput, TXOutput.newTXOutput((accumulated - amount), from));
151 |         }
152 | 
153 |         Transaction newTx = new Transaction(null, txInputs, txOutput, System.currentTimeMillis());
154 |         newTx.setTxId(newTx.hash());
155 | 
156 |         // 进行交易签名
157 |         blockchain.signTransaction(newTx, senderWallet.getPrivateKey());
158 | 
159 |         return newTx;
160 |     }
161 | 
162 | 
163 |     /**
164 |      * 创建用于签名的交易数据副本，交易输入的 signature 和 pubKey 需要设置为null
165 |      *
166 |      * @return
167 |      */
168 |     public Transaction trimmedCopy() {
169 |         TXInput[] tmpTXInputs = new TXInput[this.getInputs().length];
170 |         for (int i = 0; i < this.getInputs().length; i++) {
171 |             TXInput txInput = this.getInputs()[i];
172 |             tmpTXInputs[i] = new TXInput(txInput.getTxId(), txInput.getTxOutputIndex(), null, null);
173 |         }
174 | 
175 |         TXOutput[] tmpTXOutputs = new TXOutput[this.getOutputs().length];
176 |         for (int i = 0; i < this.getOutputs().length; i++) {
177 |             TXOutput txOutput = this.getOutputs()[i];
178 |             tmpTXOutputs[i] = new TXOutput(txOutput.getValue(), txOutput.getPubKeyHash());
179 |         }
180 | 
181 |         return new Transaction(this.getTxId(), tmpTXInputs, tmpTXOutputs, this.getCreateTime());
182 |     }
183 | 
184 | 
185 |     /**
186 |      * 签名
187 |      *
188 |      * @param privateKey 私钥
189 |      * @param prevTxMap  前面多笔交易集合
190 |      */
191 |     public void sign(BCECPrivateKey privateKey, Map<String, Transaction> prevTxMap) throws Exception {
192 |         // coinbase 交易信息不需要签名，因为它不存在交易输入信息
193 |         if (this.isCoinbase()) {
194 |             return;
195 |         }
196 |         // 再次验证一下交易信息中的交易输入是否正确，也就是能否查找对应的交易数据
197 |         for (TXInput txInput : this.getInputs()) {
198 |             if (prevTxMap.get(Hex.encodeHexString(txInput.getTxId())) == null) {
199 |                 throw new RuntimeException("ERROR: Previous transaction is not correct");
200 |             }
201 |         }
202 | 
203 |         // 创建用于签名的交易信息的副本
204 |         Transaction txCopy = this.trimmedCopy();
205 | 
206 |         Security.addProvider(new BouncyCastleProvider());
207 |         Signature ecdsaSign = Signature.getInstance("SHA256withECDSA", BouncyCastleProvider.PROVIDER_NAME);
208 |         ecdsaSign.initSign(privateKey);
209 | 
210 |         for (int i = 0; i < txCopy.getInputs().length; i++) {
211 |             TXInput txInputCopy = txCopy.getInputs()[i];
212 |             // 获取交易输入TxID对应的交易数据
213 |             Transaction prevTx = prevTxMap.get(Hex.encodeHexString(txInputCopy.getTxId()));
214 |             // 获取交易输入所对应的上一笔交易中的交易输出
215 |             TXOutput prevTxOutput = prevTx.getOutputs()[txInputCopy.getTxOutputIndex()];
216 |             txInputCopy.setPubKey(prevTxOutput.getPubKeyHash());
217 |             txInputCopy.setSignature(null);
218 |             // 得到要签名的数据，即交易ID
219 |             txCopy.setTxId(txCopy.hash());
220 |             txInputCopy.setPubKey(null);
221 | 
222 |             // 对整个交易信息仅进行签名，即对交易ID进行签名
223 |             ecdsaSign.update(txCopy.getTxId());
224 |             byte[] signature = ecdsaSign.sign();
225 | 
226 |             // 将整个交易数据的签名赋值给交易输入，因为交易输入需要包含整个交易信息的签名
227 |             // 注意是将得到的签名赋值给原交易信息中的交易输入
228 |             this.getInputs()[i].setSignature(signature);
229 |         }
230 |     }
231 | 
232 | 
233 |     /**
234 |      * 验证交易信息
235 |      *
236 |      * @param prevTxMap 前面多笔交易集合
237 |      * @return
238 |      */
239 |     public boolean verify(Map<String, Transaction> prevTxMap) throws Exception {
240 |         // coinbase 交易信息不需要签名，也就无需验证
241 |         if (this.isCoinbase()) {
242 |             return true;
243 |         }
244 | 
245 |         // 再次验证一下交易信息中的交易输入是否正确，也就是能否查找对应的交易数据
246 |         for (TXInput txInput : this.getInputs()) {
247 |             if (prevTxMap.get(Hex.encodeHexString(txInput.getTxId())) == null) {
248 |                 throw new RuntimeException("ERROR: Previous transaction is not correct");
249 |             }
250 |         }
251 | 
252 |         // 创建用于签名验证的交易信息的副本
253 |         Transaction txCopy = this.trimmedCopy();
254 | 
255 |         Security.addProvider(new BouncyCastleProvider());
256 |         ECParameterSpec ecParameters = ECNamedCurveTable.getParameterSpec("secp256k1");
257 |         KeyFactory keyFactory = KeyFactory.getInstance("ECDSA", BouncyCastleProvider.PROVIDER_NAME);
258 |         Signature ecdsaVerify = Signature.getInstance("SHA256withECDSA", BouncyCastleProvider.PROVIDER_NAME);
259 | 
260 |         for (int i = 0; i < this.getInputs().length; i++) {
261 |             TXInput txInput = this.getInputs()[i];
262 |             // 获取交易输入TxID对应的交易数据
263 |             Transaction prevTx = prevTxMap.get(Hex.encodeHexString(txInput.getTxId()));
264 |             // 获取交易输入所对应的上一笔交易中的交易输出
265 |             TXOutput prevTxOutput = prevTx.getOutputs()[txInput.getTxOutputIndex()];
266 | 
267 |             TXInput txInputCopy = txCopy.getInputs()[i];
268 |             txInputCopy.setSignature(null);
269 |             txInputCopy.setPubKey(prevTxOutput.getPubKeyHash());
270 |             // 得到要签名的数据，即交易ID
271 |             txCopy.setTxId(txCopy.hash());
272 |             txInputCopy.setPubKey(null);
273 | 
274 |             // 使用椭圆曲线 x,y 点去生成公钥Key
275 |             BigInteger x = new BigInteger(1, Arrays.copyOfRange(txInput.getPubKey(), 1, 33));
276 |             BigInteger y = new BigInteger(1, Arrays.copyOfRange(txInput.getPubKey(), 33, 65));
277 |             ECPoint ecPoint = ecParameters.getCurve().createPoint(x, y);
278 | 
279 |             ECPublicKeySpec keySpec = new ECPublicKeySpec(ecPoint, ecParameters);
280 |             PublicKey publicKey = keyFactory.generatePublic(keySpec);
281 |             ecdsaVerify.initVerify(publicKey);
282 |             ecdsaVerify.update(txCopy.getTxId());
283 |             if (!ecdsaVerify.verify(txInput.getSignature())) {
284 |                 return false;
285 |             }
286 |         }
287 |         return true;
288 |     }
289 | }
290 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                                  Apache License
  2 |                            Version 2.0, January 2004
  3 |                         http://www.apache.org/licenses/
  4 | 
  5 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 |    1. Definitions.
  8 | 
  9 |       "License" shall mean the terms and conditions for use, reproduction,
 10 |       and distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 |       "Licensor" shall mean the copyright owner or entity authorized by
 13 |       the copyright owner that is granting the License.
 14 | 
 15 |       "Legal Entity" shall mean the union of the acting entity and all
 16 |       other entities that control, are controlled by, or are under common
 17 |       control with that entity. For the purposes of this definition,
 18 |       "control" means (i) the power, direct or indirect, to cause the
 19 |       direction or management of such entity, whether by contract or
 20 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 21 |       outstanding shares, or (iii) beneficial ownership of such entity.
 22 | 
 23 |       "You" (or "Your") shall mean an individual or Legal Entity
 24 |       exercising permissions granted by this License.
 25 | 
 26 |       "Source" form shall mean the preferred form for making modifications,
 27 |       including but not limited to software source code, documentation
 28 |       source, and configuration files.
 29 | 
 30 |       "Object" form shall mean any form resulting from mechanical
 31 |       transformation or translation of a Source form, including but
 32 |       not limited to compiled object code, generated documentation,
 33 |       and conversions to other media types.
 34 | 
 35 |       "Work" shall mean the work of authorship, whether in Source or
 36 |       Object form, made available under the License, as indicated by a
 37 |       copyright notice that is included in or attached to the work
 38 |       (an example is provided in the Appendix below).
 39 | 
 40 |       "Derivative Works" shall mean any work, whether in Source or Object
 41 |       form, that is based on (or derived from) the Work and for which the
 42 |       editorial revisions, annotations, elaborations, or other modifications
 43 |       represent, as a whole, an original work of authorship. For the purposes
 44 |       of this License, Derivative Works shall not include works that remain
 45 |       separable from, or merely link (or bind by name) to the interfaces of,
 46 |       the Work and Derivative Works thereof.
 47 | 
 48 |       "Contribution" shall mean any work of authorship, including
 49 |       the original version of the Work and any modifications or additions
 50 |       to that Work or Derivative Works thereof, that is intentionally
 51 |       submitted to Licensor for inclusion in the Work by the copyright owner
 52 |       or by an individual or Legal Entity authorized to submit on behalf of
 53 |       the copyright owner. For the purposes of this definition, "submitted"
 54 |       means any form of electronic, verbal, or written communication sent
 55 |       to the Licensor or its representatives, including but not limited to
 56 |       communication on electronic mailing lists, source code control systems,
 57 |       and issue tracking systems that are managed by, or on behalf of, the
 58 |       Licensor for the purpose of discussing and improving the Work, but
 59 |       excluding communication that is conspicuously marked or otherwise
 60 |       designated in writing by the copyright owner as "Not a Contribution."
 61 | 
 62 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 63 |       on behalf of whom a Contribution has been received by Licensor and
 64 |       subsequently incorporated within the Work.
 65 | 
 66 |    2. Grant of Copyright License. Subject to the terms and conditions of
 67 |       this License, each Contributor hereby grants to You a perpetual,
 68 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 69 |       copyright license to reproduce, prepare Derivative Works of,
 70 |       publicly display, publicly perform, sublicense, and distribute the
 71 |       Work and such Derivative Works in Source or Object form.
 72 | 
 73 |    3. Grant of Patent License. Subject to the terms and conditions of
 74 |       this License, each Contributor hereby grants to You a perpetual,
 75 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 76 |       (except as stated in this section) patent license to make, have made,
 77 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 78 |       where such license applies only to those patent claims licensable
 79 |       by such Contributor that are necessarily infringed by their
 80 |       Contribution(s) alone or by combination of their Contribution(s)
 81 |       with the Work to which such Contribution(s) was submitted. If You
 82 |       institute patent litigation against any entity (including a
 83 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 84 |       or a Contribution incorporated within the Work constitutes direct
 85 |       or contributory patent infringement, then any patent licenses
 86 |       granted to You under this License for that Work shall terminate
 87 |       as of the date such litigation is filed.
 88 | 
 89 |    4. Redistribution. You may reproduce and distribute copies of the
 90 |       Work or Derivative Works thereof in any medium, with or without
 91 |       modifications, and in Source or Object form, provided that You
 92 |       meet the following conditions:
 93 | 
 94 |       (a) You must give any other recipients of the Work or
 95 |           Derivative Works a copy of this License; and
 96 | 
 97 |       (b) You must cause any modified files to carry prominent notices
 98 |           stating that You changed the files; and
 99 | 
100 |       (c) You must retain, in the Source form of any Derivative Works
101 |           that You distribute, all copyright, patent, trademark, and
102 |           attribution notices from the Source form of the Work,
103 |           excluding those notices that do not pertain to any part of
104 |           the Derivative Works; and
105 | 
106 |       (d) If the Work includes a "NOTICE" text file as part of its
107 |           distribution, then any Derivative Works that You distribute must
108 |           include a readable copy of the attribution notices contained
109 |           within such NOTICE file, excluding those notices that do not
110 |           pertain to any part of the Derivative Works, in at least one
111 |           of the following places: within a NOTICE text file distributed
112 |           as part of the Derivative Works; within the Source form or
113 |           documentation, if provided along with the Derivative Works; or,
114 |           within a display generated by the Derivative Works, if and
115 |           wherever such third-party notices normally appear. The contents
116 |           of the NOTICE file are for informational purposes only and
117 |           do not modify the License. You may add Your own attribution
118 |           notices within Derivative Works that You distribute, alongside
119 |           or as an addendum to the NOTICE text from the Work, provided
120 |           that such additional attribution notices cannot be construed
121 |           as modifying the License.
122 | 
123 |       You may add Your own copyright statement to Your modifications and
124 |       may provide additional or different license terms and conditions
125 |       for use, reproduction, or distribution of Your modifications, or
126 |       for any such Derivative Works as a whole, provided Your use,
127 |       reproduction, and distribution of the Work otherwise complies with
128 |       the conditions stated in this License.
129 | 
130 |    5. Submission of Contributions. Unless You explicitly state otherwise,
131 |       any Contribution intentionally submitted for inclusion in the Work
132 |       by You to the Licensor shall be under the terms and conditions of
133 |       this License, without any additional terms or conditions.
134 |       Notwithstanding the above, nothing herein shall supersede or modify
135 |       the terms of any separate license agreement you may have executed
136 |       with Licensor regarding such Contributions.
137 | 
138 |    6. Trademarks. This License does not grant permission to use the trade
139 |       names, trademarks, service marks, or product names of the Licensor,
140 |       except as required for reasonable and customary use in describing the
141 |       origin of the Work and reproducing the content of the NOTICE file.
142 | 
143 |    7. Disclaimer of Warranty. Unless required by applicable law or
144 |       agreed to in writing, Licensor provides the Work (and each
145 |       Contributor provides its Contributions) on an "AS IS" BASIS,
146 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 |       implied, including, without limitation, any warranties or conditions
148 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 |       PARTICULAR PURPOSE. You are solely responsible for determining the
150 |       appropriateness of using or redistributing the Work and assume any
151 |       risks associated with Your exercise of permissions under this License.
152 | 
153 |    8. Limitation of Liability. In no event and under no legal theory,
154 |       whether in tort (including negligence), contract, or otherwise,
155 |       unless required by applicable law (such as deliberate and grossly
156 |       negligent acts) or agreed to in writing, shall any Contributor be
157 |       liable to You for damages, including any direct, indirect, special,
158 |       incidental, or consequential damages of any character arising as a
159 |       result of this License or out of the use or inability to use the
160 |       Work (including but not limited to damages for loss of goodwill,
161 |       work stoppage, computer failure or malfunction, or any and all
162 |       other commercial damages or losses), even if such Contributor
163 |       has been advised of the possibility of such damages.
164 | 
165 |    9. Accepting Warranty or Additional Liability. While redistributing
166 |       the Work or Derivative Works thereof, You may choose to offer,
167 |       and charge a fee for, acceptance of support, warranty, indemnity,
168 |       or other liability obligations and/or rights consistent with this
169 |       License. However, in accepting such obligations, You may act only
170 |       on Your own behalf and on Your sole responsibility, not on behalf
171 |       of any other Contributor, and only if You agree to indemnify,
172 |       defend, and hold each Contributor harmless for any liability
173 |       incurred by, or claims asserted against, such Contributor by reason
174 |       of your accepting any such warranty or additional liability.
175 | 
176 |    END OF TERMS AND CONDITIONS
177 | 
178 |    APPENDIX: How to apply the Apache License to your work.
179 | 
180 |       To apply the Apache License to your work, attach the following
181 |       boilerplate notice, with the fields enclosed by brackets "{}"
182 |       replaced with your own identifying information. (Don't include
183 |       the brackets!)  The text should be enclosed in the appropriate
184 |       comment syntax for the file format. We also recommend that a
185 |       file or class name and description of purpose be included on the
186 |       same "printed page" as the copyright notice for easier
187 |       identification within third-party archives.
188 | 
189 |    Copyright {yyyy} {name of copyright owner}
190 | 
191 |    Licensed under the Apache License, Version 2.0 (the "License");
192 |    you may not use this file except in compliance with the License.
193 |    You may obtain a copy of the License at
194 | 
195 |        http://www.apache.org/licenses/LICENSE-2.0
196 | 
197 |    Unless required by applicable law or agreed to in writing, software
198 |    distributed under the License is distributed on an "AS IS" BASIS,
199 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 |    See the License for the specific language governing permissions and
201 |    limitations under the License.
202 | 


--------------------------------------------------------------------------------