<fix>(codec,crypto): deprecated Codec unnecessarily depends CryptoSuite.

Author: kyonRay

.ci/ci_check.sh

@@ -170,28 +170,39 @@ LOG_INFO "------ download_binary: v3.1.0---------"
 download_build_chain "v3.1.0"
 download_binary "v3.1.0"
 LOG_INFO "------ check_standard_node---------"
-check_standard_node
+check_standard_node "true" "normal" "-A"
 rm -rf ./bin
 
-LOG_INFO "------ download_binary: v3.2.0---------"
-download_build_chain "v3.2.0"
-download_binary "v3.2.0"
+LOG_INFO "------ download_binary: v3.2.3---------"
+download_build_chain "v3.2.3"
+download_binary "v3.2.3"
 LOG_INFO "------ check_standard_node---------"
+check_standard_node "false" "normal" "-A"
+LOG_INFO "------ check_sm_node---------"
 check_standard_node "true" "sm" "-s -A"
 rm -rf ./bin
 
 LOG_INFO "------ download_build_chain: v3.3.0---------"
 download_binary "v3.3.0"
 download_build_chain "v3.3.0"
 LOG_INFO "------ check_standard_node---------"
-check_standard_node "true" "sm" "-s"
+check_standard_node "true"
 rm -rf ./bin
 
 LOG_INFO "------ download_build_chain: v3.4.0---------"
 download_binary "v3.4.0"
 download_build_chain "v3.4.0"
+LOG_INFO "------ check_standard_node---------"
+check_standard_node "true"
+rm -rf ./bin
+
+LOG_INFO "------ download_build_chain: v3.5.0---------"
+download_binary "v3.5.0"
+download_build_chain "v3.5.0"
 LOG_INFO "------ check_wasm_node---------"
 check_wasm_node "false"
 LOG_INFO "------ check_standard_node---------"
+check_standard_node "false" "normal"
+LOG_INFO "------ check_standard_node---------"
 check_standard_node "true" "sm" "-s"
 rm -rf ./bin

.github/workflows/workflow.yml

@@ -51,7 +51,7 @@ jobs:
         run: ./gradlew.bat build
       - name: run integration testing
         # FIXME: macOS WASM integration testing failed
-        if: runner.os != 'Windows' && runner.os != 'macOS'
+        if: runner.os != 'Windows'
         run: /bin/bash .ci/ci_check.sh
 
   build-centos:

src/integration-test/java/org/fisco/bcos/sdk/v3/test/BcosSDKTest.java

@@ -93,28 +93,26 @@ public void testClient() {
 
         // test getBlockNumber
         BlockNumber blockNumber = client.getBlockNumber();
-        System.out.println("blockNumber=" + blockNumber.getBlockNumber());
+        Assert.assertTrue(blockNumber.getBlockNumber().compareTo(BigInteger.ZERO) >= 0);
 
         BlockHash blockHashByNumber = client.getBlockHashByNumber(blockNumber.getBlockNumber());
-        System.out.println("blockHash=" + blockHashByNumber.getBlockHashByNumber());
+        Assert.assertNotNull(blockHashByNumber.getBlockHashByNumber());
 
         // test getBlockByNumber only header
-        BcosBlock onlyHeader = client.getBlockByNumber(blockNumber.getBlockNumber(), false, false);
-        System.out.println("block header=" + onlyHeader.getBlock());
+        BcosBlock onlyHeader = client.getBlockByNumber(blockNumber.getBlockNumber(), true, false);
         Assert.assertEquals(onlyHeader.getBlock().getHash(), blockHashByNumber.getBlockHashByNumber());
 
         // test getBlockByNumber
         BcosBlock block = client.getBlockByNumber(blockNumber.getBlockNumber(), false, false);
-        System.out.println("block block=" + block.getBlock());
+        Assert.assertEquals(block.getBlock().getHash(), blockHashByNumber.getBlockHashByNumber());
         // getBlockByHash
 
         BcosBlock block0 = client.getBlockByHash(block.getBlock().getHash(), false, false);
-        System.out.println("block block=" + block0.getBlock());
         Assert.assertEquals(block.getBlock(), block0.getBlock());
 
         // get SealerList
         SealerList sealerList = client.getSealerList();
-        System.out.println(sealerList.getSealerList());
+        Assert.assertFalse(sealerList.getSealerList().isEmpty());
 
         // get observerList
         ObserverList observerList = client.getObserverList();
@@ -134,7 +132,7 @@ public void testClient() {
 
         // get getTotalTransactionCount
         TotalTransactionCount totalTransactionCount = client.getTotalTransactionCount();
-        System.out.println(totalTransactionCount.getTotalTransactionCount());
+        Assert.assertTrue(Integer.parseInt(totalTransactionCount.getTotalTransactionCount().getTransactionCount()) >= 0);
 
         // get getPeers
         Peers peers = client.getPeers();
@@ -248,7 +246,7 @@ public void onError(Response errorResponse) {
 
         // get getTotalTransactionCount
         TotalTransactionCount totalTransactionCount = client.getTotalTransactionCount();
-        System.out.println(totalTransactionCount.getTotalTransactionCount());
+        Assert.assertTrue(Integer.parseInt(totalTransactionCount.getTotalTransactionCount().getTransactionCount()) >= 0);
 
         // get getPeers
         Peers peers = client.getPeers();
@@ -261,7 +259,7 @@ public void onError(Response errorResponse) {
         client.getTotalTransactionCountAsync(new RespCallback<TotalTransactionCount>() {
             @Override
             public void onResponse(TotalTransactionCount totalTransactionCount) {
-                System.out.println("totalTransactionCount=" + totalTransactionCount.getTotalTransactionCount());
+                Assert.assertTrue(Integer.parseInt(totalTransactionCount.getTotalTransactionCount().getTransactionCount()) >= 0);
             }
 
             @Override

src/integration-test/java/org/fisco/bcos/sdk/v3/test/transaction/manager/AssembleTransactionWithRemoteSignProcessorTest.java

@@ -18,19 +18,24 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
+
 import org.apache.commons.lang3.StringUtils;
+import org.fisco.bcos.sdk.jni.utilities.tx.TransactionBuilderJniObj;
 import org.fisco.bcos.sdk.v3.BcosSDK;
 import org.fisco.bcos.sdk.v3.client.Client;
+import org.fisco.bcos.sdk.v3.codec.ContractCodec;
 import org.fisco.bcos.sdk.v3.crypto.keypair.CryptoKeyPair;
+import org.fisco.bcos.sdk.v3.crypto.signature.SignatureResult;
 import org.fisco.bcos.sdk.v3.model.ConstantConfig;
 import org.fisco.bcos.sdk.v3.model.TransactionReceipt;
+import org.fisco.bcos.sdk.v3.model.callback.TransactionCallback;
 import org.fisco.bcos.sdk.v3.test.transaction.mock.RemoteSignCallbackMock;
 import org.fisco.bcos.sdk.v3.test.transaction.mock.RemoteSignProviderMock;
 import org.fisco.bcos.sdk.v3.transaction.manager.AssembleTransactionWithRemoteSignProcessor;
 import org.fisco.bcos.sdk.v3.transaction.manager.TransactionProcessorFactory;
-import org.fisco.bcos.sdk.v3.transaction.model.dto.CallResponse;
 import org.fisco.bcos.sdk.v3.transaction.model.dto.TransactionResponse;
 import org.fisco.bcos.sdk.v3.transaction.signer.RemoteSignProviderInterface;
+import org.fisco.bcos.sdk.v3.utils.Hex;
 import org.junit.Assert;
 import org.junit.FixMethodOrder;
 import org.junit.Test;
@@ -60,7 +65,8 @@ public class AssembleTransactionWithRemoteSignProcessorTest {
     private RemoteSignProviderInterface remoteSignProviderMock =
             new RemoteSignProviderMock(this.client.getCryptoSuite());
 
-    public AssembleTransactionWithRemoteSignProcessorTest() {}
+    public AssembleTransactionWithRemoteSignProcessorTest() {
+    }
 
     @Test
     public void test1HelloWorldSync() throws Exception {
@@ -77,32 +83,38 @@ public void test1HelloWorldSync() throws Exception {
                 assembleTransactionWithRemoteSignProcessor
                         .getContractLoader()
                         .getABIByContractName("HelloWorld");
-        // function1: deploy sync
-        TransactionResponse response =
-                assembleTransactionWithRemoteSignProcessor.deployByContractLoader(
-                        "HelloWorld", new ArrayList<>());
-        System.out.println("--- finish deploy with  sync ---");
-        Assert.assertEquals(response.getTransactionReceipt().getStatus(), 0);
-        Assert.assertEquals(0, response.getReturnCode());
-        Assert.assertEquals(0, response.getTransactionReceipt().getStatus());
-        String helloWorldAddress = response.getContractAddress();
-        Assert.assertTrue(
-                StringUtils.isNotBlank(response.getContractAddress())
-                        && !StringUtils.equalsIgnoreCase(
-                                helloWorldAddress,
-                                "0x0000000000000000000000000000000000000000000000000000000000000000"));
+        String bin = assembleTransactionWithRemoteSignProcessor.getContractLoader().getBinaryByContractName("HelloWorld");
 
-        // function2: send transaction `HelloWorld.set("test")` sync
-        TransactionResponse transactionResponse2 =
-                assembleTransactionWithRemoteSignProcessor.sendTransactionAndGetResponse(
-                        helloWorldAddress, abi, "set", this.params);
-        Assert.assertEquals(0, transactionResponse2.getTransactionReceipt().getStatus());
+        ContractCodec contractCodec = new ContractCodec(client.getCryptoSuite().getHashImpl(), client.isWASM());
+
+        long transactionData = TransactionBuilderJniObj.createTransactionData(
+                "group0",
+                "chain0",
+                "",
+                Hex.toHexString(contractCodec.encodeConstructor(abi, bin, params)),
+                abi,
+                client.getBlockLimit().longValue());
+
+        String rawTxHash = TransactionBuilderJniObj.calcTransactionDataHash(client.getCryptoSuite().cryptoTypeConfig, transactionData);
+
+        SignatureResult signatureResult = remoteSignProviderMock.requestForSign(Hex.decode(rawTxHash), this.client.getCryptoSuite().cryptoTypeConfig);
+
+        String signedTransaction = TransactionBuilderJniObj.createSignedTransaction(transactionData, Hex.toHexString(signatureResult.encode()), rawTxHash, 0);
+
+        CompletableFuture<TransactionReceipt> receiptCompletableFuture = new CompletableFuture<>();
+        assembleTransactionWithRemoteSignProcessor.sendTransactionAsync(signedTransaction, new TransactionCallback() {
+            @Override
+            public void onResponse(TransactionReceipt receipt) {
+                receiptCompletableFuture.complete(receipt);
+            }
+        });
+
+        TransactionReceipt transactionReceipt = receiptCompletableFuture.get();
 
-        // function3:  call, which only support sync mode.
-        CallResponse callResponse1 =
-                assembleTransactionWithRemoteSignProcessor.sendCallByContractLoader(
-                        "HelloWorld", helloWorldAddress, "get", new ArrayList<>());
-        Assert.assertEquals("test", callResponse1.getResults().get(0).getValue());
+        Assert.assertEquals(transactionReceipt.getStatus(), 0);
+        Assert.assertFalse(transactionReceipt.getContractAddress().isEmpty());
+        String abi1 = client.getABI(transactionReceipt.getContractAddress()).getABI();
+        Assert.assertEquals(abi1, abi);
     }
 
     @Test
@@ -135,8 +147,8 @@ public void test2HelloWorldAsync() throws Exception {
         Assert.assertTrue(
                 StringUtils.isNotBlank(response.getContractAddress())
                         && !StringUtils.equalsIgnoreCase(
-                                helloWorldAddress,
-                                "0x0000000000000000000000000000000000000000000000000000000000000000"));
+                        helloWorldAddress,
+                        "0x0000000000000000000000000000000000000000000000000000000000000000"));
 
         // function2: deploy async with callback
         long transactionData =

src/main/java/org/fisco/bcos/sdk/v3/client/protocol/model/JsonTransactionResponse.java

@@ -239,45 +239,52 @@ public int hashCode() {
 
     @Override
     public String toString() {
-        return "{"
-                + "version='"
-                + this.version
-                + '\''
-                + ", from='"
-                + this.from
-                + '\''
-                + ", hash='"
-                + this.hash
-                + '\''
-                + ", input='"
-                + this.input
-                + '\''
-                + ", nonce='"
-                + this.nonce
-                + '\''
-                + ", to='"
-                + this.getTo()
-                + '\''
-                + ", abi='"
-                + this.abi
-                + '\''
-                + ", blockLimit='"
-                + this.blockLimit
-                + '\''
-                + ", chainId='"
-                + this.chainID
-                + '\''
-                + ", groupID='"
-                + this.groupID
-                + '\''
-                + ", txProof='"
-                + this.txProof
-                + '\''
-                + ", signature="
-                + this.signature
-                + ", extraData="
-                + this.extraData
-                + '}';
+        try {
+            return ObjectMapperFactory.getObjectMapper().writeValueAsString(this);
+        } catch (Exception ignored) {
+            return "JsonTransactionResponse{"
+                    + "version="
+                    + version
+                    + ", hash='"
+                    + hash
+                    + '\''
+                    + ", nonce='"
+                    + nonce
+                    + '\''
+                    + ", blockLimit="
+                    + blockLimit
+                    + ", to='"
+                    + to
+                    + '\''
+                    + ", from='"
+                    + from
+                    + '\''
+                    + ", abi='"
+                    + abi
+                    + '\''
+                    + ", input='"
+                    + input
+                    + '\''
+                    + ", chainID='"
+                    + chainID
+                    + '\''
+                    + ", groupID='"
+                    + groupID
+                    + '\''
+                    + ", extraData='"
+                    + extraData
+                    + '\''
+                    + ", signature='"
+                    + signature
+                    + '\''
+                    + ", importTime="
+                    + importTime
+                    + ", transactionProof="
+                    + transactionProof
+                    + ", txProof="
+                    + txProof
+                    + '}';
+        }
     }
 
     public String getExtraData() {

src/main/java/org/fisco/bcos/sdk/v3/codec/ContractCodec.java

@@ -48,6 +48,10 @@
 import org.fisco.bcos.sdk.v3.codec.wrapper.ContractCodecJsonWrapper;
 import org.fisco.bcos.sdk.v3.codec.wrapper.ContractCodecTools;
 import org.fisco.bcos.sdk.v3.crypto.CryptoSuite;
+import org.fisco.bcos.sdk.v3.crypto.hash.Hash;
+import org.fisco.bcos.sdk.v3.crypto.hash.Keccak256;
+import org.fisco.bcos.sdk.v3.crypto.hash.SM3Hash;
+import org.fisco.bcos.sdk.v3.model.CryptoType;
 import org.fisco.bcos.sdk.v3.model.EventLog;
 import org.fisco.bcos.sdk.v3.utils.Hex;
 import org.fisco.bcos.sdk.v3.utils.Numeric;
@@ -61,6 +65,7 @@ public class ContractCodec {
     private static final Logger logger = LoggerFactory.getLogger(ContractCodec.class);
 
     private final CryptoSuite cryptoSuite;
+    private final Hash hashImpl;
     private final boolean isWasm;
     private final ObjectMapper objectMapper = ObjectMapperFactory.getObjectMapper();
     private FunctionEncoderInterface functionEncoder = null;
@@ -69,25 +74,53 @@ public class ContractCodec {
     private final ContractCodecJsonWrapper contractCodecJsonWrapper =
             new ContractCodecJsonWrapper();
 
+    @Deprecated
     public ContractCodec(CryptoSuite cryptoSuite, boolean isWasm) {
         this.cryptoSuite = cryptoSuite;
+        this.hashImpl = cryptoSuite.getHashImpl();
+        this.isWasm = isWasm;
+        if (isWasm) {
+            this.functionEncoder =
+                    new org.fisco.bcos.sdk.v3.codec.scale.FunctionEncoder(this.hashImpl);
+            this.functionReturnDecoder = new FunctionReturnDecoder();
+        } else {
+            this.functionEncoder =
+                    new org.fisco.bcos.sdk.v3.codec.abi.FunctionEncoder(this.hashImpl);
+            this.functionReturnDecoder =
+                    new org.fisco.bcos.sdk.v3.codec.abi.FunctionReturnDecoder();
+        }
+        this.abiDefinitionFactory = new ABIDefinitionFactory(hashImpl);
+    }
+
+    public ContractCodec(Hash hashImpl, boolean isWasm) {
+        this.hashImpl = hashImpl;
         this.isWasm = isWasm;
         if (isWasm) {
             this.functionEncoder =
-                    new org.fisco.bcos.sdk.v3.codec.scale.FunctionEncoder(cryptoSuite);
+                    new org.fisco.bcos.sdk.v3.codec.scale.FunctionEncoder(this.hashImpl);
             this.functionReturnDecoder = new FunctionReturnDecoder();
         } else {
-            this.functionEncoder = new org.fisco.bcos.sdk.v3.codec.abi.FunctionEncoder(cryptoSuite);
+            this.functionEncoder =
+                    new org.fisco.bcos.sdk.v3.codec.abi.FunctionEncoder(this.hashImpl);
             this.functionReturnDecoder =
                     new org.fisco.bcos.sdk.v3.codec.abi.FunctionReturnDecoder();
         }
-        this.abiDefinitionFactory = new ABIDefinitionFactory(cryptoSuite);
+        this.abiDefinitionFactory = new ABIDefinitionFactory(this.hashImpl);
+        // for compatibility
+        if (this.hashImpl instanceof SM3Hash) {
+            this.cryptoSuite = new CryptoSuite(CryptoType.SM_TYPE);
+        } else if (this.hashImpl instanceof Keccak256) {
+            this.cryptoSuite = new CryptoSuite(CryptoType.ECDSA_TYPE);
+        } else {
+            this.cryptoSuite = null;
+        }
     }
 
     public boolean isWasm() {
         return isWasm;
     }
 
+    @Deprecated
     public CryptoSuite getCryptoSuite() {
         return this.cryptoSuite;
     }