diff --git a/.ci/ci_check_commit.sh b/.ci/ci_check_commit.sh index 9d6867355..3c02ba469 100755 --- a/.ci/ci_check_commit.sh +++ b/.ci/ci_check_commit.sh @@ -3,7 +3,7 @@ set -e scan_code_script="cobra/cobra.py -f json -o /tmp/report.json -t " -ignore_files=(Constant.java PerformanceOkDSync.java SM2Algorithm.java SM2KeyGenerator.java test) +ignore_files=(RevertResolver.java ECCParams.java ECKeyPair.java KeyUtils.java Permission.java Frozen.java ECDSASign.java Constant.java PerformanceOkDSync.java SM2Algorithm.java SM2KeyGenerator.java test) LOG_ERROR() { content=${1} diff --git a/build.gradle b/build.gradle index aeb25b1d4..a73fd384c 100644 --- a/build.gradle +++ b/build.gradle @@ -96,6 +96,7 @@ dependencies { compile 'org.projectlombok:lombok:1.18.2' } + //archivesBaseName = 'web3sdk' //group = 'org.fisco-bcos' //version = '2.0.5' @@ -149,6 +150,10 @@ try { println(" .git directory not exist."); } +tasks.withType(Test) { + maxParallelForks = 1 +} + // 1 dist jar jar { destinationDir file('dist/apps') diff --git a/release_note.txt b/release_note.txt index 0b1f88b80..b1d18bc43 100644 --- a/release_note.txt +++ b/release_note.txt @@ -1 +1 @@ -v2.2.3 +v2.3.0 diff --git a/solidity/Table.sol b/solidity/Table.sol index 51d037252..a590dabe7 100644 --- a/solidity/Table.sol +++ b/solidity/Table.sol @@ -2,57 +2,67 @@ pragma solidity ^0.4.24; contract TableFactory { function openTable(string) public constant returns (Table); //open table - function createTable(string,string,string) public returns(int); //create table + function createTable(string, string, string) public returns (int256); //create table } //select condition contract Condition { - function EQ(string, int) public; + function EQ(string, int256) public; function EQ(string, string) public; - - function NE(string, int) public; - function NE(string, string) public; - - function GT(string, int) public; - function GE(string, int) public; - - function LT(string, int) public; - function LE(string, int) public; - - function limit(int) public; - function limit(int, int) public; + + function NE(string, int256) public; + function NE(string, string) public; + + function GT(string, int256) public; + function GE(string, int256) public; + + function LT(string, int256) public; + function LE(string, int256) public; + + function limit(int256) public; + function limit(int256, int256) public; } -//one record +//one record contract Entry { - function getInt(string) public constant returns(int); - function getAddress(string) public constant returns(address); - function getBytes64(string) public constant returns(byte[64]); - function getBytes32(string) public constant returns(bytes32); - function getString(string) public constant returns(string); - - function set(string, int) public; + function getInt(string) public constant returns (int256); + function getUInt(string) public constant returns (int256); + function getAddress(string) public constant returns (address); + function getBytes64(string) public constant returns (bytes1[64]); + function getBytes32(string) public constant returns (bytes32); + function getString(string) public constant returns (string); + + function set(string, int256) public; + function set(string, uint256) public; function set(string, string) public; function set(string, address) public; } //record sets contract Entries { - function get(int) public constant returns(Entry); - function size() public constant returns(int); + function get(int256) public constant returns (Entry); + function size() public constant returns (int256); } //Table main contract contract Table { - //select api - function select(string, Condition) public constant returns(Entries); - //insert api - function insert(string, Entry) public returns(int); - //update api - function update(string, Entry, Condition) public returns(int); - //remove api - function remove(string, Condition) public returns(int); - - function newEntry() public constant returns(Entry); - function newCondition() public constant returns(Condition); + function select(string, Condition) public constant returns (Entries); + function insert(string, Entry) public returns (int256); + function update(string, Entry, Condition) public returns (int256); + function remove(string, Condition) public returns (int256); + + function newEntry() public constant returns (Entry); + function newCondition() public constant returns (Condition); +} + +contract KVTableFactory { + function openTable(string) public constant returns (KVTable); + function createTable(string, string, string) public returns (int256); +} + +//KVTable per permiary key has only one Entry +contract KVTable { + function get(string) public constant returns (bool, Entry); + function set(string, Entry) public returns (int256); + function newEntry() public constant returns (Entry); } diff --git a/solidity/TableTest.sol b/solidity/TableTest.sol index 041e3bd94..ab5677b30 100644 --- a/solidity/TableTest.sol +++ b/solidity/TableTest.sol @@ -1,89 +1,97 @@ pragma solidity ^0.4.24; pragma experimental ABIEncoderV2; - import "./Table.sol"; contract TableTest { - event CreateResult(int count); - event InsertResult(int count); - event UpdateResult(int count); - event RemoveResult(int count); - - //create table - function create() public returns(int){ - TableFactory tf = TableFactory(0x1001); //The fixed address is 0x1001 for TableFactory - - int count = tf.createTable("t_test", "name", "item_id,item_name"); - emit CreateResult(count); - return count; + event CreateResult(int256 count); + event InsertResult(int256 count); + event UpdateResult(int256 count); + event RemoveResult(int256 count); + + TableFactory tableFactory; + string constant TABLE_NAME = "t_test"; + constructor() public { + tableFactory = TableFactory(0x1001); //The fixed address is 0x1001 for TableFactory + // the parameters of createTable are tableName,keyField,"vlaueFiled1,vlaueFiled2,vlaueFiled3,..." + tableFactory.createTable(TABLE_NAME, "name", "item_id,item_name"); } //select records - function select(string name) public constant returns(string[], int[], string[]){ - TableFactory tf = TableFactory(0x1001); - Table table = tf.openTable("t_test"); - + function select(string name) + public + view + returns (string[], int256[], string[]) + { + Table table = tableFactory.openTable(TABLE_NAME); + Condition condition = table.newCondition(); - + Entries entries = table.select(name, condition); - string[] memory user_name_bytes_list = new string[](uint256(entries.size())); - int[] memory item_id_list = new int[](uint256(entries.size())); - string[] memory item_name_bytes_list = new string[](uint256(entries.size())); - - for(int i=0; i topics // topics that - * subscribe again service.setTopics(topics) 2. send update topics message to all nodes - * service.updateTopicsToNode(); - */ public void updateTopicsToNode() { logger.info(" updateTopicToNode, groupId: {}, topics: {}", groupId, getTopics()); @@ -1548,6 +1543,12 @@ public void onReceiveTransactionMessage(String seq, TransactionReceipt receipt) } try { + Tuple2 revertMessage = + RevertResolver.tryResolveRevertMessage(receipt); + if (revertMessage.getValue1()) { + logger.debug(" revert message: {}", revertMessage.getValue2()); + receipt.setMessage(revertMessage.getValue2()); + } callback.onResponse(receipt); } catch (Exception e) { logger.error("Error process transactionMessage: ", e); diff --git a/src/main/java/org/fisco/bcos/channel/dto/ChannelMessage2.java b/src/main/java/org/fisco/bcos/channel/dto/ChannelMessage2.java index de9a8f4e5..f7426cf3c 100644 --- a/src/main/java/org/fisco/bcos/channel/dto/ChannelMessage2.java +++ b/src/main/java/org/fisco/bcos/channel/dto/ChannelMessage2.java @@ -1,6 +1,7 @@ package org.fisco.bcos.channel.dto; import io.netty.buffer.ByteBuf; +import java.io.UnsupportedEncodingException; import org.fisco.bcos.channel.handler.Message; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -36,14 +37,22 @@ public void readExtra(ByteBuf in) { @Override public void writeHeader(ByteBuf out) { // total length - length = Message.HEADER_LENGTH + 1 + topic.length() + data.length; + try { + length = Message.HEADER_LENGTH + 1 + topic.getBytes("utf-8").length + data.length; + } catch (UnsupportedEncodingException e) { + throw new RuntimeException(" topic string to utf8 failed, topic: " + topic); + } super.writeHeader(out); } @Override public void writeExtra(ByteBuf out) { - out.writeByte(1 + topic.length()); + try { + out.writeByte(1 + topic.getBytes("utf-8").length); + } catch (UnsupportedEncodingException e) { + throw new RuntimeException(" topic string to utf8 failed, topic: " + topic); + } out.writeBytes(topic.getBytes()); out.writeBytes(data); diff --git a/src/main/java/org/fisco/bcos/web3j/abi/datatypes/Function.java b/src/main/java/org/fisco/bcos/web3j/abi/datatypes/Function.java index a9d1cdbf1..53a212be3 100644 --- a/src/main/java/org/fisco/bcos/web3j/abi/datatypes/Function.java +++ b/src/main/java/org/fisco/bcos/web3j/abi/datatypes/Function.java @@ -1,5 +1,6 @@ package org.fisco.bcos.web3j.abi.datatypes; +import java.util.Collections; import java.util.List; import org.fisco.bcos.web3j.abi.TypeReference; import org.fisco.bcos.web3j.abi.Utils; @@ -17,6 +18,12 @@ public Function( this.outputParameters = Utils.convert(outputParameters); } + public Function() { + this.name = ""; + this.inputParameters = Collections.emptyList(); + this.outputParameters = Collections.>emptyList(); + } + public String getName() { return name; } diff --git a/src/main/java/org/fisco/bcos/web3j/codegen/SolidityFunctionWrapper.java b/src/main/java/org/fisco/bcos/web3j/codegen/SolidityFunctionWrapper.java index 6f837e18a..7ce6a6203 100644 --- a/src/main/java/org/fisco/bcos/web3j/codegen/SolidityFunctionWrapper.java +++ b/src/main/java/org/fisco/bcos/web3j/codegen/SolidityFunctionWrapper.java @@ -177,8 +177,10 @@ private TypeSpec.Builder createClassBuilder( AnnotationSpec.builder(SuppressWarnings.class) .addMember("value", "$S", "unchecked") .build()) - .addField(createBinaryDefinition(binary)) - .addField(createABIDefinition(abi)) + .addField(createBinaryArrayDefinition(binary)) + .addField(createBinaryDefinition()) + .addField(createABIArrayDefinition()) + .addField(createABIDefinition()) .addField(createTransactionDecoderDefinition()); } @@ -203,19 +205,69 @@ private FieldSpec createTransactionDecoderDefinition() { .build(); } - private FieldSpec createBinaryDefinition(String binary) { + private FieldSpec createBinaryArrayDefinition(String binary) { + int maxField = 8 * 1024; // 8k for each field + List format = new ArrayList(); + List binaryArray = new ArrayList(); + + for (int offset = 0; offset < binary.length(); ) { + format.add("$S"); + + int length = binary.length() - offset; + if (length > maxField) { + length = maxField; + } + + String item = binary.substring(offset, offset + length); + + binaryArray.add(item); + offset += item.length(); + } + + return FieldSpec.builder(String[].class, "BINARY_ARRAY") + .addModifiers(Modifier.PUBLIC, Modifier.FINAL, Modifier.STATIC) + .initializer("{" + String.join(",", format) + "}", binaryArray.toArray()) + .build(); + } + + private FieldSpec createBinaryDefinition() { return FieldSpec.builder(String.class, BINARY) - .addModifiers(Modifier.PUBLIC, Modifier.STATIC) - // .addModifiers(Modifier.PUBLIC, Modifier.FINAL, Modifier.STATIC) - .initializer("$S", binary) + .addModifiers(Modifier.PUBLIC, Modifier.FINAL, Modifier.STATIC) + .initializer("String.join(\"\", BINARY_ARRAY)") + .build(); + } + + private FieldSpec createABIArrayDefinition() { + int maxField = 8 * 1024; // 8k for each field + + List format = new ArrayList(); + List abiArray = new ArrayList(); + + for (int offset = 0; offset < abiContent.length(); ) { + format.add("$S"); + + int length = abiContent.length() - offset; + if (length > maxField) { + length = maxField; + } + + String item = abiContent.substring(offset, offset + length); + + abiArray.add(item); + offset += item.length(); + } + + return FieldSpec.builder(String[].class, "ABI_ARRAY") + .addModifiers(Modifier.PUBLIC, Modifier.FINAL, Modifier.STATIC) + .initializer("{" + String.join(",", format) + "}", abiArray.toArray()) .build(); } - private FieldSpec createABIDefinition(List abi) { + private FieldSpec createABIDefinition() { return FieldSpec.builder(String.class, "ABI") .addModifiers(Modifier.PUBLIC, Modifier.FINAL, Modifier.STATIC) - .initializer("$S", abiContent) + .initializer("String.join(\"\", ABI_ARRAY)") .build(); } diff --git a/src/main/java/org/fisco/bcos/web3j/crypto/ECDSASign.java b/src/main/java/org/fisco/bcos/web3j/crypto/ECDSASign.java index 6379260be..04282c2c6 100644 --- a/src/main/java/org/fisco/bcos/web3j/crypto/ECDSASign.java +++ b/src/main/java/org/fisco/bcos/web3j/crypto/ECDSASign.java @@ -5,12 +5,30 @@ import java.math.BigInteger; import org.bouncycastle.crypto.digests.SHA256Digest; import org.bouncycastle.crypto.params.ECPrivateKeyParameters; -import org.bouncycastle.crypto.signers.ECDSASigner; import org.bouncycastle.crypto.signers.HMacDSAKCalculator; +import org.bouncycastle.math.ec.ECPoint; +import org.bouncycastle.util.encoders.Hex; import org.fisco.bcos.web3j.utils.Numeric; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; -/** Created by websterchen on 2018/4/25. */ public class ECDSASign implements SignInterface { + + private static final Logger logger = LoggerFactory.getLogger(ECDSASign.class); + + private static final BigInteger curveN = + new BigInteger( + 1, + Hex.decode("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141")); + private static final BigInteger halfCurveN = curveN.shiftRight(1); + + /** + * Sign the message with ECDSA algorithm + * + * @param message + * @param keyPair + * @return + */ @Override public Sign.SignatureData signMessage(byte[] message, ECKeyPair keyPair) { BigInteger privateKey = keyPair.getPrivateKey(); @@ -19,20 +37,54 @@ public Sign.SignatureData signMessage(byte[] message, ECKeyPair keyPair) { byte[] messageHash = Hash.sha3(message); ECDSASignature sig = sign(messageHash, privateKey); + // Now we have to work backwards to figure out the recId needed to recover the signature. - int recId = -1; + + /** Optimize the algorithm for calculating the recId value */ + ECPoint ecPoint = sig.p; + BigInteger affineXCoordValue = ecPoint.normalize().getAffineXCoord().toBigInteger(); + BigInteger affineYCoordValue = ecPoint.normalize().getAffineYCoord().toBigInteger(); + + int recId = affineYCoordValue.and(BigInteger.ONE).intValue(); + recId |= (affineXCoordValue.compareTo(sig.r) != 0 ? 2 : 0); + if (sig.s.compareTo(halfCurveN) > 0) { + sig.s = Sign.CURVE.getN().subtract(sig.s); + recId = recId ^ 1; + } + + /** + * The algorithm that calculated the recId value before and can be used to test if recId + * value is correct + */ + /* + int recId0 = -1; for (int i = 0; i < 4; i++) { BigInteger k = Sign.recoverFromSignature(i, sig, messageHash); if (k != null && k.equals(publicKey)) { - recId = i; + recId0 = i; break; } } - if (recId == -1) { + + if (recId0 == -1) { throw new RuntimeException( "Could not construct a recoverable key. This should never happen."); } + if (recId != recId0) { + if (logger.isErrorEnabled()) { + logger.error( + " invalid recId value111, recId={}, recIdOld={}, s={}, r={}, x={}, y={} ", + recId, + recIdOld, + sig.s, + sig.r, + affineXCoordValue, + affineYCoordValue); + } + } + */ + int headerByte = recId + 27; // 1 header + 32 bytes for R + 32 bytes for S @@ -43,13 +95,31 @@ public Sign.SignatureData signMessage(byte[] message, ECKeyPair keyPair) { return new Sign.SignatureData(v, r, s); } + /** + * Verify the ECDSA signature + * + * @param hash + * @param publicKey + * @param signatureData + * @return + */ + public boolean verify(byte[] hash, BigInteger publicKey, Sign.SignatureData signatureData) { + ECDSASignature sig = + new ECDSASignature( + Numeric.toBigInt(signatureData.getR()), + Numeric.toBigInt(signatureData.getS())); + + BigInteger k = Sign.recoverFromSignature(signatureData.getV() - 27, sig, hash); + return publicKey.equals(k); + } + public static ECDSASignature sign(byte[] transactionHash, BigInteger privateKey) { ECDSASigner signer = new ECDSASigner(new HMacDSAKCalculator(new SHA256Digest())); ECPrivateKeyParameters privKey = new ECPrivateKeyParameters(privateKey, CURVE); signer.init(true, privKey); - BigInteger[] components = signer.generateSignature(transactionHash); - - return new ECDSASignature(components[0], components[1]).toCanonicalised(); + Object[] components = signer.generateSignature2(transactionHash); + return new ECDSASignature( + (BigInteger) components[0], (BigInteger) components[1], (ECPoint) components[2]); } } diff --git a/src/main/java/org/fisco/bcos/web3j/crypto/ECDSASignature.java b/src/main/java/org/fisco/bcos/web3j/crypto/ECDSASignature.java index cb7294d9b..0ae86e16e 100644 --- a/src/main/java/org/fisco/bcos/web3j/crypto/ECDSASignature.java +++ b/src/main/java/org/fisco/bcos/web3j/crypto/ECDSASignature.java @@ -1,15 +1,26 @@ package org.fisco.bcos.web3j.crypto; import java.math.BigInteger; +import org.bouncycastle.math.ec.ECPoint; /** An ECDSA Signature. */ public class ECDSASignature { - public final BigInteger r; - public final BigInteger s; + public BigInteger r; + public BigInteger s; + /** + * The value of p is used to assist in calculating the value of recvID and it's value is + * generated during the signature process + */ + public ECPoint p; - public ECDSASignature(BigInteger r, BigInteger s) { + public ECDSASignature(BigInteger r, BigInteger s, ECPoint p) { this.r = r; this.s = s; + this.p = p; + } + + public ECDSASignature(BigInteger r, BigInteger s) { + this(r, s, null); } /** @@ -40,7 +51,7 @@ public ECDSASignature toCanonicalised() { // N = 10 // s = 8, so (-8 % 10 == 2) thus both (r, 8) and (r, 2) are valid solutions. // 10 - 8 == 2, giving us always the latter solution, which is canonical. - return new ECDSASignature(r, Sign.CURVE.getN().subtract(s)); + return new ECDSASignature(r, Sign.CURVE.getN().subtract(s), p); } else { return this; } diff --git a/src/main/java/org/fisco/bcos/web3j/crypto/ECDSASigner.java b/src/main/java/org/fisco/bcos/web3j/crypto/ECDSASigner.java new file mode 100644 index 000000000..03e0dd859 --- /dev/null +++ b/src/main/java/org/fisco/bcos/web3j/crypto/ECDSASigner.java @@ -0,0 +1,266 @@ +package org.fisco.bcos.web3j.crypto; + +import java.math.BigInteger; +import java.security.SecureRandom; +import org.bouncycastle.crypto.CipherParameters; +import org.bouncycastle.crypto.CryptoServicesRegistrar; +import org.bouncycastle.crypto.DSA; +import org.bouncycastle.crypto.params.ECDomainParameters; +import org.bouncycastle.crypto.params.ECKeyParameters; +import org.bouncycastle.crypto.params.ECPrivateKeyParameters; +import org.bouncycastle.crypto.params.ECPublicKeyParameters; +import org.bouncycastle.crypto.params.ParametersWithRandom; +import org.bouncycastle.crypto.signers.DSAKCalculator; +import org.bouncycastle.crypto.signers.RandomDSAKCalculator; +import org.bouncycastle.math.ec.ECAlgorithms; +import org.bouncycastle.math.ec.ECConstants; +import org.bouncycastle.math.ec.ECCurve; +import org.bouncycastle.math.ec.ECFieldElement; +import org.bouncycastle.math.ec.ECMultiplier; +import org.bouncycastle.math.ec.ECPoint; +import org.bouncycastle.math.ec.FixedPointCombMultiplier; + +/** + * Copy from bc library, file: org.bouncycastle.crypto.signers.ECDSASigner Only simple + * modifications(Add generateSignature2 method) were made to optimize the the calculation of recvId + */ + +/** EC-DSA as described in X9.62 */ +public class ECDSASigner implements ECConstants, DSA { + private final DSAKCalculator kCalculator; + + private ECKeyParameters key; + private SecureRandom random; + + /** Default configuration, random K values. */ + public ECDSASigner() { + this.kCalculator = new RandomDSAKCalculator(); + } + + /** + * Configuration with an alternate, possibly deterministic calculator of K. + * + * @param kCalculator a K value calculator. + */ + public ECDSASigner(DSAKCalculator kCalculator) { + this.kCalculator = kCalculator; + } + + @Override + public void init(boolean forSigning, CipherParameters param) { + SecureRandom providedRandom = null; + + if (forSigning) { + if (param instanceof ParametersWithRandom) { + ParametersWithRandom rParam = (ParametersWithRandom) param; + + this.key = (ECPrivateKeyParameters) rParam.getParameters(); + providedRandom = rParam.getRandom(); + } else { + this.key = (ECPrivateKeyParameters) param; + } + } else { + this.key = (ECPublicKeyParameters) param; + } + + this.random = + initSecureRandom(forSigning && !kCalculator.isDeterministic(), providedRandom); + } + + // 5.3 pg 28 + /** + * generate a signature for the given message using the key we were initialised with. For + * conventional DSA the message should be a SHA-1 hash of the message of interest. + * + * @param message the message that will be verified later. + */ + @Override + public BigInteger[] generateSignature(byte[] message) { + ECDomainParameters ec = key.getParameters(); + BigInteger n = ec.getN(); + BigInteger e = calculateE(n, message); + BigInteger d = ((ECPrivateKeyParameters) key).getD(); + + if (kCalculator.isDeterministic()) { + kCalculator.init(n, d, message); + } else { + kCalculator.init(n, random); + } + + BigInteger r, s; + + ECMultiplier basePointMultiplier = createBasePointMultiplier(); + + // 5.3.2 + do // generate s + { + BigInteger k; + do // generate r + { + k = kCalculator.nextK(); + + ECPoint p = basePointMultiplier.multiply(ec.getG(), k).normalize(); + + // 5.3.3 + r = p.getAffineXCoord().toBigInteger().mod(n); + } while (r.equals(ZERO)); + + s = k.modInverse(n).multiply(e.add(d.multiply(r))).mod(n); + } while (s.equals(ZERO)); + + return new BigInteger[] {r, s}; + } + + /** + * The same generateSignature with the temporary variable ECPoint P generated by the signature + * process is also returned together + * + * @param message the message that will be verified later. + */ + public Object[] generateSignature2(byte[] message) { + ECDomainParameters ec = key.getParameters(); + BigInteger n = ec.getN(); + BigInteger e = calculateE(n, message); + BigInteger d = ((ECPrivateKeyParameters) key).getD(); + + if (kCalculator.isDeterministic()) { + kCalculator.init(n, d, message); + } else { + kCalculator.init(n, random); + } + + BigInteger r, s; + + /** */ + ECPoint p; + + ECMultiplier basePointMultiplier = createBasePointMultiplier(); + + // 5.3.2 + do // generate s + { + BigInteger k; + do // generate r + { + k = kCalculator.nextK(); + + p = basePointMultiplier.multiply(ec.getG(), k).normalize(); + + // 5.3.3 + r = p.getAffineXCoord().toBigInteger().mod(n); + } while (r.equals(ZERO)); + + s = k.modInverse(n).multiply(e.add(d.multiply(r))).mod(n); + } while (s.equals(ZERO)); + + return new Object[] {r, s, p}; + } + + // 5.4 pg 29 + /** + * return true if the value r and s represent a DSA signature for the passed in message (for + * standard DSA the message should be a SHA-1 hash of the real message to be verified). + */ + @Override + public boolean verifySignature(byte[] message, BigInteger r, BigInteger s) { + ECDomainParameters ec = key.getParameters(); + BigInteger n = ec.getN(); + BigInteger e = calculateE(n, message); + + // r in the range [1,n-1] + if (r.compareTo(ONE) < 0 || r.compareTo(n) >= 0) { + return false; + } + + // s in the range [1,n-1] + if (s.compareTo(ONE) < 0 || s.compareTo(n) >= 0) { + return false; + } + + BigInteger c = s.modInverse(n); + + BigInteger u1 = e.multiply(c).mod(n); + BigInteger u2 = r.multiply(c).mod(n); + + ECPoint G = ec.getG(); + ECPoint Q = ((ECPublicKeyParameters) key).getQ(); + + ECPoint point = ECAlgorithms.sumOfTwoMultiplies(G, u1, Q, u2); + + // components must be bogus. + if (point.isInfinity()) { + return false; + } + + /* + * If possible, avoid normalizing the point (to save a modular inversion in the curve field). + * + * There are ~cofactor elements of the curve field that reduce (modulo the group order) to 'r'. + * If the cofactor is known and small, we generate those possible field values and project each + * of them to the same "denominator" (depending on the particular projective coordinates in use) + * as the calculated point.X. If any of the projected values matches point.X, then we have: + * (point.X / Denominator mod p) mod n == r + * as required, and verification succeeds. + * + * Based on an original idea by Gregory Maxwell (https://github.com/gmaxwell), as implemented in + * the libsecp256k1 project (https://github.com/bitcoin/secp256k1). + */ + ECCurve curve = point.getCurve(); + if (curve != null) { + BigInteger cofactor = curve.getCofactor(); + if (cofactor != null && cofactor.compareTo(EIGHT) <= 0) { + ECFieldElement D = getDenominator(curve.getCoordinateSystem(), point); + if (D != null && !D.isZero()) { + ECFieldElement X = point.getXCoord(); + while (curve.isValidFieldElement(r)) { + ECFieldElement R = curve.fromBigInteger(r).multiply(D); + if (R.equals(X)) { + return true; + } + r = r.add(n); + } + return false; + } + } + } + + BigInteger v = point.normalize().getAffineXCoord().toBigInteger().mod(n); + return v.equals(r); + } + + protected BigInteger calculateE(BigInteger n, byte[] message) { + int log2n = n.bitLength(); + int messageBitLength = message.length * 8; + + BigInteger e = new BigInteger(1, message); + if (log2n < messageBitLength) { + e = e.shiftRight(messageBitLength - log2n); + } + return e; + } + + protected ECMultiplier createBasePointMultiplier() { + return new FixedPointCombMultiplier(); + } + + protected ECFieldElement getDenominator(int coordinateSystem, ECPoint p) { + switch (coordinateSystem) { + case ECCurve.COORD_HOMOGENEOUS: + case ECCurve.COORD_LAMBDA_PROJECTIVE: + case ECCurve.COORD_SKEWED: + return p.getZCoord(0); + case ECCurve.COORD_JACOBIAN: + case ECCurve.COORD_JACOBIAN_CHUDNOVSKY: + case ECCurve.COORD_JACOBIAN_MODIFIED: + return p.getZCoord(0).square(); + default: + return null; + } + } + + protected SecureRandom initSecureRandom(boolean needed, SecureRandom provided) { + return !needed + ? null + : (provided != null) ? provided : CryptoServicesRegistrar.getSecureRandom(); + } +} diff --git a/src/main/java/org/fisco/bcos/web3j/crypto/ECKeyPair.java b/src/main/java/org/fisco/bcos/web3j/crypto/ECKeyPair.java index c75b8a45b..daf188933 100644 --- a/src/main/java/org/fisco/bcos/web3j/crypto/ECKeyPair.java +++ b/src/main/java/org/fisco/bcos/web3j/crypto/ECKeyPair.java @@ -3,16 +3,23 @@ import java.math.BigInteger; import java.security.KeyPair; import java.util.Arrays; +import java.util.Objects; import org.bouncycastle.crypto.digests.SHA256Digest; import org.bouncycastle.crypto.params.ECPrivateKeyParameters; +import org.bouncycastle.crypto.params.ECPublicKeyParameters; import org.bouncycastle.crypto.signers.ECDSASigner; import org.bouncycastle.crypto.signers.HMacDSAKCalculator; import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey; import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey; import org.fisco.bcos.web3j.utils.Numeric; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; /** Elliptic Curve SECP-256k1 generated key pair. */ public class ECKeyPair { + + private static final Logger logger = LoggerFactory.getLogger(ECKeyPair.class); + private final BigInteger privateKey; private final BigInteger publicKey; @@ -30,21 +37,11 @@ public BigInteger getPublicKey() { } /** - * Sign a hash with the private key of this key pair. + * create ECKeyPair from KeyPair * - * @param transactionHash the hash to sign - * @return An {@link ECDSASignature} of the hash + * @param keyPair + * @return */ - public ECDSASignature sign(byte[] transactionHash) { - ECDSASigner signer = new ECDSASigner(new HMacDSAKCalculator(new SHA256Digest())); - - ECPrivateKeyParameters privKey = new ECPrivateKeyParameters(privateKey, Sign.CURVE); - signer.init(true, privKey); - BigInteger[] components = signer.generateSignature(transactionHash); - - return new ECDSASignature(components[0], components[1]).toCanonicalised(); - } - public static ECKeyPair create(KeyPair keyPair) { BCECPrivateKey privateKey = (BCECPrivateKey) keyPair.getPrivate(); BCECPublicKey publicKey = (BCECPublicKey) keyPair.getPublic(); @@ -58,43 +55,75 @@ public static ECKeyPair create(KeyPair keyPair) { BigInteger publicKeyValue = new BigInteger(1, Arrays.copyOfRange(publicKeyBytes, 1, publicKeyBytes.length)); - return new ECKeyPair(privateKeyValue, publicKeyValue); + ECKeyPair ecKeyPair = new ECKeyPair(privateKeyValue, publicKeyValue); + return ecKeyPair; } + /** + * create ECKeyPair from privateKey + * + * @param privateKey + * @return + */ public static ECKeyPair create(BigInteger privateKey) { return new ECKeyPair(privateKey, Sign.publicKeyFromPrivate(privateKey)); } + /** + * create ECKeyPair from privateKey + * + * @param privateKey + * @return + */ public static ECKeyPair create(byte[] privateKey) { return create(Numeric.toBigInt(privateKey)); } - @Override - public boolean equals(Object o) { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; - } + /** + * Sign a hash with the private key of this key pair. + * + * @param hash the hash to sign + * @return An {@link ECDSASignature} of the hash + */ + public ECDSASignature sign(byte[] hash) { - ECKeyPair ecKeyPair = (ECKeyPair) o; + ECDSASigner signer = new ECDSASigner(new HMacDSAKCalculator(new SHA256Digest())); + + ECPrivateKeyParameters privKey = new ECPrivateKeyParameters(privateKey, Sign.CURVE); + signer.init(true, privKey); + BigInteger[] components = signer.generateSignature(hash); - if (privateKey != null - ? !privateKey.equals(ecKeyPair.privateKey) - : ecKeyPair.privateKey != null) { - return false; - } + return new ECDSASignature(components[0], components[1]).toCanonicalised(); + } + + /** + * Verify a hash with the private key of this key pair. + * + * @param hash + * @param signature + * @return + */ + public boolean verify(byte[] hash, ECDSASignature signature) { + ECDSASigner signer = new ECDSASigner(); + // not for signing... + signer.init( + false, + new ECPublicKeyParameters( + Sign.publicPointFromPrivate(getPrivateKey()), Sign.CURVE)); + return signer.verifySignature(hash, signature.r, signature.s); + } - return publicKey != null - ? publicKey.equals(ecKeyPair.publicKey) - : ecKeyPair.publicKey == null; + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + ECKeyPair ecKeyPair = (ECKeyPair) o; + return Objects.equals(privateKey, ecKeyPair.privateKey) + && Objects.equals(publicKey, ecKeyPair.publicKey); } @Override public int hashCode() { - int result = privateKey != null ? privateKey.hashCode() : 0; - result = 31 * result + (publicKey != null ? publicKey.hashCode() : 0); - return result; + return Objects.hash(privateKey, publicKey); } } diff --git a/src/main/java/org/fisco/bcos/web3j/crypto/Keys.java b/src/main/java/org/fisco/bcos/web3j/crypto/Keys.java index 2bd8794c2..a9b9aa9c5 100644 --- a/src/main/java/org/fisco/bcos/web3j/crypto/Keys.java +++ b/src/main/java/org/fisco/bcos/web3j/crypto/Keys.java @@ -25,7 +25,7 @@ public class Keys { public static final int ADDRESS_SIZE = 160; public static final int ADDRESS_LENGTH_IN_HEX = ADDRESS_SIZE >> 2; - static final int PUBLIC_KEY_LENGTH_IN_HEX = PUBLIC_KEY_SIZE << 1; + public static final int PUBLIC_KEY_LENGTH_IN_HEX = PUBLIC_KEY_SIZE << 1; public static final int PRIVATE_KEY_LENGTH_IN_HEX = PRIVATE_KEY_SIZE << 1; static { diff --git a/src/main/java/org/fisco/bcos/web3j/crypto/Sign.java b/src/main/java/org/fisco/bcos/web3j/crypto/Sign.java index 9497d7a33..c039a6edd 100644 --- a/src/main/java/org/fisco/bcos/web3j/crypto/Sign.java +++ b/src/main/java/org/fisco/bcos/web3j/crypto/Sign.java @@ -32,7 +32,7 @@ public static void setSignInterface(SignInterface signInterface) { Sign.signInterface = signInterface; } - private static final X9ECParameters CURVE_PARAMS = CustomNamedCurves.getByName("secp256k1"); + public static final X9ECParameters CURVE_PARAMS = CustomNamedCurves.getByName("secp256k1"); static final ECDomainParameters CURVE = new ECDomainParameters( CURVE_PARAMS.getCurve(), diff --git a/src/main/java/org/fisco/bcos/web3j/crypto/gm/GenCredential.java b/src/main/java/org/fisco/bcos/web3j/crypto/gm/GenCredential.java index d6586850d..c82b0fe7b 100644 --- a/src/main/java/org/fisco/bcos/web3j/crypto/gm/GenCredential.java +++ b/src/main/java/org/fisco/bcos/web3j/crypto/gm/GenCredential.java @@ -30,14 +30,9 @@ private static ECKeyPair genEcPairFromKeyPair(KeyPair keyPairData) { final byte[] publicKey = pk.getEncoded(); final byte[] privateKey = vk.getEncoded(); - // System.out.println("===public:" + Hex.toHexString(publicKey)); - // System.out.println("===private:" + Hex.toHexString(privateKey)); BigInteger biPublic = new BigInteger(Hex.toHexString(publicKey), 16); BigInteger biPrivate = new BigInteger(Hex.toHexString(privateKey), 16); - // System.out.println("---public:" + biPublic.toString(16)); - // System.out.println("---private:" + biPrivate.toString(16)); - ECKeyPair keyPair = new ECKeyPair(biPrivate, biPublic); return keyPair; } catch (Exception e) { @@ -91,6 +86,11 @@ public static Credentials create() { if (keyPair == null) return null; Credentials credentials = Credentials.create(keyPair); + logger.debug( + " privateKey: {}, publicKey: {}, address: {}", + credentials.getEcKeyPair().getPrivateKey(), + credentials.getEcKeyPair().getPrivateKey(), + credentials.getAddress()); return credentials; } catch (Exception e) { System.out.println("init credential failed"); diff --git a/src/main/java/org/fisco/bcos/web3j/crypto/gm/sm2/SM2Sign.java b/src/main/java/org/fisco/bcos/web3j/crypto/gm/sm2/SM2Sign.java index 9d7426e9d..b8338cacc 100644 --- a/src/main/java/org/fisco/bcos/web3j/crypto/gm/sm2/SM2Sign.java +++ b/src/main/java/org/fisco/bcos/web3j/crypto/gm/sm2/SM2Sign.java @@ -5,6 +5,11 @@ import org.bouncycastle.asn1.ASN1Integer; import org.bouncycastle.asn1.ASN1Primitive; import org.bouncycastle.asn1.ASN1Sequence; +import org.bouncycastle.crypto.CryptoException; +import org.bouncycastle.crypto.params.ECDomainParameters; +import org.bouncycastle.crypto.params.ECPrivateKeyParameters; +import org.bouncycastle.crypto.params.ParametersWithID; +import org.bouncycastle.crypto.params.ParametersWithRandom; import org.fisco.bcos.web3j.crypto.ECKeyPair; import org.fisco.bcos.web3j.crypto.Sign; import org.fisco.bcos.web3j.crypto.SignInterface; @@ -19,9 +24,58 @@ public class SM2Sign implements SignInterface { static Logger logger = LoggerFactory.getLogger(SM2Sign.class); + private static final ECDomainParameters eCDomainParameters = + new ECDomainParameters(SM2Algorithm.sm2Curve, SM2Algorithm.sm2Point, SM2Algorithm.n); + private static final byte[] identValue = + org.bouncycastle.util.encoders.Hex.decode("31323334353637383132333435363738"); + @Override public Sign.SignatureData signMessage(byte[] message, ECKeyPair keyPair) { - return sign(message, keyPair); + return sign2(message, keyPair); + } + + /** + * The new sm2 signature algorithm with better performance + * + * @param message + * @param ecKeyPair + * @return + */ + public static Sign.SignatureData sign2(byte[] message, ECKeyPair ecKeyPair) { + + SM2Signer sm2Signer = new SM2Signer(); + + ECPrivateKeyParameters eCPrivateKeyParameters = + new ECPrivateKeyParameters(ecKeyPair.getPrivateKey(), eCDomainParameters); + + sm2Signer.initWithCache( + true, + new ParametersWithID(new ParametersWithRandom(eCPrivateKeyParameters), identValue)); + + org.bouncycastle.crypto.digests.SM3Digest sm3Digest = + new org.bouncycastle.crypto.digests.SM3Digest(); + + byte[] md = new byte[sm3Digest.getDigestSize()]; + sm3Digest.update(message, 0, message.length); + sm3Digest.doFinal(md, 0); + + sm2Signer.update(md, 0, md.length); + + byte[] r = null; + byte[] s = null; + byte[] pub = null; + + try { + BigInteger[] bigIntegers = sm2Signer.generateSignature2(); + + pub = Numeric.toBytesPadded(ecKeyPair.getPublicKey(), 64); + r = SM2Algorithm.getEncoded(bigIntegers[0]); + s = SM2Algorithm.getEncoded(bigIntegers[1]); + } catch (CryptoException e) { + throw new RuntimeException(e); + } + + return new Sign.SignatureData((byte) 0, r, s, pub); } public static Sign.SignatureData sign(byte[] message, ECKeyPair ecKeyPair) { @@ -32,6 +86,7 @@ public static Sign.SignatureData sign(byte[] message, ECKeyPair ecKeyPair) { byte[] pub = null; byte v = 0; byte[] messageHash = sm3Digest.hash(message); + try { byte[] signByte = SM2Algorithm.sign(messageHash, ecKeyPair.getPrivateKey()); logger.debug("signData:{}", signByte); @@ -42,12 +97,14 @@ public static Sign.SignatureData sign(byte[] message, ECKeyPair ecKeyPair) { ((ASN1Integer) as.getObjectAt(0)).getValue(), ((ASN1Integer) as.getObjectAt(1)).getValue() }; + } catch (IOException ex) { logger.error("SM2 Sign ERROR"); } if (rs != null) { r = SM2Algorithm.getEncoded(rs[0]); s = SM2Algorithm.getEncoded(rs[1]); + /*System.out.println("publicKey:" + Hex.toHexString(Numeric.toBytesPadded(ecKeyPair.getPublicKey(),64))); System.out.println("publicKeyLen:" + ecKeyPair.getPublicKey().bitLength()); System.out.println("privateKey:" + Hex.toHexString(Numeric.toBytesPadded(ecKeyPair.getPrivateKey(),32))); diff --git a/src/main/java/org/fisco/bcos/web3j/crypto/gm/sm2/SM2Signer.java b/src/main/java/org/fisco/bcos/web3j/crypto/gm/sm2/SM2Signer.java new file mode 100644 index 000000000..8507a76d4 --- /dev/null +++ b/src/main/java/org/fisco/bcos/web3j/crypto/gm/sm2/SM2Signer.java @@ -0,0 +1,397 @@ +package org.fisco.bcos.web3j.crypto.gm.sm2; + +import java.io.IOException; +import java.math.BigInteger; +import java.util.Map; +import java.util.Objects; +import java.util.concurrent.ConcurrentHashMap; +import org.bouncycastle.asn1.ASN1EncodableVector; +import org.bouncycastle.asn1.ASN1Encoding; +import org.bouncycastle.asn1.ASN1Integer; +import org.bouncycastle.asn1.ASN1Primitive; +import org.bouncycastle.asn1.ASN1Sequence; +import org.bouncycastle.asn1.DERSequence; +import org.bouncycastle.crypto.CipherParameters; +import org.bouncycastle.crypto.CryptoException; +import org.bouncycastle.crypto.CryptoServicesRegistrar; +import org.bouncycastle.crypto.Digest; +import org.bouncycastle.crypto.Signer; +import org.bouncycastle.crypto.digests.SM3Digest; +import org.bouncycastle.crypto.params.ECDomainParameters; +import org.bouncycastle.crypto.params.ECKeyParameters; +import org.bouncycastle.crypto.params.ECPrivateKeyParameters; +import org.bouncycastle.crypto.params.ECPublicKeyParameters; +import org.bouncycastle.crypto.params.ParametersWithID; +import org.bouncycastle.crypto.params.ParametersWithRandom; +import org.bouncycastle.crypto.signers.DSAKCalculator; +import org.bouncycastle.crypto.signers.RandomDSAKCalculator; +import org.bouncycastle.math.ec.ECAlgorithms; +import org.bouncycastle.math.ec.ECConstants; +import org.bouncycastle.math.ec.ECFieldElement; +import org.bouncycastle.math.ec.ECMultiplier; +import org.bouncycastle.math.ec.ECPoint; +import org.bouncycastle.math.ec.FixedPointCombMultiplier; +import org.bouncycastle.util.Arrays; +import org.bouncycastle.util.encoders.Hex; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Copy from bc library, file: org.bouncycastle.crypto.signers.SM2Signer Only simple + * modifications(Add initWithCache method) were made to optimize the optimize the calculation of z + */ + +/** The SM2 Digital Signature algorithm. */ +public class SM2Signer implements Signer, ECConstants { + + private static final Logger logger = LoggerFactory.getLogger(SM2Signer.class); + + private final DSAKCalculator kCalculator = new RandomDSAKCalculator(); + private final SM3Digest digest = new SM3Digest(); + + private ECDomainParameters ecParams; + private ECPoint pubPoint; + private ECKeyParameters ecKey; + private byte[] z; + + /** z value cache. key: privateKey value: z value */ + private static Map zValueCache = new ConcurrentHashMap<>(); + + @Override + public void init(boolean forSigning, CipherParameters param) { + CipherParameters baseParam; + byte[] userID; + + if (param instanceof ParametersWithID) { + baseParam = ((ParametersWithID) param).getParameters(); + userID = ((ParametersWithID) param).getID(); + } else { + baseParam = param; + userID = Hex.decode("31323334353637383132333435363738"); // the default value + } + + if (forSigning) { + if (baseParam instanceof ParametersWithRandom) { + ParametersWithRandom rParam = (ParametersWithRandom) baseParam; + + ecKey = (ECKeyParameters) rParam.getParameters(); + ecParams = ecKey.getParameters(); + kCalculator.init(ecParams.getN(), rParam.getRandom()); + } else { + ecKey = (ECKeyParameters) baseParam; + ecParams = ecKey.getParameters(); + kCalculator.init(ecParams.getN(), CryptoServicesRegistrar.getSecureRandom()); + } + + pubPoint = + createBasePointMultiplier() + .multiply(ecParams.getG(), ((ECPrivateKeyParameters) ecKey).getD()) + .normalize(); + } else { + ecKey = (ECKeyParameters) baseParam; + ecParams = ecKey.getParameters(); + pubPoint = ((ECPublicKeyParameters) ecKey).getQ(); + } + + z = getZ(userID); + + digest.update(z, 0, z.length); + } + + /** + * The same as init method with better performance by adding the cache for the z value + * corresponding to the privateKey value + * + * @param forSigning + * @param param + */ + public void initWithCache(boolean forSigning, CipherParameters param) { + CipherParameters baseParam; + byte[] userID; + + if (param instanceof ParametersWithID) { + baseParam = ((ParametersWithID) param).getParameters(); + userID = ((ParametersWithID) param).getID(); + } else { + baseParam = param; + userID = Hex.decode("31323334353637383132333435363738"); // the default value + } + + if (forSigning) { + if (baseParam instanceof ParametersWithRandom) { + ParametersWithRandom rParam = (ParametersWithRandom) baseParam; + + ecKey = (ECKeyParameters) rParam.getParameters(); + ecParams = ecKey.getParameters(); + kCalculator.init(ecParams.getN(), rParam.getRandom()); + } else { + ecKey = (ECKeyParameters) baseParam; + ecParams = ecKey.getParameters(); + kCalculator.init(ecParams.getN(), CryptoServicesRegistrar.getSecureRandom()); + } + + BigInteger privateKey = ((ECPrivateKeyParameters) ecKey).getD(); + /** First find z value from zValueCache */ + z = zValueCache.get(privateKey); + + if (Objects.isNull(z)) { + // z value of privateKey not exist, calculate it and set it to the cache + pubPoint = + createBasePointMultiplier() + .multiply(ecParams.getG(), ((ECPrivateKeyParameters) ecKey).getD()) + .normalize(); + z = getZ(userID); + zValueCache.put(privateKey, z); + logger.info( + " privateKey: {} z value not exist, caculate z: {}", + privateKey, + Hex.toHexString(z)); + } else { + if (logger.isDebugEnabled()) { + logger.debug(" privateKey: {} z value, z: {}", privateKey, Hex.toHexString(z)); + } + } + + digest.update(z, 0, z.length); + } else { + ecKey = (ECKeyParameters) baseParam; + ecParams = ecKey.getParameters(); + pubPoint = ((ECPublicKeyParameters) ecKey).getQ(); + z = getZ(userID); + + digest.update(z, 0, z.length); + } + } + + @Override + public void update(byte b) { + digest.update(b); + } + + @Override + public void update(byte[] in, int off, int len) { + digest.update(in, off, len); + } + + public void updateMessage(byte[] in, int off, int len) { + digest.reset(); + digest.update(in, 0, in.length); + byte[] md = digestDoFinal(); + digest.update(z, 0, z.length); + digest.update(md, 0, md.length); + } + + @Override + public boolean verifySignature(byte[] signature) { + try { + BigInteger[] rs = derDecode(signature); + if (rs != null) { + return verifySignature(rs[0], rs[1]); + } + } catch (IOException e) { + } + + return false; + } + + @Override + public void reset() { + digest.reset(); + + if (z != null) { + digest.update(z, 0, z.length); + } + } + + @Override + public byte[] generateSignature() throws CryptoException { + byte[] eHash = digestDoFinal(); + + BigInteger n = ecParams.getN(); + BigInteger e = calculateE(eHash); + BigInteger d = ((ECPrivateKeyParameters) ecKey).getD(); + + BigInteger r, s; + + ECMultiplier basePointMultiplier = createBasePointMultiplier(); + + // 5.2.1 Draft RFC: SM2 Public Key Algorithms + do // generate s + { + BigInteger k; + do // generate r + { + // A3 + k = kCalculator.nextK(); + + // A4 + ECPoint p = basePointMultiplier.multiply(ecParams.getG(), k).normalize(); + + // A5 + r = e.add(p.getAffineXCoord().toBigInteger()).mod(n); + } while (r.equals(ZERO) || r.add(k).equals(n)); + + // A6 + BigInteger dPlus1ModN = d.add(ONE).modInverse(n); + + s = k.subtract(r.multiply(d)).mod(n); + s = dPlus1ModN.multiply(s).mod(n); + } while (s.equals(ZERO)); + + // A7 + try { + return derEncode(r, s); + } catch (IOException ex) { + throw new CryptoException("unable to encode signature: " + ex.getMessage(), ex); + } + } + + public BigInteger[] generateSignature2() throws CryptoException { + byte[] eHash = digestDoFinal(); + + BigInteger n = ecParams.getN(); + BigInteger e = calculateE(eHash); + BigInteger d = ((ECPrivateKeyParameters) ecKey).getD(); + + BigInteger r, s; + + ECMultiplier basePointMultiplier = createBasePointMultiplier(); + + // 5.2.1 Draft RFC: SM2 Public Key Algorithms + do // generate s + { + BigInteger k; + do // generate r + { + // A3 + k = kCalculator.nextK(); + + // A4 + ECPoint p = basePointMultiplier.multiply(ecParams.getG(), k).normalize(); + + // A5 + r = e.add(p.getAffineXCoord().toBigInteger()).mod(n); + } while (r.equals(ZERO) || r.add(k).equals(n)); + + // A6 + BigInteger dPlus1ModN = d.add(ONE).modInverse(n); + + s = k.subtract(r.multiply(d)).mod(n); + s = dPlus1ModN.multiply(s).mod(n); + } while (s.equals(ZERO)); + + return new BigInteger[] {r, s}; + } + + private boolean verifySignature(BigInteger r, BigInteger s) { + BigInteger n = ecParams.getN(); + + // 5.3.1 Draft RFC: SM2 Public Key Algorithms + // B1 + if (r.compareTo(ONE) < 0 || r.compareTo(n) >= 0) { + return false; + } + + // B2 + if (s.compareTo(ONE) < 0 || s.compareTo(n) >= 0) { + return false; + } + + // B3 + byte[] eHash = digestDoFinal(); + + // B4 + BigInteger e = calculateE(eHash); + + // B5 + BigInteger t = r.add(s).mod(n); + if (t.equals(ZERO)) { + return false; + } + + // B6 + ECPoint q = ((ECPublicKeyParameters) ecKey).getQ(); + ECPoint x1y1 = ECAlgorithms.sumOfTwoMultiplies(ecParams.getG(), s, q, t).normalize(); + if (x1y1.isInfinity()) { + return false; + } + + // B7 + BigInteger expectedR = e.add(x1y1.getAffineXCoord().toBigInteger()).mod(n); + + return expectedR.equals(r); + } + + private byte[] digestDoFinal() { + byte[] result = new byte[digest.getDigestSize()]; + digest.doFinal(result, 0); + + reset(); + + return result; + } + + private byte[] getZ(byte[] userID) { + digest.reset(); + + addUserID(digest, userID); + + addFieldElement(digest, ecParams.getCurve().getA()); + addFieldElement(digest, ecParams.getCurve().getB()); + addFieldElement(digest, ecParams.getG().getAffineXCoord()); + addFieldElement(digest, ecParams.getG().getAffineYCoord()); + addFieldElement(digest, pubPoint.getAffineXCoord()); + addFieldElement(digest, pubPoint.getAffineYCoord()); + + byte[] result = new byte[digest.getDigestSize()]; + + digest.doFinal(result, 0); + + return result; + } + + private void addUserID(Digest digest, byte[] userID) { + int len = userID.length * 8; + digest.update((byte) (len >> 8 & 0xFF)); + digest.update((byte) (len & 0xFF)); + digest.update(userID, 0, userID.length); + } + + private void addFieldElement(Digest digest, ECFieldElement v) { + byte[] p = v.getEncoded(); + digest.update(p, 0, p.length); + } + + protected static ECMultiplier createBasePointMultiplier() { + return new FixedPointCombMultiplier(); + } + + protected BigInteger calculateE(byte[] message) { + return new BigInteger(1, message); + } + + public BigInteger[] derDecode(byte[] encoding) throws IOException { + ASN1Sequence seq = ASN1Sequence.getInstance(ASN1Primitive.fromByteArray(encoding)); + if (seq.size() != 2) { + return null; + } + + BigInteger r = ASN1Integer.getInstance(seq.getObjectAt(0)).getValue(); + BigInteger s = ASN1Integer.getInstance(seq.getObjectAt(1)).getValue(); + + byte[] expectedEncoding = derEncode(r, s); + if (!Arrays.constantTimeAreEqual(expectedEncoding, encoding)) { + return null; + } + + return new BigInteger[] {r, s}; + } + + public byte[] derEncode(BigInteger r, BigInteger s) throws IOException { + + ASN1EncodableVector v = new ASN1EncodableVector(); + v.add(new ASN1Integer(r)); + v.add(new ASN1Integer(s)); + return new DERSequence(v).getEncoded(ASN1Encoding.DER); + } +} diff --git a/src/main/java/org/fisco/bcos/web3j/crypto/gm/sm2/crypto/asymmetric/SM2Algorithm.java b/src/main/java/org/fisco/bcos/web3j/crypto/gm/sm2/crypto/asymmetric/SM2Algorithm.java index f6c6ac4e0..c44d8c415 100644 --- a/src/main/java/org/fisco/bcos/web3j/crypto/gm/sm2/crypto/asymmetric/SM2Algorithm.java +++ b/src/main/java/org/fisco/bcos/web3j/crypto/gm/sm2/crypto/asymmetric/SM2Algorithm.java @@ -34,8 +34,8 @@ public class SM2Algorithm { public static final BigInteger gy = new BigInteger("BC3736A2F4F6779C59BDCEE36B692153D0A9877CC62A474002DF32E52139F0A0", 16); - private static final ECCurve sm2Curve = new ECCurve.Fp(p, a, b); - private static final ECPoint sm2Point = sm2Curve.createPoint(gx, gy); + public static final ECCurve sm2Curve = new ECCurve.Fp(p, a, b); + public static final ECPoint sm2Point = sm2Curve.createPoint(gx, gy); /* * SM2加密 @@ -323,10 +323,10 @@ private static byte[] padding(byte[] bi) { //////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////// - private static byte[] USER_ID = KeyUtils.hex2byte("31323334353637383132333435363738"); + public static byte[] USER_ID = KeyUtils.hex2byte("31323334353637383132333435363738"); private static int mFieldSizeInBytes; - private static ECCurve curve256; - private static ECPoint g256; + public static ECCurve curve256; + public static ECPoint g256; // 初始化曲线G static { diff --git a/src/main/java/org/fisco/bcos/web3j/crypto/gm/sm2/util/KeyUtils.java b/src/main/java/org/fisco/bcos/web3j/crypto/gm/sm2/util/KeyUtils.java index dabdb70c9..7c1e724ab 100644 --- a/src/main/java/org/fisco/bcos/web3j/crypto/gm/sm2/util/KeyUtils.java +++ b/src/main/java/org/fisco/bcos/web3j/crypto/gm/sm2/util/KeyUtils.java @@ -3,8 +3,6 @@ import java.io.FileInputStream; import java.security.Key; import java.security.KeyStore; -import java.security.MessageDigest; -import java.security.NoSuchAlgorithmException; import java.security.cert.Certificate; public class KeyUtils { @@ -247,56 +245,6 @@ public static final String xor(String a, String b) { return bcdhex_to_aschex(outBuf); } - /** - * * sha1 - * - * @param inStr - * @return - */ - public static String sha1String(String inStr) { - MessageDigest md = null; - String outStr = null; - try { - md = MessageDigest.getInstance("SHA-1"); // 选择SHA-1 - byte[] data = null; - try { - data = inStr.getBytes(DEFAUTL_CHARTSET); - } catch (Exception e) { - data = inStr.getBytes(); - } - byte[] digest = md.digest(data); // 返回的是byet[]，要转化为String存储比较方便 - outStr = bcdhex_to_aschex(digest); - } catch (NoSuchAlgorithmException nsae) { - nsae.printStackTrace(); - } - return outStr; - } - - /** - * md5 - * - * @param inStr - * @return - */ - public static String md5String(String inStr) { - MessageDigest md = null; - String outStr = null; - try { - md = MessageDigest.getInstance("MD5"); // 选择MD5 - byte[] data = null; - try { - data = inStr.getBytes(DEFAUTL_CHARTSET); - } catch (Exception e) { - data = inStr.getBytes(); - } - byte[] digest = md.digest(data); // 返回的是byet[]，要转化为String存储比较方便 - outStr = bcdhex_to_aschex(digest); - } catch (NoSuchAlgorithmException nsae) { - nsae.printStackTrace(); - } - return outStr; - } - /** * byte to hex * diff --git a/src/main/java/org/fisco/bcos/web3j/crypto/tool/ECCDecrypt.java b/src/main/java/org/fisco/bcos/web3j/crypto/tool/ECCDecrypt.java new file mode 100644 index 000000000..baee6f674 --- /dev/null +++ b/src/main/java/org/fisco/bcos/web3j/crypto/tool/ECCDecrypt.java @@ -0,0 +1,73 @@ +package org.fisco.bcos.web3j.crypto.tool; + +import java.math.BigInteger; +import java.security.InvalidAlgorithmParameterException; +import java.security.InvalidKeyException; +import java.security.NoSuchAlgorithmException; +import java.security.NoSuchProviderException; +import java.security.spec.ECPrivateKeySpec; +import javax.crypto.BadPaddingException; +import javax.crypto.Cipher; +import javax.crypto.IllegalBlockSizeException; +import javax.crypto.NoSuchPaddingException; +import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey; +import org.bouncycastle.jce.provider.BouncyCastleProvider; + +/** ECC decrypt utils */ +public class ECCDecrypt { + + private final BigInteger priKey; + private final BCECPrivateKey bCECPrivateKey; + + public ECCDecrypt(BigInteger privateKey) { + this.priKey = privateKey; + this.bCECPrivateKey = createBCECPrivateKey(privateKey); + } + + public BigInteger getPriKey() { + return priKey; + } + + public BCECPrivateKey getbCECPrivateKey() { + return bCECPrivateKey; + } + + /** + * create BCECPrivateKey from privateKey + * + * @param privateKey + * @return + */ + private BCECPrivateKey createBCECPrivateKey(BigInteger privateKey) { + // Handle secret key + ECPrivateKeySpec secretKeySpec = + new ECPrivateKeySpec(privateKey, ECCParams.ecNamedCurveSpec); + BCECPrivateKey bcecPrivateKey = + new BCECPrivateKey("ECDSA", secretKeySpec, BouncyCastleProvider.CONFIGURATION); + return bcecPrivateKey; + } + + /** + * Decrypt the data which encryt by ECC + * + * @param data + * @return + * @throws NoSuchPaddingException + * @throws NoSuchAlgorithmException + * @throws NoSuchProviderException + * @throws InvalidAlgorithmParameterException + * @throws InvalidKeyException + * @throws BadPaddingException + * @throws IllegalBlockSizeException + */ + public byte[] decrypt(byte[] data) + throws NoSuchPaddingException, NoSuchAlgorithmException, NoSuchProviderException, + InvalidAlgorithmParameterException, InvalidKeyException, BadPaddingException, + IllegalBlockSizeException { + + Cipher cipher = Cipher.getInstance("ECIES", "BC"); + cipher.init(Cipher.DECRYPT_MODE, getbCECPrivateKey(), ECCParams.IES_PARAMS); + + return cipher.doFinal(data); + } +} diff --git a/src/main/java/org/fisco/bcos/web3j/crypto/tool/ECCEncrypt.java b/src/main/java/org/fisco/bcos/web3j/crypto/tool/ECCEncrypt.java new file mode 100644 index 000000000..562f8c21f --- /dev/null +++ b/src/main/java/org/fisco/bcos/web3j/crypto/tool/ECCEncrypt.java @@ -0,0 +1,101 @@ +package org.fisco.bcos.web3j.crypto.tool; + +import java.math.BigInteger; +import java.security.InvalidAlgorithmParameterException; +import java.security.InvalidKeyException; +import java.security.NoSuchAlgorithmException; +import java.security.NoSuchProviderException; +import javax.crypto.BadPaddingException; +import javax.crypto.Cipher; +import javax.crypto.IllegalBlockSizeException; +import javax.crypto.NoSuchPaddingException; +import org.bouncycastle.crypto.params.ECDomainParameters; +import org.bouncycastle.crypto.params.ECPublicKeyParameters; +import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey; +import org.bouncycastle.jce.provider.BouncyCastleProvider; +import org.bouncycastle.math.ec.custom.sec.SecP256K1Curve; +import org.bouncycastle.math.ec.custom.sec.SecP256K1Point; +import org.fisco.bcos.web3j.crypto.Keys; +import org.fisco.bcos.web3j.utils.Numeric; + +/** ECC encrpt utils */ +public class ECCEncrypt { + + private final BigInteger pubKey; + private final BCECPublicKey bCECPublicKey; + + public ECCEncrypt(BigInteger pubKey) { + this.pubKey = pubKey; + this.bCECPublicKey = createBCECPublicKey(pubKey); + } + + public BigInteger getPubKey() { + return pubKey; + } + + public BCECPublicKey getbCECPublicKey() { + return bCECPublicKey; + } + + /** + * create BCECPublicKey from publicKey and privateKey + * + * @param publicKey + * @return + */ + private BCECPublicKey createBCECPublicKey(BigInteger publicKey) { + // Handle public key. + String publicKeyValue = + Numeric.toHexStringNoPrefixZeroPadded(publicKey, Keys.PUBLIC_KEY_LENGTH_IN_HEX); + String prePublicKeyStr = publicKeyValue.substring(0, 64); + String postPublicKeyStr = publicKeyValue.substring(64); + SecP256K1Curve secP256K1Curve = new SecP256K1Curve(); + SecP256K1Point secP256K1Point = + (SecP256K1Point) + secP256K1Curve.createPoint( + new BigInteger(prePublicKeyStr, 16), + new BigInteger(postPublicKeyStr, 16)); + SecP256K1Point secP256K1PointG = + (SecP256K1Point) + secP256K1Curve.createPoint(ECCParams.POINTG_PRE, ECCParams.POINTG_POST); + + ECDomainParameters domainParameters = + new ECDomainParameters(secP256K1Curve, secP256K1PointG, ECCParams.FACTOR_N); + ECPublicKeyParameters publicKeyParameters = + new ECPublicKeyParameters(secP256K1Point, domainParameters); + + BCECPublicKey bcecPublicKey = + new BCECPublicKey( + "ECDSA", + publicKeyParameters, + ECCParams.ecNamedCurveSpec, + BouncyCastleProvider.CONFIGURATION); + + return bcecPublicKey; + } + + /** + * Encrypt the data with ECC algorithm + * + * @param data + * @return + * @throws NoSuchPaddingException + * @throws NoSuchAlgorithmException + * @throws NoSuchProviderException + * @throws BadPaddingException + * @throws IllegalBlockSizeException + * @throws InvalidAlgorithmParameterException + * @throws InvalidKeyException + */ + public byte[] encrypt(byte[] data) + throws NoSuchPaddingException, NoSuchAlgorithmException, NoSuchProviderException, + BadPaddingException, IllegalBlockSizeException, + InvalidAlgorithmParameterException, InvalidKeyException { + + // Encrypt data. + Cipher cipher = Cipher.getInstance(" ECIES", "BC"); + cipher.init(Cipher.ENCRYPT_MODE, getbCECPublicKey(), ECCParams.IES_PARAMS); + + return cipher.doFinal(data); + } +} diff --git a/src/main/java/org/fisco/bcos/web3j/crypto/tool/ECCParams.java b/src/main/java/org/fisco/bcos/web3j/crypto/tool/ECCParams.java new file mode 100644 index 000000000..12b81a463 --- /dev/null +++ b/src/main/java/org/fisco/bcos/web3j/crypto/tool/ECCParams.java @@ -0,0 +1,28 @@ +package org.fisco.bcos.web3j.crypto.tool; + +import java.math.BigInteger; +import java.security.spec.ECFieldFp; +import java.security.spec.ECPoint; +import java.security.spec.EllipticCurve; +import org.bouncycastle.jce.spec.ECNamedCurveSpec; +import org.bouncycastle.jce.spec.IESParameterSpec; + +public final class ECCParams { + + // ECDSA secp256k1 algorithm constants + public static final BigInteger POINTG_PRE = + new BigInteger("79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798", 16); + public static final BigInteger POINTG_POST = + new BigInteger("483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8", 16); + public static final BigInteger FACTOR_N = + new BigInteger("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141", 16); + public static final BigInteger FIELD_P = + new BigInteger("fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f", 16); + public static final EllipticCurve ellipticCurve = + new EllipticCurve(new ECFieldFp(FIELD_P), new BigInteger("0"), new BigInteger("7")); + public static final ECPoint pointG = new ECPoint(POINTG_PRE, POINTG_POST); + public static final ECNamedCurveSpec ecNamedCurveSpec = + new ECNamedCurveSpec("secp256k1", ellipticCurve, pointG, FACTOR_N); + + public static final IESParameterSpec IES_PARAMS = new IESParameterSpec(null, null, 64); +} diff --git a/src/main/java/org/fisco/bcos/web3j/precompile/common/PrecompiledCommon.java b/src/main/java/org/fisco/bcos/web3j/precompile/common/PrecompiledCommon.java index a693cbbcd..60ba7b687 100644 --- a/src/main/java/org/fisco/bcos/web3j/precompile/common/PrecompiledCommon.java +++ b/src/main/java/org/fisco/bcos/web3j/precompile/common/PrecompiledCommon.java @@ -39,6 +39,8 @@ public class PrecompiledCommon { public static final int TableNameAndAddressNotExist_RC1 = 57; public static final int TableNameAndAddressNotExist = 51001; public static final int TableNameAndAddressNotExist_RC3 = -51001; + public static final int TableNameLengthOverflow = -51002; + public static final int ContractNotExist = -51003; public static final int InvalidNodeId = -51100; public static final int LastSealer_RC1 = 100; public static final int LastSealer = 51101; @@ -53,6 +55,14 @@ public class PrecompiledCommon { public static final int InvalidKey = 51300; public static final int InvalidKey_RC3 = -51300; + public static final int InvalidAddress = -50102; + public static final int InvalidContractFrozen = -51900; + public static final int InvalidContractAvailable = -51901; + public static final int InvalidContractRepeatAuthorization = -51902; + public static final int InvalidContractAddress = -51903; + public static final int InvalidTableNotExist = -51904; + public static final int InvalidAuthorized = -51905; + public static final int TABLE_KEY_MAX_LENGTH = 255; public static String BCOS_VERSION = ""; @@ -98,6 +108,8 @@ public static String transferToJson(int code) throws IOException { msg = "the last sealer cannot be removed"; } else if (code == TableExist_RC3) { msg = "table already exist"; + } else if (code == ContractNotExist) { + msg = "contract not exist"; } else if (code == InvalidKey_RC3) { msg = "invalid configuration entry"; } @@ -118,7 +130,24 @@ public static String transferToJson(int code) throws IOException { msg = "contract name and version already exist"; } else if (code == VersionExceeds) { msg = "version string length exceeds the maximum limit"; + } else if (code == TableNameLengthOverflow) { + msg = "tablename string length exceeds the maximum limit"; + } else if (code == InvalidAddress) { + msg = "invalid address format"; + } else if (code == InvalidContractFrozen) { + msg = "the contract has been frozen"; + } else if (code == InvalidContractAvailable) { + msg = "the contract is available"; + } else if (code == InvalidContractRepeatAuthorization) { + msg = "the contract has been granted authorization with same user"; + } else if (code == InvalidContractAddress) { + msg = "the contract address is invalid"; + } else if (code == InvalidTableNotExist) { + msg = "the address is not exist"; + } else if (code == InvalidAuthorized) { + msg = "this operation has no permissions"; } + ObjectMapper mapper = ObjectMapperFactory.getObjectMapper(); return mapper.writeValueAsString(new PrecompiledResponse(code, msg)); } diff --git a/src/main/java/org/fisco/bcos/web3j/precompile/csm/ContractLifeCyclePrecompiled.java b/src/main/java/org/fisco/bcos/web3j/precompile/csm/ContractLifeCyclePrecompiled.java new file mode 100644 index 000000000..12792faf2 --- /dev/null +++ b/src/main/java/org/fisco/bcos/web3j/precompile/csm/ContractLifeCyclePrecompiled.java @@ -0,0 +1,397 @@ +package org.fisco.bcos.web3j.precompile.csm; + +import java.math.BigInteger; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.concurrent.Callable; +import org.fisco.bcos.channel.client.TransactionSucCallback; +import org.fisco.bcos.web3j.abi.FunctionReturnDecoder; +import org.fisco.bcos.web3j.abi.TypeReference; +import org.fisco.bcos.web3j.abi.datatypes.Address; +import org.fisco.bcos.web3j.abi.datatypes.DynamicArray; +import org.fisco.bcos.web3j.abi.datatypes.Function; +import org.fisco.bcos.web3j.abi.datatypes.Type; +import org.fisco.bcos.web3j.abi.datatypes.Utf8String; +import org.fisco.bcos.web3j.abi.datatypes.generated.Int256; +import org.fisco.bcos.web3j.crypto.Credentials; +import org.fisco.bcos.web3j.protocol.Web3j; +import org.fisco.bcos.web3j.protocol.core.RemoteCall; +import org.fisco.bcos.web3j.protocol.core.methods.response.TransactionReceipt; +import org.fisco.bcos.web3j.tuples.generated.Tuple1; +import org.fisco.bcos.web3j.tuples.generated.Tuple2; +import org.fisco.bcos.web3j.tx.Contract; +import org.fisco.bcos.web3j.tx.TransactionManager; +import org.fisco.bcos.web3j.tx.gas.ContractGasProvider; +import org.fisco.bcos.web3j.tx.txdecode.TransactionDecoder; + +/** + * Auto generated code. + * + *

Do not modify! + * + *

Please use the web3j command line tools, + * or the org.fisco.bcos.web3j.codegen.SolidityFunctionWrapperGenerator in the codegen module to update. + * + *

Generated with web3j version none. + */ +@SuppressWarnings("unchecked") +public class ContractLifeCyclePrecompiled extends Contract { + public static final String[] BINARY_ARRAY = {}; + + public static final String BINARY = String.join("", BINARY_ARRAY); + + public static final String[] ABI_ARRAY = { + "[{\"constant\":true,\"inputs\":[{\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"getStatus\",\"outputs\":[{\"name\":\"\",\"type\":\"int256\"},{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"unfreeze\",\"outputs\":[{\"name\":\"\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"freeze\",\"outputs\":[{\"name\":\"\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"contractAddr\",\"type\":\"address\"},{\"name\":\"userAddr\",\"type\":\"address\"}],\"name\":\"grantManager\",\"outputs\":[{\"name\":\"\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"listManager\",\"outputs\":[{\"name\":\"\",\"type\":\"int256\"},{\"name\":\"\",\"type\":\"address[]\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]" + }; + + public static final String ABI = String.join("", ABI_ARRAY); + + public static final TransactionDecoder transactionDecoder = new TransactionDecoder(ABI, BINARY); + + public static final String FUNC_GETSTATUS = "getStatus"; + + public static final String FUNC_UNFREEZE = "unfreeze"; + + public static final String FUNC_FREEZE = "freeze"; + + public static final String FUNC_GRANTMANAGER = "grantManager"; + + public static final String FUNC_LISTMANAGER = "listManager"; + + @Deprecated + protected ContractLifeCyclePrecompiled( + String contractAddress, + Web3j web3j, + Credentials credentials, + BigInteger gasPrice, + BigInteger gasLimit) { + super(BINARY, contractAddress, web3j, credentials, gasPrice, gasLimit); + } + + protected ContractLifeCyclePrecompiled( + String contractAddress, + Web3j web3j, + Credentials credentials, + ContractGasProvider contractGasProvider) { + super(BINARY, contractAddress, web3j, credentials, contractGasProvider); + } + + @Deprecated + protected ContractLifeCyclePrecompiled( + String contractAddress, + Web3j web3j, + TransactionManager transactionManager, + BigInteger gasPrice, + BigInteger gasLimit) { + super(BINARY, contractAddress, web3j, transactionManager, gasPrice, gasLimit); + } + + protected ContractLifeCyclePrecompiled( + String contractAddress, + Web3j web3j, + TransactionManager transactionManager, + ContractGasProvider contractGasProvider) { + super(BINARY, contractAddress, web3j, transactionManager, contractGasProvider); + } + + public static TransactionDecoder getTransactionDecoder() { + return transactionDecoder; + } + + public RemoteCall> getStatus(String addr) { + final Function function = + new Function( + FUNC_GETSTATUS, + Arrays.asList(new org.fisco.bcos.web3j.abi.datatypes.Address(addr)), + Arrays.>asList( + new TypeReference() {}, + new TypeReference() {})); + return new RemoteCall>( + new Callable>() { + @Override + public Tuple2 call() throws Exception { + List results = executeCallMultipleValueReturn(function); + return new Tuple2( + (BigInteger) results.get(0).getValue(), + (String) results.get(1).getValue()); + } + }); + } + + public RemoteCall unfreeze(String addr) { + final Function function = + new Function( + FUNC_UNFREEZE, + Arrays.asList(new org.fisco.bcos.web3j.abi.datatypes.Address(addr)), + Collections.>emptyList()); + return executeRemoteCallTransaction(function); + } + + public void unfreeze(String addr, TransactionSucCallback callback) { + final Function function = + new Function( + FUNC_UNFREEZE, + Arrays.asList(new org.fisco.bcos.web3j.abi.datatypes.Address(addr)), + Collections.>emptyList()); + asyncExecuteTransaction(function, callback); + } + + public String unfreezeSeq(String addr) { + final Function function = + new Function( + FUNC_UNFREEZE, + Arrays.asList(new org.fisco.bcos.web3j.abi.datatypes.Address(addr)), + Collections.>emptyList()); + return createTransactionSeq(function); + } + + public Tuple1 getUnfreezeInput(TransactionReceipt transactionReceipt) { + String data = transactionReceipt.getInput().substring(10); + final Function function = + new Function( + FUNC_UNFREEZE, + Arrays.asList(), + Arrays.>asList(new TypeReference

() {})); + List results = FunctionReturnDecoder.decode(data, function.getOutputParameters()); + ; + return new Tuple1((String) results.get(0).getValue()); + } + + public Tuple1 getUnfreezeOutput(TransactionReceipt transactionReceipt) { + String data = transactionReceipt.getOutput(); + final Function function = + new Function( + FUNC_UNFREEZE, + Arrays.asList(), + Arrays.>asList(new TypeReference() {})); + List results = FunctionReturnDecoder.decode(data, function.getOutputParameters()); + ; + return new Tuple1((BigInteger) results.get(0).getValue()); + } + + public RemoteCall freeze(String addr) { + final Function function = + new Function( + FUNC_FREEZE, + Arrays.asList(new org.fisco.bcos.web3j.abi.datatypes.Address(addr)), + Collections.>emptyList()); + return executeRemoteCallTransaction(function); + } + + public void freeze(String addr, TransactionSucCallback callback) { + final Function function = + new Function( + FUNC_FREEZE, + Arrays.asList(new org.fisco.bcos.web3j.abi.datatypes.Address(addr)), + Collections.>emptyList()); + asyncExecuteTransaction(function, callback); + } + + public String freezeSeq(String addr) { + final Function function = + new Function( + FUNC_FREEZE, + Arrays.asList(new org.fisco.bcos.web3j.abi.datatypes.Address(addr)), + Collections.>emptyList()); + return createTransactionSeq(function); + } + + public Tuple1 getFreezeInput(TransactionReceipt transactionReceipt) { + String data = transactionReceipt.getInput().substring(10); + final Function function = + new Function( + FUNC_FREEZE, + Arrays.asList(), + Arrays.>asList(new TypeReference
() {})); + List results = FunctionReturnDecoder.decode(data, function.getOutputParameters()); + ; + return new Tuple1((String) results.get(0).getValue()); + } + + public Tuple1 getFreezeOutput(TransactionReceipt transactionReceipt) { + String data = transactionReceipt.getOutput(); + final Function function = + new Function( + FUNC_FREEZE, + Arrays.asList(), + Arrays.>asList(new TypeReference() {})); + List results = FunctionReturnDecoder.decode(data, function.getOutputParameters()); + ; + return new Tuple1((BigInteger) results.get(0).getValue()); + } + + public RemoteCall grantManager(String contractAddr, String userAddr) { + final Function function = + new Function( + FUNC_GRANTMANAGER, + Arrays.asList( + new org.fisco.bcos.web3j.abi.datatypes.Address(contractAddr), + new org.fisco.bcos.web3j.abi.datatypes.Address(userAddr)), + Collections.>emptyList()); + return executeRemoteCallTransaction(function); + } + + public void grantManager( + String contractAddr, String userAddr, TransactionSucCallback callback) { + final Function function = + new Function( + FUNC_GRANTMANAGER, + Arrays.asList( + new org.fisco.bcos.web3j.abi.datatypes.Address(contractAddr), + new org.fisco.bcos.web3j.abi.datatypes.Address(userAddr)), + Collections.>emptyList()); + asyncExecuteTransaction(function, callback); + } + + public String grantManagerSeq(String contractAddr, String userAddr) { + final Function function = + new Function( + FUNC_GRANTMANAGER, + Arrays.asList( + new org.fisco.bcos.web3j.abi.datatypes.Address(contractAddr), + new org.fisco.bcos.web3j.abi.datatypes.Address(userAddr)), + Collections.>emptyList()); + return createTransactionSeq(function); + } + + public Tuple2 getGrantManagerInput(TransactionReceipt transactionReceipt) { + String data = transactionReceipt.getInput().substring(10); + final Function function = + new Function( + FUNC_GRANTMANAGER, + Arrays.asList(), + Arrays.>asList( + new TypeReference
() {}, new TypeReference
() {})); + List results = FunctionReturnDecoder.decode(data, function.getOutputParameters()); + ; + return new Tuple2( + (String) results.get(0).getValue(), (String) results.get(1).getValue()); + } + + public Tuple1 getGrantManagerOutput(TransactionReceipt transactionReceipt) { + String data = transactionReceipt.getOutput(); + final Function function = + new Function( + FUNC_GRANTMANAGER, + Arrays.asList(), + Arrays.>asList(new TypeReference() {})); + List results = FunctionReturnDecoder.decode(data, function.getOutputParameters()); + ; + return new Tuple1((BigInteger) results.get(0).getValue()); + } + + public RemoteCall>> listManager(String addr) { + final Function function = + new Function( + FUNC_LISTMANAGER, + Arrays.asList(new org.fisco.bcos.web3j.abi.datatypes.Address(addr)), + Arrays.>asList( + new TypeReference() {}, + new TypeReference>() {})); + return new RemoteCall>>( + new Callable>>() { + @Override + public Tuple2> call() throws Exception { + List results = executeCallMultipleValueReturn(function); + return new Tuple2>( + (BigInteger) results.get(0).getValue(), + convertToNative((List
) results.get(1).getValue())); + } + }); + } + + @Deprecated + public static ContractLifeCyclePrecompiled load( + String contractAddress, + Web3j web3j, + Credentials credentials, + BigInteger gasPrice, + BigInteger gasLimit) { + return new ContractLifeCyclePrecompiled( + contractAddress, web3j, credentials, gasPrice, gasLimit); + } + + @Deprecated + public static ContractLifeCyclePrecompiled load( + String contractAddress, + Web3j web3j, + TransactionManager transactionManager, + BigInteger gasPrice, + BigInteger gasLimit) { + return new ContractLifeCyclePrecompiled( + contractAddress, web3j, transactionManager, gasPrice, gasLimit); + } + + public static ContractLifeCyclePrecompiled load( + String contractAddress, + Web3j web3j, + Credentials credentials, + ContractGasProvider contractGasProvider) { + return new ContractLifeCyclePrecompiled( + contractAddress, web3j, credentials, contractGasProvider); + } + + public static ContractLifeCyclePrecompiled load( + String contractAddress, + Web3j web3j, + TransactionManager transactionManager, + ContractGasProvider contractGasProvider) { + return new ContractLifeCyclePrecompiled( + contractAddress, web3j, transactionManager, contractGasProvider); + } + + public static RemoteCall deploy( + Web3j web3j, Credentials credentials, ContractGasProvider contractGasProvider) { + return deployRemoteCall( + ContractLifeCyclePrecompiled.class, + web3j, + credentials, + contractGasProvider, + BINARY, + ""); + } + + @Deprecated + public static RemoteCall deploy( + Web3j web3j, Credentials credentials, BigInteger gasPrice, BigInteger gasLimit) { + return deployRemoteCall( + ContractLifeCyclePrecompiled.class, + web3j, + credentials, + gasPrice, + gasLimit, + BINARY, + ""); + } + + public static RemoteCall deploy( + Web3j web3j, + TransactionManager transactionManager, + ContractGasProvider contractGasProvider) { + return deployRemoteCall( + ContractLifeCyclePrecompiled.class, + web3j, + transactionManager, + contractGasProvider, + BINARY, + ""); + } + + @Deprecated + public static RemoteCall deploy( + Web3j web3j, + TransactionManager transactionManager, + BigInteger gasPrice, + BigInteger gasLimit) { + return deployRemoteCall( + ContractLifeCyclePrecompiled.class, + web3j, + transactionManager, + gasPrice, + gasLimit, + BINARY, + ""); + } +} diff --git a/src/main/java/org/fisco/bcos/web3j/precompile/csm/ContractLifeCyclePrecompiled.sol b/src/main/java/org/fisco/bcos/web3j/precompile/csm/ContractLifeCyclePrecompiled.sol new file mode 100644 index 000000000..f0941b1ea --- /dev/null +++ b/src/main/java/org/fisco/bcos/web3j/precompile/csm/ContractLifeCyclePrecompiled.sol @@ -0,0 +1,9 @@ +pragma solidity ^0.4.24; + +contract ContractLifeCyclePrecompiled { + function freeze(address addr) public returns(int); + function unfreeze(address addr) public returns(int); + function grantManager(address contractAddr, address userAddr) public returns(int); + function getStatus(address addr) public constant returns(uint,string); + function queryManager(address addr) public constant returns(uint,address[]); +} diff --git a/src/main/java/org/fisco/bcos/web3j/precompile/csm/ContractStatusService.java b/src/main/java/org/fisco/bcos/web3j/precompile/csm/ContractStatusService.java new file mode 100644 index 000000000..25b0d00cb --- /dev/null +++ b/src/main/java/org/fisco/bcos/web3j/precompile/csm/ContractStatusService.java @@ -0,0 +1,86 @@ +package org.fisco.bcos.web3j.precompile.csm; + +import java.math.BigInteger; +import java.util.List; +import org.fisco.bcos.web3j.crypto.Credentials; +import org.fisco.bcos.web3j.crypto.WalletUtils; +import org.fisco.bcos.web3j.precompile.common.PrecompiledCommon; +import org.fisco.bcos.web3j.protocol.ObjectMapperFactory; +import org.fisco.bcos.web3j.protocol.Web3j; +import org.fisco.bcos.web3j.protocol.core.methods.response.TransactionReceipt; +import org.fisco.bcos.web3j.tuples.generated.Tuple2; +import org.fisco.bcos.web3j.tx.gas.ContractGasProvider; +import org.fisco.bcos.web3j.tx.gas.StaticGasProvider; + +public class ContractStatusService { + private static BigInteger gasPrice = new BigInteger("30000000000"); + private static BigInteger gasLimit = new BigInteger("30000000000"); + private static String ContractLifeCyclePrecompiledAddress = + "0x0000000000000000000000000000000000001007"; + private Web3j web3j; + private ContractLifeCyclePrecompiled contractLifeCycle; + + public ContractStatusService(Web3j web3j, Credentials credentials) { + ContractGasProvider contractGasProvider = new StaticGasProvider(gasPrice, gasLimit); + this.web3j = web3j; + this.contractLifeCycle = + ContractLifeCyclePrecompiled.load( + ContractLifeCyclePrecompiledAddress, + web3j, + credentials, + contractGasProvider); + } + + public String freeze(String addr) throws Exception { + if (!WalletUtils.isValidAddress(addr)) { + return PrecompiledCommon.transferToJson(PrecompiledCommon.InvalidAddress); + } + + TransactionReceipt receipt = contractLifeCycle.freeze(addr).send(); + return PrecompiledCommon.handleTransactionReceipt(receipt, web3j); + } + + public String unfreeze(String addr) throws Exception { + if (!WalletUtils.isValidAddress(addr)) { + return PrecompiledCommon.transferToJson(PrecompiledCommon.InvalidAddress); + } + + TransactionReceipt receipt = contractLifeCycle.unfreeze(addr).send(); + return PrecompiledCommon.handleTransactionReceipt(receipt, web3j); + } + + public String grantManager(String addr, String user) throws Exception { + if (!WalletUtils.isValidAddress(addr) || !WalletUtils.isValidAddress(user)) { + return PrecompiledCommon.transferToJson(PrecompiledCommon.InvalidAddress); + } + + TransactionReceipt receipt = contractLifeCycle.grantManager(addr, user).send(); + return PrecompiledCommon.handleTransactionReceipt(receipt, web3j); + } + + public String getStatus(String addr) throws Exception { + if (!WalletUtils.isValidAddress(addr)) { + return PrecompiledCommon.transferToJson(PrecompiledCommon.InvalidAddress); + } + + Tuple2 send = contractLifeCycle.getStatus(addr).send(); + if (!(send.getValue1().intValue() == PrecompiledCommon.Success)) { + return PrecompiledCommon.transferToJson(send.getValue1().intValue()); + } + return send.getValue2(); + } + + public String listManager(String addr) throws Exception { + if (!WalletUtils.isValidAddress(addr)) { + return PrecompiledCommon.transferToJson(PrecompiledCommon.InvalidAddress); + } + + Tuple2> send = contractLifeCycle.listManager(addr).send(); + + if (!(send.getValue1().intValue() == PrecompiledCommon.Success)) { + return PrecompiledCommon.transferToJson(send.getValue1().intValue()); + } + + return ObjectMapperFactory.getObjectMapper().writeValueAsString(send.getValue2()); + } +} diff --git a/src/main/java/org/fisco/bcos/web3j/precompile/permission/Permission.java b/src/main/java/org/fisco/bcos/web3j/precompile/permission/Permission.java index b28dca875..d6ead67f4 100644 --- a/src/main/java/org/fisco/bcos/web3j/precompile/permission/Permission.java +++ b/src/main/java/org/fisco/bcos/web3j/precompile/permission/Permission.java @@ -3,17 +3,26 @@ import java.math.BigInteger; import java.util.Arrays; import java.util.Collections; +import java.util.List; +import org.fisco.bcos.channel.client.TransactionSucCallback; +import org.fisco.bcos.web3j.abi.FunctionReturnDecoder; import org.fisco.bcos.web3j.abi.TypeReference; +import org.fisco.bcos.web3j.abi.datatypes.Address; import org.fisco.bcos.web3j.abi.datatypes.Function; import org.fisco.bcos.web3j.abi.datatypes.Type; import org.fisco.bcos.web3j.abi.datatypes.Utf8String; +import org.fisco.bcos.web3j.abi.datatypes.generated.Int256; import org.fisco.bcos.web3j.crypto.Credentials; +import org.fisco.bcos.web3j.crypto.EncryptType; import org.fisco.bcos.web3j.protocol.Web3j; import org.fisco.bcos.web3j.protocol.core.RemoteCall; import org.fisco.bcos.web3j.protocol.core.methods.response.TransactionReceipt; +import org.fisco.bcos.web3j.tuples.generated.Tuple1; +import org.fisco.bcos.web3j.tuples.generated.Tuple2; import org.fisco.bcos.web3j.tx.Contract; import org.fisco.bcos.web3j.tx.TransactionManager; import org.fisco.bcos.web3j.tx.gas.ContractGasProvider; +import org.fisco.bcos.web3j.tx.txdecode.TransactionDecoder; /** * Auto generated code. @@ -26,8 +35,18 @@ * *

Generated with web3j version none. */ +@SuppressWarnings("unchecked") public class Permission extends Contract { - private static final String BINARY = ""; + public static String BINARY = + "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"; + + public static final String ABI = + "[{\"constant\":false,\"inputs\":[{\"name\":\"table_name\",\"type\":\"string\"},{\"name\":\"addr\",\"type\":\"string\"}],\"name\":\"insert\",\"outputs\":[{\"name\":\"\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"table_name\",\"type\":\"string\"}],\"name\":\"queryByName\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"table_name\",\"type\":\"string\"},{\"name\":\"addr\",\"type\":\"string\"}],\"name\":\"remove\",\"outputs\":[{\"name\":\"\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"contractAddr\",\"type\":\"address\"}],\"name\":\"queryPermission\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"contractAddr\",\"type\":\"address\"},{\"name\":\"user\",\"type\":\"address\"}],\"name\":\"grantWrite\",\"outputs\":[{\"name\":\"\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"contractAddr\",\"type\":\"address\"},{\"name\":\"user\",\"type\":\"address\"}],\"name\":\"revokeWrite\",\"outputs\":[{\"name\":\"\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"; + + public static final TransactionDecoder transactionDecoder = new TransactionDecoder(ABI, BINARY); + + public static String SM_BINARY = + "608060405234801561001057600080fd5b506104e9806100206000396000f300608060405260043610610078576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806367547e081461007d57806385d23afc14610139578063bbec3f91146101fc578063ce0a9fb9146102de578063d010d23c146103a1578063df12fe7814610418575b600080fd5b34801561008957600080fd5b506100be600480360381019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919050505061048f565b6040518080602001828103825283818151815260200191508051906020019080838360005b838110156100fe5780820151818401526020810190506100e3565b50505050905090810190601f16801561012b5780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b34801561014557600080fd5b506101e6600480360381019080803590602001908201803590602001908080601f0160208091040260200160405190810160405280939291908181526020018383808284378201915050505050509192919290803590602001908201803590602001908080601f0160208091040260200160405190810160405280939291908181526020018383808284378201915050505050509192919290505050610496565b6040518082815260200191505060405180910390f35b34801561020857600080fd5b50610263600480360381019080803590602001908201803590602001908080601f016020809104026020016040519081016040528093929190818152602001838380828437820191505050505050919291929050505061049e565b6040518080602001828103825283818151815260200191508051906020019080838360005b838110156102a3578082015181840152602081019050610288565b50505050905090810190601f1680156102d05780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b3480156102ea57600080fd5b5061038b600480360381019080803590602001908201803590602001908080601f0160208091040260200160405190810160405280939291908181526020018383808284378201915050505050509192919290803590602001908201803590602001908080601f01602080910402602001604051908101604052809392919081815260200183838082843782019150505050505091929192905050506104a5565b6040518082815260200191505060405180910390f35b3480156103ad57600080fd5b50610402600480360381019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190803573ffffffffffffffffffffffffffffffffffffffff1690602001909291905050506104ad565b6040518082815260200191505060405180910390f35b34801561042457600080fd5b50610479600480360381019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190803573ffffffffffffffffffffffffffffffffffffffff1690602001909291905050506104b5565b6040518082815260200191505060405180910390f35b6060919050565b600092915050565b6060919050565b600092915050565b600092915050565b6000929150505600a165627a7a72305820bf0f81656b6d3d710d2b773a559163c0b2d52c36128a9f6f9064eae123f7743c0029"; public static final String FUNC_INSERT = "insert"; @@ -35,6 +54,12 @@ public class Permission extends Contract { public static final String FUNC_REMOVE = "remove"; + public static final String FUNC_QUERYPERMISSION = "queryPermission"; + + public static final String FUNC_GRANTWRITE = "grantWrite"; + + public static final String FUNC_REVOKEWRITE = "revokeWrite"; + @Deprecated protected Permission( String contractAddress, @@ -42,7 +67,7 @@ protected Permission( Credentials credentials, BigInteger gasPrice, BigInteger gasLimit) { - super(BINARY, contractAddress, web3j, credentials, gasPrice, gasLimit); + super(getBinary(), contractAddress, web3j, credentials, gasPrice, gasLimit); } protected Permission( @@ -50,7 +75,7 @@ protected Permission( Web3j web3j, Credentials credentials, ContractGasProvider contractGasProvider) { - super(BINARY, contractAddress, web3j, credentials, contractGasProvider); + super(getBinary(), contractAddress, web3j, credentials, contractGasProvider); } @Deprecated @@ -60,7 +85,7 @@ protected Permission( TransactionManager transactionManager, BigInteger gasPrice, BigInteger gasLimit) { - super(BINARY, contractAddress, web3j, transactionManager, gasPrice, gasLimit); + super(getBinary(), contractAddress, web3j, transactionManager, gasPrice, gasLimit); } protected Permission( @@ -68,23 +93,83 @@ protected Permission( Web3j web3j, TransactionManager transactionManager, ContractGasProvider contractGasProvider) { - super(BINARY, contractAddress, web3j, transactionManager, contractGasProvider); + super(getBinary(), contractAddress, web3j, transactionManager, contractGasProvider); + } + + public static String getBinary() { + return (EncryptType.encryptType == EncryptType.ECDSA_TYPE ? BINARY : SM_BINARY); + } + + public static TransactionDecoder getTransactionDecoder() { + return transactionDecoder; } public RemoteCall insert(String table_name, String addr) { final Function function = new Function( FUNC_INSERT, - Arrays.asList(new Utf8String(table_name), new Utf8String(addr)), + Arrays.asList( + new org.fisco.bcos.web3j.abi.datatypes.Utf8String(table_name), + new org.fisco.bcos.web3j.abi.datatypes.Utf8String(addr)), Collections.>emptyList()); return executeRemoteCallTransaction(function); } + public void insert(String table_name, String addr, TransactionSucCallback callback) { + final Function function = + new Function( + FUNC_INSERT, + Arrays.asList( + new org.fisco.bcos.web3j.abi.datatypes.Utf8String(table_name), + new org.fisco.bcos.web3j.abi.datatypes.Utf8String(addr)), + Collections.>emptyList()); + asyncExecuteTransaction(function, callback); + } + + public String insertSeq(String table_name, String addr) { + final Function function = + new Function( + FUNC_INSERT, + Arrays.asList( + new org.fisco.bcos.web3j.abi.datatypes.Utf8String(table_name), + new org.fisco.bcos.web3j.abi.datatypes.Utf8String(addr)), + Collections.>emptyList()); + return createTransactionSeq(function); + } + + public Tuple2 getInsertInput(TransactionReceipt transactionReceipt) { + String data = transactionReceipt.getInput().substring(10); + final Function function = + new Function( + FUNC_INSERT, + Arrays.asList(), + Arrays.>asList( + new TypeReference() {}, + new TypeReference() {})); + List results = FunctionReturnDecoder.decode(data, function.getOutputParameters()); + ; + return new Tuple2( + (String) results.get(0).getValue(), (String) results.get(1).getValue()); + } + + public Tuple1 getInsertOutput(TransactionReceipt transactionReceipt) { + String data = transactionReceipt.getOutput(); + final Function function = + new Function( + FUNC_INSERT, + Arrays.asList(), + Arrays.>asList(new TypeReference() {})); + List results = FunctionReturnDecoder.decode(data, function.getOutputParameters()); + ; + return new Tuple1((BigInteger) results.get(0).getValue()); + } + public RemoteCall queryByName(String table_name) { final Function function = new Function( FUNC_QUERYBYNAME, - Arrays.asList(new Utf8String(table_name)), + Arrays.asList( + new org.fisco.bcos.web3j.abi.datatypes.Utf8String(table_name)), Arrays.>asList(new TypeReference() {})); return executeRemoteCallSingleValueReturn(function, String.class); } @@ -93,11 +178,190 @@ public RemoteCall remove(String table_name, String addr) { final Function function = new Function( FUNC_REMOVE, - Arrays.asList(new Utf8String(table_name), new Utf8String(addr)), + Arrays.asList( + new org.fisco.bcos.web3j.abi.datatypes.Utf8String(table_name), + new org.fisco.bcos.web3j.abi.datatypes.Utf8String(addr)), + Collections.>emptyList()); + return executeRemoteCallTransaction(function); + } + + public void remove(String table_name, String addr, TransactionSucCallback callback) { + final Function function = + new Function( + FUNC_REMOVE, + Arrays.asList( + new org.fisco.bcos.web3j.abi.datatypes.Utf8String(table_name), + new org.fisco.bcos.web3j.abi.datatypes.Utf8String(addr)), + Collections.>emptyList()); + asyncExecuteTransaction(function, callback); + } + + public String removeSeq(String table_name, String addr) { + final Function function = + new Function( + FUNC_REMOVE, + Arrays.asList( + new org.fisco.bcos.web3j.abi.datatypes.Utf8String(table_name), + new org.fisco.bcos.web3j.abi.datatypes.Utf8String(addr)), + Collections.>emptyList()); + return createTransactionSeq(function); + } + + public Tuple2 getRemoveInput(TransactionReceipt transactionReceipt) { + String data = transactionReceipt.getInput().substring(10); + final Function function = + new Function( + FUNC_REMOVE, + Arrays.asList(), + Arrays.>asList( + new TypeReference() {}, + new TypeReference() {})); + List results = FunctionReturnDecoder.decode(data, function.getOutputParameters()); + ; + return new Tuple2( + (String) results.get(0).getValue(), (String) results.get(1).getValue()); + } + + public Tuple1 getRemoveOutput(TransactionReceipt transactionReceipt) { + String data = transactionReceipt.getOutput(); + final Function function = + new Function( + FUNC_REMOVE, + Arrays.asList(), + Arrays.>asList(new TypeReference() {})); + List results = FunctionReturnDecoder.decode(data, function.getOutputParameters()); + ; + return new Tuple1((BigInteger) results.get(0).getValue()); + } + + public RemoteCall queryPermission(String contractAddr) { + final Function function = + new Function( + FUNC_QUERYPERMISSION, + Arrays.asList( + new org.fisco.bcos.web3j.abi.datatypes.Address(contractAddr)), + Arrays.>asList(new TypeReference() {})); + return executeRemoteCallSingleValueReturn(function, String.class); + } + + public RemoteCall grantWrite(String contractAddr, String user) { + final Function function = + new Function( + FUNC_GRANTWRITE, + Arrays.asList( + new org.fisco.bcos.web3j.abi.datatypes.Address(contractAddr), + new org.fisco.bcos.web3j.abi.datatypes.Address(user)), + Collections.>emptyList()); + return executeRemoteCallTransaction(function); + } + + public void grantWrite(String contractAddr, String user, TransactionSucCallback callback) { + final Function function = + new Function( + FUNC_GRANTWRITE, + Arrays.asList( + new org.fisco.bcos.web3j.abi.datatypes.Address(contractAddr), + new org.fisco.bcos.web3j.abi.datatypes.Address(user)), + Collections.>emptyList()); + asyncExecuteTransaction(function, callback); + } + + public String grantWriteSeq(String contractAddr, String user) { + final Function function = + new Function( + FUNC_GRANTWRITE, + Arrays.asList( + new org.fisco.bcos.web3j.abi.datatypes.Address(contractAddr), + new org.fisco.bcos.web3j.abi.datatypes.Address(user)), + Collections.>emptyList()); + return createTransactionSeq(function); + } + + public Tuple2 getGrantWriteInput(TransactionReceipt transactionReceipt) { + String data = transactionReceipt.getInput().substring(10); + final Function function = + new Function( + FUNC_GRANTWRITE, + Arrays.asList(), + Arrays.>asList( + new TypeReference

() {}, new TypeReference
() {})); + List results = FunctionReturnDecoder.decode(data, function.getOutputParameters()); + ; + return new Tuple2( + (String) results.get(0).getValue(), (String) results.get(1).getValue()); + } + + public Tuple1 getGrantWriteOutput(TransactionReceipt transactionReceipt) { + String data = transactionReceipt.getOutput(); + final Function function = + new Function( + FUNC_GRANTWRITE, + Arrays.asList(), + Arrays.>asList(new TypeReference() {})); + List results = FunctionReturnDecoder.decode(data, function.getOutputParameters()); + ; + return new Tuple1((BigInteger) results.get(0).getValue()); + } + + public RemoteCall revokeWrite(String contractAddr, String user) { + final Function function = + new Function( + FUNC_REVOKEWRITE, + Arrays.asList( + new org.fisco.bcos.web3j.abi.datatypes.Address(contractAddr), + new org.fisco.bcos.web3j.abi.datatypes.Address(user)), Collections.>emptyList()); return executeRemoteCallTransaction(function); } + public void revokeWrite(String contractAddr, String user, TransactionSucCallback callback) { + final Function function = + new Function( + FUNC_REVOKEWRITE, + Arrays.asList( + new org.fisco.bcos.web3j.abi.datatypes.Address(contractAddr), + new org.fisco.bcos.web3j.abi.datatypes.Address(user)), + Collections.>emptyList()); + asyncExecuteTransaction(function, callback); + } + + public String revokeWriteSeq(String contractAddr, String user) { + final Function function = + new Function( + FUNC_REVOKEWRITE, + Arrays.asList( + new org.fisco.bcos.web3j.abi.datatypes.Address(contractAddr), + new org.fisco.bcos.web3j.abi.datatypes.Address(user)), + Collections.>emptyList()); + return createTransactionSeq(function); + } + + public Tuple2 getRevokeWriteInput(TransactionReceipt transactionReceipt) { + String data = transactionReceipt.getInput().substring(10); + final Function function = + new Function( + FUNC_REVOKEWRITE, + Arrays.asList(), + Arrays.>asList( + new TypeReference
() {}, new TypeReference
() {})); + List results = FunctionReturnDecoder.decode(data, function.getOutputParameters()); + ; + return new Tuple2( + (String) results.get(0).getValue(), (String) results.get(1).getValue()); + } + + public Tuple1 getRevokeWriteOutput(TransactionReceipt transactionReceipt) { + String data = transactionReceipt.getOutput(); + final Function function = + new Function( + FUNC_REVOKEWRITE, + Arrays.asList(), + Arrays.>asList(new TypeReference() {})); + List results = FunctionReturnDecoder.decode(data, function.getOutputParameters()); + ; + return new Tuple1((BigInteger) results.get(0).getValue()); + } + @Deprecated public static Permission load( String contractAddress, @@ -137,14 +401,14 @@ public static Permission load( public static RemoteCall deploy( Web3j web3j, Credentials credentials, ContractGasProvider contractGasProvider) { return deployRemoteCall( - Permission.class, web3j, credentials, contractGasProvider, BINARY, ""); + Permission.class, web3j, credentials, contractGasProvider, getBinary(), ""); } @Deprecated public static RemoteCall deploy( Web3j web3j, Credentials credentials, BigInteger gasPrice, BigInteger gasLimit) { return deployRemoteCall( - Permission.class, web3j, credentials, gasPrice, gasLimit, BINARY, ""); + Permission.class, web3j, credentials, gasPrice, gasLimit, getBinary(), ""); } public static RemoteCall deploy( @@ -152,7 +416,7 @@ public static RemoteCall deploy( TransactionManager transactionManager, ContractGasProvider contractGasProvider) { return deployRemoteCall( - Permission.class, web3j, transactionManager, contractGasProvider, BINARY, ""); + Permission.class, web3j, transactionManager, contractGasProvider, getBinary(), ""); } @Deprecated @@ -162,6 +426,6 @@ public static RemoteCall deploy( BigInteger gasPrice, BigInteger gasLimit) { return deployRemoteCall( - Permission.class, web3j, transactionManager, gasPrice, gasLimit, BINARY, ""); + Permission.class, web3j, transactionManager, gasPrice, gasLimit, getBinary(), ""); } } diff --git a/src/main/java/org/fisco/bcos/web3j/precompile/permission/Permission.sol b/src/main/java/org/fisco/bcos/web3j/precompile/permission/Permission.sol index 6a06e5e85..e6c5d6bad 100644 --- a/src/main/java/org/fisco/bcos/web3j/precompile/permission/Permission.sol +++ b/src/main/java/org/fisco/bcos/web3j/precompile/permission/Permission.sol @@ -1,7 +1,10 @@ pragma solidity ^0.4.2; contract Permission { - function insert(string table_name, string addr) public returns(int); - function remove(string table_name, string addr) public returns(int); - function queryByName(string table_name) public constant returns(string); + function insert(string table_name, string addr) public returns(int) {} + function remove(string table_name, string addr) public returns(int) {} + function queryByName(string table_name) public constant returns(string) {} + function grantWrite(address contractAddr, address user) public returns (int256) {} + function revokeWrite(address contractAddr, address user) public returns (int256) {} + function queryPermission(address contractAddr) public constant returns (string) {} } \ No newline at end of file diff --git a/src/main/java/org/fisco/bcos/web3j/precompile/permission/PermissionService.java b/src/main/java/org/fisco/bcos/web3j/precompile/permission/PermissionService.java index f2330ce53..dc90fd0cd 100644 --- a/src/main/java/org/fisco/bcos/web3j/precompile/permission/PermissionService.java +++ b/src/main/java/org/fisco/bcos/web3j/precompile/permission/PermissionService.java @@ -30,6 +30,26 @@ public PermissionService(Web3j web3j, Credentials credentials) { this.credentials = credentials; } + public List queryPermission(String address) throws Exception { + String permissionyInfo = permission.queryPermission(address).send(); + ObjectMapper objectMapper = ObjectMapperFactory.getObjectMapper(); + return objectMapper.readValue( + permissionyInfo, + objectMapper + .getTypeFactory() + .constructCollectionType(List.class, PermissionInfo.class)); + } + + public String grantWrite(String address, String user) throws Exception { + TransactionReceipt receipt = permission.grantWrite(address, user).send(); + return PrecompiledCommon.handleTransactionReceipt(receipt, web3j); + } + + public String revokeWrite(String address, String user) throws Exception { + TransactionReceipt receipt = permission.revokeWrite(address, user).send(); + return PrecompiledCommon.handleTransactionReceipt(receipt, web3j); + } + public String grantUserTableManager(String tableName, String grantress) throws Exception { CRUDService crudSerivce = new CRUDService(web3j, credentials); crudSerivce.desc(tableName); diff --git a/src/main/java/org/fisco/bcos/web3j/protocol/channel/ChannelEthereumService.java b/src/main/java/org/fisco/bcos/web3j/protocol/channel/ChannelEthereumService.java index 2ba9b2769..f01a1bc58 100644 --- a/src/main/java/org/fisco/bcos/web3j/protocol/channel/ChannelEthereumService.java +++ b/src/main/java/org/fisco/bcos/web3j/protocol/channel/ChannelEthereumService.java @@ -11,6 +11,8 @@ import org.fisco.bcos.web3j.protocol.core.methods.response.SendTransaction; import org.fisco.bcos.web3j.protocol.core.methods.response.TransactionReceipt; import org.fisco.bcos.web3j.protocol.exceptions.MessageDecodingException; +import org.fisco.bcos.web3j.tuples.generated.Tuple2; +import org.fisco.bcos.web3j.tx.RevertResolver; import org.fisco.bcos.web3j.tx.exceptions.ContractCallException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -80,9 +82,22 @@ public T send(Request request, Class responseType) throw } if (t.getResult() instanceof CallOutput) { CallOutput callResult = (CallOutput) t.getResult(); + + Tuple2 revertMessage = + RevertResolver.tryResolveRevertMessage( + callResult.getStatus(), callResult.getOutput()); + if (revertMessage.getValue1()) { + logger.debug(" revert message: {}", revertMessage.getValue2()); + // throw new ContractCallException(revertMessage.getValue2()); + } + if (StatusCode.RevertInstruction.equals(callResult.getStatus())) { throw new ContractCallException( - "The execution of the contract rolled back."); + "The execution of the contract rolled back" + + (revertMessage.getValue1() + ? ", " + revertMessage.getValue2() + : "") + + "."); } if (StatusCode.CallAddressError.equals(callResult.getStatus())) { throw new ContractCallException("The contract address is incorrect."); diff --git a/src/main/java/org/fisco/bcos/web3j/protocol/channel/StatusCode.java b/src/main/java/org/fisco/bcos/web3j/protocol/channel/StatusCode.java index 056dd51da..056839eab 100644 --- a/src/main/java/org/fisco/bcos/web3j/protocol/channel/StatusCode.java +++ b/src/main/java/org/fisco/bcos/web3j/protocol/channel/StatusCode.java @@ -32,6 +32,7 @@ public class StatusCode { public static final String GasOverflow = "0x1b"; public static final String TxPoolIsFull = "0x1c"; public static final String TransactionRefused = "0x1d"; + public static final String ContractFrozen = "0x1e"; // extension public static final String ExceptionCatched = "0x30"; @@ -163,6 +164,9 @@ public static String getStatusMessage(String status, String errorMessage) { case MalformedTx: message = "malformed transaction"; break; + case ContractFrozen: + message = "contract has been frozen"; + break; default: message = errorMessage; break; diff --git a/src/main/java/org/fisco/bcos/web3j/protocol/core/Ethereum.java b/src/main/java/org/fisco/bcos/web3j/protocol/core/Ethereum.java index 85f12b0e1..57885e588 100644 --- a/src/main/java/org/fisco/bcos/web3j/protocol/core/Ethereum.java +++ b/src/main/java/org/fisco/bcos/web3j/protocol/core/Ethereum.java @@ -1,7 +1,9 @@ package org.fisco.bcos.web3j.protocol.core; +import java.io.IOException; import java.math.BigInteger; import java.util.List; +import org.fisco.bcos.channel.client.TransactionSucCallback; import org.fisco.bcos.web3j.protocol.core.methods.response.BcosBlock; import org.fisco.bcos.web3j.protocol.core.methods.response.BcosFilter; import org.fisco.bcos.web3j.protocol.core.methods.response.BcosLog; @@ -97,6 +99,9 @@ Request call( Request sendRawTransaction(String signedTransactionData); + void sendRawTransaction(String signedTransactionData, TransactionSucCallback callback) + throws IOException; + // generateGroup Request generateGroup(int groupId, int timestamp, List nodeList); diff --git a/src/main/java/org/fisco/bcos/web3j/protocol/core/JsonRpc2_0Web3j.java b/src/main/java/org/fisco/bcos/web3j/protocol/core/JsonRpc2_0Web3j.java index e9d609e5b..df3ebcf3a 100644 --- a/src/main/java/org/fisco/bcos/web3j/protocol/core/JsonRpc2_0Web3j.java +++ b/src/main/java/org/fisco/bcos/web3j/protocol/core/JsonRpc2_0Web3j.java @@ -9,6 +9,7 @@ import java.util.List; import java.util.Map; import java.util.concurrent.ScheduledExecutorService; +import org.fisco.bcos.channel.client.TransactionSucCallback; import org.fisco.bcos.web3j.protocol.Web3j; import org.fisco.bcos.web3j.protocol.Web3jService; import org.fisco.bcos.web3j.protocol.channel.ChannelEthereumService; @@ -318,6 +319,16 @@ public Request sendRawTransaction(String signedTransactionDa SendTransaction.class); } + @Override + public void sendRawTransaction(String signedTransactionData, TransactionSucCallback callback) + throws IOException { + Request request = sendRawTransaction(signedTransactionData); + request.setNeedTransCallback(true); + request.setTransactionSucCallback(callback); + + request.sendOnly(); + } + @Override public Request getGroupPeers() { return new Request<>( diff --git a/src/main/java/org/fisco/bcos/web3j/tx/ClientTransactionManager.java b/src/main/java/org/fisco/bcos/web3j/tx/ClientTransactionManager.java index a2e7a80d4..8810bbe6d 100644 --- a/src/main/java/org/fisco/bcos/web3j/tx/ClientTransactionManager.java +++ b/src/main/java/org/fisco/bcos/web3j/tx/ClientTransactionManager.java @@ -97,7 +97,8 @@ public SendTransaction signAndSend(RawTransaction rawTransaction) throws IOExcep return sendTransaction; } - BigInteger getBlockLimit() throws IOException { + @Override + protected BigInteger getBlockLimit() throws IOException { return web3j.getBlockNumberCache(); } } diff --git a/src/main/java/org/fisco/bcos/web3j/tx/Contract.java b/src/main/java/org/fisco/bcos/web3j/tx/Contract.java index e1ecbdd7a..142fa0507 100644 --- a/src/main/java/org/fisco/bcos/web3j/tx/Contract.java +++ b/src/main/java/org/fisco/bcos/web3j/tx/Contract.java @@ -95,12 +95,13 @@ protected Contract( public static TransactionManager getTheTransactionManager( Web3j web3j, Credentials credentials) { JsonRpc2_0Web3j jsonRpc2_0Web3j = (JsonRpc2_0Web3j) web3j; - int groupId = jsonRpc2_0Web3j.getGroupId(); String chainId = "1"; + int groupId = 1; String version = ""; String supportedVersion = ""; NodeVersion.Version nodeVersion = null; try { + groupId = jsonRpc2_0Web3j.getGroupId(); nodeVersion = web3j.getNodeVersion().send().getNodeVersion(); version = nodeVersion.getVersion(); supportedVersion = nodeVersion.getSupportedVersion(); @@ -114,7 +115,7 @@ public static TransactionManager getTheTransactionManager( logger.debug( "fisco-bcos version:{}, supported version:{}", version, supportedVersion); } - } catch (IOException e) { + } catch (Exception e) { logger.error("Query fisco-bcos version failed", e); } @@ -533,6 +534,7 @@ protected static T deploy( } catch (TransactionException e) { throw e; } catch (Exception e) { + logger.debug("e: {}", e); throw new RuntimeException(e); } } diff --git a/src/main/java/org/fisco/bcos/web3j/tx/ExtendedRawTransactionManager.java b/src/main/java/org/fisco/bcos/web3j/tx/ExtendedRawTransactionManager.java index 95b2de6b4..1cc44c3e1 100644 --- a/src/main/java/org/fisco/bcos/web3j/tx/ExtendedRawTransactionManager.java +++ b/src/main/java/org/fisco/bcos/web3j/tx/ExtendedRawTransactionManager.java @@ -2,8 +2,8 @@ import java.io.IOException; import java.math.BigInteger; -import java.security.SecureRandom; import java.util.Random; +import java.util.concurrent.ThreadLocalRandom; import org.fisco.bcos.channel.client.TransactionSucCallback; import org.fisco.bcos.web3j.crypto.*; import org.fisco.bcos.web3j.protocol.Web3j; @@ -76,7 +76,8 @@ public ExtendedRawTransactionManager( this(web3j, credentials, ChainId.NONE, attempts, sleepDuration, groupId, fiscoChainId); } - BigInteger getBlockLimit() throws IOException { + @Override + protected BigInteger getBlockLimit() throws IOException { return web3j.getBlockNumberCache(); } @@ -97,7 +98,8 @@ public ExtendedRawTransaction createTransaction( BigInteger value, String extraData) throws IOException { - Random r = new SecureRandom(); + // Random r = new SecureRandom(); + Random r = ThreadLocalRandom.current(); BigInteger randomid = new BigInteger(250, r); BigInteger blockLimit = getBlockLimit(); ExtendedRawTransaction rawTransaction = diff --git a/src/main/java/org/fisco/bcos/web3j/tx/RawTransactionManager.java b/src/main/java/org/fisco/bcos/web3j/tx/RawTransactionManager.java index bb12e9f1d..b58dfd262 100644 --- a/src/main/java/org/fisco/bcos/web3j/tx/RawTransactionManager.java +++ b/src/main/java/org/fisco/bcos/web3j/tx/RawTransactionManager.java @@ -57,7 +57,8 @@ public RawTransactionManager( this(web3j, credentials, ChainId.NONE, attempts, sleepDuration); } - BigInteger getBlockLimit() throws IOException { + @Override + protected BigInteger getBlockLimit() throws IOException { return web3j.getBlockNumberCache(); } diff --git a/src/main/java/org/fisco/bcos/web3j/tx/RevertResolver.java b/src/main/java/org/fisco/bcos/web3j/tx/RevertResolver.java new file mode 100644 index 000000000..117aa5db4 --- /dev/null +++ b/src/main/java/org/fisco/bcos/web3j/tx/RevertResolver.java @@ -0,0 +1,113 @@ +package org.fisco.bcos.web3j.tx; + +import java.math.BigInteger; +import java.util.Collections; +import java.util.List; +import org.fisco.bcos.web3j.abi.FunctionReturnDecoder; +import org.fisco.bcos.web3j.abi.TypeReference; +import org.fisco.bcos.web3j.abi.datatypes.Function; +import org.fisco.bcos.web3j.abi.datatypes.Type; +import org.fisco.bcos.web3j.abi.datatypes.Utf8String; +import org.fisco.bcos.web3j.protocol.core.methods.response.TransactionReceipt; +import org.fisco.bcos.web3j.tuples.generated.Tuple2; +import org.fisco.bcos.web3j.utils.Numeric; +import org.fisco.bcos.web3j.utils.Strings; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/* +pragma solidity ^0.4.25; +contract Revert { + function Error(string memory s) public {} +} + +"08c379a0": "Error(string)" // Not SM Method +"c703cb12": "Error(string)" // SM Method +*/ + +public class RevertResolver { + + private static final Logger logger = LoggerFactory.getLogger(RevertResolver.class); + + public static final String RevertMethod = "08c379a0"; + public static final String RevertMethodWithHexPrefix = "0x08c379a0"; + + public static final String SMRevertMethod = "c703cb12"; + public static final String SMRevertMethodWithHexPrefix = "0xc703cb12"; + + // Error(String) + public static final Function revertFunction = + new Function( + "Error", + Collections.emptyList(), + Collections.singletonList(new TypeReference() {})); + + /** + * Does output start with the code of the Revert method, If so, the output may be error message + * + * @param output + * @return + */ + public static boolean isOutputStartWithRevertMethod(String output) { + return output.startsWith(RevertMethodWithHexPrefix) + || output.startsWith(SMRevertMethodWithHexPrefix) + || (output.startsWith(RevertMethod) || output.startsWith(SMRevertMethod)); + } + + /** + * @param status + * @param output + * @return + */ + public static boolean hasRevertMessage(String status, String output) { + if (Strings.isEmpty(status) || Strings.isEmpty(output)) { + return false; + } + try { + BigInteger statusQuantity = Numeric.decodeQuantity(status); + return !BigInteger.ZERO.equals(statusQuantity) && isOutputStartWithRevertMethod(output); + } catch (Exception e) { + return false; + } + } + + /** + * @param status + * @param output + * @return + */ + public static Tuple2 tryResolveRevertMessage(String status, String output) { + if (!hasRevertMessage(status, output)) { + return new Tuple2<>(false, null); + } + + try { + // 00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000030497373756572526f6c653a2063616c6c657220646f6573206e6f742068617665207468652049737375657220726f6c6500000000000000000000000000000000 + String rawOutput = + Numeric.containsHexPrefix(output) + ? output.substring(RevertMethodWithHexPrefix.length()) + : output.substring(RevertMethod.length()); + List result = + FunctionReturnDecoder.decode(rawOutput, revertFunction.getOutputParameters()); + if (result.get(0) instanceof Utf8String) { + String message = ((Utf8String) result.get(0)).getValue(); + if (logger.isDebugEnabled()) { + logger.debug(" ABI: {} , RevertMessage: {}", output, message); + } + return new Tuple2<>(true, message); + } + } catch (Exception e) { + logger.warn(" ABI: {}, e: {}", output, e); + } + + return new Tuple2<>(false, null); + } + + /** + * @param receipt + * @return + */ + public static Tuple2 tryResolveRevertMessage(TransactionReceipt receipt) { + return tryResolveRevertMessage(receipt.getStatus(), receipt.getOutput()); + } +} diff --git a/src/main/java/org/fisco/bcos/web3j/tx/TransactionManager.java b/src/main/java/org/fisco/bcos/web3j/tx/TransactionManager.java index bd71c0781..e8a4d43db 100644 --- a/src/main/java/org/fisco/bcos/web3j/tx/TransactionManager.java +++ b/src/main/java/org/fisco/bcos/web3j/tx/TransactionManager.java @@ -57,6 +57,8 @@ protected TransactionManager( this(new PollingTransactionReceiptProcessor(web3j, sleepDuration, attempts), credentials); } + protected abstract BigInteger getBlockLimit() throws IOException; + @Deprecated protected TransactionReceipt executeTransaction( BigInteger gasPrice, diff --git a/src/test/java/org/fisco/bcos/channel/test/RevertResolverTest.java b/src/test/java/org/fisco/bcos/channel/test/RevertResolverTest.java new file mode 100644 index 000000000..774913109 --- /dev/null +++ b/src/test/java/org/fisco/bcos/channel/test/RevertResolverTest.java @@ -0,0 +1,239 @@ +package org.fisco.bcos.channel.test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +import java.io.IOException; +import java.util.Arrays; +import java.util.Collections; +import org.fisco.bcos.web3j.abi.FunctionEncoder; +import org.fisco.bcos.web3j.abi.TypeReference; +import org.fisco.bcos.web3j.abi.datatypes.Function; +import org.fisco.bcos.web3j.abi.datatypes.Type; +import org.fisco.bcos.web3j.abi.datatypes.Utf8String; +import org.fisco.bcos.web3j.crypto.EncryptType; +import org.fisco.bcos.web3j.tuples.generated.Tuple2; +import org.fisco.bcos.web3j.tx.RevertResolver; +import org.junit.Test; + +public class RevertResolverTest { + + private Function newFunction(String name, String message) { + return new Function( + name, + Arrays.asList(new org.fisco.bcos.web3j.abi.datatypes.Utf8String(message)), + Collections.singletonList(new TypeReference() {})); + } + + @Test + public void hasRevertMessageTest() throws IOException { + String revertMessage = "RevertMessage"; + Function revertFunction = newFunction("Error", revertMessage); + String revertABI = FunctionEncoder.encode(revertFunction); + + Function testFunction = newFunction("testFunc", revertMessage); + String testABI = FunctionEncoder.encode(testFunction); + + assertFalse(RevertResolver.hasRevertMessage(null, null)); + assertFalse(RevertResolver.hasRevertMessage("", null)); + assertFalse(RevertResolver.hasRevertMessage(null, "")); + assertFalse(RevertResolver.hasRevertMessage("", "")); + assertFalse(RevertResolver.hasRevertMessage("0x0", "")); + assertFalse(RevertResolver.hasRevertMessage("0x0", "")); + assertFalse(RevertResolver.hasRevertMessage("0x0", revertABI)); + assertTrue(RevertResolver.hasRevertMessage("0x1", revertABI)); + assertFalse(RevertResolver.hasRevertMessage(null, revertABI)); + + assertFalse(RevertResolver.hasRevertMessage("0x0", testABI)); + assertFalse(RevertResolver.hasRevertMessage("0x1", testABI)); + assertFalse(RevertResolver.hasRevertMessage(null, testABI)); + } + + @Test + public void hasRevertMessageSMTest() throws IOException { + EncryptType encryptType = new EncryptType(EncryptType.SM2_TYPE); + String revertMessage = "RevertMessage"; + Function revertFunction = newFunction("Error", revertMessage); + String revertABI = FunctionEncoder.encode(revertFunction); + + Function testFunction = newFunction("testFunc", revertMessage); + String testABI = FunctionEncoder.encode(testFunction); + + assertFalse(RevertResolver.hasRevertMessage(null, null)); + assertFalse(RevertResolver.hasRevertMessage("", null)); + assertFalse(RevertResolver.hasRevertMessage(null, "")); + assertFalse(RevertResolver.hasRevertMessage("", "")); + assertFalse(RevertResolver.hasRevertMessage("0x0", "")); + assertFalse(RevertResolver.hasRevertMessage("0x0", "")); + assertFalse(RevertResolver.hasRevertMessage("0x0", revertABI)); + assertTrue(RevertResolver.hasRevertMessage("0x1", revertABI)); + assertFalse(RevertResolver.hasRevertMessage(null, revertABI)); + + assertFalse(RevertResolver.hasRevertMessage("0x0", testABI)); + assertFalse(RevertResolver.hasRevertMessage("0x1", testABI)); + assertFalse(RevertResolver.hasRevertMessage(null, testABI)); + EncryptType encryptType0 = new EncryptType(EncryptType.ECDSA_TYPE); + } + + @Test + public void isOutputStartWithRevertMethodTest() { + String revertMessage = "isOutputStartWithRevertMethodTest"; + Function revertFunction = newFunction("Error", revertMessage); + String revertABI = FunctionEncoder.encode(revertFunction); + + Function testFunction = newFunction("testFunc", revertMessage); + String testABI = FunctionEncoder.encode(testFunction); + + assertTrue(RevertResolver.isOutputStartWithRevertMethod(revertABI)); + assertFalse(RevertResolver.isOutputStartWithRevertMethod(testABI)); + assertTrue(RevertResolver.isOutputStartWithRevertMethod(revertABI)); + assertFalse(RevertResolver.isOutputStartWithRevertMethod(testABI)); + } + + @Test + public void isOutputStartWithRevertMethodSMTest() { + EncryptType encryptType = new EncryptType(EncryptType.SM2_TYPE); + String revertMessage = "isOutputStartWithRevertMethodTest"; + Function revertFunction = newFunction("Error", revertMessage); + String revertABI = FunctionEncoder.encode(revertFunction); + + Function testFunction = newFunction("testFunc", revertMessage); + String testABI = FunctionEncoder.encode(testFunction); + + assertTrue(RevertResolver.isOutputStartWithRevertMethod(revertABI)); + assertFalse(RevertResolver.isOutputStartWithRevertMethod(testABI)); + assertTrue(RevertResolver.isOutputStartWithRevertMethod(revertABI)); + assertFalse(RevertResolver.isOutputStartWithRevertMethod(testABI)); + EncryptType encryptType0 = new EncryptType(EncryptType.ECDSA_TYPE); + } + + @Test + public void tryResolveRevertMessageTest() throws IOException { + String revertMessage = "RevertMessage"; + Function revertFunction = newFunction("Error", revertMessage); + String revertABI = FunctionEncoder.encode(revertFunction); + + Function testFunction = newFunction("testFunc", revertMessage); + String testABI = FunctionEncoder.encode(testFunction); + + Tuple2 booleanStringTuple2 = + RevertResolver.tryResolveRevertMessage("", ""); + assertTrue(!booleanStringTuple2.getValue1()); + + Tuple2 booleanStringTuple20 = + RevertResolver.tryResolveRevertMessage("0x0", revertABI); + assertFalse(booleanStringTuple20.getValue1()); + + Tuple2 booleanStringTuple21 = + RevertResolver.tryResolveRevertMessage("0x0", testABI); + assertFalse(booleanStringTuple21.getValue1()); + + Tuple2 booleanStringTuple22 = + RevertResolver.tryResolveRevertMessage("0x1", testABI); + assertFalse(booleanStringTuple22.getValue1()); + + Tuple2 booleanStringTuple23 = + RevertResolver.tryResolveRevertMessage("0x1", revertABI); + assertTrue(booleanStringTuple23.getValue1()); + assertEquals(booleanStringTuple23.getValue2(), revertMessage); + } + + @Test + public void tryResolveRevertMessageSMTest() throws IOException { + EncryptType encryptType = new EncryptType(EncryptType.SM2_TYPE); + String revertMessage = "RevertMessage"; + Function revertFunction = newFunction("Error", revertMessage); + String revertABI = FunctionEncoder.encode(revertFunction); + + Function testFunction = newFunction("testFunc", revertMessage); + String testABI = FunctionEncoder.encode(testFunction); + + Tuple2 booleanStringTuple2 = + RevertResolver.tryResolveRevertMessage("", ""); + assertFalse(booleanStringTuple2.getValue1()); + + Tuple2 booleanStringTuple20 = + RevertResolver.tryResolveRevertMessage("0x0", revertABI); + assertFalse(booleanStringTuple20.getValue1()); + + Tuple2 booleanStringTuple21 = + RevertResolver.tryResolveRevertMessage("0x0", testABI); + assertFalse(booleanStringTuple21.getValue1()); + + Tuple2 booleanStringTuple22 = + RevertResolver.tryResolveRevertMessage("0x1", testABI); + assertFalse(booleanStringTuple22.getValue1()); + + Tuple2 booleanStringTuple23 = + RevertResolver.tryResolveRevertMessage("0x1", revertABI); + assertTrue(booleanStringTuple23.getValue1()); + assertEquals(booleanStringTuple23.getValue2(), revertMessage); + EncryptType encryptType0 = new EncryptType(EncryptType.ECDSA_TYPE); + } + + @Test + public void tryResolveRevertMessageTest0() throws IOException { + String revertMessage = ""; + Function revertFunction = newFunction("Error", revertMessage); + String revertABI = FunctionEncoder.encode(revertFunction); + + Function testFunction = newFunction("testFunc", revertMessage); + String testABI = FunctionEncoder.encode(testFunction); + + Tuple2 booleanStringTuple2 = + RevertResolver.tryResolveRevertMessage("", ""); + assertFalse(booleanStringTuple2.getValue1()); + + Tuple2 booleanStringTuple20 = + RevertResolver.tryResolveRevertMessage("0x0", revertABI); + assertFalse(booleanStringTuple20.getValue1()); + + Tuple2 booleanStringTuple21 = + RevertResolver.tryResolveRevertMessage("0x0", testABI); + assertFalse(booleanStringTuple21.getValue1()); + + Tuple2 booleanStringTuple22 = + RevertResolver.tryResolveRevertMessage("0x1", testABI); + assertFalse(booleanStringTuple22.getValue1()); + + Tuple2 booleanStringTuple23 = + RevertResolver.tryResolveRevertMessage("0x1", revertABI); + assertTrue(booleanStringTuple23.getValue1()); + assertEquals(booleanStringTuple23.getValue2(), revertMessage); + } + + @Test + public void tryResolveRevertMessageSMTest0() throws IOException { + EncryptType encryptType = new EncryptType(EncryptType.SM2_TYPE); + String revertMessage = ""; + Function revertFunction = newFunction("Error", revertMessage); + String revertABI = FunctionEncoder.encode(revertFunction); + + Function testFunction = newFunction("testFunc", revertMessage); + String testABI = FunctionEncoder.encode(testFunction); + + Tuple2 booleanStringTuple2 = + RevertResolver.tryResolveRevertMessage("", ""); + assertFalse(booleanStringTuple2.getValue1()); + + Tuple2 booleanStringTuple20 = + RevertResolver.tryResolveRevertMessage("0x0", revertABI); + assertFalse(booleanStringTuple20.getValue1()); + + Tuple2 booleanStringTuple21 = + RevertResolver.tryResolveRevertMessage("0x0", testABI); + assertFalse(booleanStringTuple21.getValue1()); + + Tuple2 booleanStringTuple22 = + RevertResolver.tryResolveRevertMessage("0x1", testABI); + assertFalse(booleanStringTuple22.getValue1()); + + Tuple2 booleanStringTuple23 = + RevertResolver.tryResolveRevertMessage("0x1", revertABI); + assertTrue(booleanStringTuple23.getValue1()); + assertEquals(booleanStringTuple23.getValue2(), revertMessage); + + EncryptType encryptType0 = new EncryptType(EncryptType.ECDSA_TYPE); + } +} diff --git a/src/test/java/org/fisco/bcos/channel/test/message/ChannelMessage2Test.java b/src/test/java/org/fisco/bcos/channel/test/message/ChannelMessage2Test.java new file mode 100644 index 000000000..a1061ea52 --- /dev/null +++ b/src/test/java/org/fisco/bcos/channel/test/message/ChannelMessage2Test.java @@ -0,0 +1,74 @@ +package org.fisco.bcos.channel.test.message; + +import static org.junit.Assert.assertEquals; + +import io.netty.buffer.ByteBuf; +import io.netty.buffer.Unpooled; +import java.util.UUID; +import org.fisco.bcos.channel.dto.ChannelMessage2; +import org.fisco.bcos.channel.protocol.ChannelMessageType; +import org.junit.Test; + +public class ChannelMessage2Test { + @Test + public void channelMessage2CodecTest0() { + ChannelMessage2 channelMessage2 = new ChannelMessage2(); + + String seq = UUID.randomUUID().toString().replaceAll("-", ""); + Integer result = Integer.valueOf(0); + String content = "test content"; + String topic = "test_topic"; + channelMessage2.setSeq(seq); + channelMessage2.setResult(result); + channelMessage2.setType((short) ChannelMessageType.AMOP_REQUEST.getType()); + + channelMessage2.setData(content.getBytes()); + channelMessage2.setTopic(topic); + + ByteBuf buffer = Unpooled.buffer(); + channelMessage2.writeHeader(buffer); + channelMessage2.writeExtra(buffer); + + ChannelMessage2 channelMessage21 = new ChannelMessage2(); + channelMessage21.readHeader(buffer); + channelMessage21.readExtra(buffer); + + assertEquals(channelMessage21.getTopic(), topic); + assertEquals(new String(channelMessage21.getData()), content); + assertEquals(channelMessage21.getResult(), result); + assertEquals(channelMessage21.getSeq(), seq); + assertEquals( + channelMessage21.getType().intValue(), ChannelMessageType.AMOP_REQUEST.getType()); + } + + @Test + public void channelMessage2CodecTest2() { + ChannelMessage2 channelMessage2 = new ChannelMessage2(); + + String seq = UUID.randomUUID().toString().replaceAll("-", ""); + Integer result = Integer.valueOf(0); + String content = "中文测试"; + String topic = "中文topic测试"; + channelMessage2.setSeq(seq); + channelMessage2.setResult(result); + channelMessage2.setType((short) ChannelMessageType.AMOP_REQUEST.getType()); + + channelMessage2.setData(content.getBytes()); + channelMessage2.setTopic(topic); + + ByteBuf buffer = Unpooled.buffer(); + channelMessage2.writeHeader(buffer); + channelMessage2.writeExtra(buffer); + + ChannelMessage2 channelMessage21 = new ChannelMessage2(); + channelMessage21.readHeader(buffer); + channelMessage21.readExtra(buffer); + + assertEquals(channelMessage21.getTopic(), topic); + assertEquals(new String(channelMessage21.getData()), content); + assertEquals(channelMessage21.getResult(), result); + assertEquals(channelMessage21.getSeq(), seq); + assertEquals( + channelMessage21.getType().intValue(), ChannelMessageType.AMOP_REQUEST.getType()); + } +} diff --git a/src/test/java/org/fisco/bcos/channel/test/parallel/parallelok/PerformanceDTCallback.java b/src/test/java/org/fisco/bcos/channel/test/parallel/parallelok/PerformanceDTCallback.java index ee326291e..b52940c8f 100644 --- a/src/test/java/org/fisco/bcos/channel/test/parallel/parallelok/PerformanceDTCallback.java +++ b/src/test/java/org/fisco/bcos/channel/test/parallel/parallelok/PerformanceDTCallback.java @@ -8,7 +8,7 @@ public class PerformanceDTCallback extends TransactionSucCallback { - private Long startTime = System.currentTimeMillis(); + private Long startTime; private PerformanceDTCollector collector = null; private DagUserMgr dagUserMgr = null; @@ -28,6 +28,10 @@ public void setCallBackType(String callBackType) { this.callBackType = callBackType; } + public void recordStartTime() { + this.startTime = System.currentTimeMillis(); + } + public DagUserMgr getDagUserMgr() { return dagUserMgr; } diff --git a/src/test/java/org/fisco/bcos/channel/test/parallel/parallelok/PerformanceDTCollector.java b/src/test/java/org/fisco/bcos/channel/test/parallel/parallelok/PerformanceDTCollector.java index bce48bd0e..db579fb44 100644 --- a/src/test/java/org/fisco/bcos/channel/test/parallel/parallelok/PerformanceDTCollector.java +++ b/src/test/java/org/fisco/bcos/channel/test/parallel/parallelok/PerformanceDTCollector.java @@ -96,22 +96,24 @@ public void onMessage(TransactionReceipt receipt, Long cost) { less50.incrementAndGet(); } else if (cost < 100) { less100.incrementAndGet(); - ; } else if (cost < 200) { less200.incrementAndGet(); - ; } else if (cost < 400) { less400.incrementAndGet(); - ; } else if (cost < 1000) { less1000.incrementAndGet(); - ; } else if (cost < 2000) { less2000.incrementAndGet(); - ; + } else if (cost < 5000) { + less5000.incrementAndGet(); + } else if (cost < 10000) { + less10000.incrementAndGet(); + } else if (cost < 30000) { + less30000.incrementAndGet(); + } else if (cost < 60000) { + less60000.incrementAndGet(); } else { - timeout2000.incrementAndGet(); - ; + timeout60000.incrementAndGet(); } totalCost.addAndGet(cost); @@ -173,16 +175,40 @@ public void onMessage(TransactionReceipt receipt, Long cost) { + String.valueOf((double) less1000.get() / total * 100) + "%"); System.out.println( - "1000 < time < 2000ms : " + "1 < time < 2s : " + String.valueOf(less2000) + " : " + String.valueOf((double) less2000.get() / total * 100) + "%"); System.out.println( - "2000 < time : " - + String.valueOf(timeout2000) + "2 < time < 5s : " + + String.valueOf(less5000) + " : " - + String.valueOf((double) timeout2000.get() / total * 100) + + String.valueOf((double) less5000.get() / total * 100) + + "%"); + System.out.println( + "5 < time < 10s : " + + String.valueOf(less10000) + + " : " + + String.valueOf((double) less10000.get() / total * 100) + + "%"); + System.out.println( + "10 < time < 30s : " + + String.valueOf(less30000) + + " : " + + String.valueOf((double) less30000.get() / total * 100) + + "%"); + System.out.println( + "30 < time < 60s : " + + String.valueOf(less60000) + + " : " + + String.valueOf((double) less60000.get() / total * 100) + + "%"); + System.out.println( + "time > 60s : " + + String.valueOf(timeout60000) + + " : " + + String.valueOf((double) timeout60000.get() / total * 100) + "%"); } @@ -198,7 +224,11 @@ public void onMessage(TransactionReceipt receipt, Long cost) { private AtomicLong less400 = new AtomicLong(0); private AtomicLong less1000 = new AtomicLong(0); private AtomicLong less2000 = new AtomicLong(0); - private AtomicLong timeout2000 = new AtomicLong(0); + private AtomicLong less5000 = new AtomicLong(0); + private AtomicLong less10000 = new AtomicLong(0); + private AtomicLong less30000 = new AtomicLong(0); + private AtomicLong less60000 = new AtomicLong(0); + private AtomicLong timeout60000 = new AtomicLong(0); private AtomicLong totalCost = new AtomicLong(0); private AtomicInteger received = new AtomicInteger(0); diff --git a/src/test/java/org/fisco/bcos/channel/test/parallel/parallelok/PerformanceDTTest.java b/src/test/java/org/fisco/bcos/channel/test/parallel/parallelok/PerformanceDTTest.java index b6b9d7365..c4e61252d 100644 --- a/src/test/java/org/fisco/bcos/channel/test/parallel/parallelok/PerformanceDTTest.java +++ b/src/test/java/org/fisco/bcos/channel/test/parallel/parallelok/PerformanceDTTest.java @@ -242,6 +242,7 @@ public void run() { callback.setCallBackType("set"); try { + callback.recordStartTime(); parallelok.set(user, amount, callback); success = true; } catch (Exception e) { @@ -371,6 +372,7 @@ public void run() { System.out.println(info); try { + callback.recordStartTime(); parallelok.transferWithRevert( from.getUser(), to.getUser(), amount, callback); success = true; @@ -499,6 +501,7 @@ public void run() { callback.setAmount(amount); try { + callback.recordStartTime(); String signedTransaction = parallelok.transferSeq( from.getUser(), to.getUser(), amount); @@ -551,6 +554,7 @@ public void run() { public void run() { while (true) { try { + callbacks.get(index).recordStartTime(); transactionManager.sendTransaction( signedTransactions.get(index), callbacks.get(index)); diff --git a/src/test/java/org/fisco/bcos/channel/test/parallel/precompile/DagUserMgr.java b/src/test/java/org/fisco/bcos/channel/test/parallel/precompile/DagUserMgr.java index 7e468d80e..822760bb0 100644 --- a/src/test/java/org/fisco/bcos/channel/test/parallel/precompile/DagUserMgr.java +++ b/src/test/java/org/fisco/bcos/channel/test/parallel/precompile/DagUserMgr.java @@ -1,6 +1,7 @@ package org.fisco.bcos.channel.test.parallel.precompile; import java.io.*; +import java.math.BigInteger; import java.util.ArrayList; import java.util.List; import org.slf4j.Logger; @@ -54,6 +55,24 @@ public DagTransferUser getNext(int idx) { return userList.get((idx + 1) % userList.size()); } + /** + * Create the specified number of users + * + * @param userCount + */ + public void createUser(int userCount) { + userCount = (userCount > 0 ? userCount : 1); + long seconds = System.currentTimeMillis() / 1000L; + for (int i = 0; i < userCount; i++) { + DagTransferUser dagTransferUser = new DagTransferUser(); + String user = Long.toHexString(seconds) + Integer.toHexString(i); + BigInteger amount = new BigInteger("1000000000"); + dagTransferUser.setUser(user); + dagTransferUser.setAmount(amount); + this.getUserList().add(dagTransferUser); + } + } + public void writeDagTransferUser() throws IOException { if (file == null) { return; diff --git a/src/test/java/org/fisco/bcos/channel/test/parallel/precompile/PerformanceDTCallback.java b/src/test/java/org/fisco/bcos/channel/test/parallel/precompile/PerformanceDTCallback.java index 0bacb4f08..75ce37e8d 100644 --- a/src/test/java/org/fisco/bcos/channel/test/parallel/precompile/PerformanceDTCallback.java +++ b/src/test/java/org/fisco/bcos/channel/test/parallel/precompile/PerformanceDTCallback.java @@ -8,7 +8,7 @@ public class PerformanceDTCallback extends TransactionSucCallback { - private Long startTime = System.currentTimeMillis(); + private Long startTime; private PerformanceDTCollector collector = null; private DagUserMgr dagUserMgr = null; @@ -28,6 +28,10 @@ public void setCallBackType(String callBackType) { this.callBackType = callBackType; } + public void recordStartTime() { + this.startTime = System.currentTimeMillis(); + } + public DagUserMgr getDagUserMgr() { return dagUserMgr; } diff --git a/src/test/java/org/fisco/bcos/channel/test/parallel/precompile/PerformanceDTCollector.java b/src/test/java/org/fisco/bcos/channel/test/parallel/precompile/PerformanceDTCollector.java index 9355a0764..fb888a6ff 100644 --- a/src/test/java/org/fisco/bcos/channel/test/parallel/precompile/PerformanceDTCollector.java +++ b/src/test/java/org/fisco/bcos/channel/test/parallel/precompile/PerformanceDTCollector.java @@ -111,22 +111,24 @@ public void onMessage(TransactionReceipt receipt, Long cost) { less50.incrementAndGet(); } else if (cost < 100) { less100.incrementAndGet(); - ; } else if (cost < 200) { less200.incrementAndGet(); - ; } else if (cost < 400) { less400.incrementAndGet(); - ; } else if (cost < 1000) { less1000.incrementAndGet(); - ; } else if (cost < 2000) { less2000.incrementAndGet(); - ; + } else if (cost < 5000) { + less5000.incrementAndGet(); + } else if (cost < 10000) { + less10000.incrementAndGet(); + } else if (cost < 30000) { + less30000.incrementAndGet(); + } else if (cost < 60000) { + less60000.incrementAndGet(); } else { - timeout2000.incrementAndGet(); - ; + timeout60000.incrementAndGet(); } totalCost.addAndGet(cost); @@ -188,16 +190,40 @@ public void onMessage(TransactionReceipt receipt, Long cost) { + String.valueOf((double) less1000.get() / total * 100) + "%"); System.out.println( - "1000 < time < 2000ms : " + "1 < time < 2s : " + String.valueOf(less2000) + " : " + String.valueOf((double) less2000.get() / total * 100) + "%"); System.out.println( - "2000 < time : " - + String.valueOf(timeout2000) + "2 < time < 5s : " + + String.valueOf(less5000) + " : " - + String.valueOf((double) timeout2000.get() / total * 100) + + String.valueOf((double) less5000.get() / total * 100) + + "%"); + System.out.println( + "5 < time < 10s : " + + String.valueOf(less10000) + + " : " + + String.valueOf((double) less10000.get() / total * 100) + + "%"); + System.out.println( + "10 < time < 30s : " + + String.valueOf(less30000) + + " : " + + String.valueOf((double) less30000.get() / total * 100) + + "%"); + System.out.println( + "30 < time < 60s : " + + String.valueOf(less60000) + + " : " + + String.valueOf((double) less60000.get() / total * 100) + + "%"); + System.out.println( + "time > 60s : " + + String.valueOf(timeout60000) + + " : " + + String.valueOf((double) timeout60000.get() / total * 100) + "%"); } @@ -213,7 +239,11 @@ public void onMessage(TransactionReceipt receipt, Long cost) { private AtomicLong less400 = new AtomicLong(0); private AtomicLong less1000 = new AtomicLong(0); private AtomicLong less2000 = new AtomicLong(0); - private AtomicLong timeout2000 = new AtomicLong(0); + private AtomicLong less5000 = new AtomicLong(0); + private AtomicLong less10000 = new AtomicLong(0); + private AtomicLong less30000 = new AtomicLong(0); + private AtomicLong less60000 = new AtomicLong(0); + private AtomicLong timeout60000 = new AtomicLong(0); private AtomicLong totalCost = new AtomicLong(0); private AtomicInteger received = new AtomicInteger(0); diff --git a/src/test/java/org/fisco/bcos/channel/test/parallel/precompile/PerformanceDTTest.java b/src/test/java/org/fisco/bcos/channel/test/parallel/precompile/PerformanceDTTest.java index 1d5d94cb1..d01051d51 100644 --- a/src/test/java/org/fisco/bcos/channel/test/parallel/precompile/PerformanceDTTest.java +++ b/src/test/java/org/fisco/bcos/channel/test/parallel/precompile/PerformanceDTTest.java @@ -59,6 +59,10 @@ public PerformanceDTTest(String groupID) throws Exception { initialize(groupId); } + public PerformanceDTTest() throws Exception { + groupId = ""; + } + public DagUserMgr getDagUserMgr() { return dagUserMgr; } @@ -245,6 +249,7 @@ public void run() { callback.setCallBackType("add"); try { + callback.recordStartTime(); dagTransfer.userAdd(user, amount, callback); } catch (Exception e) { TransactionReceipt receipt = new TransactionReceipt(); @@ -286,6 +291,104 @@ public void run() { } } + /** + * Stress tests that create tx and sign them + * + * @param totalSignedTxCount + * @param threadC + * @throws InterruptedException + */ + public void userTransferSignTxPerfTest(BigInteger totalSignedTxCount, int threadC) + throws InterruptedException { + + ThreadPoolTaskExecutor threadPool = new ThreadPoolTaskExecutor(); + + threadPool.setCorePoolSize(threadC > 0 ? threadC : 10); + threadPool.setMaxPoolSize(threadC > 0 ? threadC : 10); + threadPool.setQueueCapacity(threadC > 0 ? threadC : 10); + threadPool.initialize(); + + Credentials credentials = GenCredential.create(); + + TransferSignTransactionManager extendedRawTransactionManager = + new TransferSignTransactionManager( + null, credentials, BigInteger.ONE, BigInteger.ONE); + + dagTransfer = + DagTransfer.load( + dagTransferAddr, + null, + extendedRawTransactionManager, + new StaticGasProvider( + new BigInteger("30000000"), new BigInteger("30000000"))); + + AtomicLong signed = new AtomicLong(0); + + long startTime = System.currentTimeMillis(); + System.out.println(" => " + dateFormat.format(new Date())); + + for (int i = 0; i < threadC; i++) { + threadPool.execute( + new Runnable() { + @Override + public void run() { + while (true) { + + long index = signed.incrementAndGet(); + if (index > totalSignedTxCount.intValue()) { + break; + } + DagTransferUser from = dagUserMgr.getFrom((int) index); + DagTransferUser to = dagUserMgr.getTo((int) index); + + Random random = new Random(); + int r = random.nextInt(100) + 1; + BigInteger amount = BigInteger.valueOf(r); + + try { + String signedTransaction = + dagTransfer.userTransferSeq( + from.getUser(), to.getUser(), amount); + + if (index % (totalSignedTxCount.longValue() / 10) == 0) { + System.out.println( + "Signed transaction: " + + String.valueOf( + index + * 100 + / totalSignedTxCount + .longValue()) + + "%"); + } + } catch (Exception e) { + e.printStackTrace(); + System.exit(-1); + } + } + } + }); + } + + while (signed.get() < totalSignedTxCount.intValue()) { + Thread.sleep(10); + } + + long endTime = System.currentTimeMillis(); + double elapsed = (endTime - startTime) / 1000.0; + + System.out.println(" => " + dateFormat.format(new Date())); + + System.out.print( + " sign transactions finished, elapse time: " + + elapsed + + ", tx count = " + + totalSignedTxCount + + " ,sps = " + + (totalSignedTxCount.intValue() / elapsed)); + + System.exit(0); + } + public void userTransferTest(BigInteger count, BigInteger qps, BigInteger deci) { System.out.println("Start UserTransfer test..."); System.out.println("==================================================================="); @@ -380,13 +483,12 @@ public void run() { Lock fileLock = new ReentrantLock(); BufferedWriter writer = null; - + AtomicLong writed = new AtomicLong(0); + final int totalWrite = end - start; try { writer = new BufferedWriter(new FileWriter(fileName)); - AtomicLong writed = new AtomicLong(0); for (int j = start; j < end; ++j) { final int index = j; - final int totalWrite = end - start; final BufferedWriter finalWriter = writer; threadPool.execute( new Runnable() { @@ -454,6 +556,11 @@ public void run() { e.printStackTrace(); System.exit(0); + } finally { + if ((writed.get() >= totalWrite) && (writer != null)) { + writer.close(); + writer = null; + } } } @@ -519,6 +626,7 @@ public void run() { public void run() { while (true) { try { + callbacks.get(index).recordStartTime(); transactionManager.sendTransaction( signedTransactions.get(index), callbacks.get(index)); diff --git a/src/test/java/org/fisco/bcos/channel/test/parallel/precompile/TransferSignTransactionManager.java b/src/test/java/org/fisco/bcos/channel/test/parallel/precompile/TransferSignTransactionManager.java new file mode 100644 index 000000000..289b2e664 --- /dev/null +++ b/src/test/java/org/fisco/bcos/channel/test/parallel/precompile/TransferSignTransactionManager.java @@ -0,0 +1,19 @@ +package org.fisco.bcos.channel.test.parallel.precompile; + +import java.io.IOException; +import java.math.BigInteger; +import org.fisco.bcos.web3j.crypto.Credentials; +import org.fisco.bcos.web3j.protocol.Web3j; +import org.fisco.bcos.web3j.tx.ExtendedRawTransactionManager; + +public class TransferSignTransactionManager extends ExtendedRawTransactionManager { + public TransferSignTransactionManager( + Web3j web3j, Credentials credentials, BigInteger groupId, BigInteger fiscoChainId) { + super(web3j, credentials, groupId, fiscoChainId); + } + + @Override + protected BigInteger getBlockLimit() throws IOException { + return new BigInteger("1"); + } +} diff --git a/src/test/java/org/fisco/bcos/channel/test/parallel/precompile/transferSign.java b/src/test/java/org/fisco/bcos/channel/test/parallel/precompile/transferSign.java new file mode 100644 index 000000000..902088908 --- /dev/null +++ b/src/test/java/org/fisco/bcos/channel/test/parallel/precompile/transferSign.java @@ -0,0 +1,52 @@ +package org.fisco.bcos.channel.test.parallel.precompile; + +import java.math.BigInteger; +import org.fisco.bcos.web3j.crypto.EncryptType; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** create and sign tx pressure test */ +public class transferSign { + private static Logger logger = LoggerFactory.getLogger(transferSign.class); + + public static void Usage() { + System.out.println(" Usage:"); + System.out.println( + " \t java -cp conf/:lib/*:apps/* org.fisco.bcos.channel.test.parallel.parallelok.transferSign txCount ThreadCount GMOrNot."); + System.exit(0); + } + + public static void main(String[] args) throws Exception { + if (args.length < 2) { + Usage(); + } + + try { + BigInteger count = new BigInteger(args[0]); + BigInteger threadCount = new BigInteger(args[1]); + if (args.length > 2 && args[2].equals("gm")) { + EncryptType encryptType = new EncryptType(1); + } else { + EncryptType encryptType = new EncryptType(0); + } + + System.out.println( + (EncryptType.encryptType == EncryptType.ECDSA_TYPE) + ? " ===>> normal transfer sign test " + : " ===>> sm transfer sign test "); + + logger.info(" transfer tx sign test, txCount: {}, threadCount: {}", count, threadCount); + + DagUserMgr d = new DagUserMgr(); + d.createUser(1000); + + PerformanceDTTest performanceDTTest = new PerformanceDTTest(); + performanceDTTest.setDagUserMgr(d); + + performanceDTTest.userTransferSignTxPerfTest(count, threadCount.intValue()); + + } catch (Exception e) { + e.printStackTrace(); + } + } +} diff --git a/src/test/java/org/fisco/bcos/web3j/crypto/ECKeyPairTest.java b/src/test/java/org/fisco/bcos/web3j/crypto/ECKeyPairTest.java new file mode 100644 index 000000000..58026bc2f --- /dev/null +++ b/src/test/java/org/fisco/bcos/web3j/crypto/ECKeyPairTest.java @@ -0,0 +1,154 @@ +package org.fisco.bcos.web3j.crypto; + +import static org.junit.Assert.assertEquals; + +import org.fisco.bcos.channel.client.P12Manager; +import org.fisco.bcos.web3j.crypto.gm.GenCredential; +import org.fisco.bcos.web3j.crypto.tool.ECCDecrypt; +import org.fisco.bcos.web3j.crypto.tool.ECCEncrypt; +import org.junit.Test; +import org.springframework.context.ApplicationContext; +import org.springframework.context.support.ClassPathXmlApplicationContext; + +public class ECKeyPairTest { + + @Test + public void encryptECKeyPairTest() throws Exception { + ECKeyPair ecKeyPair = Keys.createEcKeyPair(); + + ECCEncrypt encrypt = new ECCEncrypt(ecKeyPair.getPublicKey()); + ECCDecrypt decrypt = new ECCDecrypt(ecKeyPair.getPrivateKey()); + + String message = "ecc encrypt test"; + byte[] encryptData = encrypt.encrypt(message.getBytes("utf-8")); + byte[] decryptData = decrypt.decrypt(encryptData); + + String decrpptMessage = new String(decryptData, "utf-8"); + assertEquals(message, decrpptMessage); + } + + @Test + public void encryptECKeyPairTestEmptyString() throws Exception { + Credentials credentials = GenCredential.create(); + ECKeyPair ecKeyPair = credentials.getEcKeyPair(); + + ECCEncrypt encrypt = new ECCEncrypt(ecKeyPair.getPublicKey()); + ECCDecrypt decrypt = new ECCDecrypt(ecKeyPair.getPrivateKey()); + + String message = ""; + byte[] encryptData = encrypt.encrypt(message.getBytes("utf-8")); + byte[] decryptData = decrypt.decrypt(encryptData); + + assertEquals(message, new String(decryptData, "utf-8")); + } + + @Test + public void encryptECKeyPairTestWithPem() throws Exception { + ApplicationContext context = + new ClassPathXmlApplicationContext( + "classpath:applicationContext-keystore-sample.xml"); + // test p12 + P12Manager p12 = context.getBean(P12Manager.class); + + ECKeyPair ecKeyPair = p12.getECKeyPair(); + + ECCEncrypt encrypt = new ECCEncrypt(ecKeyPair.getPublicKey()); + ECCDecrypt decrypt = new ECCDecrypt(ecKeyPair.getPrivateKey()); + + String message = ""; + byte[] encryptData = encrypt.encrypt(message.getBytes("utf-8")); + byte[] decryptData = decrypt.decrypt(encryptData); + + assertEquals(message, new String(decryptData, "utf-8")); + } + + @Test + public void verifyECKeyPairTest() throws Exception { + ECKeyPair ecKeyPair = Keys.createEcKeyPair(); + String message = "verify test"; + ECDSASignature signature = ecKeyPair.sign(message.getBytes()); + boolean verify = ecKeyPair.verify(message.getBytes(), signature); + + assertEquals(verify, true); + } + + @Test + public void verifyECKeyPairTestEmptyString() throws Exception { + ECKeyPair ecKeyPair = Keys.createEcKeyPair(); + String message = ""; + ECDSASignature signature = ecKeyPair.sign(message.getBytes()); + boolean verify = ecKeyPair.verify(message.getBytes(), signature); + + assertEquals(verify, true); + } + + @Test + public void verifyECKeyPairTestWithPem() throws Exception { + ApplicationContext context = + new ClassPathXmlApplicationContext( + "classpath:applicationContext-keystore-sample.xml"); + // test p12 + P12Manager p12 = context.getBean(P12Manager.class); + + ECKeyPair ecKeyPair = p12.getECKeyPair(); + + String message = "ecc encrypt test"; + ECDSASignature signature = ecKeyPair.sign(message.getBytes()); + boolean verify = ecKeyPair.verify(message.getBytes(), signature); + + assertEquals(verify, true); + } + + @Test + public void verifyECDSASignTest() throws Exception { + ECKeyPair ecKeyPair = Keys.createEcKeyPair(); + ECDSASign ecdsaSign = new ECDSASign(); + String message = "message"; + Sign.SignatureData signatureData = ecdsaSign.signMessage(message.getBytes(), ecKeyPair); + + SHA3Digest sha3Digest = new SHA3Digest(); + byte[] hash = sha3Digest.hash(message.getBytes()); + + boolean verify = ecdsaSign.verify(hash, ecKeyPair.getPublicKey(), signatureData); + + assertEquals(verify, true); + } + + @Test + public void verifyECDSASignTest0() throws Exception { + ApplicationContext context = + new ClassPathXmlApplicationContext( + "classpath:applicationContext-keystore-sample.xml"); + // test p12 + P12Manager p12 = context.getBean(P12Manager.class); + ECKeyPair ecKeyPair = p12.getECKeyPair(); + + ECDSASign ecdsaSign = new ECDSASign(); + String message = "message"; + Sign.SignatureData signatureData = ecdsaSign.signMessage(message.getBytes(), ecKeyPair); + + SHA3Digest sha3Digest = new SHA3Digest(); + byte[] hash = sha3Digest.hash(message.getBytes()); + + boolean verify = ecdsaSign.verify(hash, ecKeyPair.getPublicKey(), signatureData); + + assertEquals(verify, true); + } + + @Test + public void verifyECDSASignTest1() throws Exception { + + ECKeyPair ecKeyPair = Keys.createEcKeyPair(); + + ECDSASign ecdsaSign = new ECDSASign(); + String message = "message"; + Sign.SignatureData signatureData = ecdsaSign.signMessage(message.getBytes(), ecKeyPair); + + SHA3Digest sha3Digest = new SHA3Digest(); + byte[] hash = sha3Digest.hash(message.getBytes()); + + boolean verify = ecdsaSign.verify(hash, ecKeyPair.getPublicKey(), signatureData); + + assertEquals(verify, true); + } +} diff --git a/tools/get_account.sh b/tools/get_account.sh deleted file mode 100644 index c64560ac9..000000000 --- a/tools/get_account.sh +++ /dev/null @@ -1,117 +0,0 @@ -#!/bin/bash - -set -e -pkcs12_file="" -keccak256sum="" -output_path="accounts" -keccak_256_bin="/tmp/keccak-256sum" -keccak_256_tar="/tmp/keccak-256sum.tgz" - -help() { - echo $1 - cat << EOF -Usage: $0 - default generate account and store private key in PEM format file - -p generate account and store private key in PKCS12 format file - -k [FILE] calculate address of PEM format [FILE] - -P [FILE] calculate address of PKCS12 format [FILE] - -h Help -EOF - -exit 0 -} - -prepare_keccak256() -{ - if [[ ! -f ${keccak_256_bin} ]];then - if [ "$(uname)" == "Darwin" ];then - keccak256sum="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" - echo ${keccak256sum} | base64 -D - > ${keccak_256_tar} - else - keccak256sum="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" - echo ${keccak256sum} | base64 -d - > ${keccak_256_tar} - fi - tar -zxf ${keccak_256_tar} -C /tmp - chmod u+x ${keccak_256_bin} - fi - mkdir -p accounts -} - -LOG_INFO() -{ - local content=${1} - echo -e "\033[32m[INFO] ${content}\033[0m" -} - -check_env() { - [ ! -z "$(openssl version | grep 1.0.2)" ] || [ ! -z "$(openssl version | grep 1.1)" ] || [ ! -z "$(openssl version | grep reSSL)" ] || { - echo "please install openssl! use \"openssl version\" command to check." - LOG_INFO " Ubuntu : sudo apt install -y openssl" - LOG_INFO " CentOS : sudo yum install -y openssl" - LOG_INFO " macOS : brew install -y openssl" - exit 1 - } - if [ ! -z "$(openssl version | grep reSSL)" ];then - export PATH="/usr/local/opt/openssl/bin:$PATH" - fi -} - -calculate_address_pem() -{ - local pem_file=$1 - local no_print="$2" - prepare_keccak256 - privKey=$(openssl ec -in ${pem_file} -text -noout 2>/dev/null| sed -n '3,5p' | tr -d ": \n" | awk '{print $0}') - pubKey=$(openssl ec -in ${pem_file} -text -noout 2>/dev/null| sed -n '7,11p' | tr -d ": \n" | awk '{print substr($0,3);}') - accountAddress=$(echo ${pubKey}| ${keccak_256_bin} -x -l | tr -d ' -' | tail -c 41) - [ ! -z "${no_print}" ] || LOG_INFO "Account Address : 0x${accountAddress}" -} - -calculate_address_pkcs12() -{ - local p12_file=$1 - local pem_file="/tmp/.tmp.pem" - openssl pkcs12 -in ${p12_file} -out ${pem_file} -nodes - calculate_address_pem ${pem_file} - rm ${pem_file} -} - -main() -{ - while getopts "k:pP:h" option;do - case $option in - k) calculate_address_pem "$OPTARG" - exit 0;; - P) calculate_address_pkcs12 "$OPTARG" - exit 0;; - p) #pkcs12_file="$OPTARG" - pkcs12_file="true" - ;; - h) help;; - esac - done - check_env - prepare_keccak256 - openssl ecparam -out /tmp/secp256k1.param -name secp256k1 - openssl genpkey -paramfile /tmp/secp256k1.param -out ${output_path}/ecprivkey.pem - calculate_address_pem ${output_path}/ecprivkey.pem "true" - if [ -z "$pkcs12_file" ];then - mv ${output_path}/ecprivkey.pem ${output_path}/0x${accountAddress}.pem - LOG_INFO "Account Address : 0x${accountAddress}" - LOG_INFO "Private Key (pem) : ${output_path}/0x${accountAddress}.pem" - # echo "0x${privKey}" > ${output_path}/${accountAddress}.private.hex - # openssl ec -in ${output_path}/ecprivkey.pem -pubout -out ${output_path}/${accountAddress}.public.pem 2>/dev/null - # LOG_INFO "Public Key (pem) : ${output_path}/${accountAddress}.publick.pem" - else - openssl pkcs12 -export -name key -nocerts -inkey "${output_path}/ecprivkey.pem" -out "${output_path}/0x${accountAddress}.p12" # -passout "pass:${pkcs12_passwd}" - rm ${output_path}/ecprivkey.pem - LOG_INFO "Account Address : 0x${accountAddress}" - LOG_INFO "Private Key (p12) : ${output_path}/0x${accountAddress}.p12" - fi - # LOG_INFO "Private Key (hex) : 0x${privKey}" - # echo "0x${pubKey}" > ${output_path}/${accountAddress}.public.hex - # LOG_INFO "Public File(hex) : ${output_path}/${accountAddress}.public.hex" -} - -main $@ -