【区块链】——区块链学习初探（二）

最新推荐文章于 2024-05-01 10:52:41 发布
最新推荐文章于 2024-05-01 10:52:41 发布
阅读量299 收藏
点赞数
分类专栏： 区块链 文章标签： 区块链 代码 java 比特币
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/neu_lightbulb/article/details/103475390
版权

Java实现比特币区块链工具包

结合上一篇的介绍：https://blog.csdn.net/NEU_LightBulb/article/details/103086867

以下就是代码介绍想看源码直接：

https://github.com/zjw271208550/learn/tree/master/blockchain-core

  • 工程结构

  • 实体类

Block

区块的数据结构的模板，也是上一篇文章中介绍的最原始的区块结构，其内部的方法会根据实际业务情况修改

BlockChain

上一篇文章中介绍的最原始的链结构，实际中链不可能长时间的存在于内存中，而是存在本地的，所以这个仅仅是一个模板，其内部的方法会根据实际业务情况修改

TransactionGroup

交易的实体类，也是上一篇文章中介绍的最原始的交易结构

TransactionIn

输入交易的实体类，也是上一篇文章中介绍的最原始的输入交易结构

TransactionOut

输出交易的实体类，也是上一篇文章中介绍的最原始的输出交易结构

TransactionOutUnspent

未输出交易的实体类，也是上一篇文章中介绍的最原始的未输出交易结构

  • 静态方法类

  • Crypt

加密、签名相关的方法，使用bouncycastle的椭圆曲线算法进行非对称加密，包含的方法如下

    /**    
     * Java 的非对称加密的密钥是配对生成的
     */
    public static Map<String, Key> generateECKeyPair() 
            throws NoSuchAlgorithmException,NoSuchProviderException {
        //实例化密钥生成器
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM_EC,KEY_PROVIDER_EC);
        //初始化密钥生成器
        keyPairGenerator.initialize(KEY_SIZE_EC,new SecureRandom());
        //生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        //公钥
        ECPublicKey publicKey = (ECPublicKey) keyPair.getPublic();
        //私钥
        ECPrivateKey privateKey = (ECPrivateKey) keyPair.getPrivate();
        //将密钥存储在map中
        Map<String, Key> keyMap = new HashMap<String, Key>();
        keyMap.put(Consts.KEY_PUBLIC_MAP, publicKey);
        keyMap.put(Consts.KEY_PRIVATE_MAP, privateKey);
        return keyMap;
    }

    /**
     * 找到一种 GayGay的方法实现由随机串生成私钥，实际上是生成密钥对但只返回私钥
     */
    public static byte[] generateECPrivateKeyFromRandom(byte[] random)
            throws NoSuchAlgorithmException,NoSuchProviderException{
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM_EC,KEY_PROVIDER_EC);
        keyPairGenerator.initialize(KEY_SIZE_EC,new SecureRandom(random));
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        ECPrivateKey privateKey = (ECPrivateKey) keyPair.getPrivate();
        return privateKey.getEncoded();
    }

    /**
     * 从生成的密钥对中获得私钥
     */
    public static byte[] getECPrivateKey(Map<String, Key> keyMap) {
        ECPrivateKey key = (ECPrivateKey) keyMap.get(Consts.KEY_PRIVATE_MAP);
        return key.getEncoded();
    }

    /**
     * 从生成的密钥对中获得公钥
     */
    public static byte[] getECPublicKey(Map<String, Key> keyMap){
        ECPublicKey key = (ECPublicKey) keyMap.get(Consts.KEY_PUBLIC_MAP);
        return key.getEncoded();
    }


    /**
     * 使用签名者私钥对数据散列值签名
     */
    public static byte[] doSignature(byte[] data,byte[] privateKey)
            throws NoSuchAlgorithmException,NoSuchProviderException,
            InvalidKeySpecException,InvalidKeyException,SignatureException {
        Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(privateKey);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM_EC,KEY_PROVIDER_EC);
        PrivateKey pKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
        Signature signature = Signature.getInstance(KEY_SIGNATURE_INS_EC);
        signature.initSign(pKey);
        signature.update(data);
        return signature.sign();
    }

    /**
     * 使用签名者公钥、数据散列值来验证签名
     */
    public static boolean verifySignature(byte[] data,byte[] publicKey,byte[] sign)
            throws NoSuchAlgorithmException,NoSuchProviderException,
                    InvalidKeySpecException,InvalidKeyException,SignatureException {
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(publicKey);
        KeyFactory  keyFactory = KeyFactory.getInstance(KEY_ALGORITHM_EC,KEY_PROVIDER_EC);
        PublicKey pKey = keyFactory.generatePublic(x509EncodedKeySpec);
        Signature  signature = Signature.getInstance(KEY_SIGNATURE_INS_EC);
        signature.initVerify(pKey);
        signature.update(data);
        return signature.verify(sign);
    }

    /**
     * 使用私钥对散列化数据加密
     */
    public static byte[] encryptByPrivateKey(byte[] data, byte[] privateKey) 
            throws NoSuchAlgorithmException,NoSuchProviderException, NoSuchPaddingException,
                InvalidKeySpecException,InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
        PrivateKey pKey = parsePrivateKey(privateKey);
        Cipher cipher = Cipher.getInstance(KEY_ALGORITHM_CIPHER_EC,KEY_PROVIDER_CIPHER_EC);
        cipher.init(Cipher.ENCRYPT_MODE, pKey);
        return cipher.doFinal(data);
    }

    /**
     * 使用公钥对加密数据解密
     */
    public static byte[] encryptByPublicKey(byte[] data, byte[] publicKey) 
            throws NoSuchAlgorithmException,NoSuchProviderException, NoSuchPaddingException,
                InvalidKeySpecException,InvalidKeyException, IllegalBlockSizeException, BadPaddingException{
        PublicKey pKey = parsePublicKey(publicKey);
        Cipher cipher = Cipher.getInstance(KEY_ALGORITHM_CIPHER_EC,KEY_PROVIDER_CIPHER_EC);
        cipher.init(Cipher.ENCRYPT_MODE, pKey);
        return cipher.doFinal(data);
    }

    /**
     * Base64编码
     */
    public static String bytes2Base64String(byte[] key){
        return (new BASE64Encoder()).encodeBuffer(key);
    }

    /**
     * Base64解码
     */
    public static byte[] base64String2Bytes(String key) throws IOException {
        return (new BASE64Decoder()).decodeBuffer(key);
    }


    /**
     * 由公钥获得私钥
     */
    public static byte[] getECPublicKeyFromPrivateKey(byte[] privateKey)
            throws NoSuchAlgorithmException,NoSuchProviderException,InvalidKeySpecException{
        ECPrivateKey pKey = (ECPrivateKey)parsePrivateKey(privateKey);
        ECParameterSpec parameter = pKey.getParameters();
        ECPoint Q = parameter.getG().multiply(pKey.getD());
        byte[] publicDerBytes = Q.getEncoded(false);
        ECPoint point = parameter.getCurve().decodePoint(publicDerBytes);
        ECPublicKeySpec publicKeySpec =
                new ECPublicKeySpec(point,pKey.getParameters());

        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM_EC,KEY_PROVIDER_EC);
        ECPublicKey publicKey = (ECPublicKey)keyFactory.generatePublic(publicKeySpec);
        return publicKey.getEncoded();
    }

private static PrivateKey parsePrivateKey(byte[] key)
            throws NoSuchAlgorithmException,NoSuchProviderException,InvalidKeySpecException{
        //取得私钥
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM_EC,KEY_PROVIDER_EC);
        //生成私钥
        return keyFactory.generatePrivate(pkcs8KeySpec);
    }

    private static PublicKey parsePublicKey(byte[] key)
            throws NoSuchAlgorithmException,NoSuchProviderException,InvalidKeySpecException{
        //初始化公钥
        //密钥材料转换
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
        //实例化密钥工厂
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM_EC,KEY_PROVIDER_EC);
        //生成私钥
        return keyFactory.generatePublic(x509KeySpec);
    }

  • HashFunction

Hash相关操作的方法：

    /**
     * 生成该区块的 Hash
     * @param block 区块
     * @return Hash
     */
    public static String generateHash(Block block){
        MessageDigest messageDigest;

        if(null==block.getData() && null==block.getPreviousHash())
            throw new RuntimeException("data or previous-hash is null");

        StringBuilder nocodeBuilder = new StringBuilder();
        nocodeBuilder.append(block.getIndex());
        nocodeBuilder.append(block.getCreateTimestamp());
        for(TransactionGroup tx:block.getData()) {
            nocodeBuilder.append(tx.toString());
        }
        nocodeBuilder.append(block.getPreviousHash());
        nocodeBuilder.append(block.getHashDifficulty());
        String nocode = nocodeBuilder.toString();

        int hashOffset = 0;
        String encode = "";

        try{
            messageDigest = MessageDigest.getInstance(Consts.ENCRYPT_INSTANCE);
            while (true) {
                String nocodetmp = nocode + hashOffset;
                messageDigest.update(nocodetmp.getBytes(Consts.ENCRYPT_BYTES_CODING));
                encode = bytes2Hex(messageDigest.digest());
                if(checkHashDifficulty(encode,block.getHashDifficulty())) {
                    block.setHashOffset(hashOffset);
                    break;
                }
                else {
                    hashOffset = hashOffset + 1;
                    encode = "";
                    nocodetmp = "";
                }
            }
        }catch (NoSuchAlgorithmException e){
            throw new RuntimeException("error on loading SHA-256");
        }catch (UnsupportedEncodingException e) {
            throw new RuntimeException("error on loading UTF-8");
        }
        return encode;
    }

    /**
     * 检查生成的 Hash是否符合 Difficulty的要求
     * @param hash Hash
     * @param difficulty 难度
     * @return 是否
     */
    private static boolean checkHashDifficulty(String hash,int difficulty){
        String hashBinary = hex2Binary(hash);
        return hashBinary.startsWith(generatePrefix(difficulty));
    }

    /**
     * bytes转16进制数的字符串
     * @param bytes bytes
     * @return 16进制数的字符串
     */
    private static String bytes2Hex(byte[] bytes){
        StringBuilder stringBuilder = new StringBuilder("");
        if (bytes == null || bytes.length <= 0) {
            return null;
        }
        for (byte b : bytes) {
            int v = b & 0xFF;
            String hv = Integer.toHexString(v);
            if (hv.length() < 2) {
                stringBuilder.append(0);
            }
            stringBuilder.append(hv);
        }
        return stringBuilder.toString();
    }

    /**
     * bytes转2进制数的字符串
     * @param bytes bytes
     * @return 2进制数的字符串
     */
    private static String bytes2Binary(byte[] bytes){
        StringBuilder stringBuilder = new StringBuilder("");
        if (bytes == null || bytes.length <= 0) {
            return null;
        }
        for (byte b : bytes) {
            stringBuilder.append(Long.toString(b & 0xff, 2));
        }
        return stringBuilder.toString().substring(0, stringBuilder.length() - 1);
    }

    /**
     * 16进制数的字符串转2进制数的字符串
     * @param hex 16进制数的字符串
     * @return 2进制数的字符串
     */
    private static String hex2Binary(String hex){
        char[] strChar=hex.toCharArray();
        StringBuilder stringBuilder = new StringBuilder("");
        for(char c:strChar){
            int ihex = Integer.valueOf(String.valueOf(c),16);
            String sbin = Integer.toBinaryString(ihex);
            String sbinf = String.format("%04d",Integer.valueOf(sbin));
            stringBuilder.append(sbinf);
        }
        return stringBuilder.toString();
    }
    
    /**
     * 生成难度对应的 Hash前缀用于难度验证
     * @param offset 难度
     * @return 前缀字符串
     */
    private static String generatePrefix(int offset){
        StringBuilder prefix = new StringBuilder();
        for (int i=0;i<offset;i++){
            prefix.append('0');
        }
        return prefix.toString();
    }

    /**
     * SHA256编码
     * @param nocode 未编码字符串
     * @return 编码后字符串
     */
    public static String getSHA256Code(String nocode){
        String encode;
        try{
            MessageDigest messageDigest = MessageDigest.getInstance(Consts.ENCRYPT_INSTANCE);
            messageDigest.update(nocode.getBytes(Consts.ENCRYPT_BYTES_CODING));
            encode = bytes2Hex(messageDigest.digest());
        }catch (NoSuchAlgorithmException e){
            throw new RuntimeException("error on loading SHA-256");
        }catch (UnsupportedEncodingException e) {
            throw new RuntimeException("error on loading UTF-8");
        }
        return encode;
    }

  • Transaction

交易的相关方法

    /**
     * 生成交易组的 ID
     */
    public static String generateId(TransactionGroup transaction){
        StringBuilder inId = new StringBuilder(transaction.getFromAddress());
        for(TransactionIn txIn:transaction.getTxIns()){
            inId.append(txIn.getOutFromTxId()+txIn.getOutFromIndex());
        }
        StringBuilder outId = new StringBuilder("");
        for(TransactionOut txOut:transaction.getTxOuts()){
            inId.append(txOut.getToAddress()+txOut.getInfo().getDataEncryptString());
        }
        return HashFunction.getSHA256Code(inId.toString()+outId.toString());
    }


    /**
     * 给一个 TxInORM 签名
     */
    public static String signForTransactionIn(String bodyId,
                                              TransactionIn txIn,
                                              String privateKey,
                                              List<TransactionOutUnspent> unspents)
            throws IOException, NoSuchAlgorithmException, NoSuchProviderException,
                    InvalidKeySpecException, InvalidKeyException, SignatureException {
       String idToSign = bodyId;

       TransactionOutUnspent referencedUnspentTxOut =
               findUnspentTxOut(txIn.getOutFromTxId(), txIn.getOutFromIndex(), unspents);
       if(null == referencedUnspentTxOut)
           throw new RuntimeException("没有匹配的未使用TxOut");
       String referencedAddress = referencedUnspentTxOut.getToAddress();

       if(!getPublicKey(privateKey).equals(referencedAddress))
           throw new RuntimeException("私钥生成的公钥与地址不符");

       String signature = bytes2Base64String(
               doSignature(
                       base64String2Bytes(idToSign),
                       base64String2Bytes(privateKey)
               )
       );

       return signature;
    }

    /**
     * 给一个 创始TxInORM 签名
     */
    public static String signForTransactionIn0(String bodyId,
                                                String addressTo,
                                                String privateKey)
            throws IOException, NoSuchAlgorithmException, NoSuchProviderException,
            InvalidKeySpecException, InvalidKeyException, SignatureException {
        String idToSign = bodyId;

        if(!getPublicKey(privateKey).equals(addressTo))
            throw new RuntimeException("私钥生成的公钥与地址不符");

        String signature = bytes2Base64String(
                doSignature(
                        base64String2Bytes(idToSign),
                        base64String2Bytes(privateKey)
                )
        );

        return signature;
    }

    /**
     * 根据私钥 Base64编码字符串获得 Base64编码后的公钥字符串
     */
    public static String getPublicKey(String privateKey)
            throws IOException, NoSuchAlgorithmException, NoSuchProviderException, InvalidKeySpecException {
        byte[] privateK = base64String2Bytes(privateKey);
        byte[] publicK = getECPublicKeyFromPrivateKey(privateK);
        return bytes2Base64String(publicK);
    }


    /**
     * 判断是否是合法的交易组
     */
    public static boolean isLegalTransaction(TransactionGroup transaction,
                                             List<TransactionOutUnspent> unspents)
            throws IOException,NoSuchAlgorithmException,NoSuchProviderException,
                InvalidKeySpecException,InvalidKeyException,SignatureException{
        //判断 Id是否合法
        if(!generateId(transaction).equals(transaction.getId()) ){
            log.error("交易序列不合法：交易序列 ID不合法");
            return false;
        }


        //遍历所有的 txIn判断是否合法
        List<BlockData> txInInfos = new ArrayList<>();
        for(TransactionIn in:transaction.getTxIns()){
            //some of the txIns are invalid in t
            if(!isLegalTransactionIn(in,transaction,unspents)){
                log.error("交易序列不合法：发现签名不合法的 TxInORM，idx为{}",in.getOutFromIndex());
                return false;
            }
            txInInfos.add(getTransactionInInfo(in,unspents));
        }

        List<BlockData> txOutInfos = new ArrayList<>();
        for(TransactionOut out :transaction.getTxOuts()){
            txOutInfos.add(out.getInfo());
        }

        if(txInInfos.size()!=txOutInfos.size()) {
            log.error("交易输入 TxIn与交易输出 TxOut数量不符");
            return false;
        }

        for(BlockData txInInfo:txInInfos){
            int tmp=0;
            for(BlockData txOutInfo:txOutInfos) {
                if (txInInfo.equals(txOutInfo)){
                    break;
                }else {
                    tmp+=1;
                }
            }
            if(tmp==txOutInfos.size()) {
                return false;
            }
        }

        return true;
    }

    /**
     * 判断是否是合法的 txIn
     */
    private static boolean isLegalTransactionIn(TransactionIn txIn,
                                                TransactionGroup transaction,
                                                List<TransactionOutUnspent> unspents)
            throws IOException,NoSuchAlgorithmException,NoSuchProviderException,
                    InvalidKeySpecException,InvalidKeyException,SignatureException{
        //找到 txIn 引用的 txOutUnspent
        TransactionOutUnspent referencedUTxOut =
                findUnspentTxOut(txIn.getOutFromTxId(),txIn.getOutFromIndex(),unspents);

        //如果找不到说明 txIn 不合法
        if(null == referencedUTxOut) {
            log.error("交易输入 TxIn不合法：找不到引用的未使用交易输出 TxOutUnspent");
            return false;
        }

        String senderAddress = referencedUTxOut.getToAddress();

        //判断签名合法性
        return verifySignature(
                base64String2Bytes(transaction.getId()),
                base64String2Bytes(senderAddress),
                base64String2Bytes(txIn.getSignature()));
    }

    /**
     * 找到与交易输入匹配的未使用的交易输出
     */
    private static BlockData getTransactionInInfo(TransactionIn txIn,
                                                List<TransactionOutUnspent> unspents){
        TransactionOutUnspent referencedUTxOut =
                findUnspentTxOut(txIn.getOutFromTxId(),txIn.getOutFromIndex(),unspents);
        return referencedUTxOut.getInfo();
    }

    /**
     * 找到与 txOut 匹配的 txOutUnspent
     */
    private static TransactionOutUnspent findUnspentTxOut(String txInId,
                                                          int txInIndex,
                                                          List<TransactionOutUnspent> unspents){
        for(TransactionOutUnspent unspent: unspents){
            if(unspent.getOutFromTxId().equals(txInId) &&
                    unspent.getOutFromIndex() == txInIndex)
                return unspent;
        }
        return null;
    }

  • 使用关系型数据库作为元数据载体的工具

  • 元数据结构

public abstract class BlockData {
    private String dataId;
    private String sha256_data;

    public BlockData(String dataId, String dataString) {
        this.dataId = dataId;
        this.sha256_data = HashFunction.getSHA256Code(dataString);
    }

    public BlockData(String dataId, String dataString,boolean hasCoding) {
        this.dataId = dataId;
        if(hasCoding)
            this.sha256_data = dataString;
        else
            this.sha256_data = HashFunction.getSHA256Code(dataString);
    }

    public String getDataId() {
        return dataId;
    }

    public void setDataId(String dataId) {
        this.dataId = dataId;
    }

    public String getSHA256Data() {
        return sha256_data;
    }

    public void setData(String dataString) {
        this.sha256_data = HashFunction.getSHA256Code(dataString);
    }

    public void setSHA256Data(String sha256_data) {
        this.sha256_data = sha256_data;
    }

    @Override
    public boolean equals(Object obj) {
        if(obj instanceof  BlockData){
            return this.dataId.equals(((BlockData) obj).getDataId())&&
                    this.sha256_data.equals(((BlockData) obj).getSHA256Data());
        }else return false;
    }

    public String getDataEncryptString(){
        return this.sha256_data;
    }
}

  • ORM

BlockORM

int：index
long：createTimestamp
long：createTimeUse
LinkedList<TxORM>：data
String：hash
String：previousHash
int：hashOffset
int：hashDifficulty

与数据库交互的区块实体

只有构造方法和Getter、Setter

TxInORM

String：txId
String：preTxId
int：preTxIdx
String：sign

与数据库交互的输入交易实体

只有构造方法和Getter、Setter

TxOutORM

String：txId
String：addressTo
String：dataId
String：data

与数据库交互的输出交易实体

只有构造方法和Getter、Setter

TxORM

int：blockIdx
String：id
String：fromAddress
List<TxInORM>：txInORMS
List<TxOutORM>：txOutORMS

与数据库交互的交易实体

只有构造方法和Getter、Setter

UTxOutORM

String：publicKey
String：dataId
String：data
String：txId
int：txIdx

与数据库交互的未输出交易实体

只有构造方法和Getter、Setter

  • Mybatis Mapper

这里要首先说一下RDB中区块、输入交易、输出交易、交易、未输出交易的表结构从上文的ORM结构就能看出来，这些都是预先建好的表：

根据区块位置获得区块信息

SELECT n_index,dt_create,n_use_time,c_hash,c_prehash,n_offset,n_difficaulty FROM db_data.t_blockchain WHERE n_index=#{index}

根据区块位置获得区块内交易列表SELECT n_block_index,c_id,c_from_addr FROM db_data.t_txs WHERE n_block_index=#{n_index}
获取未上链的交易SELECT n_block_index,c_id,c_from_addr FROM db_data.t_txs WHERE n_block_index ISNULL
根据交易ID获取该交易的输入交易列表SELECT c_tx_id,c_pretx_id,n_pretx_idx,c_sign FROM db_data.t_txins WHERE c_tx_id=#{c_id}
根据交易ID获取该交易的输出交易列表SELECT c_tx_id,c_address_to,c_data_id,c_data FROM db_data.t_txouts WHERE c_tx_id=#{c_id}
插入一个区块INSERT INTO db_data.t_blockchain (n_index,dt_create,n_use_time,c_hash,c_prehash,n_offset,n_difficaulty) VALUES(#{index},#{createTimestamp},#{createTimeUse},#{hash},#{previousHash},#{hashOffset},#{hashDifficulty})
更新刚刚上链的交易的区块位置

UPDATE db_data.t_txs SET n_block_index=#{bid} WHERE c_id=#{cid}

新增一个输入交易INSERT INTO db_data.t_txins (c_tx_id,c_pretx_id,n_pretx_idx,c_sign) VALUES(#{txId},#{preTxId},#{preTxIdx},#{sign})
新增一个输出交易INSERT INTO db_data.t_txouts (c_tx_id,c_address_to,c_data_id,c_data) VALUES(#{txId},#{addressTo},#{dataId},#{data})
根据数据所有者（公钥）获取未输出交易列表SELECT c_publickey,c_data_id,c_data,c_txid,n_txidx FROM db_data.t_utxos WHERE c_publickey=#{publicKey}
根据交易ID获取未输出交易列表SELECT c_publickey,c_data_id,c_data,c_txid,n_txidx FROM db_data.t_utxos WHERE c_txid=#{txId}
根据交易ID和输出交易位置获取未输出交易SELECT c_publickey,c_data_id,c_data,c_txid,n_txidx FROM db_data.t_utxos WHERE c_txid=#{txId} AND n_txidx=#{txIds}
根据数据ID取未输出交易SELECT c_publickey,c_data_id,c_data,c_txid,n_txidx FROM db_data.t_utxos WHERE c_data_id=#{dataId}
插入一个未输出交易INSERT INTO db_data.t_utxos (c_publickey,c_data_id,c_data,c_txid,n_txidx) VALUES(#{publicKey},#{dataId},#{data},#{txId},#{txIdx})
根据数据ID删除一个未输出交易DELETE FROM db_data.t_utxos WHERE c_data_id=#{dataId}
获取链尾区块信息SELECT n_index,dt_create,n_use_time,c_hash,c_prehash,n_offset,n_difficaulty FROM db_data.t_blockchain ORDER BY n_index DESC LIMIT 1
获取创世块信息SELECT n_index,dt_create,n_use_time,c_hash,c_prehash,n_offset,n_difficaulty FROM db_data.t_blockchain WHERE n_index=1

  • 给Service调用的静态方法

    /**
     * 检查数据是否被篡改
     * @param mapper 继承 BCMapper 的 Mapper
     * @param dataInDB 要被检验的数据
     * @return 是否
     */
    public static boolean checkDataById(BCMapper mapper, BlockData dataInDB){
        UTxOutORM uTxOut = mapper.getUTxOutByDataId(dataInDB.getDataId());
        if(null == uTxOut){
            logger.error("该数据未在账本或未被挖掘");
            return false;
        }else {
            return uTxOut.getData().equals(dataInDB.getSHA256Data());
        }
    }

    /**
     * 检查是否已经创世
     * @param mapper 继承 BCMapper 的 Mapper
     * @return 是否
     */
    public static boolean hasInit(BCMapper mapper){
        BlockORM initBlockInfo = mapper.getInitBlockInfo();
        if(null==initBlockInfo){
            return false;
        }

        Block initBlock = ORM2EntityFunction.BlockOrm2Entity(initBlockInfo);
        String initHash = HashFunction.generateHash(initBlock);
        if(initHash.equals(initBlockInfo.getHash())){
            return true;
        }else {
            System.out.println("创世块HASH不合法");
            return false;
        }
    }

    /**
     * 创世
     * @param mapper 继承 BCMapper 的 Mapper
     * @return 成功与否
     */
    public static boolean initBlock(BCMapper mapper){
        Block initBlock = new Block(1,0,0,null,
                "","",0, Consts.HASH_DIFFICULTY_INIT);
        long start = new Date().getTime();
        String hash = HashFunction.generateHash(initBlock);
        long end = new Date().getTime();
        BlockORM initBlockORM = new BlockORM(1,0,end-start,hash,
                "",initBlock.getHashOffset(),Consts.HASH_DIFFICULTY_INIT);
        mapper.addOneBlock(initBlockORM);
        return true;
    }

    /**
     * 添加一个新的数据，数据准备上链
     * @param mapper 继承 BCMapper 的 Mapper
     * @param publicKey 数据所有者公钥
     * @param privateKey 数据所有者私钥
     * @param data 数据
     * @return 成功与否
     */
    public static boolean addNewData(BCMapper mapper,String publicKey,String privateKey, BlockData data)
    throws Exception{
        TransactionIn txIn = new TransactionIn("",1,null);
        TransactionOut txOut = new TransactionOut(publicKey,data);
        TransactionGroup tx = new TransactionGroup(
                publicKey,
                Arrays.asList(new TransactionIn[] {txIn}),
                Arrays.asList(new TransactionOut[] {txOut})
        );
        String sign = Transaction.signForTransactionIn0(tx.getId(), publicKey, privateKey);
        txIn.setSignature(sign);
        mapper.addOneTx(
                new TxORM(null,publicKey,tx.getId()));
        mapper.addOneTxIn(
                new TxInORM(tx.getId(), txIn.getOutFromTxId(), txIn.getOutFromIndex(), txIn.getSignature()));
        mapper.addOneTxOut(
                new TxOutORM(tx.getId(),txOut.getToAddress(),txOut.getInfo().getDataId(),txOut.getInfo().getSHA256Data()));
        return true;
    }

    /**
     * 挖掘未上链的数据，数据上链
     * @param mapper 继承 BCMapper 的 Mapper
     * @param publicKey 挖掘者公钥
     * @return 成功与否
     */
    public static boolean mineTransactions(BCMapper mapper,String publicKey) throws Exception{
        List<TxORM> txOrms = mapper.getTxsByNull();
        if(null == txOrms || txOrms.size()==0){
            return true;
        }
        /*
         * 此处会广播 txOrms给全部节点，一起算
         */

        BlockORM lastBlockInfo = mapper.getLastBlockInfo();
        LinkedList<TransactionGroup> txs = new LinkedList<>();

        for(TxORM txORM: txOrms){
            TransactionGroup tx = ORM2EntityFunction.TxOrm2Entity(txORM);

            //正确的TxId
            if(tx.getId().equals(txORM.getId())){
                for(TransactionIn txIn:tx.getTxIns()){
                    boolean check = Crypt.verifySignature(
                            Crypt.base64String2Bytes(tx.getId()),
                            Crypt.base64String2Bytes(txORM.getFromAddress()),
                            Crypt.base64String2Bytes(txIn.getSignature())
                    );
                    if(!check){
                        throw new RuntimeException("交易ID"+tx.getId()+",签名不合法");
                    }
                }
                txs.add(tx);
            }else {
                throw new RuntimeException("交易ID:"+txORM.getId()+",不合法");
            }
        }

        Block newBlock = new Block(
                lastBlockInfo.getIndex()+1,
                txs,
                lastBlockInfo.getHash(),
                lastBlockInfo.getHashDifficulty());

        BlockORM newBlockOrm = new BlockORM(
                newBlock.getIndex(),
                newBlock.getCreateTimestamp(),
                newBlock.getCreateTimeUse(),
                null,
                newBlock.getHash(),
                newBlock.getPreviousHash(),
                newBlock.getHashOffset(),
                newBlock.getHashDifficulty());
        mapper.addOneBlock(newBlockOrm);

        for(TxORM txORM: txOrms){
            List<TxOutORM> txOutOrms = txORM.getTxOutORMS();
            mapper.updateTxBlockId(newBlockOrm.getIndex(),txORM.getId());
            int idx=1;
            for(TxOutORM txOutORM:txOutOrms){
                mapper.addOneUTxOut(
                        new UTxOutORM(publicKey,txOutORM.getDataId(),txOutORM.getData(),txORM.getId(),idx));
                idx += 1;
            }
        }

        return true;
    }

 

NEU_LightBulb
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
lamppost::light_bulb:Sparkbox的2016年学徒项目
05-01
路灯 本地技术事件汇总使用Ruby on Rails，Sass和PostgreSQL构建 Lamp Post是一个旨在使公众更容易接触到科技活动的项目。 这是一个综合清单，易于浏览，并且侧重于内容。 基于易于复制的想法，我们邀请您（是的，您）使用此存储库作为起点，并为您自己的城市部署站点。 本自述文件可帮助您以最小的麻烦入门和运行。 正在努力使“路灯柱”更易于社区使用。 随着应用程序变得更加通用和可定制，以下设置说明将发生变化。 准备为自己的本地开发人员场景设置路灯柱了吗？ 继续阅读。 设置您自己的灯柱 我们喜欢 ，建议您使用它来部署您的Lamp Post。 为此，请按照以下三个步骤进行操作，您将摇晃两次。 将此存储库分叉到您自己的GitHub帐户。 按下此按钮。 填写一些环境变量，以便Heroku可以构建您的应用程序。 下表概述了您需要的内容。 变量名 解释 城市 该路灯柱
blockchain java_blockchain-java(简易区块链项目)
weixin_42599558的博客
02-16 580
blockchain-java(简易区块链项目)是基于Java实现的一个简易区块链(联盟链)项目，包括加密工具，钱包，P2P 传输，区块同步，POW 共识等基础实现。使用方法单节点部署这个很简单, 直接像运行普通的 SpringBoot 项目一样运行就好了，单节点默认使用的 node1 节点的配置多节点部署项目默认部署3个节点，创建了3个配置文件 application-{env}.yml， 如果...
用java写一个简单的区块链（上）
跟派大星学编程
03-29 1万+
创建区块链区块链就是一串或者是一系列区块的集合，类似于链表的概念，每个区块都指向于后面一个区块，然后顺序的连接在一起。那么每个区块中的内容是什么呢？在区块链中的每一个区块都存放了很多很有价值的信息，主要包括三个部分：自己的数字签名，上一个区块的数字签名，还有一切需要加密的数据（这些数据在比特币中就相当于是交易的信息，它是加密货币的本质）。每个数字签名不但证明了自己是特有的一个区块，而且指向了前一个...
被5月GitHub Top20榜单惊呆了! 原来区块链大佬都在做这个...
区块链大本营
06-05 1万+
作者 | 乔治出品 | 区块链大本营GitHub 上项目的活跃指数，在一定程度上代表了这个项目的开发状态。频繁更新代码的项目有可能正处于构建和完善中，而停止更新代码的项目...
使用Java开发一个自己的区块链产品、联盟链
热门推荐
tianyaleixiaowu的专栏
04-11 2万+
开源地址：https://gitee.com/tianyalei/md_blockchain https://gitee.com/tianyalei/md_blockchain_manager Java区块链平台，基于Springboot开发的区块链平台。区块链qq交流群737858576，一起学习区块链平台开发，当然也交流Springboot、springcloud、机器学习等知识。 起因...
区块链DApp开发环境embark初探
02-24
embark是什么embark是一款特定于Ethereum区块链平台的DApp开发环境，辅助开发者创建、构建编译、测试和部署DApp，可无缝集成计算（EVM）、存储（IPFS/Swarm）和网络（Whisper）资源。embark的便捷之处在尝试embark并...
5G技术与区块链技术的相互赋能初探.pdf
08-15
#资源达人分享计划#
区块链初探原理
09-14
小弟我第一次使用CSDN，也是第一次接触区块链，这里是个人总结的一些原理基础，可能孤陋寡闻，也可能说得不对，还请大家多多指教
区块链资产融资初探.pdf
08-15
#资源达人分享计划#
hyperledger fabric fabric-sdk-java 从区块中解析交易内容及读写集 (7)
让代码飞
07-10 2437
官方示例其实是有完整例子的, 但是我想你可能对那几千行代码不是很感兴趣, 所以把解析读写集部分给摘出来了, 代码奉上 public static List<Map> getRWSetFromBlock(BlockInfo blockInfo) throws InvalidProtocolBufferException { List<Map> transactionList = new ArrayList<>(); for (Bloc.
【区块链】——区块链学习初探（三）
NEU_LightBulb的博客
12-10 237
从0开始搭建一个区块链Demo 主要以比特币区块链为基础，做一个法院案件记录上链及修改的样例。结合上一篇的介绍 https://blog.csdn.net/NEU_LightBulb/article/details/103475390 假设区块链服务用的库表和数据库表在一个数据库里。整个工程是一个Springboot2工程 https://github.com/zjw271208550/l...
笃行致远，“易”往无前 | 易保全成立10周年啦
weixin_49292035的博客
04-28 352
10年间，我们聚焦四大区块链核心业务，在一次次技术创新与实践中，不断推进产品迭代升级，实现了与金融、物流运输、人力资源、电子政务、汽车、生产制造、医药医疗、图片摄影、律所等各行业的深度融合与应用。”为使命，坚信区块链的未来，夯实区块链底层技术，搭建“保全链”系统，首创“区块链+司法+应用”的模式，推出了四大区块链基础应用设施。10年后，易保全成为国内权威的电子数据存证保全机构，每一项成就背后都是“易”家人以步履铿锵之姿走过的每一步，当然也离不开广大用户、客户、伙伴的信赖与支持，才能让易保全行稳致远。
4月20日，杭州Sui Meetup活动回顾
最新发布
Sui_Network的博客
05-01 776
4 月 20 日在风景如画的杭州，「TinTin DESTINATION MOON」成功举办。此次活动深入探讨了 Sui 生态系统的演进及未来机遇，包括 Sui 上的资产管理协议 Mole、全链引擎 Obelisk Engine 以及 Generator 的开发范式等热点话题，行业专家提供了深刻见解和答案。
【区块链】椭圆曲线数字签名算法（ECDSA）
qq_64585761的博客
04-27 705
椭圆曲线数字签名算法的原理。
武汉星起航：挂牌上海股权中心，开启资本新篇章助力跨境电商飞跃
xqhang的博客
04-28 322
从长远来看，武汉星起航的挂牌上市还将对整个跨境电商行业产生积极的影响。同时，随着武汉星起航在资本市场上的不断壮大，其对于跨境电商行业的技术创新、模式创新等方面的投入也将不断增加，为整个行业的进步和发展注入新的动力。武汉星起航在跨境电商领域的专业能力和丰富经验将得到更多投资者的认可，进而吸引更多的合作伙伴和战略投资者，共同推动公司业务的快速发展。我们有理由相信，在未来的发展中，武汉星起航将继续发挥其在跨境电商领域的专业优势和创新精神，为更多的创业者和投资者提供优质服务，推动整个行业的持续健康发展。
区块链技术：DAPP开发
再熬夜头发就要掉光光咯
04-30 399
此外，区块链技术还将推动数字货币和智能合约的发展，为未来的商业交易和结算提供更加安全、便捷和高效的方式。面对挑战和机遇，我们需要加强技术研发和人才培养，推动监管政策的制定和实施，以实现DAPP的健康和可持续发展。我们相信，在不久的将来，DAPP将成为未来商业生态的关键一环，为人类社会带来更多的便利和价值。为了解决这个问题，需要加强国际合作，推动监管政策的制定和实施，确保DAPP的健康和可持续发展。通过区块链技术，可以实现物联网设备之间的安全、透明的数据交换，提高物联网应用的可靠性和安全性。
Web3与智能合约：科技革新下的新金融时代
weixin_44672358的博客
04-29 880
Web3与智能合约的结合将为金融行业带来巨大的变革和创新，开启了一个全新的数字化金融时代。我们期待着智能合约技术的不断发展和应用，共同推动着金融行业向更加智能、高效和可信的方向迈进。
2024-04-29 区块链-项目-记录
技术之路
04-29 773
2024-04-29 区块链-项目-记录。
「生存即赚」链接现实与游戏，打造3T平台生态
2401_83906209的博客
04-28 953
3T游戏的推出，旨在聚合资源，开拓新的市场领域，为整个行业创造更多的增长点和价值空间。抵抗者算力救助：为了缓解玩家在游戏中可能遭受的损失，当玩家所在的房间被攻破时，虽然他们投入的USDT或3TC会损失，但作为补偿，玩家将获得相应比例的3TC算力救助，这种机制既体现了游戏的人文关怀，又为玩家提供了继续参与游戏的动力。3T游戏平台解决的不仅仅是玩家游戏体验的问题，它还将区块链技术与DEFI和跨链相结合，链接全球的各个环节，让用户可以在不同链上进行游戏交互，享受更加多样化和丰富的游戏体验，打造3T游戏生态。
Educoder Python初探
09-21
Educoder Python初探是一个学习Python编程语言的课程。其中包含了多个编程示例，例如字符串查找与替换、用数字说话和字符转换。在字符串查找与替换示例中，我们首先使用find函数查找字符串中的特定子串，并返回其...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值