Fixed compilation errors due to refactoring crypto-framework;

source/consensus/consensus-bftsmart/src/main/java/com/jd/blockchain/consensus/bftsmart/client/BftsmartConsensusClientFactory.java

@@ -1,28 +1,22 @@
 package com.jd.blockchain.consensus.bftsmart.client;
 
-import bftsmart.reconfiguration.util.TOMConfiguration;
-import com.jd.blockchain.consensus.ClientIdentification;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
 import com.jd.blockchain.consensus.ClientIncomingSettings;
 import com.jd.blockchain.consensus.ConsensusManageService;
-import com.jd.blockchain.consensus.ConsensusSecurityException;
 import com.jd.blockchain.consensus.bftsmart.BftsmartClientIncomingSettings;
-import com.jd.blockchain.consensus.bftsmart.BftsmartTopology;
-import com.jd.blockchain.consensus.bftsmart.service.BftsmartConsensusManageService;
 import com.jd.blockchain.consensus.client.ClientFactory;
 import com.jd.blockchain.consensus.client.ClientSettings;
 import com.jd.blockchain.consensus.client.ConsensusClient;
-import com.jd.blockchain.crypto.CryptoUtils;
+import com.jd.blockchain.crypto.CryptoServiceProviders;
 import com.jd.blockchain.crypto.PrivKey;
 import com.jd.blockchain.crypto.PubKey;
-import com.jd.blockchain.crypto.asymmetric.*;
-import com.jd.blockchain.utils.http.agent.HttpServiceAgent;
-import com.jd.blockchain.utils.http.agent.ServiceEndpoint;
+import com.jd.blockchain.crypto.asymmetric.CryptoKeyPair;
+import com.jd.blockchain.crypto.asymmetric.SignatureDigest;
+import com.jd.blockchain.crypto.asymmetric.SignatureFunction;
 import com.jd.blockchain.utils.net.NetworkAddress;
-import com.jd.blockchain.utils.serialize.binary.BinarySerializeUtils;
-
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
 public class BftsmartConsensusClientFactory implements ClientFactory {
 
@@ -43,7 +37,7 @@ public class BftsmartConsensusClientFactory implements ClientFactory {
 		PubKey pubKey = clientKeyPair.getPubKey();
 		PrivKey privKey = clientKeyPair.getPrivKey();
 
-		SignatureFunction signatureFunction = CryptoUtils.sign(pubKey.getAlgorithm());
+		SignatureFunction signatureFunction =CryptoServiceProviders.getSignatureFunction(pubKey.getAlgorithm());
 		SignatureDigest signatureDigest = signatureFunction.sign(privKey, pubKey.toBytes());
 
 		BftsmartClientIdentification bftsmartClientIdentification = new BftsmartClientIdentification();

source/consensus/consensus-bftsmart/src/main/java/com/jd/blockchain/consensus/bftsmart/service/BftsmartConsensusManageService.java

@@ -1,59 +1,62 @@
 package com.jd.blockchain.consensus.bftsmart.service;
 
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
 import com.jd.blockchain.consensus.ClientIdentification;
 import com.jd.blockchain.consensus.ConsensusManageService;
-import com.jd.blockchain.consensus.ConsensusSecurityException;
 import com.jd.blockchain.consensus.bftsmart.BftsmartClientIncomingConfig;
 import com.jd.blockchain.consensus.bftsmart.BftsmartClientIncomingSettings;
-import com.jd.blockchain.crypto.CryptoUtils;
+import com.jd.blockchain.crypto.CryptoServiceProviders;
 import com.jd.blockchain.crypto.asymmetric.SignatureFunction;
 import com.jd.blockchain.utils.serialize.binary.BinarySerializeUtils;
 
-import java.util.concurrent.locks.Lock;
-import java.util.concurrent.locks.ReentrantLock;
-
 public class BftsmartConsensusManageService implements ConsensusManageService {
 
-    public static final int CLIENT_RANGE = 100 * 1000;
+	public static final int CLIENT_RANGE = 100 * 1000;
 
-    private BftsmartNodeServer nodeServer;
-    private int clientId;
-    private static final Lock authLock = new ReentrantLock();
+	private BftsmartNodeServer nodeServer;
+	private int clientId;
+	private static final Lock authLock = new ReentrantLock();
 
-    public BftsmartConsensusManageService(BftsmartNodeServer nodeServer) {
-        this.nodeServer = nodeServer;
-        //Assume that each peer node corresponds to up to 100 gateways
-        clientId = nodeServer.getServerId() * CLIENT_RANGE;
-    }
+	public BftsmartConsensusManageService(BftsmartNodeServer nodeServer) {
+		this.nodeServer = nodeServer;
+		// Assume that each peer node corresponds to up to 100 gateways
+		clientId = nodeServer.getServerId() * CLIENT_RANGE;
+	}
 
-    @Override
-    public BftsmartClientIncomingSettings authClientIncoming(ClientIdentification authId) {
-        if (verify(authId)) {
-            BftsmartClientIncomingSettings clientIncomingSettings = new BftsmartClientIncomingConfig();
+	@Override
+	public BftsmartClientIncomingSettings authClientIncoming(ClientIdentification authId) {
+		if (verify(authId)) {
+			BftsmartClientIncomingSettings clientIncomingSettings = new BftsmartClientIncomingConfig();
 
-            ((BftsmartClientIncomingConfig) clientIncomingSettings).setTopology(BinarySerializeUtils.serialize(nodeServer.getTopology()));
-            ((BftsmartClientIncomingConfig) clientIncomingSettings).setTomConfig(BinarySerializeUtils.serialize(nodeServer.getTomConfig()));
-            ((BftsmartClientIncomingConfig) clientIncomingSettings).setConsensusSettings(nodeServer.getConsensusSetting());
-            ((BftsmartClientIncomingConfig) clientIncomingSettings).setPubKey(authId.getPubKey());
-            //compute gateway id
-            try {
-                authLock.lock();
-                ((BftsmartClientIncomingConfig) clientIncomingSettings).setClientId(clientId++);
-            } finally {
-                authLock.unlock();
-            }
+			((BftsmartClientIncomingConfig) clientIncomingSettings)
+					.setTopology(BinarySerializeUtils.serialize(nodeServer.getTopology()));
+			((BftsmartClientIncomingConfig) clientIncomingSettings)
+					.setTomConfig(BinarySerializeUtils.serialize(nodeServer.getTomConfig()));
+			((BftsmartClientIncomingConfig) clientIncomingSettings)
+					.setConsensusSettings(nodeServer.getConsensusSetting());
+			((BftsmartClientIncomingConfig) clientIncomingSettings).setPubKey(authId.getPubKey());
+			// compute gateway id
+			try {
+				authLock.lock();
+				((BftsmartClientIncomingConfig) clientIncomingSettings).setClientId(clientId++);
+			} finally {
+				authLock.unlock();
+			}
 
-            return clientIncomingSettings;
+			return clientIncomingSettings;
 
-        }
+		}
 
-        return null;
-    }
+		return null;
+	}
 
-    public boolean verify(ClientIdentification authId) {
+	public boolean verify(ClientIdentification authId) {
 
-        SignatureFunction signatureFunction = CryptoUtils.sign(authId.getPubKey().getAlgorithm());
+		SignatureFunction signatureFunction = CryptoServiceProviders
+				.getSignatureFunction(authId.getPubKey().getAlgorithm());
 
-        return signatureFunction.verify(authId.getSignature(), authId.getPubKey(), authId.getIdentityInfo());
-    }
+		return signatureFunction.verify(authId.getSignature(), authId.getPubKey(), authId.getIdentityInfo());
+	}
 }

source/consensus/consensus-bftsmart/src/main/java/com/jd/blockchain/consensus/bftsmart/service/BftsmartNodeServer.java

@@ -1,27 +1,18 @@
 package com.jd.blockchain.consensus.bftsmart.service;
 
-import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
-import java.util.*;
-import java.util.concurrent.ConcurrentHashMap;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Properties;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledThreadPoolExecutor;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicLong;
-
-import bftsmart.tom.*;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import com.jd.blockchain.binaryproto.BinaryEncodingUtils;
 import com.jd.blockchain.consensus.ConsensusManageService;
 import com.jd.blockchain.consensus.NodeSettings;
-import com.jd.blockchain.consensus.bftsmart.BftsmartCommitBlockSettings;
 import com.jd.blockchain.consensus.bftsmart.BftsmartConsensusProvider;
 import com.jd.blockchain.consensus.bftsmart.BftsmartConsensusSettings;
 import com.jd.blockchain.consensus.bftsmart.BftsmartNodeSettings;
@@ -31,28 +22,17 @@ import com.jd.blockchain.consensus.service.NodeServer;
 import com.jd.blockchain.consensus.service.ServerSettings;
 import com.jd.blockchain.consensus.service.StateHandle;
 import com.jd.blockchain.consensus.service.StateMachineReplicate;
-import com.jd.blockchain.crypto.CryptoAlgorithm;
-import com.jd.blockchain.crypto.CryptoUtils;
-import com.jd.blockchain.crypto.hash.HashDigest;
-import com.jd.blockchain.ledger.BlockchainKeyGenerator;
-import com.jd.blockchain.ledger.BlockchainKeyPair;
-import com.jd.blockchain.ledger.TransactionContent;
-import com.jd.blockchain.ledger.TransactionRequest;
-import com.jd.blockchain.ledger.TransactionRespHandle;
-import com.jd.blockchain.ledger.TransactionResponse;
 import com.jd.blockchain.ledger.TransactionState;
-import com.jd.blockchain.ledger.data.TxContentBlob;
-import com.jd.blockchain.ledger.data.TxRequestMessage;
 import com.jd.blockchain.utils.PropertiesUtils;
-import com.jd.blockchain.utils.codec.Base58Utils;
 import com.jd.blockchain.utils.concurrent.AsyncFuture;
-import com.jd.blockchain.utils.concurrent.CompletableAsyncFuture;
 import com.jd.blockchain.utils.io.BytesUtils;
-import com.jd.blockchain.utils.serialize.binary.BinarySerializeUtils;
 
 import bftsmart.reconfiguration.util.HostsConfig;
 import bftsmart.reconfiguration.util.TOMConfiguration;
-import bftsmart.reconfiguration.views.MemoryBasedViewStorage;
+import bftsmart.tom.MessageContext;
+import bftsmart.tom.ReplyContext;
+import bftsmart.tom.ReplyContextMessage;
+import bftsmart.tom.ServiceReplica;
 import bftsmart.tom.core.messages.TOMMessage;
 import bftsmart.tom.server.defaultservices.DefaultRecoverable;
 

source/consensus/consensus-mq/src/main/java/com/jd/blockchain/consensus/mq/client/MsgQueueClientFactory.java

@@ -10,23 +10,18 @@ package com.jd.blockchain.consensus.mq.client;
 
 import com.jd.blockchain.consensus.ClientIncomingSettings;
 import com.jd.blockchain.consensus.ConsensusManageService;
-import com.jd.blockchain.consensus.ConsensusSettings;
 import com.jd.blockchain.consensus.client.ClientFactory;
 import com.jd.blockchain.consensus.client.ClientSettings;
 import com.jd.blockchain.consensus.mq.config.MsgQueueClientConfig;
-import com.jd.blockchain.consensus.mq.config.MsgQueueClientIncomingConfig;
-import com.jd.blockchain.consensus.mq.config.MsgQueueConsensusConfig;
 import com.jd.blockchain.consensus.mq.settings.MsgQueueClientIncomingSettings;
 import com.jd.blockchain.consensus.mq.settings.MsgQueueClientSettings;
 import com.jd.blockchain.consensus.mq.settings.MsgQueueConsensusSettings;
-import com.jd.blockchain.crypto.CryptoUtils;
+import com.jd.blockchain.crypto.CryptoServiceProviders;
 import com.jd.blockchain.crypto.PubKey;
 import com.jd.blockchain.crypto.asymmetric.CryptoKeyPair;
 import com.jd.blockchain.crypto.asymmetric.SignatureDigest;
 import com.jd.blockchain.crypto.asymmetric.SignatureFunction;
 
-import java.lang.reflect.Proxy;
-
 /**
  *
  * @author shaozhuguang
@@ -41,7 +36,7 @@ public class MsgQueueClientFactory implements ClientFactory {
         PubKey pubKey = clientKeyPair.getPubKey();
         byte[] address = pubKey.toBytes(); // 使用公钥地址作为认证信息
 
-        SignatureFunction signatureFunction = CryptoUtils.sign(pubKey.getAlgorithm());
+        SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(pubKey.getAlgorithm());
         SignatureDigest signatureDigest = signatureFunction.sign(clientKeyPair.getPrivKey(), address);
 
         MsgQueueClientIdentification mqci = new MsgQueueClientIdentification()

source/consensus/consensus-mq/src/main/java/com/jd/blockchain/consensus/mq/client/MsgQueueClientIdentification.java

@@ -10,12 +10,8 @@ package com.jd.blockchain.consensus.mq.client;
 
 import com.jd.blockchain.consensus.ClientIdentification;
 import com.jd.blockchain.consensus.mq.MsgQueueConsensusProvider;
-import com.jd.blockchain.crypto.CryptoUtils;
 import com.jd.blockchain.crypto.PubKey;
 import com.jd.blockchain.crypto.asymmetric.SignatureDigest;
-import com.jd.blockchain.crypto.asymmetric.SignatureFunction;
-
-import java.util.Arrays;
 
 /**
  *

source/consensus/consensus-mq/src/main/java/com/jd/blockchain/consensus/mq/server/MsgQueueConsensusManageService.java

@@ -8,21 +8,18 @@
  */
 package com.jd.blockchain.consensus.mq.server;
 
+import java.util.Arrays;
+
 import com.jd.blockchain.consensus.ClientIdentification;
 import com.jd.blockchain.consensus.ConsensusManageService;
 import com.jd.blockchain.consensus.ConsensusSecurityException;
-import com.jd.blockchain.consensus.mq.client.MsgQueueClientIdentification;
 import com.jd.blockchain.consensus.mq.config.MsgQueueClientIncomingConfig;
-import com.jd.blockchain.consensus.mq.config.MsgQueueConsensusConfig;
 import com.jd.blockchain.consensus.mq.settings.MsgQueueClientIncomingSettings;
 import com.jd.blockchain.consensus.mq.settings.MsgQueueConsensusSettings;
-import com.jd.blockchain.crypto.CryptoUtils;
+import com.jd.blockchain.crypto.CryptoServiceProviders;
 import com.jd.blockchain.crypto.PubKey;
 import com.jd.blockchain.crypto.asymmetric.SignatureFunction;
 
-import java.lang.reflect.Proxy;
-import java.util.Arrays;
-
 /**
  *
  * @author shaozhuguang
@@ -65,7 +62,7 @@ public class MsgQueueConsensusManageService implements ConsensusManageService {
         byte[] identityInfo = authId.getIdentityInfo();
         byte[] address = pubKey.toBytes(); // 使用公钥地址作为认证信息
         if (Arrays.equals(address, identityInfo)) {
-            SignatureFunction signatureFunction = CryptoUtils.sign(pubKey.getAlgorithm());
+            SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(pubKey.getAlgorithm());
             isLegal = signatureFunction.verify(authId.getSignature(), pubKey, identityInfo);
         }
         return isLegal;

source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/CryptoServiceProviders.java

@@ -125,16 +125,21 @@ public final class CryptoServiceProviders {
 		return algorithms.get(code);
 	}
 
+	/**
+	 * Return the CryptoAlogrithm object of the specified name ,or null if none;
+	 * 
+	 * @param name
+	 * @return
+	 */
 	public static CryptoAlgorithm getAlgorithm(String name) {
 		Short code = names.get(name.toUpperCase());
 		return code == null ? null : algorithms.get(code);
 	}
-	
+
 	public static RandomFunction getRandomFunction(String algorithmName) {
 		CryptoAlgorithm algorithm = getAlgorithm(algorithmName);
 		if (algorithm == null) {
-			throw new CryptoException(
-					"Algorithm " + algorithmName + " has no service provider!");
+			throw new CryptoException("Algorithm " + algorithmName + " has no service provider!");
 		}
 		return getRandomFunction(algorithm);
 	}
@@ -152,12 +157,11 @@ public final class CryptoServiceProviders {
 
 		return (RandomFunction) func;
 	}
-	
+
 	public static HashFunction getHashFunction(String algorithmName) {
 		CryptoAlgorithm algorithm = getAlgorithm(algorithmName);
 		if (algorithm == null) {
-			throw new CryptoException(
-					"Algorithm " + algorithmName + " has no service provider!");
+			throw new CryptoException("Algorithm " + algorithmName + " has no service provider!");
 		}
 		return getHashFunction(algorithm);
 	}
@@ -175,12 +179,11 @@ public final class CryptoServiceProviders {
 
 		return (HashFunction) func;
 	}
-	
+
 	public static AsymmetricEncryptionFunction getAsymmetricEncryptionFunction(String algorithmName) {
 		CryptoAlgorithm algorithm = getAlgorithm(algorithmName);
 		if (algorithm == null) {
-			throw new CryptoException(
-					"Algorithm " + algorithmName + " has no service provider!");
+			throw new CryptoException("Algorithm " + algorithmName + " has no service provider!");
 		}
 		return getAsymmetricEncryptionFunction(algorithm);
 	}
@@ -198,13 +201,11 @@ public final class CryptoServiceProviders {
 
 		return (AsymmetricEncryptionFunction) func;
 	}
-	
 
 	public static SignatureFunction getSignatureFunction(String algorithmName) {
 		CryptoAlgorithm algorithm = getAlgorithm(algorithmName);
 		if (algorithm == null) {
-			throw new CryptoException(
-					"Algorithm " + algorithmName + " has no service provider!");
+			throw new CryptoException("Algorithm " + algorithmName + " has no service provider!");
 		}
 		return getSignatureFunction(algorithm);
 	}
@@ -222,13 +223,11 @@ public final class CryptoServiceProviders {
 
 		return (SignatureFunction) func;
 	}
-	
 
 	public static SymmetricEncryptionFunction getSymmetricEncryptionFunction(String algorithmName) {
 		CryptoAlgorithm algorithm = getAlgorithm(algorithmName);
 		if (algorithm == null) {
-			throw new CryptoException(
-					"Algorithm " + algorithmName + " has no service provider!");
+			throw new CryptoException("Algorithm " + algorithmName + " has no service provider!");
 		}
 		return getSymmetricEncryptionFunction(algorithm);
 	}
@@ -246,13 +245,11 @@ public final class CryptoServiceProviders {
 
 		return (SymmetricEncryptionFunction) func;
 	}
-	
 
 	public static CryptoFunction getCryptoFunction(String algorithmName) {
 		CryptoAlgorithm algorithm = getAlgorithm(algorithmName);
 		if (algorithm == null) {
-			throw new CryptoException(
-					"Algorithm " + algorithmName + " has no service provider!");
+			throw new CryptoException("Algorithm " + algorithmName + " has no service provider!");
 		}
 		return getCryptoFunction(algorithm);
 	}

source/gateway/src/main/java/com/jd/blockchain/gateway/web/TxProcessingController.java

@@ -1,6 +1,5 @@
 package com.jd.blockchain.gateway.web;
 
-
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
@@ -9,7 +8,7 @@ import org.springframework.web.bind.annotation.ResponseBody;
 import org.springframework.web.bind.annotation.RestController;
 
 import com.jd.blockchain.binaryproto.BinaryEncodingUtils;
-import com.jd.blockchain.crypto.CryptoUtils;
+import com.jd.blockchain.crypto.CryptoServiceProviders;
 import com.jd.blockchain.crypto.asymmetric.SignatureFunction;
 import com.jd.blockchain.crypto.hash.HashDigest;
 import com.jd.blockchain.gateway.PeerService;
@@ -56,7 +55,8 @@ public class TxProcessingController implements TransactionService {
 			// 验证签名；
 			byte[] content = BinaryEncodingUtils.encode(txRequest.getTransactionContent(), TransactionContent.class);
 			for (DigitalSignature sign : partiSigns) {
-				SignatureFunction signFunc = CryptoUtils.sign(sign.getPubKey().getAlgorithm());
+				SignatureFunction signFunc = CryptoServiceProviders
+						.getSignatureFunction(sign.getPubKey().getAlgorithm());
 				if (!signFunc.verify(sign.getDigest(), sign.getPubKey(), content)) {
 					throw new BusinessException("The validation of participant signatures fail!");
 				}
@@ -67,4 +67,3 @@ public class TxProcessingController implements TransactionService {
 		return peerService.getTransactionService().process(txRequest);
 	}
 }
-

source/gateway/src/test/java/test/com/jd/blockchain/gateway/data/HashDigestJSONSerializeTest.java

@@ -3,13 +3,11 @@ package test.com.jd.blockchain.gateway.data;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 
-import java.util.Random;
-
 import org.junit.Test;
 
-import com.jd.blockchain.crypto.CryptoAlgorithm;
-import com.jd.blockchain.crypto.CryptoUtils;
+import com.jd.blockchain.crypto.CryptoServiceProviders;
 import com.jd.blockchain.crypto.hash.HashDigest;
+import com.jd.blockchain.crypto.hash.HashFunction;
 import com.jd.blockchain.utils.serialize.json.JSONSerializeUtils;
 
 public class HashDigestJSONSerializeTest {
@@ -43,11 +41,11 @@ public class HashDigestJSONSerializeTest {
 		JSONSerializeUtils.configSerialization(HashDigest.class, HashDigestSerializer.INSTANCE,
 				HashDigestDeserializer.INSTANCE);
 
-
-		HashDigest hash = new HashDigest(CryptoAlgorithm.SHA256, "jd-test".getBytes());
+		HashFunction hashFunc = CryptoServiceProviders.getHashFunction("SHA256");
+		HashDigest hash = hashFunc.hash("jd-test".getBytes());
 
 		String hashJson = JSONSerializeUtils.serializeToJSON(hash, true);
-		HashDigest hashDigest  = JSONSerializeUtils.deserializeFromJSON(hashJson, HashDigest.class);
+		HashDigest hashDigest = JSONSerializeUtils.deserializeFromJSON(hashJson, HashDigest.class);
 
 		assertArrayEquals(hash.getRawDigest(), hashDigest.getRawDigest());
 		assertEquals(hash.getAlgorithm(), hashDigest.getAlgorithm());
@@ -58,7 +56,7 @@ public class HashDigestJSONSerializeTest {
 
 		String json = JSONSerializeUtils.serializeToJSON(data, true);
 
-		TestData desData  = JSONSerializeUtils.deserializeFromJSON(json, TestData.class);
+		TestData desData = JSONSerializeUtils.deserializeFromJSON(json, TestData.class);
 		assertEquals(data.getHash(), desData.getHash());
 		assertEquals(data.getId(), desData.getId());
 	}

source/ledger/ledger-core/src/main/java/com/jd/blockchain/ledger/core/LedgerAdminAccount.java

@@ -5,15 +5,16 @@ import org.slf4j.LoggerFactory;
 
 import com.jd.blockchain.binaryproto.BinaryEncodingUtils;
 import com.jd.blockchain.binaryproto.DataContractRegistry;
-import com.jd.blockchain.crypto.CryptoUtils;
+import com.jd.blockchain.crypto.CryptoServiceProviders;
 import com.jd.blockchain.crypto.hash.HashDigest;
+import com.jd.blockchain.crypto.hash.HashFunction;
 import com.jd.blockchain.ledger.LedgerInitSetting;
 import com.jd.blockchain.ledger.ParticipantNode;
 import com.jd.blockchain.storage.service.ExPolicyKVStorage;
 import com.jd.blockchain.storage.service.ExPolicyKVStorage.ExPolicy;
+import com.jd.blockchain.storage.service.VersioningKVStorage;
 import com.jd.blockchain.utils.Bytes;
 import com.jd.blockchain.utils.Transactional;
-import com.jd.blockchain.storage.service.VersioningKVStorage;
 
 public class LedgerAdminAccount implements Transactional, LedgerAdministration {
 
@@ -94,9 +95,10 @@ public class LedgerAdminAccount implements Transactional, LedgerAdministration {
 		// 检查参与者列表是否已经按照 id 升序排列，并且 id 不冲突；
 		// 注：参与者的 id 要求从 0 开始编号，顺序依次递增，不允许跳空；
 		for (int i = 0; i < parties.length; i++) {
-//			if (parties[i].getAddress() != i) {
-//				throw new LedgerException("The id of participant isn't match the order of the participant list!");
-//			}
+			// if (parties[i].getAddress() != i) {
+			// throw new LedgerException("The id of participant isn't match the order of the
+			// participant list!");
+			// }
 		}
 
 		// 初始化元数据；
@@ -155,7 +157,8 @@ public class LedgerAdminAccount implements Transactional, LedgerAdministration {
 		// String key = encodeMetadataKey(base58Hash);
 		Bytes key = encodeMetadataKey(adminAccountHash);
 		byte[] bytes = settingsStorage.get(key);
-		if (!CryptoUtils.hashCrypto().verify(adminAccountHash, bytes)) {
+		HashFunction hashFunc = CryptoServiceProviders.getHashFunction(adminAccountHash.getAlgorithm());
+		if (!hashFunc.verify(adminAccountHash, bytes)) {
 			LOGGER.error("The hash verification of ledger settings fail! --[HASH=" + key + "]");
 			throw new LedgerException("The hash verification of ledger settings fail!");
 		}
@@ -216,18 +219,19 @@ public class LedgerAdminAccount implements Transactional, LedgerAdministration {
 		return participants.getParticipantCount();
 	}
 
-//	/*
-//	 * (non-Javadoc)
-//	 * 
-//	 * @see
-//	 * com.jd.blockchain.ledger.core.LedgerAdministration#getParticipant(java.lang.
-//	 * String)
-//	 */
-//	@Override
-//	public ParticipantNode getParticipant(int id) {
-//		return participants.getParticipant(id);
-//	}
-	
+	// /*
+	// * (non-Javadoc)
+	// *
+	// * @see
+	// *
+	// com.jd.blockchain.ledger.core.LedgerAdministration#getParticipant(java.lang.
+	// * String)
+	// */
+	// @Override
+	// public ParticipantNode getParticipant(int id) {
+	// return participants.getParticipant(id);
+	// }
+
 	@Override
 	public ParticipantNode[] getParticipants() {
 		return participants.getParticipants();
@@ -258,8 +262,9 @@ public class LedgerAdminAccount implements Transactional, LedgerAdministration {
 
 		// 基于之前的密码配置来计算元数据的哈希；
 		byte[] metadataBytes = serializeMetadata(metadata);
-		HashDigest metadataHash = CryptoUtils.hashCrypto()
-				.getFunction(previousSetting.getCryptoSetting().getHashAlgorithm()).hash(metadataBytes);
+		HashFunction hashFunc = CryptoServiceProviders
+				.getHashFunction(previousSetting.getCryptoSetting().getHashAlgorithm());
+		HashDigest metadataHash = hashFunc.hash(metadataBytes);
 		if (adminAccountHash == null || !adminAccountHash.equals(metadataHash)) {
 			// update modify;
 			// String base58MetadataHash = metadataHash.toBase58();

source/ledger/ledger-core/src/main/java/com/jd/blockchain/ledger/core/impl/LedgerRepositoryImpl.java

@@ -1,8 +1,10 @@
 package com.jd.blockchain.ledger.core.impl;
 
 import com.jd.blockchain.binaryproto.BinaryEncodingUtils;
+import com.jd.blockchain.crypto.CryptoServiceProviders;
 import com.jd.blockchain.crypto.CryptoUtils;
 import com.jd.blockchain.crypto.hash.HashDigest;
+import com.jd.blockchain.crypto.hash.HashFunction;
 import com.jd.blockchain.ledger.BlockBody;
 import com.jd.blockchain.ledger.CryptoSetting;
 import com.jd.blockchain.ledger.LedgerBlock;
@@ -230,7 +232,8 @@ public class LedgerRepositoryImpl implements LedgerRepository {
 			} else {
 				blockBodyBytes = BinaryEncodingUtils.encode(block, BlockBody.class);
 			}
-			boolean pass = CryptoUtils.hashCrypto().verify(blockHash, blockBodyBytes);
+			HashFunction hashFunc = CryptoServiceProviders.getHashFunction(blockHash.getAlgorithm());
+			boolean pass = hashFunc.verify(blockHash, blockBodyBytes);
 			if (!pass) {
 				throw new LedgerException("Block hash verification fail!");
 			}

source/ledger/ledger-core/src/main/java/com/jd/blockchain/ledger/core/impl/LedgerTransactionalEditor.java

@@ -3,7 +3,7 @@ package com.jd.blockchain.ledger.core.impl;
 import java.util.Stack;
 
 import com.jd.blockchain.binaryproto.BinaryEncodingUtils;
-import com.jd.blockchain.crypto.CryptoUtils;
+import com.jd.blockchain.crypto.CryptoServiceProviders;
 import com.jd.blockchain.crypto.hash.HashDigest;
 import com.jd.blockchain.ledger.BlockBody;
 import com.jd.blockchain.ledger.CryptoSetting;
@@ -189,7 +189,7 @@ public class LedgerTransactionalEditor implements LedgerEditor {
 
 		// compute block hash;
 		byte[] blockBodyBytes = BinaryEncodingUtils.encode(newlyBlock, BlockBody.class);
-		HashDigest blockHash = CryptoUtils.hashCrypto().getFunction(cryptoSetting.getHashAlgorithm())
+		HashDigest blockHash = CryptoServiceProviders.getHashFunction(cryptoSetting.getHashAlgorithm())
 				.hash(blockBodyBytes);
 		newlyBlock.setHash(blockHash);
 		if (newlyBlock.getLedgerHash() == null) {

source/ledger/ledger-core/src/test/java/test/com/jd/blockchain/ledger/LedgerEditerTest.java

@@ -9,9 +9,7 @@ import org.junit.Test;
 
 import com.jd.blockchain.binaryproto.DataContractRegistry;
 import com.jd.blockchain.crypto.AddressEncoding;
-import com.jd.blockchain.crypto.CryptoAlgorithm;
-import com.jd.blockchain.crypto.CryptoUtils;
-import com.jd.blockchain.crypto.asymmetric.AsymmetricCryptography;
+import com.jd.blockchain.crypto.CryptoServiceProviders;
 import com.jd.blockchain.crypto.asymmetric.CryptoKeyPair;
 import com.jd.blockchain.crypto.asymmetric.SignatureFunction;
 import com.jd.blockchain.crypto.service.classic.ClassicCryptoService;
@@ -44,9 +42,7 @@ public class LedgerEditerTest {
 	}
 
 	String ledgerKeyPrefix = "LDG://";
-	AsymmetricCryptography asymmetricCryptography = CryptoUtils.asymmCrypto();
-	SignatureFunction signatureFunction = asymmetricCryptography
-			.getSignatureFunction(ClassicCryptoService.ED25519_ALGORITHM);
+	SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction("ED25519");
 
 	// 存储；
 	MemoryKVStorage storage = new MemoryKVStorage();
@@ -111,6 +107,8 @@ public class LedgerEditerTest {
 	}
 
 	private LedgerInitSetting createLedgerInitSetting() {
+		SignatureFunction signFunc = CryptoServiceProviders.getSignatureFunction("ED25519");
+		
 		CryptoConfig defCryptoSetting = new CryptoConfig();
 		defCryptoSetting.setAutoVerifyHash(true);
 		defCryptoSetting.setHashAlgorithm(ClassicCryptoService.SHA256_ALGORITHM);
@@ -123,7 +121,7 @@ public class LedgerEditerTest {
 		parties[0] = new ConsensusParticipantData();
 		parties[0].setId(0);
 		parties[0].setName("John");
-		CryptoKeyPair kp0 = CryptoUtils.sign(ClassicCryptoService.ED25519_ALGORITHM).generateKeyPair();
+		CryptoKeyPair kp0 = signFunc.generateKeyPair();
 		parties[0].setPubKey(kp0.getPubKey());
 		parties[0].setAddress(AddressEncoding.generateAddress(kp0.getPubKey()).toBase58());
 		parties[0].setHostAddress(new NetworkAddress("192.168.1.6", 9000));
@@ -131,7 +129,7 @@ public class LedgerEditerTest {
 		parties[1] = new ConsensusParticipantData();
 		parties[1].setId(1);
 		parties[1].setName("John");
-		CryptoKeyPair kp1 = CryptoUtils.sign(ClassicCryptoService.ED25519_ALGORITHM).generateKeyPair();
+		CryptoKeyPair kp1 = signFunc.generateKeyPair();
 		parties[1].setPubKey(kp1.getPubKey());
 		parties[1].setAddress(AddressEncoding.generateAddress(kp1.getPubKey()).toBase58());
 		parties[1].setHostAddress(new NetworkAddress("192.168.1.7", 9000));

source/ledger/ledger-core/src/test/java/test/com/jd/blockchain/ledger/LedgerManagerTest.java

@@ -4,19 +4,14 @@ import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import org.bouncycastle.util.io.Streams;
+import org.junit.Before;
 import org.junit.Test;
 
 import com.jd.blockchain.binaryproto.DataContractRegistry;
 import com.jd.blockchain.crypto.AddressEncoding;
-import com.jd.blockchain.crypto.CryptoAlgorithm;
-import com.jd.blockchain.crypto.CryptoUtils;
+import com.jd.blockchain.crypto.CryptoServiceProviders;
 import com.jd.blockchain.crypto.asymmetric.CryptoKeyPair;
 import com.jd.blockchain.crypto.asymmetric.SignatureFunction;
 import com.jd.blockchain.crypto.hash.HashDigest;
@@ -53,7 +48,7 @@ import com.jd.blockchain.utils.io.BytesUtils;
 import com.jd.blockchain.utils.net.NetworkAddress;
 
 public class LedgerManagerTest {
-	
+
 	static {
 		DataContractRegistry.register(TransactionContent.class);
 		DataContractRegistry.register(UserRegisterOperation.class);
@@ -61,7 +56,12 @@ public class LedgerManagerTest {
 		DataContractRegistry.register(BlockBody.class);
 	}
 
-	private static SignatureFunction signatureFunction = CryptoUtils.sign(ClassicCryptoService.ED25519_ALGORITHM);
+	private SignatureFunction signatureFunction;
+
+	@Before
+	public void intialize() {
+		signatureFunction = CryptoServiceProviders.getSignatureFunction("ED25519");
+	}
 
 	@Test
 	public void testLedgerInit() {
@@ -81,11 +81,12 @@ public class LedgerManagerTest {
 		// 记录交易，注册用户；
 		LedgerTransactionContext txCtx = ldgEdt.newTransaction(genesisTxReq);
 		LedgerDataSet ldgDS = txCtx.getDataSet();
-		BlockchainKeyPair userKP = BlockchainKeyGenerator.getInstance().generate();;
+		BlockchainKeyPair userKP = BlockchainKeyGenerator.getInstance().generate();
+		;
 		UserAccount userAccount = ldgDS.getUserAccountSet().register(userKP.getAddress(), userKP.getPubKey());
 		userAccount.setProperty("Name", "孙悟空", -1);
 		userAccount.setProperty("Age", "10000", -1);
-		
+
 		System.out.println("UserAddress=" + userAccount.getAddress());
 
 		// 提交交易结果；
@@ -105,63 +106,62 @@ public class LedgerManagerTest {
 
 		// 提交数据，写入存储；
 		ldgEdt.commit();
-		
-		//重新加载并校验结果；
+
+		// 重新加载并校验结果；
 		LedgerManager reloadLedgerManager = new LedgerManager();
 		LedgerRepository reloadLedgerRepo = reloadLedgerManager.register(ledgerHash, storage);
-		
-		HashDigest genesisHash= reloadLedgerRepo.getBlockHash(0);
+
+		HashDigest genesisHash = reloadLedgerRepo.getBlockHash(0);
 		assertEquals(ledgerHash, genesisHash);
-		
+
 		LedgerBlock latestBlock = reloadLedgerRepo.getLatestBlock();
 		assertEquals(0, latestBlock.getHeight());
 		assertEquals(ledgerHash, latestBlock.getHash());
 		assertEquals(ledgerHash, latestBlock.getLedgerHash());
-		
+
 		LedgerEditor editor1 = reloadLedgerRepo.createNextBlock();
-		
+
 		TxBuilder txBuilder = new TxBuilder(ledgerHash);
 		BlockchainKeyPair dataKey = BlockchainKeyGenerator.getInstance().generate();
 		txBuilder.dataAccounts().register(dataKey.getIdentity());
 		TransactionRequestBuilder txReqBuilder = txBuilder.prepareRequest();
 		DigitalSignature dgtsign = txReqBuilder.signAsEndpoint(userKP);
 		TransactionRequest txRequest = txReqBuilder.buildRequest();
-		
+
 		LedgerTransactionContext txCtx1 = editor1.newTransaction(txRequest);
 		txCtx1.getDataSet().getDataAccountSet().register(dataKey.getAddress(), dataKey.getPubKey(), null);
 		txCtx1.commit(TransactionState.SUCCESS);
-		
+
 		LedgerBlock block1 = editor1.prepare();
 		editor1.commit();
 		assertEquals(1, block1.getHeight());
 		assertNotNull(block1.getHash());
 		assertEquals(genesisHash, block1.getPreviousHash());
 		assertEquals(ledgerHash, block1.getLedgerHash());
-		
+
 		latestBlock = reloadLedgerRepo.getLatestBlock();
 		assertEquals(1, latestBlock.getHeight());
 		assertEquals(block1.getHash(), latestBlock.getHash());
-		
+
 		showStorageKeys(storage);
-		
+
 		reloadLedgerManager = new LedgerManager();
 		reloadLedgerRepo = reloadLedgerManager.register(ledgerHash, storage);
 		latestBlock = reloadLedgerRepo.getLatestBlock();
 		assertEquals(1, latestBlock.getHeight());
 		assertEquals(block1.getHash(), latestBlock.getHash());
-		
+
 		DataAccountSet dataAccountSet = reloadLedgerRepo.getDataAccountSet(latestBlock);
 		UserAccountSet userAccountSet = reloadLedgerRepo.getUserAccountSet(latestBlock);
 		ContractAccountSet contractAccountSet = reloadLedgerRepo.getContractAccountSet(latestBlock);
 
 	}
 
-
-
 	private void showStorageKeys(MemoryKVStorage storage) {
 		// 输出写入的 kv；
 		System.out.println("------------------- Storage Keys -------------------");
-		Object[] keys = Stream.of(storage.getStorageKeySet().toArray(new Bytes[0])).map(p -> p.toString()).sorted((o1, o2) -> o1.compareTo(o2)).toArray();
+		Object[] keys = Stream.of(storage.getStorageKeySet().toArray(new Bytes[0])).map(p -> p.toString())
+				.sorted((o1, o2) -> o1.compareTo(o2)).toArray();
 		int i = 0;
 		for (Object k : keys) {
 			i++;
@@ -169,7 +169,6 @@ public class LedgerManagerTest {
 		}
 	}
 
-
 	private LedgerInitSetting createLedgerInitSetting() {
 		CryptoConfig defCryptoSetting = new CryptoConfig();
 		defCryptoSetting.setAutoVerifyHash(true);
@@ -183,7 +182,7 @@ public class LedgerManagerTest {
 		parties[0] = new ConsensusParticipantData();
 		parties[0].setId(0);
 		parties[0].setName("John");
-		CryptoKeyPair kp0 = CryptoUtils.sign(ClassicCryptoService.ED25519_ALGORITHM).generateKeyPair();
+		CryptoKeyPair kp0 = signatureFunction.generateKeyPair();
 		parties[0].setPubKey(kp0.getPubKey());
 		parties[0].setAddress(AddressEncoding.generateAddress(kp0.getPubKey()).toBase58());
 		parties[0].setHostAddress(new NetworkAddress("127.0.0.1", 9000));
@@ -191,7 +190,7 @@ public class LedgerManagerTest {
 		parties[1] = new ConsensusParticipantData();
 		parties[1].setId(1);
 		parties[1].setName("Mary");
-		CryptoKeyPair kp1 = CryptoUtils.sign(ClassicCryptoService.ED25519_ALGORITHM).generateKeyPair();
+		CryptoKeyPair kp1 = signatureFunction.generateKeyPair();
 		parties[1].setPubKey(kp1.getPubKey());
 		parties[1].setAddress(AddressEncoding.generateAddress(kp1.getPubKey()).toBase58());
 		parties[1].setHostAddress(new NetworkAddress("127.0.0.1", 9010));
@@ -199,7 +198,7 @@ public class LedgerManagerTest {
 		parties[2] = new ConsensusParticipantData();
 		parties[2].setId(2);
 		parties[2].setName("Jerry");
-		CryptoKeyPair kp2 = CryptoUtils.sign(ClassicCryptoService.ED25519_ALGORITHM).generateKeyPair();
+		CryptoKeyPair kp2 = signatureFunction.generateKeyPair();
 		parties[2].setPubKey(kp2.getPubKey());
 		parties[2].setAddress(AddressEncoding.generateAddress(kp2.getPubKey()).toBase58());
 		parties[2].setHostAddress(new NetworkAddress("127.0.0.1", 9020));
@@ -207,7 +206,7 @@ public class LedgerManagerTest {
 		parties[3] = new ConsensusParticipantData();
 		parties[3].setId(3);
 		parties[3].setName("Tom");
-		CryptoKeyPair kp3 = CryptoUtils.sign(ClassicCryptoService.ED25519_ALGORITHM).generateKeyPair();
+		CryptoKeyPair kp3 = signatureFunction.generateKeyPair();
 		parties[3].setPubKey(kp3.getPubKey());
 		parties[3].setAddress(AddressEncoding.generateAddress(kp3.getPubKey()).toBase58());
 		parties[3].setHostAddress(new NetworkAddress("127.0.0.1", 9030));
@@ -216,6 +215,6 @@ public class LedgerManagerTest {
 
 		return initSetting;
 	}
-	
-//	
+
+	//
 }

source/ledger/ledger-core/src/test/java/test/com/jd/blockchain/ledger/LedgerTestUtils.java

@@ -2,14 +2,17 @@ package test.com.jd.blockchain.ledger;
 
 import java.util.Random;
 
-import com.jd.blockchain.crypto.CryptoAlgorithm;
-import com.jd.blockchain.crypto.CryptoUtils;
+import com.jd.blockchain.crypto.CryptoServiceProviders;
 import com.jd.blockchain.crypto.PubKey;
 import com.jd.blockchain.crypto.asymmetric.CryptoKeyPair;
 import com.jd.blockchain.crypto.asymmetric.SignatureFunction;
 import com.jd.blockchain.crypto.hash.HashDigest;
 import com.jd.blockchain.crypto.service.classic.ClassicCryptoService;
-import com.jd.blockchain.ledger.*;
+import com.jd.blockchain.ledger.BlockchainIdentityData;
+import com.jd.blockchain.ledger.CryptoSetting;
+import com.jd.blockchain.ledger.PreparedTransaction;
+import com.jd.blockchain.ledger.TransactionRequest;
+import com.jd.blockchain.ledger.TransactionResponse;
 import com.jd.blockchain.ledger.core.CryptoConfig;
 import com.jd.blockchain.ledger.core.impl.TransactionStagedSnapshot;
 import com.jd.blockchain.ledger.data.TransactionService;
@@ -20,12 +23,12 @@ public class LedgerTestUtils {
 	// private static ThreadLocalRandom rand = ThreadLocalRandom.current();
 
 	private static Random rand = new Random();
-	
-	
+
 	public static TransactionRequest createTxRequest(HashDigest ledgerHash) {
-		return createTxRequest(ledgerHash, CryptoUtils.sign(ClassicCryptoService.ED25519_ALGORITHM));
+		SignatureFunction signFunc = CryptoServiceProviders.getSignatureFunction("ED25519");
+		return createTxRequest(ledgerHash, signFunc);
 	}
-	
+
 	public static TransactionRequest createTxRequest(HashDigest ledgerHash, SignatureFunction signatureFunction) {
 		TxHandle txHandle = new TxHandle();
 
@@ -65,21 +68,19 @@ public class LedgerTestUtils {
 		txDataSnapshot.setUserAccountSetHash(generateRandomHash());
 		return txDataSnapshot;
 	}
-	
+
 	public static HashDigest generateRandomHash() {
 		byte[] data = new byte[64];
 		rand.nextBytes(data);
-		return CryptoUtils.hash(ClassicCryptoService.SHA256_ALGORITHM).hash(data);
+		return CryptoServiceProviders.getHashFunction("SHA256").hash(data);
 	}
-	
-	
+
 	public static CryptoSetting createDefaultCryptoSetting() {
 		CryptoConfig cryptoSetting = new CryptoConfig();
 		cryptoSetting.setAutoVerifyHash(true);
 		cryptoSetting.setHashAlgorithm(ClassicCryptoService.SHA256_ALGORITHM);
 		return cryptoSetting;
 	}
-	
 
 	private static class TxHandle implements TransactionService {
 

source/ledger/ledger-core/src/test/java/test/com/jd/blockchain/ledger/LedgerTransactionDataTest.java

@@ -17,8 +17,7 @@ import org.junit.Test;
 
 import com.jd.blockchain.binaryproto.BinaryEncodingUtils;
 import com.jd.blockchain.binaryproto.DataContractRegistry;
-import com.jd.blockchain.crypto.CryptoAlgorithm;
-import com.jd.blockchain.crypto.CryptoUtils;
+import com.jd.blockchain.crypto.CryptoServiceProviders;
 import com.jd.blockchain.crypto.PubKey;
 import com.jd.blockchain.crypto.asymmetric.SignatureDigest;
 import com.jd.blockchain.crypto.hash.HashDigest;
@@ -53,209 +52,217 @@ import com.jd.blockchain.utils.io.ByteArray;
 
 public class LedgerTransactionDataTest {
 
-    private LedgerTransactionData data;
-
-    @Before
-    public void initLedgerTransactionImpl() throws Exception {
-        DataContractRegistry.register(LedgerTransaction.class);
-        DataContractRegistry.register(Transaction.class);
-        DataContractRegistry.register(LedgerDataSnapshot.class);
-        DataContractRegistry.register(NodeRequest.class);
-        DataContractRegistry.register(EndpointRequest.class);
-        DataContractRegistry.register(HashObject.class);
-        DataContractRegistry.register(DataAccountKVSetOperation.class);
-
-        TransactionRequest txRequestMessage = initTxRequestMessage();
-
-        long blockHeight = 9986L;
-        data = new LedgerTransactionData(blockHeight, txRequestMessage, TransactionState.SUCCESS, initTransactionStagedSnapshot());
-
-        HashDigest hash = new HashDigest(ClassicCryptoService.SHA256_ALGORITHM, "zhangsan".getBytes());
-        HashDigest adminAccountHash = new HashDigest(ClassicCryptoService.SHA256_ALGORITHM, "lisi".getBytes());
-        HashDigest userAccountSetHash = new HashDigest(ClassicCryptoService.SHA256_ALGORITHM, "wangwu".getBytes());
-        HashDigest dataAccountSetHash = new HashDigest(ClassicCryptoService.SHA256_ALGORITHM, "zhaoliu".getBytes());
-        HashDigest contractAccountSetHash = new HashDigest(ClassicCryptoService.SHA256_ALGORITHM, "sunqi".getBytes());
-
-        data.setHash(hash);
-//        data.setBlockHeight(blockHeight);
-        data.setAdminAccountHash(adminAccountHash);
-        data.setUserAccountSetHash(userAccountSetHash);
-        data.setDataAccountSetHash(dataAccountSetHash);
-        data.setContractAccountSetHash(contractAccountSetHash);
-    }
-
-
-    @Test
-    public void testSerialize_LedgerTransaction() throws Exception {
-        byte[] serialBytes = BinaryEncodingUtils.encode(data, LedgerTransaction.class);
-        LedgerTransaction resolvedData = BinaryEncodingUtils.decode(serialBytes);
-
-        System.out.println("------Assert start ------");
-        assertEquals(resolvedData.getAdminAccountHash(), data.getAdminAccountHash());
-        assertEquals(resolvedData.getContractAccountSetHash(), data.getContractAccountSetHash());
-        assertEquals(resolvedData.getDataAccountSetHash(), data.getDataAccountSetHash());
-        assertEquals(resolvedData.getUserAccountSetHash(), data.getUserAccountSetHash());
-        assertEquals(resolvedData.getExecutionState(), data.getExecutionState());
-        assertEquals(resolvedData.getHash(), data.getHash());
-        assertEquals(resolvedData.getBlockHeight(), data.getBlockHeight());
-
-        // EndpointSignatures 验证
-        DigitalSignature[] dataEndpointSignatures = data.getEndpointSignatures();
-        DigitalSignature[] resolvedEndpointSignatures = resolvedData.getEndpointSignatures();
-        for (int i = 0; i < dataEndpointSignatures.length; i++) {
-            assertEquals(dataEndpointSignatures[i].getPubKey(), resolvedEndpointSignatures[i].getPubKey());
-            assertEquals(dataEndpointSignatures[i].getDigest(), resolvedEndpointSignatures[i].getDigest());
-        }
-
-        // NodeSignatures 验证
-        DigitalSignature[] dataNodeSignatures = data.getNodeSignatures();
-        DigitalSignature[] resolvedNodeSignatures = resolvedData.getNodeSignatures();
-        for (int i = 0; i < dataNodeSignatures.length; i++) {
-            assertEquals(dataNodeSignatures[i].getPubKey(), resolvedNodeSignatures[i].getPubKey());
-            assertEquals(dataNodeSignatures[i].getDigest(), resolvedNodeSignatures[i].getDigest());
-        }
-
-        assertEqual(data.getTransactionContent(), resolvedData.getTransactionContent());
-        System.out.println("------Assert OK ------");
-    }
-
-    @Test
-    public void testSerialize_Transaction() throws Exception {
-        byte[] serialBytes = BinaryEncodingUtils.encode(data, Transaction.class);
-        Transaction resolvedData = BinaryEncodingUtils.decode(serialBytes);
-
-        System.out.println("------Assert start ------");
-        assertEquals(resolvedData.getExecutionState(), data.getExecutionState());
-        assertEquals(resolvedData.getHash(), data.getHash());
-        assertEquals(resolvedData.getBlockHeight(), data.getBlockHeight());
-
-        // EndpointSignatures 验证
-        DigitalSignature[] dataEndpointSignatures = data.getEndpointSignatures();
-        DigitalSignature[] resolvedEndpointSignatures = resolvedData.getEndpointSignatures();
-        for (int i = 0; i < dataEndpointSignatures.length; i++) {
-            assertEquals(dataEndpointSignatures[i].getPubKey(), resolvedEndpointSignatures[i].getPubKey());
-            assertEquals(dataEndpointSignatures[i].getDigest(), resolvedEndpointSignatures[i].getDigest());
-        }
-
-        // NodeSignatures 验证
-        DigitalSignature[] dataNodeSignatures = data.getNodeSignatures();
-        DigitalSignature[] resolvedNodeSignatures = resolvedData.getNodeSignatures();
-        for (int i = 0; i < dataNodeSignatures.length; i++) {
-            assertEquals(dataNodeSignatures[i].getPubKey(), resolvedNodeSignatures[i].getPubKey());
-            assertEquals(dataNodeSignatures[i].getDigest(), resolvedNodeSignatures[i].getDigest());
-        }
-
-        assertEqual(data.getTransactionContent(), resolvedData.getTransactionContent());
-        System.out.println("------Assert OK ------");
-    }
-
-    @Test
-    public void testSerialize_LedgerDataSnapshot() throws Exception {
-        byte[] serialBytes = BinaryEncodingUtils.encode(data, LedgerDataSnapshot.class);
-        LedgerDataSnapshot resolvedData = BinaryEncodingUtils.decode(serialBytes);
-
-        System.out.println("------Assert start ------");
-        assertEquals(resolvedData.getAdminAccountHash(), data.getAdminAccountHash());
-        assertEquals(resolvedData.getContractAccountSetHash(), data.getContractAccountSetHash());
-        assertEquals(resolvedData.getDataAccountSetHash(), data.getDataAccountSetHash());
-        assertEquals(resolvedData.getUserAccountSetHash(), data.getUserAccountSetHash());
-        System.out.println("------Assert OK ------");
-    }
-
-    @Test
-    public void testSerialize_NodeRequest() throws Exception {
-        byte[] serialBytes = BinaryEncodingUtils.encode(data, NodeRequest.class);
-        NodeRequest resolvedData = BinaryEncodingUtils.decode(serialBytes);
-
-        System.out.println("------Assert start ------");
-        // EndpointSignatures 验证
-        DigitalSignature[] dataEndpointSignatures = data.getEndpointSignatures();
-        DigitalSignature[] resolvedEndpointSignatures = resolvedData.getEndpointSignatures();
-        for (int i = 0; i < dataEndpointSignatures.length; i++) {
-            assertEquals(dataEndpointSignatures[i].getPubKey(), resolvedEndpointSignatures[i].getPubKey());
-            assertEquals(dataEndpointSignatures[i].getDigest(), resolvedEndpointSignatures[i].getDigest());
-        }
-
-        // NodeSignatures 验证
-        DigitalSignature[] dataNodeSignatures = data.getNodeSignatures();
-        DigitalSignature[] resolvedNodeSignatures = resolvedData.getNodeSignatures();
-        for (int i = 0; i < dataNodeSignatures.length; i++) {
-            assertEquals(dataNodeSignatures[i].getPubKey(), resolvedNodeSignatures[i].getPubKey());
-            assertEquals(dataNodeSignatures[i].getDigest(), resolvedNodeSignatures[i].getDigest());
-        }
-
-        assertEqual(data.getTransactionContent(), resolvedData.getTransactionContent());
-        System.out.println("------Assert OK ------");
-    }
-
-    @Test
-    public void testSerialize_EndpointRequest() throws Exception {
-        byte[] serialBytes = BinaryEncodingUtils.encode(data, EndpointRequest.class);
-        EndpointRequest resolvedData = BinaryEncodingUtils.decode(serialBytes);
-
-        System.out.println("------Assert start ------");
-        // EndpointSignatures 验证
-        DigitalSignature[] dataEndpointSignatures = data.getEndpointSignatures();
-        DigitalSignature[] resolvedEndpointSignatures = resolvedData.getEndpointSignatures();
-        for (int i = 0; i < dataEndpointSignatures.length; i++) {
-            assertEquals(dataEndpointSignatures[i].getPubKey(), resolvedEndpointSignatures[i].getPubKey());
-            assertEquals(dataEndpointSignatures[i].getDigest(), resolvedEndpointSignatures[i].getDigest());
-        }
-        assertEqual(data.getTransactionContent(), resolvedData.getTransactionContent());
-        System.out.println("------Assert OK ------");
-    }
-
-    private void assertEqual(TransactionContent dataTxContent, TransactionContent resolvedTxContent) {
-        assertEquals(dataTxContent.getHash(), resolvedTxContent.getHash());
-        assertEquals(dataTxContent.getLedgerHash(), resolvedTxContent.getLedgerHash());
-//        assertEquals(dataTxContent.getSequenceNumber(), resolvedTxContent.getSequenceNumber());
-//        assertEquals(dataTxContent.getSubjectAccount(), resolvedTxContent.getSubjectAccount());
-    }
-
-    private TransactionStagedSnapshot initTransactionStagedSnapshot() {
-        TransactionStagedSnapshot transactionStagedSnapshot = new TransactionStagedSnapshot();
-        transactionStagedSnapshot.setAdminAccountHash(new HashDigest(ClassicCryptoService.SHA256_ALGORITHM, "zhangsan".getBytes()));
-        transactionStagedSnapshot.setContractAccountSetHash(new HashDigest(ClassicCryptoService.SHA256_ALGORITHM, "lisi".getBytes()));
-        transactionStagedSnapshot.setDataAccountSetHash(new HashDigest(ClassicCryptoService.SHA256_ALGORITHM, "wangwu".getBytes()));
-        transactionStagedSnapshot.setUserAccountSetHash(new HashDigest(ClassicCryptoService.SHA256_ALGORITHM, "zhaoliu".getBytes()));
-        return transactionStagedSnapshot;
-    }
-
-    private TxRequestMessage initTxRequestMessage() throws Exception {
-        TxRequestMessage txRequestMessage = new TxRequestMessage(initTransactionContent());
-
-        SignatureDigest digest1 = new SignatureDigest(ClassicCryptoService.ED25519_ALGORITHM, "zhangsan".getBytes());
-        SignatureDigest digest2 = new SignatureDigest(ClassicCryptoService.ED25519_ALGORITHM, "lisi".getBytes());
-        DigitalSignatureBlob endPoint1 = new DigitalSignatureBlob(new PubKey(ClassicCryptoService.ED25519_ALGORITHM, "jd1.com".getBytes())
-                , digest1);
-        DigitalSignatureBlob endPoint2 = new DigitalSignatureBlob(new PubKey(ClassicCryptoService.ED25519_ALGORITHM, "jd2.com".getBytes())
-                , digest2);
-        txRequestMessage.addEndpointSignatures(endPoint1);
-        txRequestMessage.addEndpointSignatures(endPoint2);
-
-        SignatureDigest digest3 = new SignatureDigest(ClassicCryptoService.ED25519_ALGORITHM, "wangwu".getBytes());
-        SignatureDigest digest4 = new SignatureDigest(ClassicCryptoService.ED25519_ALGORITHM, "zhaoliu".getBytes());
-        DigitalSignatureBlob node1 = new DigitalSignatureBlob(new PubKey(ClassicCryptoService.ED25519_ALGORITHM, "jd3.com".getBytes())
-                , digest3);
-        DigitalSignatureBlob node2 = new DigitalSignatureBlob(new PubKey(ClassicCryptoService.ED25519_ALGORITHM, "jd4.com".getBytes())
-                , digest4);
-        txRequestMessage.addNodeSignatures(node1);
-        txRequestMessage.addNodeSignatures(node2);
-
-        return txRequestMessage;
-    }
-
-    private TransactionContent initTransactionContent() throws Exception{
-        TxContentBlob contentBlob = null;
-        BlockchainKeyPair id = BlockchainKeyGenerator.getInstance().generate(ClassicCryptoService.ED25519_ALGORITHM);
-        HashDigest ledgerHash = CryptoUtils.hash(ClassicCryptoService.SHA256_ALGORITHM).hash(UUID.randomUUID().toString().getBytes("UTF-8"));
-        BlockchainOperationFactory opFactory = new BlockchainOperationFactory();
-        contentBlob = new TxContentBlob(ledgerHash);
-        contentBlob.setHash(new HashDigest(ClassicCryptoService.SHA256_ALGORITHM, "jd.com".getBytes()));
-//        contentBlob.setSubjectAccount(id.getAddress());
-//        contentBlob.setSequenceNumber(1);
-        DataAccountKVSetOperation kvsetOP = opFactory.dataAccount(id.getAddress()).set("Name", ByteArray.fromString("AAA", "UTF-8"), -1).getOperation();
-        contentBlob.addOperation(kvsetOP);
-        return contentBlob;
-    }
+	private LedgerTransactionData data;
+
+	@Before
+	public void initLedgerTransactionImpl() throws Exception {
+		DataContractRegistry.register(LedgerTransaction.class);
+		DataContractRegistry.register(Transaction.class);
+		DataContractRegistry.register(LedgerDataSnapshot.class);
+		DataContractRegistry.register(NodeRequest.class);
+		DataContractRegistry.register(EndpointRequest.class);
+		DataContractRegistry.register(HashObject.class);
+		DataContractRegistry.register(DataAccountKVSetOperation.class);
+
+		TransactionRequest txRequestMessage = initTxRequestMessage();
+
+		long blockHeight = 9986L;
+		data = new LedgerTransactionData(blockHeight, txRequestMessage, TransactionState.SUCCESS,
+				initTransactionStagedSnapshot());
+
+		HashDigest hash = new HashDigest(ClassicCryptoService.SHA256_ALGORITHM, "zhangsan".getBytes());
+		HashDigest adminAccountHash = new HashDigest(ClassicCryptoService.SHA256_ALGORITHM, "lisi".getBytes());
+		HashDigest userAccountSetHash = new HashDigest(ClassicCryptoService.SHA256_ALGORITHM, "wangwu".getBytes());
+		HashDigest dataAccountSetHash = new HashDigest(ClassicCryptoService.SHA256_ALGORITHM, "zhaoliu".getBytes());
+		HashDigest contractAccountSetHash = new HashDigest(ClassicCryptoService.SHA256_ALGORITHM, "sunqi".getBytes());
+
+		data.setHash(hash);
+		// data.setBlockHeight(blockHeight);
+		data.setAdminAccountHash(adminAccountHash);
+		data.setUserAccountSetHash(userAccountSetHash);
+		data.setDataAccountSetHash(dataAccountSetHash);
+		data.setContractAccountSetHash(contractAccountSetHash);
+	}
+
+	@Test
+	public void testSerialize_LedgerTransaction() throws Exception {
+		byte[] serialBytes = BinaryEncodingUtils.encode(data, LedgerTransaction.class);
+		LedgerTransaction resolvedData = BinaryEncodingUtils.decode(serialBytes);
+
+		System.out.println("------Assert start ------");
+		assertEquals(resolvedData.getAdminAccountHash(), data.getAdminAccountHash());
+		assertEquals(resolvedData.getContractAccountSetHash(), data.getContractAccountSetHash());
+		assertEquals(resolvedData.getDataAccountSetHash(), data.getDataAccountSetHash());
+		assertEquals(resolvedData.getUserAccountSetHash(), data.getUserAccountSetHash());
+		assertEquals(resolvedData.getExecutionState(), data.getExecutionState());
+		assertEquals(resolvedData.getHash(), data.getHash());
+		assertEquals(resolvedData.getBlockHeight(), data.getBlockHeight());
+
+		// EndpointSignatures 验证
+		DigitalSignature[] dataEndpointSignatures = data.getEndpointSignatures();
+		DigitalSignature[] resolvedEndpointSignatures = resolvedData.getEndpointSignatures();
+		for (int i = 0; i < dataEndpointSignatures.length; i++) {
+			assertEquals(dataEndpointSignatures[i].getPubKey(), resolvedEndpointSignatures[i].getPubKey());
+			assertEquals(dataEndpointSignatures[i].getDigest(), resolvedEndpointSignatures[i].getDigest());
+		}
+
+		// NodeSignatures 验证
+		DigitalSignature[] dataNodeSignatures = data.getNodeSignatures();
+		DigitalSignature[] resolvedNodeSignatures = resolvedData.getNodeSignatures();
+		for (int i = 0; i < dataNodeSignatures.length; i++) {
+			assertEquals(dataNodeSignatures[i].getPubKey(), resolvedNodeSignatures[i].getPubKey());
+			assertEquals(dataNodeSignatures[i].getDigest(), resolvedNodeSignatures[i].getDigest());
+		}
+
+		assertEqual(data.getTransactionContent(), resolvedData.getTransactionContent());
+		System.out.println("------Assert OK ------");
+	}
+
+	@Test
+	public void testSerialize_Transaction() throws Exception {
+		byte[] serialBytes = BinaryEncodingUtils.encode(data, Transaction.class);
+		Transaction resolvedData = BinaryEncodingUtils.decode(serialBytes);
+
+		System.out.println("------Assert start ------");
+		assertEquals(resolvedData.getExecutionState(), data.getExecutionState());
+		assertEquals(resolvedData.getHash(), data.getHash());
+		assertEquals(resolvedData.getBlockHeight(), data.getBlockHeight());
+
+		// EndpointSignatures 验证
+		DigitalSignature[] dataEndpointSignatures = data.getEndpointSignatures();
+		DigitalSignature[] resolvedEndpointSignatures = resolvedData.getEndpointSignatures();
+		for (int i = 0; i < dataEndpointSignatures.length; i++) {
+			assertEquals(dataEndpointSignatures[i].getPubKey(), resolvedEndpointSignatures[i].getPubKey());
+			assertEquals(dataEndpointSignatures[i].getDigest(), resolvedEndpointSignatures[i].getDigest());
+		}
+
+		// NodeSignatures 验证
+		DigitalSignature[] dataNodeSignatures = data.getNodeSignatures();
+		DigitalSignature[] resolvedNodeSignatures = resolvedData.getNodeSignatures();
+		for (int i = 0; i < dataNodeSignatures.length; i++) {
+			assertEquals(dataNodeSignatures[i].getPubKey(), resolvedNodeSignatures[i].getPubKey());
+			assertEquals(dataNodeSignatures[i].getDigest(), resolvedNodeSignatures[i].getDigest());
+		}
+
+		assertEqual(data.getTransactionContent(), resolvedData.getTransactionContent());
+		System.out.println("------Assert OK ------");
+	}
+
+	@Test
+	public void testSerialize_LedgerDataSnapshot() throws Exception {
+		byte[] serialBytes = BinaryEncodingUtils.encode(data, LedgerDataSnapshot.class);
+		LedgerDataSnapshot resolvedData = BinaryEncodingUtils.decode(serialBytes);
+
+		System.out.println("------Assert start ------");
+		assertEquals(resolvedData.getAdminAccountHash(), data.getAdminAccountHash());
+		assertEquals(resolvedData.getContractAccountSetHash(), data.getContractAccountSetHash());
+		assertEquals(resolvedData.getDataAccountSetHash(), data.getDataAccountSetHash());
+		assertEquals(resolvedData.getUserAccountSetHash(), data.getUserAccountSetHash());
+		System.out.println("------Assert OK ------");
+	}
+
+	@Test
+	public void testSerialize_NodeRequest() throws Exception {
+		byte[] serialBytes = BinaryEncodingUtils.encode(data, NodeRequest.class);
+		NodeRequest resolvedData = BinaryEncodingUtils.decode(serialBytes);
+
+		System.out.println("------Assert start ------");
+		// EndpointSignatures 验证
+		DigitalSignature[] dataEndpointSignatures = data.getEndpointSignatures();
+		DigitalSignature[] resolvedEndpointSignatures = resolvedData.getEndpointSignatures();
+		for (int i = 0; i < dataEndpointSignatures.length; i++) {
+			assertEquals(dataEndpointSignatures[i].getPubKey(), resolvedEndpointSignatures[i].getPubKey());
+			assertEquals(dataEndpointSignatures[i].getDigest(), resolvedEndpointSignatures[i].getDigest());
+		}
+
+		// NodeSignatures 验证
+		DigitalSignature[] dataNodeSignatures = data.getNodeSignatures();
+		DigitalSignature[] resolvedNodeSignatures = resolvedData.getNodeSignatures();
+		for (int i = 0; i < dataNodeSignatures.length; i++) {
+			assertEquals(dataNodeSignatures[i].getPubKey(), resolvedNodeSignatures[i].getPubKey());
+			assertEquals(dataNodeSignatures[i].getDigest(), resolvedNodeSignatures[i].getDigest());
+		}
+
+		assertEqual(data.getTransactionContent(), resolvedData.getTransactionContent());
+		System.out.println("------Assert OK ------");
+	}
+
+	@Test
+	public void testSerialize_EndpointRequest() throws Exception {
+		byte[] serialBytes = BinaryEncodingUtils.encode(data, EndpointRequest.class);
+		EndpointRequest resolvedData = BinaryEncodingUtils.decode(serialBytes);
+
+		System.out.println("------Assert start ------");
+		// EndpointSignatures 验证
+		DigitalSignature[] dataEndpointSignatures = data.getEndpointSignatures();
+		DigitalSignature[] resolvedEndpointSignatures = resolvedData.getEndpointSignatures();
+		for (int i = 0; i < dataEndpointSignatures.length; i++) {
+			assertEquals(dataEndpointSignatures[i].getPubKey(), resolvedEndpointSignatures[i].getPubKey());
+			assertEquals(dataEndpointSignatures[i].getDigest(), resolvedEndpointSignatures[i].getDigest());
+		}
+		assertEqual(data.getTransactionContent(), resolvedData.getTransactionContent());
+		System.out.println("------Assert OK ------");
+	}
+
+	private void assertEqual(TransactionContent dataTxContent, TransactionContent resolvedTxContent) {
+		assertEquals(dataTxContent.getHash(), resolvedTxContent.getHash());
+		assertEquals(dataTxContent.getLedgerHash(), resolvedTxContent.getLedgerHash());
+		// assertEquals(dataTxContent.getSequenceNumber(),
+		// resolvedTxContent.getSequenceNumber());
+		// assertEquals(dataTxContent.getSubjectAccount(),
+		// resolvedTxContent.getSubjectAccount());
+	}
+
+	private TransactionStagedSnapshot initTransactionStagedSnapshot() {
+		TransactionStagedSnapshot transactionStagedSnapshot = new TransactionStagedSnapshot();
+		transactionStagedSnapshot
+				.setAdminAccountHash(new HashDigest(ClassicCryptoService.SHA256_ALGORITHM, "zhangsan".getBytes()));
+		transactionStagedSnapshot
+				.setContractAccountSetHash(new HashDigest(ClassicCryptoService.SHA256_ALGORITHM, "lisi".getBytes()));
+		transactionStagedSnapshot
+				.setDataAccountSetHash(new HashDigest(ClassicCryptoService.SHA256_ALGORITHM, "wangwu".getBytes()));
+		transactionStagedSnapshot
+				.setUserAccountSetHash(new HashDigest(ClassicCryptoService.SHA256_ALGORITHM, "zhaoliu".getBytes()));
+		return transactionStagedSnapshot;
+	}
+
+	private TxRequestMessage initTxRequestMessage() throws Exception {
+		TxRequestMessage txRequestMessage = new TxRequestMessage(initTransactionContent());
+
+		SignatureDigest digest1 = new SignatureDigest(ClassicCryptoService.ED25519_ALGORITHM, "zhangsan".getBytes());
+		SignatureDigest digest2 = new SignatureDigest(ClassicCryptoService.ED25519_ALGORITHM, "lisi".getBytes());
+		DigitalSignatureBlob endPoint1 = new DigitalSignatureBlob(
+				new PubKey(ClassicCryptoService.ED25519_ALGORITHM, "jd1.com".getBytes()), digest1);
+		DigitalSignatureBlob endPoint2 = new DigitalSignatureBlob(
+				new PubKey(ClassicCryptoService.ED25519_ALGORITHM, "jd2.com".getBytes()), digest2);
+		txRequestMessage.addEndpointSignatures(endPoint1);
+		txRequestMessage.addEndpointSignatures(endPoint2);
+
+		SignatureDigest digest3 = new SignatureDigest(ClassicCryptoService.ED25519_ALGORITHM, "wangwu".getBytes());
+		SignatureDigest digest4 = new SignatureDigest(ClassicCryptoService.ED25519_ALGORITHM, "zhaoliu".getBytes());
+		DigitalSignatureBlob node1 = new DigitalSignatureBlob(
+				new PubKey(ClassicCryptoService.ED25519_ALGORITHM, "jd3.com".getBytes()), digest3);
+		DigitalSignatureBlob node2 = new DigitalSignatureBlob(
+				new PubKey(ClassicCryptoService.ED25519_ALGORITHM, "jd4.com".getBytes()), digest4);
+		txRequestMessage.addNodeSignatures(node1);
+		txRequestMessage.addNodeSignatures(node2);
+
+		return txRequestMessage;
+	}
+
+	private TransactionContent initTransactionContent() throws Exception {
+		TxContentBlob contentBlob = null;
+		BlockchainKeyPair id = BlockchainKeyGenerator.getInstance().generate(ClassicCryptoService.ED25519_ALGORITHM);
+		HashDigest ledgerHash = CryptoServiceProviders.getHashFunction("SHA256")
+				.hash(UUID.randomUUID().toString().getBytes("UTF-8"));
+		BlockchainOperationFactory opFactory = new BlockchainOperationFactory();
+		contentBlob = new TxContentBlob(ledgerHash);
+		contentBlob.setHash(new HashDigest(ClassicCryptoService.SHA256_ALGORITHM, "jd.com".getBytes()));
+		// contentBlob.setSubjectAccount(id.getAddress());
+		// contentBlob.setSequenceNumber(1);
+		DataAccountKVSetOperation kvsetOP = opFactory.dataAccount(id.getAddress())
+				.set("Name", ByteArray.fromString("AAA", "UTF-8"), -1).getOperation();
+		contentBlob.addOperation(kvsetOP);
+		return contentBlob;
+	}
 }

source/test/test-integration/pom.xml

@@ -49,14 +49,14 @@
 			<groupId>io.nats</groupId>
 			<artifactId>jnats</artifactId>
 		</dependency>
-		
+
 		<dependency>
 			<groupId>com.jd.blockchain</groupId>
-			<artifactId>crypto-impl</artifactId>
+			<artifactId>crypto-classic</artifactId>
 			<version>${project.version}</version>
 			<scope>test</scope>
 		</dependency>
-		
+
 	</dependencies>
 	<build>
 		<plugins>

source/test/test-integration/src/main/java/test/com/jd/blockchain/intgr/IntegrationTest.java

@@ -8,14 +8,13 @@ import java.util.Properties;
 import java.util.Random;
 import java.util.concurrent.CountDownLatch;
 
-import com.jd.blockchain.storage.service.KVStorageService;
 import org.springframework.core.io.ClassPathResource;
 
 import com.jd.blockchain.consensus.ConsensusProvider;
 import com.jd.blockchain.consensus.ConsensusProviders;
 import com.jd.blockchain.consensus.ConsensusSettings;
 import com.jd.blockchain.crypto.AddressEncoding;
-import com.jd.blockchain.crypto.CryptoAlgorithm;
+import com.jd.blockchain.crypto.CryptoServiceProviders;
 import com.jd.blockchain.crypto.PrivKey;
 import com.jd.blockchain.crypto.PubKey;
 import com.jd.blockchain.crypto.asymmetric.CryptoKeyPair;
@@ -39,6 +38,7 @@ import com.jd.blockchain.ledger.core.LedgerRepository;
 import com.jd.blockchain.ledger.core.impl.LedgerManager;
 import com.jd.blockchain.sdk.BlockchainService;
 import com.jd.blockchain.sdk.client.GatewayServiceFactory;
+import com.jd.blockchain.storage.service.KVStorageService;
 import com.jd.blockchain.tools.initializer.DBConnectionConfig;
 import com.jd.blockchain.tools.initializer.LedgerBindingConfig;
 import com.jd.blockchain.tools.initializer.LedgerInitProperties;
@@ -59,7 +59,6 @@ public class IntegrationTest {
 	private String contractZipName = "AssetContract1.contract";
 	private String eventName = "issue-asset";
 	HashDigest txContentHash;
-	String pubKeyVal = "jd.com" + System.currentTimeMillis();;
 	// String userPubKeyVal = "this is user's pubKey";
 	// 保存资产总数的键；
 	private static final String KEY_TOTAL = "TOTAL";
@@ -597,7 +596,7 @@ public class IntegrationTest {
 		txTpl.contractEvents().send(contractDeployKey.getAddress(), eventName,
 				("888##abc##" + contractDataKey.getAddress() + "##" + previousBlock.getHash().toBase58() + "##"
 						+ userKey.getAddress() + "##" + contractDeployKey.getAddress() + "##" + txContentHash.toBase58()
-						+ "##" + pubKeyVal).getBytes());
+						+ "##SOME-VALUE").getBytes());
 
 		// 签名；
 		PreparedTransaction ptx = txTpl.prepare();
@@ -617,7 +616,8 @@ public class IntegrationTest {
 
 		// 验证合约中的赋值，外部可以获得;
 		DataAccountSet dataAccountSet = ledgerOfNode0.getDataAccountSet(backgroundLedgerBlock);
-		PubKey pubKey = new PubKey(CryptoAlgorithm.ED25519, pubKeyVal.getBytes());
+		CryptoKeyPair key = CryptoServiceProviders.getSignatureFunction("ED25519").generateKeyPair();
+		PubKey pubKey = key.getPubKey();
 		Bytes dataAddress = AddressEncoding.generateAddress(pubKey);
 
 		// 验证userAccount，从合约内部赋值，然后外部验证;由于目前不允许输入重复的key，所以在内部合约中构建的key，不便于在外展示，屏蔽之;

source/test/test-integration/src/main/java/test/com/jd/blockchain/intgr/perf/LedgerInitializeTest.java

@@ -6,14 +6,13 @@ import java.util.Map;
 import java.util.Properties;
 import java.util.concurrent.ConcurrentHashMap;
 
-import com.jd.blockchain.storage.service.utils.MemoryDBConnFactory;
 import org.springframework.core.io.ClassPathResource;
 
 import com.jd.blockchain.consensus.ConsensusProvider;
 import com.jd.blockchain.consensus.ConsensusProviders;
 import com.jd.blockchain.consensus.ConsensusSettings;
 import com.jd.blockchain.crypto.AddressEncoding;
-import com.jd.blockchain.crypto.CryptoAlgorithm;
+import com.jd.blockchain.crypto.CryptoServiceProviders;
 import com.jd.blockchain.crypto.PrivKey;
 import com.jd.blockchain.crypto.PubKey;
 import com.jd.blockchain.crypto.asymmetric.CryptoKeyPair;
@@ -27,6 +26,7 @@ import com.jd.blockchain.ledger.core.LedgerRepository;
 import com.jd.blockchain.ledger.core.UserAccount;
 import com.jd.blockchain.ledger.core.UserAccountSet;
 import com.jd.blockchain.ledger.core.impl.LedgerManager;
+import com.jd.blockchain.storage.service.utils.MemoryDBConnFactory;
 //import com.jd.blockchain.storage.service.utils.MemoryBasedDb;
 import com.jd.blockchain.tools.initializer.DBConnectionConfig;
 import com.jd.blockchain.tools.initializer.LedgerInitProcess;
@@ -217,7 +217,7 @@ public class LedgerInitializeTest {
 
 			CryptoConfig cryptoSetting = new CryptoConfig();
 			cryptoSetting.setAutoVerifyHash(autoVerifyHash);
-			cryptoSetting.setHashAlgorithm(CryptoAlgorithm.SHA256);
+			cryptoSetting.setHashAlgorithm(CryptoServiceProviders.getAlgorithm("SHA256"));
 
 			partiKey = new CryptoKeyPair(setting.getConsensusParticipant(0).getPubKey(), privKey);
 

source/test/test-integration/src/main/java/test/com/jd/blockchain/intgr/perf/LedgerInitializeWebTest.java

@@ -5,7 +5,6 @@ import java.io.InputStream;
 import java.util.Properties;
 import java.util.concurrent.CountDownLatch;
 
-import com.jd.blockchain.storage.service.impl.composite.CompositeConnectionFactory;
 import org.springframework.boot.SpringApplication;
 import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.core.io.ClassPathResource;
@@ -15,11 +14,11 @@ import com.jd.blockchain.consensus.ConsensusProvider;
 import com.jd.blockchain.consensus.ConsensusProviders;
 import com.jd.blockchain.consensus.ConsensusSettings;
 import com.jd.blockchain.crypto.AddressEncoding;
-import com.jd.blockchain.crypto.CryptoAlgorithm;
-import com.jd.blockchain.crypto.CryptoUtils;
+import com.jd.blockchain.crypto.CryptoServiceProviders;
 import com.jd.blockchain.crypto.PrivKey;
 import com.jd.blockchain.crypto.PubKey;
 import com.jd.blockchain.crypto.asymmetric.SignatureDigest;
+import com.jd.blockchain.crypto.asymmetric.SignatureFunction;
 import com.jd.blockchain.crypto.hash.HashDigest;
 import com.jd.blockchain.ledger.LedgerBlock;
 import com.jd.blockchain.ledger.LedgerInitOperation;
@@ -33,6 +32,7 @@ import com.jd.blockchain.ledger.core.UserAccount;
 import com.jd.blockchain.ledger.core.UserAccountSet;
 import com.jd.blockchain.ledger.core.impl.LedgerManager;
 import com.jd.blockchain.storage.service.DbConnection;
+import com.jd.blockchain.storage.service.impl.composite.CompositeConnectionFactory;
 //import com.jd.blockchain.storage.service.utils.MemoryBasedDb;
 import com.jd.blockchain.tools.initializer.DBConnectionConfig;
 import com.jd.blockchain.tools.initializer.LedgerBindingConfig;
@@ -73,7 +73,7 @@ public class LedgerInitializeWebTest {
 		LedgerInitProperties initSetting = loadInitSetting_1();
 		// 加载共识配置；
 		Properties props = loadConsensusSetting();
-//		ConsensusProperties csProps = new ConsensusProperties(props);
+		// ConsensusProperties csProps = new ConsensusProperties(props);
 		ConsensusProvider csProvider = getConsensusProvider();
 		ConsensusSettings csProps = csProvider.getSettingsFactory().getConsensusSettingsBuilder().createSettings(props);
 
@@ -223,10 +223,11 @@ public class LedgerInitializeWebTest {
 
 	public SignatureDigest signPermissionRequest(int requesterId, PrivKey privKey, LedgerInitProperties initSetting) {
 		byte[] reqAuthBytes = BytesUtils.concat(BytesUtils.toBytes(requesterId), initSetting.getLedgerSeed());
-		SignatureDigest reqAuthSign = CryptoUtils.sign(CryptoAlgorithm.ED25519).sign(privKey, reqAuthBytes);
+		SignatureFunction signFunc = CryptoServiceProviders.getSignatureFunction("ED25519");
+		SignatureDigest reqAuthSign = signFunc.sign(privKey, reqAuthBytes);
 		return reqAuthSign;
 	}
-	
+
 	private static ConsensusProvider getConsensusProvider() {
 		return ConsensusProviders.getProvider("com.jd.blockchain.consensus.bftsmart.BftsmartConsensusProvider");
 	}
@@ -237,7 +238,7 @@ public class LedgerInitializeWebTest {
 		Prompter consolePrompter = new PresetAnswerPrompter("N"); // new ConsolePrompter();
 		LedgerInitProperties initSetting = loadInitSetting_2();
 		Properties props = loadConsensusSetting();
-//		ConsensusProperties csProps = new ConsensusProperties(props);
+		// ConsensusProperties csProps = new ConsensusProperties(props);
 		ConsensusProvider csProvider = getConsensusProvider();
 		ConsensusSettings csProps = csProvider.getSettingsFactory().getConsensusSettingsBuilder().createSettings(props);
 
@@ -263,23 +264,23 @@ public class LedgerInitializeWebTest {
 
 		DBConnectionConfig testDb0 = new DBConnectionConfig();
 		testDb0.setConnectionUri("memory://local/0");
-		AsyncCallback<HashDigest> callback0 = node0.startInit(privkey0, initSetting, csProps, csProvider, testDb0, consolePrompter,
-				quitLatch);
+		AsyncCallback<HashDigest> callback0 = node0.startInit(privkey0, initSetting, csProps, csProvider, testDb0,
+				consolePrompter, quitLatch);
 
 		DBConnectionConfig testDb1 = new DBConnectionConfig();
 		testDb1.setConnectionUri("memory://local/1");
-		AsyncCallback<HashDigest> callback1 = node1.startInit(privkey1, initSetting, csProps, csProvider, testDb1, consolePrompter,
-				quitLatch);
+		AsyncCallback<HashDigest> callback1 = node1.startInit(privkey1, initSetting, csProps, csProvider, testDb1,
+				consolePrompter, quitLatch);
 
 		DBConnectionConfig testDb2 = new DBConnectionConfig();
 		testDb2.setConnectionUri("memory://local/2");
-		AsyncCallback<HashDigest> callback2 = node2.startInit(privkey2, initSetting, csProps,csProvider,  testDb2, consolePrompter,
-				quitLatch);
+		AsyncCallback<HashDigest> callback2 = node2.startInit(privkey2, initSetting, csProps, csProvider, testDb2,
+				consolePrompter, quitLatch);
 
 		DBConnectionConfig testDb03 = new DBConnectionConfig();
 		testDb03.setConnectionUri("memory://local/3");
-		AsyncCallback<HashDigest> callback3 = node3.startInit(privkey3, initSetting, csProps, csProvider, testDb03, consolePrompter,
-				quitLatch);
+		AsyncCallback<HashDigest> callback3 = node3.startInit(privkey3, initSetting, csProps, csProvider, testDb03,
+				consolePrompter, quitLatch);
 
 		HashDigest ledgerHash0 = callback0.waitReturn();
 		HashDigest ledgerHash1 = callback1.waitReturn();
@@ -347,7 +348,7 @@ public class LedgerInitializeWebTest {
 
 		private DBConnectionConfig dbConnConfig;
 
-//		private MQConnectionConfig mqConnConfig;
+		// private MQConnectionConfig mqConnConfig;
 
 		private volatile ConfigurableApplicationContext ctx;
 

source/test/test-integration/src/main/java/test/com/jd/blockchain/intgr/perf/LedgerPerformanceTest.java

@@ -1,14 +1,37 @@
 package test.com.jd.blockchain.intgr.perf;
 
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.DoubleStream;
+
+import org.springframework.core.io.ClassPathResource;
+
 import com.jd.blockchain.binaryproto.DataContractRegistry;
 import com.jd.blockchain.consensus.ConsensusProvider;
 import com.jd.blockchain.consensus.ConsensusProviders;
 import com.jd.blockchain.consensus.ConsensusSettings;
 import com.jd.blockchain.crypto.CryptoAlgorithm;
+import com.jd.blockchain.crypto.CryptoServiceProviders;
 import com.jd.blockchain.crypto.PrivKey;
 import com.jd.blockchain.crypto.asymmetric.CryptoKeyPair;
 import com.jd.blockchain.crypto.hash.HashDigest;
-import com.jd.blockchain.ledger.*;
+import com.jd.blockchain.ledger.BlockchainIdentity;
+import com.jd.blockchain.ledger.BlockchainKeyGenerator;
+import com.jd.blockchain.ledger.BlockchainKeyPair;
+import com.jd.blockchain.ledger.DataAccountKVSetOperation;
+import com.jd.blockchain.ledger.DataAccountRegisterOperation;
+import com.jd.blockchain.ledger.LedgerBlock;
+import com.jd.blockchain.ledger.LedgerInitOperation;
+import com.jd.blockchain.ledger.TransactionRequest;
+import com.jd.blockchain.ledger.TransactionRequestBuilder;
+import com.jd.blockchain.ledger.TransactionResponse;
+import com.jd.blockchain.ledger.UserRegisterOperation;
 import com.jd.blockchain.ledger.core.LedgerDataSet;
 import com.jd.blockchain.ledger.core.LedgerEditor;
 import com.jd.blockchain.ledger.core.LedgerRepository;
@@ -34,20 +57,10 @@ import com.jd.blockchain.utils.concurrent.ThreadInvoker.AsyncCallback;
 import com.jd.blockchain.utils.io.BytesUtils;
 import com.jd.blockchain.utils.io.FileUtils;
 import com.jd.blockchain.utils.net.NetworkAddress;
-import org.springframework.core.io.ClassPathResource;
+
 import test.com.jd.blockchain.intgr.PresetAnswerPrompter;
 import test.com.jd.blockchain.intgr.perf.Utils.NodeContext;
 
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.Properties;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.stream.DoubleStream;
-
 //import com.jd.blockchain.storage.service.utils.MemoryBasedDb;
 
 /**
@@ -97,8 +110,8 @@ public class LedgerPerformanceTest {
 				dbType = DBType.ROCKSDB;
 			}
 
-			CryptoAlgorithm hashAlg = ArgumentSet.hasOption(args, "-160") ? CryptoAlgorithm.RIPEMD160
-					: CryptoAlgorithm.SHA256;
+			CryptoAlgorithm hashAlg = ArgumentSet.hasOption(args, "-160") ? CryptoServiceProviders.getAlgorithm("RIPEMD260")
+					: CryptoServiceProviders.getAlgorithm("SHA256");
 			System.out.println(
 					String.format("----- LedgerPerformanceTest [HashAlgorithm=%s][DBType=%s] ----", hashAlg, dbType));
 			// 初始化，并获取其中一个节点的账本，单独进行性能测试；

source/test/test-integration/src/main/java/test/com/jd/blockchain/intgr/perf/Utils.java

@@ -11,6 +11,7 @@ import org.springframework.core.io.ClassPathResource;
 import com.jd.blockchain.consensus.ConsensusProvider;
 import com.jd.blockchain.consensus.ConsensusSettings;
 import com.jd.blockchain.crypto.CryptoAlgorithm;
+import com.jd.blockchain.crypto.CryptoServiceProviders;
 import com.jd.blockchain.crypto.PrivKey;
 import com.jd.blockchain.crypto.asymmetric.CryptoKeyPair;
 import com.jd.blockchain.crypto.asymmetric.SignatureDigest;
@@ -124,8 +125,9 @@ public class Utils {
 		public AsyncCallback<HashDigest> startInit(int currentId, PrivKey privKey, LedgerInitProperties setting,
 				ConsensusSettings csProps, ConsensusProvider consensusProvider, DBConnectionConfig dbConnConfig,
 				Prompter prompter, boolean autoVerifyHash) {
+			CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("SHA256");
 			return startInit(currentId, privKey, setting, csProps, consensusProvider, dbConnConfig, prompter,
-					autoVerifyHash, CryptoAlgorithm.SHA256);
+					autoVerifyHash, algorithm);
 		}
 
 		public AsyncCallback<HashDigest> startInit(int currentId, PrivKey privKey, LedgerInitProperties setting,

source/test/test-integration/src/test/java/test/com/jd/blockchain/intgr/IntegrationTestAll4Redis.java

@@ -15,7 +15,7 @@ import org.junit.Test;
 import org.springframework.core.io.ClassPathResource;
 
 import com.jd.blockchain.crypto.AddressEncoding;
-import com.jd.blockchain.crypto.CryptoAlgorithm;
+import com.jd.blockchain.crypto.CryptoServiceProviders;
 import com.jd.blockchain.crypto.PrivKey;
 import com.jd.blockchain.crypto.PubKey;
 import com.jd.blockchain.crypto.asymmetric.CryptoKeyPair;
@@ -52,7 +52,6 @@ import test.com.jd.blockchain.intgr.initializer.LedgerInitializeWeb4SingleStepsT
 
 public class IntegrationTestAll4Redis {
 
-
 	public static final String PASSWORD = "abc";
 
 	public static final String[] PUB_KEYS = { "endPsK36imXrY66pru6ttZ8dZ3TynWekmdqoM1K7ZRRoRBBiYVzM",
@@ -76,8 +75,8 @@ public class IntegrationTestAll4Redis {
 	private String contractZipName = "AssetContract1.contract";
 	private String eventName = "issue-asset";
 	HashDigest txContentHash;
-	String pubKeyVal = "jd.com"+System.currentTimeMillis();
-//	String userPubKeyVal = "this is user's pubKey";
+	String pubKeyVal = "jd.com" + System.currentTimeMillis();
+	// String userPubKeyVal = "this is user's pubKey";
 	// 保存资产总数的键；
 	private static final String KEY_TOTAL = "TOTAL";
 	// 第二个参数;
@@ -130,8 +129,10 @@ public class IntegrationTestAll4Redis {
 		gwStarting0.waitReturn();
 
 		// 执行测试用例之前，校验每个节点的一致性；
-		LedgerRepository[] ledgers = buildLedgers(new LedgerBindingConfig[]{bindingConfig0, bindingConfig1, bindingConfig2, bindingConfig3},
-				new DbConnectionFactory[]{dbConnectionFactory0,dbConnectionFactory1,dbConnectionFactory2,dbConnectionFactory3});
+		LedgerRepository[] ledgers = buildLedgers(
+				new LedgerBindingConfig[] { bindingConfig0, bindingConfig1, bindingConfig2, bindingConfig3 },
+				new DbConnectionFactory[] { dbConnectionFactory0, dbConnectionFactory1, dbConnectionFactory2,
+						dbConnectionFactory3 });
 		testConsistencyAmongNodes(ledgers);
 
 		PrivKey privkey0 = KeyGenCommand.decodePrivKeyWithRawPassword(PRIV_KEYS[0], PASSWORD);
@@ -144,34 +145,35 @@ public class IntegrationTestAll4Redis {
 		PubKey pubKey2 = KeyGenCommand.decodePubKey(PUB_KEYS[2]);
 		PubKey pubKey3 = KeyGenCommand.decodePubKey(PUB_KEYS[3]);
 
-		CryptoKeyPair adminKey = new CryptoKeyPair(pubKey0,privkey0);
+		CryptoKeyPair adminKey = new CryptoKeyPair(pubKey0, privkey0);
 
 		testWriteBatchTransactions(gateway0, adminKey, ledgers[0]);
 
-
 		testSDK(gateway0, adminKey, ledgers[0]);
 
 		// 执行测试用例之后，校验每个节点的一致性；
 		testConsistencyAmongNodes(ledgers);
 	}
 
-	private LedgerBindingConfig loadBindingConfig(int id){
+	private LedgerBindingConfig loadBindingConfig(int id) {
 		ClassPathResource res = new ClassPathResource("ledger-binding-redis-" + id + ".conf");
-		try(InputStream in = res.getInputStream()){
+		try (InputStream in = res.getInputStream()) {
 			return LedgerBindingConfig.resolve(in);
 		} catch (IOException e) {
 			throw new IllegalStateException(e.getMessage(), e);
 		}
 	}
 
-	private LedgerRepository[] buildLedgers(LedgerBindingConfig[] bindingConfigs, DbConnectionFactory[] dbConnectionFactories){
-		int[] ids = {0, 1, 2, 3};
+	private LedgerRepository[] buildLedgers(LedgerBindingConfig[] bindingConfigs,
+			DbConnectionFactory[] dbConnectionFactories) {
+		int[] ids = { 0, 1, 2, 3 };
 		LedgerRepository[] ledgers = new LedgerRepository[ids.length];
 		LedgerManager[] ledgerManagers = new LedgerManager[ids.length];
 		for (int i = 0; i < ids.length; i++) {
 			ledgerManagers[i] = new LedgerManager();
 			HashDigest ledgerHash = bindingConfigs[0].getLedgerHashs()[0];
-			DbConnection conn = dbConnectionFactories[i].connect(bindingConfigs[i].getLedger(ledgerHash).getDbConnection().getUri(),
+			DbConnection conn = dbConnectionFactories[i].connect(
+					bindingConfigs[i].getLedger(ledgerHash).getDbConnection().getUri(),
 					bindingConfigs[i].getLedger(ledgerHash).getDbConnection().getPassword());
 			ledgers[i] = ledgerManagers[i].register(ledgerHash, conn.getStorageService());
 		}
@@ -199,8 +201,9 @@ public class IntegrationTestAll4Redis {
 		}
 	}
 
-	//测试一个区块包含多个交易的写入情况，并验证写入结果；
-	private void testWriteBatchTransactions(GatewayTestRunner gateway, CryptoKeyPair adminKey,LedgerRepository ledgerRepository) {
+	// 测试一个区块包含多个交易的写入情况，并验证写入结果；
+	private void testWriteBatchTransactions(GatewayTestRunner gateway, CryptoKeyPair adminKey,
+			LedgerRepository ledgerRepository) {
 		// 连接网关；
 		GatewayServiceFactory gwsrvFact = GatewayServiceFactory.connect(gateway.getServiceAddress());
 		BlockchainService blockchainService = gwsrvFact.getBlockchainService();
@@ -209,18 +212,16 @@ public class IntegrationTestAll4Redis {
 
 		TransactionTemplate txTpl = blockchainService.newTransaction(ledgerHashs[0]);
 
-		//regist user account
+		// regist user account
 		txTpl.users().register(userKey.getIdentity());
 
-		//regist data account
+		// regist data account
 		txTpl.dataAccounts().register(dataKey.getIdentity());
 
-		//add kv ops for data account
+		// add kv ops for data account
 		DataAccountKVSetOperation dataKvsetOP = txTpl.dataAccount(dataKey.getAddress())
-				.set("A", "Value_A_0".getBytes(), -1)
-				.set("B", "Value_B_0".getBytes(), -1)
-				.set("C", "Value_C_0".getBytes(), -1)
-				.set("D", "Value_D_0".getBytes(), -1).getOperation();
+				.set("A", "Value_A_0".getBytes(), -1).set("B", "Value_B_0".getBytes(), -1)
+				.set("C", "Value_C_0".getBytes(), -1).set("D", "Value_D_0".getBytes(), -1).getOperation();
 
 		// 签名；
 		PreparedTransaction ptx = txTpl.prepare();
@@ -232,27 +233,39 @@ public class IntegrationTestAll4Redis {
 		assertTrue(txResp.isSuccess());
 		assertEquals(ledgerRepository.retrieveLatestBlockHeight(), txResp.getBlockHeight());
 
-		assertArrayEquals("Value_A_0".getBytes(), ledgerRepository.getDataAccountSet(ledgerRepository.retrieveLatestBlock()).getDataAccount(dataKey.getAddress()).getBytes("A"));
-		assertArrayEquals("Value_B_0".getBytes(), ledgerRepository.getDataAccountSet(ledgerRepository.retrieveLatestBlock()).getDataAccount(dataKey.getAddress()).getBytes("B"));
-		assertArrayEquals("Value_C_0".getBytes(), ledgerRepository.getDataAccountSet(ledgerRepository.retrieveLatestBlock()).getDataAccount(dataKey.getAddress()).getBytes("C"));
-		assertArrayEquals("Value_D_0".getBytes(), ledgerRepository.getDataAccountSet(ledgerRepository.retrieveLatestBlock()).getDataAccount(dataKey.getAddress()).getBytes("D"));
-		assertEquals(0, ledgerRepository.getDataAccountSet(ledgerRepository.retrieveLatestBlock()).getDataAccount(dataKey.getAddress()).getDataVersion("A"));
-		assertEquals(0, ledgerRepository.getDataAccountSet(ledgerRepository.retrieveLatestBlock()).getDataAccount(dataKey.getAddress()).getDataVersion("B"));
-		assertEquals(0, ledgerRepository.getDataAccountSet(ledgerRepository.retrieveLatestBlock()).getDataAccount(dataKey.getAddress()).getDataVersion("C"));
-		assertEquals(0, ledgerRepository.getDataAccountSet(ledgerRepository.retrieveLatestBlock()).getDataAccount(dataKey.getAddress()).getDataVersion("D"));
+		assertArrayEquals("Value_A_0".getBytes(),
+				ledgerRepository.getDataAccountSet(ledgerRepository.retrieveLatestBlock())
+						.getDataAccount(dataKey.getAddress()).getBytes("A"));
+		assertArrayEquals("Value_B_0".getBytes(),
+				ledgerRepository.getDataAccountSet(ledgerRepository.retrieveLatestBlock())
+						.getDataAccount(dataKey.getAddress()).getBytes("B"));
+		assertArrayEquals("Value_C_0".getBytes(),
+				ledgerRepository.getDataAccountSet(ledgerRepository.retrieveLatestBlock())
+						.getDataAccount(dataKey.getAddress()).getBytes("C"));
+		assertArrayEquals("Value_D_0".getBytes(),
+				ledgerRepository.getDataAccountSet(ledgerRepository.retrieveLatestBlock())
+						.getDataAccount(dataKey.getAddress()).getBytes("D"));
+		assertEquals(0, ledgerRepository.getDataAccountSet(ledgerRepository.retrieveLatestBlock())
+				.getDataAccount(dataKey.getAddress()).getDataVersion("A"));
+		assertEquals(0, ledgerRepository.getDataAccountSet(ledgerRepository.retrieveLatestBlock())
+				.getDataAccount(dataKey.getAddress()).getDataVersion("B"));
+		assertEquals(0, ledgerRepository.getDataAccountSet(ledgerRepository.retrieveLatestBlock())
+				.getDataAccount(dataKey.getAddress()).getDataVersion("C"));
+		assertEquals(0, ledgerRepository.getDataAccountSet(ledgerRepository.retrieveLatestBlock())
+				.getDataAccount(dataKey.getAddress()).getDataVersion("D"));
 
 		return;
 	}
 
-
-	private void testSDK(GatewayTestRunner gateway, CryptoKeyPair adminKey,LedgerRepository ledgerRepository) {
+	private void testSDK(GatewayTestRunner gateway, CryptoKeyPair adminKey, LedgerRepository ledgerRepository) {
 		// 连接网关；
 		GatewayServiceFactory gwsrvFact = GatewayServiceFactory.connect(gateway.getServiceAddress());
 		BlockchainService bcsrv = gwsrvFact.getBlockchainService();
 
 		HashDigest[] ledgerHashs = bcsrv.getLedgerHashs();
 		BlockchainKeyPair newUserAcount = testSDK_RegisterUser(adminKey, ledgerHashs[0], bcsrv, ledgerRepository);
-		BlockchainKeyPair newDataAccount = testSDK_RegisterDataAccount(adminKey, ledgerHashs[0], bcsrv, ledgerRepository);
+		BlockchainKeyPair newDataAccount = testSDK_RegisterDataAccount(adminKey, ledgerHashs[0], bcsrv,
+				ledgerRepository);
 		testSDK_InsertData(adminKey, ledgerHashs[0], bcsrv, newDataAccount.getAddress(), ledgerRepository);
 		LedgerBlock latestBlock = testSDK_Contract(adminKey, ledgerHashs[0], bcsrv, ledgerRepository);
 
@@ -291,7 +304,8 @@ public class IntegrationTestAll4Redis {
 		assertEquals(txResp.getContentHash(), prepTx.getHash());
 		assertEquals(txResp.getBlockHash(), ledgerRepository.getLatestBlockHash());
 
-		KVDataEntry[] kvDataEntries = blockchainService.getDataEntries(ledgerHash, dataAccountAddress.toString(), dataKey);
+		KVDataEntry[] kvDataEntries = blockchainService.getDataEntries(ledgerHash, dataAccountAddress.toString(),
+				dataKey);
 		for (KVDataEntry kvDataEntry : kvDataEntries) {
 			assertEquals(dataKey, kvDataEntry.getKey());
 			String valHexText = (String) kvDataEntry.getValue();
@@ -302,7 +316,7 @@ public class IntegrationTestAll4Redis {
 	}
 
 	private BlockchainKeyPair testSDK_RegisterDataAccount(CryptoKeyPair adminKey, HashDigest ledgerHash,
-														  BlockchainService blockchainService, LedgerRepository ledgerRepository) {
+			BlockchainService blockchainService, LedgerRepository ledgerRepository) {
 		// 注册数据账户，并验证最终写入；
 		BlockchainKeyPair dataAccount = BlockchainKeyGenerator.getInstance().generate();
 
@@ -337,7 +351,7 @@ public class IntegrationTestAll4Redis {
 	}
 
 	private BlockchainKeyPair testSDK_RegisterUser(CryptoKeyPair adminKey, HashDigest ledgerHash,
-												   BlockchainService blockchainService, LedgerRepository ledgerRepository) {
+			BlockchainService blockchainService, LedgerRepository ledgerRepository) {
 		// 注册用户，并验证最终写入；
 		BlockchainKeyPair user = BlockchainKeyGenerator.getInstance().generate();
 
@@ -366,7 +380,6 @@ public class IntegrationTestAll4Redis {
 		return user;
 	}
 
-
 	public static LedgerInitProperties loadInitSetting_integration() {
 		ClassPathResource ledgerInitSettingResource = new ClassPathResource("ledger_init_test_integration.init");
 		try (InputStream in = ledgerInitSettingResource.getInputStream()) {
@@ -378,12 +391,13 @@ public class IntegrationTestAll4Redis {
 	}
 
 	private LedgerBlock testSDK_Contract(CryptoKeyPair adminKey, HashDigest ledgerHash,
-										 BlockchainService blockchainService,LedgerRepository ledgerRepository) {
-		System.out.println("adminKey="+AddressEncoding.generateAddress(adminKey.getPubKey()));
+			BlockchainService blockchainService, LedgerRepository ledgerRepository) {
+		System.out.println("adminKey=" + AddressEncoding.generateAddress(adminKey.getPubKey()));
 		BlockchainKeyPair userKey = BlockchainKeyGenerator.getInstance().generate();
-		System.out.println("userKey="+userKey.getAddress());
+		System.out.println("userKey=" + userKey.getAddress());
 		// valid the basic data in contract;
-//		prepareContractData(adminKey, ledgerHash, blockchainService,ledgerRepository);
+		// prepareContractData(adminKey, ledgerHash,
+		// blockchainService,ledgerRepository);
 
 		TransactionTemplate txTpl = blockchainService.newTransaction(ledgerHash);
 		txTpl.users().register(userKey.getIdentity());
@@ -391,12 +405,12 @@ public class IntegrationTestAll4Redis {
 		// 定义交易；
 		// 注册数据账户，并验证最终写入；
 		txTpl.dataAccounts().register(contractDataKey.getIdentity());
-//		dataAccountSet.getDataAccount(dataAddress)
-		DataAccount dataAccount = ledgerRepository.getDataAccountSet(ledgerRepository.getLatestBlock()).getDataAccount(contractDataKey.getAddress());
+		// dataAccountSet.getDataAccount(dataAddress)
+		DataAccount dataAccount = ledgerRepository.getDataAccountSet(ledgerRepository.getLatestBlock())
+				.getDataAccount(contractDataKey.getAddress());
 
 		DataAccountKVSetOperation kvsetOP = txTpl.dataAccount(contractDataKey.getAddress())
-				.set("A", "Value_A_0".getBytes(), -1)
-				.set("B", "Value_B_0".getBytes(), -1)
+				.set("A", "Value_A_0".getBytes(), -1).set("B", "Value_B_0".getBytes(), -1)
 				.set(KEY_TOTAL, "total value,dataAccount".getBytes(), -1)
 				.set(KEY_ABC, "abc value,dataAccount".getBytes(), -1)
 				// 所有的模拟数据都在这个dataAccount中填充;
@@ -417,19 +431,19 @@ public class IntegrationTestAll4Redis {
 		txResp.getContentHash();
 
 		LedgerBlock block = ledgerRepository.getBlock(txResp.getBlockHeight());
-		byte[] contractCodeInDb = ledgerRepository.getContractAccountSet(block).getContract(contractDeployKey.getAddress())
-				.getChainCode();
+		byte[] contractCodeInDb = ledgerRepository.getContractAccountSet(block)
+				.getContract(contractDeployKey.getAddress()).getChainCode();
 		assertArrayEquals(contractCode, contractCodeInDb);
 		txContentHash = ptx.getHash();
 
 		// execute the contract;
-		testContractExe(adminKey, ledgerHash, userKey,  blockchainService, ledgerRepository);
+		testContractExe(adminKey, ledgerHash, userKey, blockchainService, ledgerRepository);
 
 		return block;
 	}
 
 	private void testContractExe(CryptoKeyPair adminKey, HashDigest ledgerHash, BlockchainKeyPair userKey,
-								 BlockchainService blockchainService,LedgerRepository ledgerRepository) {
+			BlockchainService blockchainService, LedgerRepository ledgerRepository) {
 		LedgerInfo ledgerInfo = blockchainService.getLedger(ledgerHash);
 		LedgerBlock previousBlock = blockchainService.getBlock(ledgerHash, ledgerInfo.getLatestBlockHeight() - 1);
 
@@ -438,8 +452,8 @@ public class IntegrationTestAll4Redis {
 
 		txTpl.contractEvents().send(contractDeployKey.getAddress(), eventName,
 				("888##abc##" + contractDataKey.getAddress() + "##" + previousBlock.getHash().toBase58() + "##"
-						+ userKey.getAddress() + "##" + contractDeployKey.getAddress() + "##"
-						+ txContentHash.toBase58()+"##"+pubKeyVal).getBytes());
+						+ userKey.getAddress() + "##" + contractDeployKey.getAddress() + "##" + txContentHash.toBase58()
+						+ "##" + pubKeyVal).getBytes());
 
 		// 签名；
 		PreparedTransaction ptx = txTpl.prepare();
@@ -460,25 +474,27 @@ public class IntegrationTestAll4Redis {
 
 		// 验证合约中的赋值，外部可以获得;
 		DataAccountSet dataAccountSet = ledgerRepository.getDataAccountSet(backgroundLedgerBlock);
-		PubKey pubKey = new PubKey(CryptoAlgorithm.ED25519, pubKeyVal.getBytes());
+		CryptoKeyPair key = CryptoServiceProviders.getSignatureFunction("ED25519").generateKeyPair();
+		PubKey pubKey = key.getPubKey();
 		Bytes dataAddress = AddressEncoding.generateAddress(pubKey);
 		assertEquals(dataAddress, dataAccountSet.getDataAccount(dataAddress).getAddress());
 		assertEquals("hello", new String(dataAccountSet.getDataAccount(dataAddress).getBytes(KEY_TOTAL, -1)));
 
 		// 验证userAccount，从合约内部赋值，然后外部验证;内部定义动态key，外部不便于得到，临时屏蔽;
-//		UserAccountSet userAccountSet = ledgerRepository.getUserAccountSet(backgroundLedgerBlock);
-//		PubKey userPubKey = new PubKey(CryptoAlgorithm.ED25519, userPubKeyVal.getBytes());
-//		String userAddress = AddressEncoding.generateAddress(userPubKey);
-//		assertEquals(userAddress, userAccountSet.getUser(userAddress).getAddress());
+		// UserAccountSet userAccountSet =
+		// ledgerRepository.getUserAccountSet(backgroundLedgerBlock);
+		// PubKey userPubKey = new PubKey(CryptoAlgorithm.ED25519,
+		// userPubKeyVal.getBytes());
+		// String userAddress = AddressEncoding.generateAddress(userPubKey);
+		// assertEquals(userAddress, userAccountSet.getUser(userAddress).getAddress());
 	}
 
-	private void prepareContractData(CryptoKeyPair adminKey, HashDigest ledgerHash,
-									 BlockchainService blockchainService, LedgerRepository ledgerRepository) {
+	private void prepareContractData(CryptoKeyPair adminKey, HashDigest ledgerHash, BlockchainService blockchainService,
+			LedgerRepository ledgerRepository) {
 
 		// 定义交易；
 		TransactionTemplate txTpl = blockchainService.newTransaction(ledgerHash);
 
-
 		// 签名；
 		PreparedTransaction ptx = txTpl.prepare();
 		ptx.sign(adminKey);

source/test/test-integration/src/test/java/test/com/jd/blockchain/intgr/batch/bftsmart/BftsmartTestBase.java

@@ -8,15 +8,16 @@
  */
 package test.com.jd.blockchain.intgr.batch.bftsmart;
 
-import com.jd.blockchain.crypto.CryptoAlgorithm;
-import com.jd.blockchain.crypto.CryptoUtils;
+import static com.jd.blockchain.tools.keygen.KeyGenCommand.encodePrivKey;
+import static com.jd.blockchain.tools.keygen.KeyGenCommand.encodePubKey;
+
+import org.junit.Test;
+
+import com.jd.blockchain.crypto.CryptoServiceProviders;
 import com.jd.blockchain.crypto.asymmetric.CryptoKeyPair;
+import com.jd.blockchain.crypto.asymmetric.SignatureFunction;
 import com.jd.blockchain.utils.codec.Base58Utils;
 import com.jd.blockchain.utils.security.ShaUtils;
-import org.junit.Test;
-
-import static com.jd.blockchain.tools.keygen.KeyGenCommand.encodePrivKey;
-import static com.jd.blockchain.tools.keygen.KeyGenCommand.encodePubKey;
 
 /**
  *
@@ -35,8 +36,9 @@ public class BftsmartTestBase {
 
     @Test
     public void newUsers() {
+    	SignatureFunction signFunc = CryptoServiceProviders.getSignatureFunction("ED25519");
         for (int i = 0; i < userSize; i++) {
-            CryptoKeyPair kp = CryptoUtils.sign(CryptoAlgorithm.ED25519).generateKeyPair();
+            CryptoKeyPair kp = signFunc.generateKeyPair();
 
             String base58PubKey = encodePubKey(kp.getPubKey());
 

source/test/test-integration/src/test/java/test/com/jd/blockchain/intgr/initializer/LedgerInitializeTest.java

@@ -19,6 +19,7 @@ import com.jd.blockchain.consensus.ConsensusProviders;
 import com.jd.blockchain.consensus.ConsensusSettings;
 import com.jd.blockchain.crypto.AddressEncoding;
 import com.jd.blockchain.crypto.CryptoAlgorithm;
+import com.jd.blockchain.crypto.CryptoServiceProviders;
 import com.jd.blockchain.crypto.PrivKey;
 import com.jd.blockchain.crypto.PubKey;
 import com.jd.blockchain.crypto.asymmetric.CryptoKeyPair;
@@ -255,7 +256,7 @@ public class LedgerInitializeTest {
 
 			CryptoConfig cryptoSetting = new CryptoConfig();
 			cryptoSetting.setAutoVerifyHash(autoVerifyHash);
-			cryptoSetting.setHashAlgorithm(CryptoAlgorithm.SHA256);
+			cryptoSetting.setHashAlgorithm(CryptoServiceProviders.getAlgorithm("SHA256"));
 
 			partiKey = new CryptoKeyPair(setting.getConsensusParticipant(0).getPubKey(), privKey);
 

source/test/test-integration/src/test/java/test/com/jd/blockchain/intgr/initializer/LedgerInitializeWeb4SingleStepsTest.java

@@ -10,24 +10,17 @@ import java.io.InputStream;
 import java.util.Properties;
 import java.util.concurrent.CountDownLatch;
 
-import com.jd.blockchain.storage.service.impl.composite.CompositeConnectionFactory;
-import org.junit.Test;
 import org.springframework.boot.SpringApplication;
 import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.core.io.ClassPathResource;
 
 import com.jd.blockchain.binaryproto.BinaryEncodingUtils;
 import com.jd.blockchain.consensus.ConsensusProvider;
-import com.jd.blockchain.consensus.ConsensusProviders;
 import com.jd.blockchain.consensus.ConsensusSettings;
-import com.jd.blockchain.crypto.AddressEncoding;
-import com.jd.blockchain.crypto.CryptoAlgorithm;
-import com.jd.blockchain.crypto.CryptoUtils;
 import com.jd.blockchain.crypto.PrivKey;
 import com.jd.blockchain.crypto.PubKey;
 import com.jd.blockchain.crypto.asymmetric.SignatureDigest;
 import com.jd.blockchain.crypto.hash.HashDigest;
-import com.jd.blockchain.ledger.LedgerBlock;
 import com.jd.blockchain.ledger.LedgerInitOperation;
 import com.jd.blockchain.ledger.Operation;
 import com.jd.blockchain.ledger.TransactionContent;
@@ -35,11 +28,10 @@ import com.jd.blockchain.ledger.UserRegisterOperation;
 import com.jd.blockchain.ledger.core.LedgerInitDecision;
 import com.jd.blockchain.ledger.core.LedgerInitPermission;
 import com.jd.blockchain.ledger.core.LedgerRepository;
-import com.jd.blockchain.ledger.core.UserAccount;
-import com.jd.blockchain.ledger.core.UserAccountSet;
 import com.jd.blockchain.ledger.core.impl.LedgerManager;
 import com.jd.blockchain.ledger.data.TxRequestBuilder;
 import com.jd.blockchain.storage.service.DbConnection;
+import com.jd.blockchain.storage.service.impl.composite.CompositeConnectionFactory;
 import com.jd.blockchain.tools.initializer.DBConnectionConfig;
 import com.jd.blockchain.tools.initializer.LedgerBindingConfig;
 import com.jd.blockchain.tools.initializer.LedgerInitCommand;
@@ -50,7 +42,6 @@ import com.jd.blockchain.tools.initializer.web.HttpInitConsensServiceFactory;
 import com.jd.blockchain.tools.initializer.web.LedgerInitConsensusService;
 import com.jd.blockchain.tools.initializer.web.LedgerInitializeWebController;
 import com.jd.blockchain.tools.keygen.KeyGenCommand;
-import com.jd.blockchain.utils.Bytes;
 import com.jd.blockchain.utils.concurrent.ThreadInvoker;
 import com.jd.blockchain.utils.concurrent.ThreadInvoker.AsyncCallback;
 import com.jd.blockchain.utils.io.BytesUtils;

source/test/test-ledger-core/src/main/java/test/perf/com/jd/blockchain/ledger/core/MerkleDatasetPerformanceTester.java

@@ -4,6 +4,7 @@ import java.io.IOException;
 import java.util.Random;
 
 import com.jd.blockchain.crypto.CryptoAlgorithm;
+import com.jd.blockchain.crypto.CryptoServiceProviders;
 import com.jd.blockchain.crypto.hash.HashDigest;
 import com.jd.blockchain.ledger.core.CryptoConfig;
 import com.jd.blockchain.ledger.core.MerkleDataSet;
@@ -131,7 +132,7 @@ public class MerkleDatasetPerformanceTester {
 		Random rand = new Random();
 
 		CryptoConfig cryptoConfig = new CryptoConfig();
-		cryptoConfig.setHashAlgorithm(CryptoAlgorithm.SHA256);
+		cryptoConfig.setHashAlgorithm(CryptoServiceProviders.getAlgorithm("SHA256"));
 		cryptoConfig.setAutoVerifyHash(true);
 
 		// generate base data sample;

source/tools/tools-initializer/src/main/java/com/jd/blockchain/tools/initializer/web/LedgerInitializeWebController.java

@@ -20,18 +20,19 @@ import com.jd.blockchain.binaryproto.DataContractRegistry;
 import com.jd.blockchain.consensus.ConsensusProvider;
 import com.jd.blockchain.consensus.ConsensusSettings;
 import com.jd.blockchain.crypto.CryptoAlgorithm;
-import com.jd.blockchain.crypto.CryptoUtils;
+import com.jd.blockchain.crypto.CryptoServiceProviders;
 import com.jd.blockchain.crypto.PrivKey;
 import com.jd.blockchain.crypto.PubKey;
 import com.jd.blockchain.crypto.asymmetric.SignatureDigest;
+import com.jd.blockchain.crypto.asymmetric.SignatureFunction;
 import com.jd.blockchain.crypto.hash.HashDigest;
 import com.jd.blockchain.ledger.BlockchainIdentity;
 import com.jd.blockchain.ledger.BlockchainIdentityData;
-import com.jd.blockchain.ledger.ParticipantNode;
 import com.jd.blockchain.ledger.CryptoSetting;
 import com.jd.blockchain.ledger.LedgerBlock;
 import com.jd.blockchain.ledger.LedgerInitSetting;
 import com.jd.blockchain.ledger.Operation;
+import com.jd.blockchain.ledger.ParticipantNode;
 import com.jd.blockchain.ledger.TransactionBuilder;
 import com.jd.blockchain.ledger.TransactionContent;
 import com.jd.blockchain.ledger.TransactionRequest;
@@ -56,11 +57,11 @@ import com.jd.blockchain.tools.initializer.LedgerInitException;
 import com.jd.blockchain.tools.initializer.LedgerInitProcess;
 import com.jd.blockchain.tools.initializer.LedgerInitProperties;
 import com.jd.blockchain.tools.initializer.LedgerInitProperties.ConsensusParticipantConfig;
+import com.jd.blockchain.tools.initializer.Prompter;
 import com.jd.blockchain.utils.Bytes;
 import com.jd.blockchain.utils.concurrent.InvocationResult;
 import com.jd.blockchain.utils.io.BytesUtils;
 import com.jd.blockchain.utils.net.NetworkAddress;
-import com.jd.blockchain.tools.initializer.Prompter;
 
 /**
  * 账本初始化控制器；
@@ -75,7 +76,9 @@ public class LedgerInitializeWebController implements LedgerInitProcess, LedgerI
 		DataContractRegistry.register(TransactionRequest.class);
 	}
 
-	private static final CryptoAlgorithm SIGN_ALG = CryptoAlgorithm.ED25519;
+	private static final String DEFAULT_SIGN_ALGORITHM = "ED25519";
+	
+	private final SignatureFunction SIGN_FUNC;
 
 	private volatile LedgerInitPermission localPermission;
 
@@ -113,10 +116,13 @@ public class LedgerInitializeWebController implements LedgerInitProcess, LedgerI
 	private InitConsensusServiceFactory initCsServiceFactory;
 
 	public LedgerInitializeWebController() {
+		this.SIGN_FUNC = CryptoServiceProviders.getSignatureFunction(DEFAULT_SIGN_ALGORITHM);
 	}
 
 	public LedgerInitializeWebController(LedgerManage ledgerManager, DbConnectionFactory dbConnFactory,
 			InitConsensusServiceFactory initCsServiceFactory) {
+		this.SIGN_FUNC = CryptoServiceProviders.getSignatureFunction(DEFAULT_SIGN_ALGORITHM);
+		
 		this.ledgerManager = ledgerManager;
 		this.dbConnFactory = dbConnFactory;
 		this.initCsServiceFactory = initCsServiceFactory;
@@ -295,7 +301,7 @@ public class LedgerInitializeWebController implements LedgerInitProcess, LedgerI
 	public CryptoSetting createDefaultCryptoSetting() {
 		CryptoConfig defCryptoSetting = new CryptoConfig();
 		defCryptoSetting.setAutoVerifyHash(true);
-		defCryptoSetting.setHashAlgorithm(CryptoAlgorithm.SHA256);
+		defCryptoSetting.setHashAlgorithm(CryptoServiceProviders.getAlgorithm("SHA256"));
 
 		return defCryptoSetting;
 	}
@@ -335,9 +341,9 @@ public class LedgerInitializeWebController implements LedgerInitProcess, LedgerI
 
 		// 校验当前的公钥、私钥是否匹配；
 		byte[] testBytes = BytesUtils.toBytes(currentId);
-		SignatureDigest testSign = CryptoUtils.sign(SIGN_ALG).sign(privKey, testBytes);
+		SignatureDigest testSign = SIGN_FUNC.sign(privKey, testBytes);
 		PubKey myPubKey = orderedParties[currentId].getPubKey();
-		if (!CryptoUtils.sign(SIGN_ALG).verify(testSign, myPubKey, testBytes)) {
+		if (!SIGN_FUNC.verify(testSign, myPubKey, testBytes)) {
 			throw new LedgerInitException("Your pub-key specified in the init-settings isn't match your priv-key!");
 		}
 		this.initializerAddresses = new NetworkAddress[orderedParties.length];
@@ -370,7 +376,8 @@ public class LedgerInitializeWebController implements LedgerInitProcess, LedgerI
 
 	private LedgerInitDecision makeDecision(int participantId, HashDigest ledgerHash, PrivKey privKey) {
 		byte[] dataBytes = getDecisionBytes(participantId, ledgerHash);
-		SignatureDigest signature = CryptoUtils.sign(privKey.getAlgorithm()).sign(privKey, dataBytes);
+		SignatureFunction signFunc = CryptoServiceProviders.getSignatureFunction(privKey.getAlgorithm());
+		SignatureDigest signature = signFunc.sign(privKey, dataBytes);
 
 		LedgerInitDecisionData decision = new LedgerInitDecisionData();
 		decision.setParticipantId(participantId);
@@ -496,7 +503,7 @@ public class LedgerInitializeWebController implements LedgerInitProcess, LedgerI
 
 	public SignatureDigest signPermissionRequest(int requesterId, PrivKey privKey) {
 		byte[] reqAuthBytes = BytesUtils.concat(BytesUtils.toBytes(requesterId), ledgerInitSetting.getLedgerSeed());
-		SignatureDigest reqAuthSign = CryptoUtils.sign(SIGN_ALG).sign(privKey, reqAuthBytes);
+		SignatureDigest reqAuthSign = SIGN_FUNC.sign(privKey, reqAuthBytes);
 		return reqAuthSign;
 	}
 
@@ -561,7 +568,7 @@ public class LedgerInitializeWebController implements LedgerInitProcess, LedgerI
 		}
 		byte[] requestCodeBytes = BytesUtils.concat(BytesUtils.toBytes(requesterId), ledgerInitSetting.getLedgerSeed());
 		PubKey requesterPubKey = participants[requesterId].getPubKey();
-		if (!CryptoUtils.sign(SIGN_ALG).verify(signature, requesterPubKey, requestCodeBytes)) {
+		if (!SIGN_FUNC.verify(signature, requesterPubKey, requestCodeBytes)) {
 			throw new LedgerInitException("The requester signature is invalid!");
 		}
 		return localPermission;
@@ -700,7 +707,7 @@ public class LedgerInitializeWebController implements LedgerInitProcess, LedgerI
 		PubKey targetPubKey = ledgerInitSetting.getConsensusParticipants()[targetDecision.getParticipantId()]
 				.getPubKey();
 		byte[] deciBytes = getDecisionBytes(targetDecision.getParticipantId(), targetDecision.getLedgerHash());
-		if ((!CryptoUtils.sign(hashAlgorithm).verify(targetDecision.getSignature(), targetPubKey, deciBytes))
+		if ((!SIGN_FUNC.verify(targetDecision.getSignature(), targetPubKey, deciBytes))
 				&& resultHandle.getResult() == null) {
 			prompter.error("The signature of received decision is invalid! --[Id=%s]",
 					targetDecision.getParticipantId());

source/tools/tools-keygen/src/main/java/com/jd/blockchain/tools/keygen/KeyGenCommand.java

@@ -8,15 +8,14 @@ import java.util.List;
 
 import javax.crypto.SecretKey;
 
-import com.jd.blockchain.crypto.CryptoAlgorithm;
-import com.jd.blockchain.crypto.CryptoUtils;
+import com.jd.blockchain.crypto.CryptoServiceProviders;
 import com.jd.blockchain.crypto.PrivKey;
 import com.jd.blockchain.crypto.PubKey;
 import com.jd.blockchain.crypto.asymmetric.CryptoKeyPair;
 import com.jd.blockchain.utils.ArgumentSet;
-import com.jd.blockchain.utils.ConsoleUtils;
 import com.jd.blockchain.utils.ArgumentSet.ArgEntry;
 import com.jd.blockchain.utils.ArgumentSet.Setting;
+import com.jd.blockchain.utils.ConsoleUtils;
 import com.jd.blockchain.utils.codec.Base58Utils;
 import com.jd.blockchain.utils.io.BytesUtils;
 import com.jd.blockchain.utils.io.FileUtils;
@@ -105,7 +104,7 @@ public class KeyGenCommand {
 	 * @param outputDir
 	 */
 	private static void generateKeyPair(String name, String outputDir, String localConfPath) {
-		CryptoKeyPair kp = CryptoUtils.sign(CryptoAlgorithm.ED25519).generateKeyPair();
+		CryptoKeyPair kp = CryptoServiceProviders.getSignatureFunction("ED25519").generateKeyPair();
 
 		String base58PubKey = encodePubKey(kp.getPubKey());