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/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 |
--------------------------------------------------------------------------------
/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 | * 工作量计算结果
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/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 | *
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 | *
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/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 blocksBucket;
60 | /**
61 | * chainstate buckets
62 | */
63 | @Getter
64 | private Map 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/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 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 internalLevel(List children) {
56 | List 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 bottomLevel(byte[][] hashes) {
82 | List 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/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 unspentOuts;
28 |
29 | }
30 |
--------------------------------------------------------------------------------
/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/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/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 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> iterator = unspentOuts.entrySet().iterator();
135 |
136 | TXInput[] txInputs = {};
137 | while (iterator.hasNext()) {
138 | Map.Entry 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 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 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 |
--------------------------------------------------------------------------------
/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 unspentOuts = Maps.newHashMap();
38 | int accumulated = 0;
39 | Map chainstateBucket = RocksDBUtils.getInstance().getChainstateBucket();
40 | for (Map.Entry 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 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 allUTXOs = blockchain.findAllUTXOs();
98 | for (Map.Entry 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 | *
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/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 |
--------------------------------------------------------------------------------
/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/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 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/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/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/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 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 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 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/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 |
--------------------------------------------------------------------------------