HD地址批量生成 java

HD地址批量生成 java前言:HD钱包全称为是分层确定性(HierarchicalDeterministic)钱包的缩写HDWallets。首次创建HD钱包或者备份钱包时,会产生一个助记词,助记词是一连串的英⽂单词,这一串单词序列就可以创建种子,种子又可以创建所有的私钥。单词顺序也是钱包的备份,可以恢复钱包。而种⼦对应的就是所确定性钱包的随机数。HD钱包的优点在于只需要主公钥,…

大家好,又见面了,我是你们的朋友全栈君。

 前言:

   HD 钱包全称为是分层确定性(Hierarchical Deterministic)钱包的缩写 HD Wallets。

HD地址批量生成 java

 

首次创建 HD 钱包或者备份钱包时,会产生一个助记词,助记词是一连串的英⽂单词,这一串单词序列就可以创建种子,种子又可以创建所有的私钥。单词顺序也是钱包的备份,可以恢复钱包。而种⼦对应的就是所确定性钱包的随机数。

HD 钱包的优点在于只需要主公钥,就可以生成出任意数量的子公钥。也就是说,无需私钥介入(主私钥和子私钥),就能基于主公钥生成新(公钥)地址,而这些地址其实都能被主私钥所控制。

 直接撸代码:

        <dependency>
			<groupId>org.bitcoinj</groupId>
			<artifactId>bitcoinj-tools</artifactId>
			<version>0.14.7</version>
		</dependency>
		<dependency>
			<groupId>org.bitcoinj</groupId>
			<artifactId>bitcoinj-core</artifactId>
			<version>0.14.7</version>
		</dependency>
		<dependency>
			<groupId>org.bouncycastle</groupId>
			<artifactId>bcprov-jdk15on</artifactId>
			<version>1.59</version>
		</dependency>
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.math.BigInteger;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Properties;

import org.apache.commons.configuration2.Configuration;
import org.apache.commons.configuration2.builder.fluent.Configurations;
import org.bitcoinj.core.Base58;
import org.bitcoinj.core.ECKey;
import org.bitcoinj.core.NetworkParameters;
import org.bitcoinj.crypto.ChildNumber;
import org.bitcoinj.crypto.DeterministicHierarchy;
import org.bitcoinj.crypto.DeterministicKey;
import org.bitcoinj.crypto.HDKeyDerivation;
import org.bitcoinj.crypto.HDUtils;
import org.bitcoinj.params.MainNetParams;
import org.bitcoinj.params.TestNet3Params;
import org.bitcoinj.wallet.DeterministicKeyChain;
import org.bitcoinj.wallet.DeterministicSeed;
import org.bitcoinj.wallet.UnreadableWalletException;
import org.bouncycastle.crypto.digests.RIPEMD160Digest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.bscoin.coldwallet.cointype.common.ConfigUtil;
import com.bscoin.coldwallet.cointype.common.HDWallet;
import com.bscoin.coldwallet.cointype.common.HashUtils;
import com.bscoin.coldwallet.cointype.common.SecretOperation;

public class HDWalletPK {
	
	private static Logger LOG = LoggerFactory.getLogger(HDWalletPK.class);

	static NetworkParameters params;
	
	static{
		try {
			Configuration config = ConfigUtil.getInstance();
			params = config.getBoolean("bitcoin.testnet") ? TestNet3Params.get() : MainNetParams.get();
			LOG.info("=== [BTC] bitcoin  client networkID:{} ===",params.getId());
		} catch (Exception e) {
			 LOG.info("=== [BTC] com.bscoin.coldwallet.cointype.btc.HDWalletPK:{} ===",e.getMessage(),e);
		}
	}
	
	  
	    /**
	     * @throws IOException 
	     * @throws FileNotFoundException   
	    * @Title: createHDWalletByPATH  
	    * @param @param word 助记词
	    * @param @param passphrase 密码
	    * @param @param childNum 生成的hd钱包数量
	    * @param @param params 
	    * @param @return    参数  
	    * @return List<HDWallet>    返回类型  
	    * @throws  
	    */  
	 public static List<HDWallet> createHDWalletByPATH(String word, String passphrase, int[] childNum) throws FileNotFoundException, IOException {
		List<HDWallet> wallet = new ArrayList<HDWallet>();
		try {
			DeterministicSeed deterministicSeed = new DeterministicSeed(word, null, passphrase, 0L);
			DeterministicKeyChain deterministicKeyChain = DeterministicKeyChain.builder().seed(deterministicSeed).build();
			DeterministicKey main = deterministicKeyChain.getKeyByPath(HDUtils.parsePath("44H/0H"), true);
			DeterministicHierarchy tree = new DeterministicHierarchy(main);
			DeterministicKey rootKey = tree.getRootKey();			
			LOG.info("### [BTC] childs privKey , pubKey , address start ###");
			for (int i = childNum[0], len = childNum[1]; i < len; i++) {
				DeterministicKey deriveChildKey = HDKeyDerivation.deriveChildKey(rootKey, new ChildNumber(i));
				wallet.add(new HDWallet(deriveChildKey.getPathAsString(), 
														   deriveChildKey.getPrivateKeyAsWiF(params), 
														   Base58.encode(deriveChildKey.getPubKey()), 
														   ECKey.fromPrivate(deriveChildKey.getPrivKey()).toAddress(params).toBase58()));
			}
			
			LOG.info("### [BTC] childs privKey , pubKey , address end ###");
		} catch (UnreadableWalletException e) {
			e.printStackTrace();
		}
		return wallet;
	}
	
	  
	    /**  
	    * @Title: generateMnemonic  
	    * @param @param passphrase
	    * @param @param params
	    * @param @return
	    * @param @throws IOException    参数  
	    * @return String    返回类型  
	    * @throws  
	    */  
	public static String generateMnemonic(String passphrase) throws IOException {
		StringBuilder words = new StringBuilder();
		SecureRandom secureRandom = new SecureRandom();
		long creationTimeSeconds = System.currentTimeMillis() / 1000;
		DeterministicSeed ds = new DeterministicSeed(secureRandom, 128, passphrase, creationTimeSeconds);
		
		for (String str : ds.getMnemonicCode()) {
			words.append(str).append(" ");
		}
		return words.toString().trim();
	}
	
	
	  
	    /**  
	    * @Title: generateAddress   根据公钥生成地址
	    * @param @param publicKey
	    * @param @return    参数  
	    * @return String    返回类型  
	    * @throws  
	    */  
	public static String generateAddress(String publicKey) {
		//1. 计算公钥的 SHA-256 哈希值
		byte[] sha256Bytes = HashUtils.sha256(Base58.decode(publicKey));
		//2. 取上一步结果,计算 RIPEMD-160 哈希值
		RIPEMD160Digest digest = new RIPEMD160Digest();
		digest.update(sha256Bytes, 0, sha256Bytes.length);
		byte[] ripemd160Bytes = new byte[digest.getDigestSize()];
		digest.doFinal(ripemd160Bytes, 0);
		//3. 取上一步结果,前面加入地址版本号(主网版本号“0x00”)
		byte[] networkID = new BigInteger("00", 16).toByteArray();
		byte[] extendedRipemd160Bytes = HashUtils.add(networkID, ripemd160Bytes);
		//4. 取上一步结果,计算 SHA-256 哈希值
		byte[] oneceSha256Bytes = HashUtils.sha256(extendedRipemd160Bytes);
		//5. 取上一步结果,再计算一下 SHA-256 哈希值
		byte[] twiceSha256Bytes = HashUtils.sha256(oneceSha256Bytes);
		//6. 取上一步结果的前4个字节(8位十六进制)
		byte[] checksum = new byte[4];
		System.arraycopy(twiceSha256Bytes, 0, checksum, 0, 4);
		//7. 把这4个字节加在第5步的结果后面,作为校验
		byte[] binaryAddressBytes = HashUtils.add(extendedRipemd160Bytes, checksum);
		//8. 把结果用 Base58 编码算法进行一次编码
		return Base58.encode(binaryAddressBytes);
	}
	
	/**
	 * 验证地址是否合法
	 * @param address
	 * @return
	 */
	public static boolean verifyAddress(String address) {
		if (address.length() < 26 || address.length() > 35) {
			return false;
		}
		byte[] decoded = HashUtils.decodeBase58To25Bytes(address);
		if (null == decoded) {
			return false;
		}
		// 验证校验码
		byte[] hash1 = HashUtils.sha256(Arrays.copyOfRange(decoded, 0, 21));
		byte[] hash2 = HashUtils.sha256(hash1);

		return Arrays.equals(Arrays.copyOfRange(hash2, 0, 4), Arrays.copyOfRange(decoded, 21, 25));
	}
	
	public static void main(String[] args) throws IOException {
		 String s = generateMnemonic("xx");//生成助记次
		 int[] a = {1,10};//根据助记词生成childID={1-10}的钱包地址
		 List<HDWallet> walls = createHDWalletByPATH(s, "123457",a);
		 for (HDWallet hdWallet : walls) {
			System.out.println(hdWallet.getPubKey());
			System.out.println(hdWallet.getPrivKey());
			System.out.println(hdWallet.getAddress());
			System.out.println("----------------------");
		}
	}
}

HashUtil:
 

import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.stream.Stream;

import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.lang3.ArrayUtils;

 
  
/**  
    * @ClassName: HashUtils  
    * @author DHing  
 
    *    
*/  
public class HashUtils {


	/**
	 * 加密字符集合
	 */
	private static final String ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";

	/**
	 * 使用 sha256 算法加密
	 * @param input
	 * @return
	 */
	public static String sha256Hex(String input) {
		return DigestUtils.sha256Hex(input);
	}

	/**
	 * 使用 sha256 hash 算法加密,返回一个 64 位的字符串 hash
	 * @param input
	 * @return
	 */
	public static String sha256Hex(byte[] input) {
		return DigestUtils.sha256Hex(input);
	}

	public static byte[] sha256(String input) {
		return DigestUtils.sha256(input);
	}

	public static byte[] sha256(byte[] input) {
		return DigestUtils.sha256(input);
	}
	
	/**
	 * 两个byte[]数组相加
	 *
	 * @param data1
	 * @param data2
	 * @return
	 */
	public static byte[] add(byte[] data1, byte[] data2) {

		byte[] result = new byte[data1.length + data2.length];
		System.arraycopy(data1, 0, result, 0, data1.length);
		System.arraycopy(data2, 0, result, data1.length, data2.length);

		return result;
	}

	/**
	 * 将多个字节数组合并成一个字节数组
	 *
	 * @param bytes
	 * @return
	 */
	public static byte[] merge(byte[]... bytes) {
		Stream<Byte> stream = Stream.of();
		for (byte[] b : bytes) {
			stream = Stream.concat(stream, Arrays.stream(ArrayUtils.toObject(b)));
		}
		return ArrayUtils.toPrimitive(stream.toArray(Byte[]::new));
	}

	/**
	 * long 类型转 byte[]
	 *
	 * @param val
	 * @return
	 */
	public static byte[] toBytes(long val) {
		return ByteBuffer.allocate(Long.BYTES).putLong(val).array();
	}

	
	/**
	 * 使用 Base58 把地址解码成 25 字节
	 * @param input
	 * @return
	 */
	public static byte[] decodeBase58To25Bytes(String input) {

		BigInteger num = BigInteger.ZERO;
		for (char t : input.toCharArray()) {
			int p = ALPHABET.indexOf(t);
			if (p == -1) {
				return null;
			}
			num = num.multiply(BigInteger.valueOf(58)).add(BigInteger.valueOf(p));
		}

		byte[] result = new byte[25];
		byte[] numBytes = num.toByteArray();
		System.arraycopy(numBytes, 0, result, result.length - numBytes.length, numBytes.length);
		return result;
	}
}

 

package com.bscoin.coldwallet.cointype.common;

import java.io.Serializable;

import org.bitcoinj.core.NetworkParameters;

public class HDWallet  implements Serializable{
	       
	private static final long serialVersionUID = 1L;
	
	public HDWallet(){}
	
	 public HDWallet(String path, String privKey, String pubKey, String address) {
			super();
			this.path = path;
			this.privKey = privKey;
			this.pubKey = pubKey;
			this.address = address;
		}
	
		public HDWallet(String privKey, String pubKey, String address) {
		super();
		this.privKey = privKey;
		this.pubKey = pubKey;
		this.address = address;
	}


		private String word; //助记词
	   


		private String path;//路径-标识位
	    private String passphrase;
	    
	     private String privKey; //私钥
	     private String pubKey; //公钥
	 
		private String address;//地址
	     
		public String getWord() {
			return word;
		}
		public void setWord(String word) {
			this.word = word;
		}
		public String getPrivKey() {
			return privKey;
		}
		public void setPrivKey(String privKey) {
			this.privKey = privKey;
		}
		public String getPubKey() {
			return pubKey;
		}
		public void setPubKey(String pubKey) {
			this.pubKey = pubKey;
		}
		public String getAddress() {
			return address;
		}
		public void setAddress(String address) {
			this.address = address;
		}
	 
		public String getPassphrase() {
			return passphrase;
		}
		public void setPassphrase(String passphrase) {
			this.passphrase = passphrase;
		}
		public String getPath() {
			return path;
		}
		public void setPath(String path) {
			this.path = path;
		}
}

 

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/156835.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)
blank

相关推荐

  • 医疗用户端app原型/问诊/挂号/开药/视频问诊/电子处方/预约/互联网医疗平台用户端/Axure原型/电话问诊/药品/就诊开药/远程医疗平台/线上问诊/线上看病/rp源文件/移动端医疗原型/门诊「建议收藏」

    医疗用户端app原型/问诊/挂号/开药/视频问诊/电子处方/预约/互联网医疗平台用户端/Axure原型/电话问诊/药品/就诊开药/远程医疗平台/线上问诊/线上看病/rp源文件/移动端医疗原型/门诊「建议收藏」医疗用户端app原型/问诊/挂号/开药/视频问诊/电子处方/预约/互联网医疗平台用户端/Axure原型/电话问诊/药品/就诊开药/远程医疗平台/线上问诊/线上看病/rp源文件/移动端医疗原型Axure原型演示地址:https://www.pmdaniu.com/storages/124091/e51ce895d0be36e758d8fbcebc67f6ef-93733/start.html#g=1&p=%E9%A6%96%E9%A1%B5【医药、医疗】互联网医疗平台(问诊+挂号+开药)-用户

  • 期货真的可以做到长期稳定盈利吗?[通俗易懂]

    期货真的可以做到长期稳定盈利吗?[通俗易懂]我主要做外汇,期货和期权,A股也做,但是中国的股票你们知道的,做空的限制太多,融券融不到,股指期货还限制开仓和提高杠杆率。所以要等一个轮回需要5年以上,所以股票等待建仓机会比较漫长。从交易者的层面来看,我一般把他们分为这么几类人:一,幼儿园阶段:无知者无畏这种人没做过交易,只是从朋友那里听说,交易能赚大钱,或者是书刊杂志上读了一些交易大师的成功学传记,然后就跟打了鸡血似的,觉得自己也能和他们一样在金融市场赚到很多钱,这些人没有风控意识,甚至感觉这个市场只会赚钱,不会亏钱。于是他们就开户,然后一头

  • U盘市场调查分析

    U盘市场调查分析U盘市场分析2005年前后,是U盘行业最辉煌的年代,然而随着互联网的普及应用,各种网盘以及智能手机传输越来越方便,给U盘施加了一定的压力。除此之外,近几年移动硬盘迅速兴起,更是抢占了大量市场份额,让U盘厂商的日子越来越艰难。但凭借体积小、携带方便、即插即用、稳定等特点,U盘在移动存储领域依然占据着一定优势。面对着各类对手的“围攻”,U盘厂商们一方面升级主流产品,留住客户群,另一方面则纷纷开发细分市场,通过挖掘用户不同领域的需求,以实现新的业务增长。需求下降,U盘行业萎缩 2017年有业内人士发出.

  • 激光slam学习日记——基于滤波器的激光SLAM方法

    激光slam学习日记——基于滤波器的激光SLAM方法激光slam学习日记——基于滤波器的基于滤波的方法不适合大型场景,因为误差慢慢累积,没办法修复。贝叶斯与频率学派相对应,贝叶斯估计概率,频率估计数值粒子滤波:贝叶斯中的一个特例一、贝叶斯估计独立:我们知道其中一个,并不能对求解另一个产生任何帮助;条件独立:在某种情况下,才相互独立;假设,我们知道上一时刻位姿和上一个位姿的运动情况,那我们可以根据这两个得到此时刻的位姿,进而得到此时刻的观测情况,但是我们一旦知道这时刻的位姿,那上一时刻的运动情况与观测便不再有关系了。(好啰嗦)全概率:积分号内部

  • vim选中复制粘贴_vim 复制一行并且粘贴

    vim选中复制粘贴_vim 复制一行并且粘贴vim有12个粘贴板        ”代表全局粘贴板:reg查看粘贴板    “Np 粘贴其中一个:n,mcon 从第几行到第几行复制到第几行后:n,mmn 从第几行到第几行移动第几行后:n,md   从第几行到第几行删除:n,mwfilename 从第几行到第几行保存文件:savfilena

  • 白盒测试技术_静态白盒测试

    白盒测试技术_静态白盒测试覆盖率 它是度量测试完整性的一个工具,通常可以分为逻辑覆盖和功能覆盖。覆盖率=(被执行到的项数/总项数)*100%逻辑覆盖 逻辑覆盖是以程序内部的逻辑结构为基础设计测试用例的技术,属于白盒测试。      被测试模块的流程图语句覆盖 设计若干测试用例,运行被测程序,使每个可执行语句至少执行一次。 语句覆盖率=被评价到的语句数量/

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号