@@ -10,7 +10,7 @@ import com.jd.blockchain.utils.io.BytesOutputBuffer; | |||
import com.jd.blockchain.utils.io.BytesSlice; | |||
import com.jd.blockchain.utils.io.BytesUtils; | |||
public class BinaryEncodingUtils { | |||
public class BinaryProtocol { | |||
public static void encode(Object data, Class<?> contractType, OutputStream out) { |
@@ -13,6 +13,9 @@ public class DataContractRegistry { | |||
private DataContractRegistry() { | |||
} | |||
//TODO: Refactor contract type registering in service provider mode; | |||
public static DataContractEncoder register(Class<?> contractType) { | |||
DataContractEncoder encoder = DataContractContext.resolve(contractType); | |||
return encoder; | |||
@@ -2,10 +2,23 @@ package com.jd.blockchain.binaryproto; | |||
public interface DataType { | |||
public static final byte NUMERIC_FLAG = (byte)0x10; | |||
public static final byte TEXT_FLAG = (byte)0x20; | |||
public static final byte BINARY_FLAG = (byte)0x40; | |||
/** | |||
* 空值; | |||
*/ | |||
public static final byte NIL = (byte) 0x00; | |||
/** | |||
* 布尔; | |||
*/ | |||
public static final byte BOOLEAN = (byte) 0x01; | |||
/** | |||
* 数值; | |||
*/ | |||
public static final byte NUMERIC = (byte) 0x10; | |||
public static final byte TEXT = (byte) 0x20; | |||
public static final byte BINARY = (byte) 0x40; | |||
} |
@@ -7,73 +7,72 @@ package com.jd.blockchain.binaryproto; | |||
* | |||
*/ | |||
public enum PrimitiveType { | |||
/** | |||
* 空; | |||
*/ | |||
NIL((byte) 0x00), | |||
NIL(DataType.NIL), | |||
/** | |||
* 布尔型; | |||
*/ | |||
BOOLEAN((byte) 0x10), | |||
BOOLEAN(DataType.BOOLEAN), | |||
/** | |||
* 数值型: | |||
*/ | |||
INT8((byte) 0x11), | |||
INT8((byte) (DataType.NUMERIC | 0x01)), | |||
INT16((byte) 0x12), | |||
INT16((byte) (DataType.NUMERIC | 0x02)), | |||
INT32((byte) 0x13), | |||
INT32((byte) (DataType.NUMERIC | 0x03)), | |||
INT64((byte) 0x14), | |||
INT64((byte) (DataType.NUMERIC | 0x04)), | |||
/** | |||
* 日期时间; | |||
*/ | |||
DATETIME((byte) 0x15), | |||
DATETIME((byte) (DataType.NUMERIC | 0x08)), | |||
/** | |||
* 文本数据; | |||
*/ | |||
TEXT((byte) 0x20), | |||
TEXT(DataType.TEXT), | |||
/** | |||
* 文本数据; | |||
*/ | |||
JSON((byte) 0x21), | |||
JSON((byte) (DataType.TEXT | 0x01)), | |||
/** | |||
* 文本数据; | |||
*/ | |||
XML((byte) 0x22), | |||
XML((byte) (DataType.TEXT | 0x02)), | |||
/** | |||
* 二进制数据; | |||
*/ | |||
BYTES((byte) 0x40), | |||
BYTES(DataType.BINARY), | |||
/** | |||
* 大整数; | |||
*/ | |||
BIG_INT((byte) 0x41), | |||
BIG_INT((byte) (DataType.BINARY | 0x01)), | |||
/** | |||
* 图片; | |||
*/ | |||
IMG((byte) 0x42), | |||
IMG((byte) (DataType.BINARY | 0x02)), | |||
/** | |||
* 视频; | |||
*/ | |||
VIDEO((byte) 0x43), | |||
VIDEO((byte) (DataType.BINARY | 0x03)), | |||
/** | |||
* 位置; | |||
* 位置坐标; | |||
*/ | |||
LOCATION((byte) 0x44); | |||
LOCATION((byte) (DataType.BINARY | 0x04)); | |||
public final byte CODE; | |||
@@ -7,7 +7,7 @@ import static org.junit.Assert.assertTrue; | |||
import org.junit.Test; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.DataContractException; | |||
import com.jd.blockchain.binaryproto.DataContractRegistry; | |||
import com.jd.blockchain.utils.Bytes; | |||
@@ -37,7 +37,7 @@ public class BinaryEncodingTest { | |||
pd.setConfig(Bytes.fromString("Configuration of something.")); | |||
pd.setNetworkAddress(networkAddress); | |||
byte[] bytes = BinaryEncodingUtils.encode(pd, PrimitiveDatas.class); | |||
byte[] bytes = BinaryProtocol.encode(pd, PrimitiveDatas.class); | |||
int offset = 0; | |||
int code = BytesUtils.toInt(bytes, offset); | |||
offset += 12; | |||
@@ -109,7 +109,7 @@ public class BinaryEncodingTest { | |||
public void testEncoding_Null() { | |||
DataContractRegistry.register(PrimitiveDatas.class); | |||
byte[] bytes = BinaryEncodingUtils.encode(null, PrimitiveDatas.class); | |||
byte[] bytes = BinaryProtocol.encode(null, PrimitiveDatas.class); | |||
int offset = 0; | |||
int code = BytesUtils.toInt(bytes, offset); | |||
offset += 12;// 暂不校验 version; | |||
@@ -138,8 +138,8 @@ public class BinaryEncodingTest { | |||
pd.setConfig(Bytes.fromString("Configuration of something.")); | |||
pd.setNetworkAddress(networkAddress); | |||
byte[] bytes = BinaryEncodingUtils.encode(pd, PrimitiveDatas.class); | |||
PrimitiveDatas decodeData = BinaryEncodingUtils.decode(bytes); | |||
byte[] bytes = BinaryProtocol.encode(pd, PrimitiveDatas.class); | |||
PrimitiveDatas decodeData = BinaryProtocol.decode(bytes); | |||
assertEquals(pd.getId(), decodeData.getId()); | |||
assertEquals(pd.isEnable(), decodeData.isEnable()); | |||
assertEquals(pd.isBoy(), decodeData.isBoy()); | |||
@@ -163,7 +163,7 @@ public class BinaryEncodingTest { | |||
EnumDatasImpl enumDatas = new EnumDatasImpl(); | |||
enumDatas.setLevel(EnumLevel.V1); | |||
byte[] bytes = BinaryEncodingUtils.encode(enumDatas, EnumDatas.class); | |||
byte[] bytes = BinaryProtocol.encode(enumDatas, EnumDatas.class); | |||
int offset = 0; | |||
int code = BytesUtils.toInt(bytes, offset); | |||
offset += 12; | |||
@@ -186,8 +186,8 @@ public class BinaryEncodingTest { | |||
EnumDatasImpl enumDatas = new EnumDatasImpl(); | |||
enumDatas.setLevel(EnumLevel.V1); | |||
byte[] bytes = BinaryEncodingUtils.encode(enumDatas, EnumDatas.class); | |||
EnumDatas decodeData = BinaryEncodingUtils.decode(bytes); | |||
byte[] bytes = BinaryProtocol.encode(enumDatas, EnumDatas.class); | |||
EnumDatas decodeData = BinaryProtocol.decode(bytes); | |||
assertEquals(enumDatas.getLevel(), decodeData.getLevel()); | |||
} | |||
@@ -215,7 +215,7 @@ public class BinaryEncodingTest { | |||
refContractDatas.setPrimitiveDatas(primitiveDatas); | |||
byte[] bytes = BinaryEncodingUtils.encode(refContractDatas, RefContractDatas.class); | |||
byte[] bytes = BinaryProtocol.encode(refContractDatas, RefContractDatas.class); | |||
int offset = 0; | |||
int code = BytesUtils.toInt(bytes, offset); | |||
offset += 12; | |||
@@ -248,7 +248,7 @@ public class BinaryEncodingTest { | |||
RefContractDatasImpl refContractDatas = new RefContractDatasImpl(); | |||
byte[] bytes = BinaryEncodingUtils.encode(refContractDatas, RefContractDatas.class); | |||
byte[] bytes = BinaryProtocol.encode(refContractDatas, RefContractDatas.class); | |||
int offset = 0; | |||
int code = BytesUtils.toInt(bytes, offset); | |||
offset += 12; | |||
@@ -295,8 +295,8 @@ public class BinaryEncodingTest { | |||
refContractDatas.setPrimitiveDatas(primitiveDatas); | |||
byte[] bytes = BinaryEncodingUtils.encode(refContractDatas, RefContractDatas.class); | |||
RefContractDatas decodeData = BinaryEncodingUtils.decode(bytes); | |||
byte[] bytes = BinaryProtocol.encode(refContractDatas, RefContractDatas.class); | |||
RefContractDatas decodeData = BinaryProtocol.decode(bytes); | |||
assertEquals(refContractDatas.getPrimitive().getId(), decodeData.getPrimitive().getId()); | |||
assertEquals(refContractDatas.getPrimitive().isEnable(), decodeData.getPrimitive().isEnable()); | |||
@@ -329,7 +329,7 @@ public class BinaryEncodingTest { | |||
operations[0] = subOperation; | |||
genericRefContractDatas.setOperations(operations); | |||
byte[] bytes = BinaryEncodingUtils.encode(genericRefContractDatas, GenericRefContractDatas.class); | |||
byte[] bytes = BinaryProtocol.encode(genericRefContractDatas, GenericRefContractDatas.class); | |||
int offset = 0; | |||
int code = BytesUtils.toInt(bytes, offset); | |||
offset += 12; | |||
@@ -391,9 +391,9 @@ public class BinaryEncodingTest { | |||
operations[0] = subOperation; | |||
genericRefContractDatas.setOperations(operations); | |||
byte[] bytes = BinaryEncodingUtils.encode(genericRefContractDatas, GenericRefContractDatas.class); | |||
byte[] bytes = BinaryProtocol.encode(genericRefContractDatas, GenericRefContractDatas.class); | |||
GenericRefContractDatas decodeData = BinaryEncodingUtils.decode(bytes); | |||
GenericRefContractDatas decodeData = BinaryProtocol.decode(bytes); | |||
assertEquals("Jerry", ((SubOperation) (decodeData.getOperations()[0])).getUserName()); | |||
} | |||
@@ -432,7 +432,7 @@ public class BinaryEncodingTest { | |||
operations[0] = subOperation; | |||
compositeDatas.setOperations(operations); | |||
byte[] bytes = BinaryEncodingUtils.encode(compositeDatas, CompositeDatas.class); | |||
byte[] bytes = BinaryProtocol.encode(compositeDatas, CompositeDatas.class); | |||
int offset = 0; | |||
int code = BytesUtils.toInt(bytes, offset); | |||
@@ -508,8 +508,8 @@ public class BinaryEncodingTest { | |||
operations[0] = subOperation; | |||
compositeDatas.setOperations(operations); | |||
byte[] bytes = BinaryEncodingUtils.encode(compositeDatas, CompositeDatas.class); | |||
CompositeDatas decodeData = BinaryEncodingUtils.decode(bytes); | |||
byte[] bytes = BinaryProtocol.encode(compositeDatas, CompositeDatas.class); | |||
CompositeDatas decodeData = BinaryProtocol.decode(bytes); | |||
assertEquals(compositeDatas.isEnable(), decodeData.isEnable()); | |||
assertEquals(compositeDatas.getAge(), decodeData.getAge()); | |||
@@ -1,6 +1,6 @@ | |||
package com.jd.blockchain.consensus.bftsmart; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.DataContractRegistry; | |||
import com.jd.blockchain.consensus.*; | |||
import com.jd.blockchain.utils.io.BytesEncoder; | |||
@@ -40,14 +40,14 @@ public class BftsmartSettingsFactory implements SettingsFactory { | |||
@Override | |||
public byte[] encode(ConsensusSettings data) { | |||
if (data instanceof BftsmartConsensusSettings) { | |||
return BinaryEncodingUtils.encode(data, BftsmartConsensusSettings.class); | |||
return BinaryProtocol.encode(data, BftsmartConsensusSettings.class); | |||
} | |||
throw new IllegalArgumentException("Settings data isn't supported! Accept BftsmartConsensusSettings only!"); | |||
} | |||
@Override | |||
public ConsensusSettings decode(byte[] bytes) { | |||
return BinaryEncodingUtils.decodeAs(bytes, BftsmartConsensusSettings.class); | |||
return BinaryProtocol.decodeAs(bytes, BftsmartConsensusSettings.class); | |||
} | |||
} | |||
@@ -57,14 +57,14 @@ public class BftsmartSettingsFactory implements SettingsFactory { | |||
@Override | |||
public byte[] encode(ClientIncomingSettings data) { | |||
if (data instanceof BftsmartClientIncomingSettings) { | |||
return BinaryEncodingUtils.encode(data, BftsmartClientIncomingSettings.class); | |||
return BinaryProtocol.encode(data, BftsmartClientIncomingSettings.class); | |||
} | |||
throw new IllegalArgumentException("Settings data isn't supported! Accept BftsmartClientIncomingSettings only!"); | |||
} | |||
@Override | |||
public ClientIncomingSettings decode(byte[] bytes) { | |||
return BinaryEncodingUtils.decodeAs(bytes, BftsmartClientIncomingSettings.class); | |||
return BinaryProtocol.decodeAs(bytes, BftsmartClientIncomingSettings.class); | |||
} | |||
} | |||
@@ -8,7 +8,7 @@ | |||
*/ | |||
package com.jd.blockchain.consensus.mq.config; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.DataContractRegistry; | |||
import com.jd.blockchain.consensus.ClientIncomingSettings; | |||
import com.jd.blockchain.consensus.ConsensusSettings; | |||
@@ -75,14 +75,14 @@ public class MsgQueueSettingsFactory implements SettingsFactory { | |||
@Override | |||
public byte[] encode(ConsensusSettings data) { | |||
if (data instanceof MsgQueueConsensusSettings) { | |||
return BinaryEncodingUtils.encode(data, MsgQueueConsensusSettings.class); | |||
return BinaryProtocol.encode(data, MsgQueueConsensusSettings.class); | |||
} | |||
throw new IllegalArgumentException("Settings data isn't supported! Accept MsgQueueConsensusSettings only!"); | |||
} | |||
@Override | |||
public MsgQueueConsensusSettings decode(byte[] bytes) { | |||
return BinaryEncodingUtils.decodeAs(bytes, MsgQueueConsensusSettings.class); | |||
return BinaryProtocol.decodeAs(bytes, MsgQueueConsensusSettings.class); | |||
} | |||
} | |||
@@ -91,14 +91,14 @@ public class MsgQueueSettingsFactory implements SettingsFactory { | |||
@Override | |||
public byte[] encode(ClientIncomingSettings data) { | |||
if (data instanceof MsgQueueClientIncomingSettings) { | |||
return BinaryEncodingUtils.encode(data, MsgQueueClientIncomingSettings.class); | |||
return BinaryProtocol.encode(data, MsgQueueClientIncomingSettings.class); | |||
} | |||
throw new IllegalArgumentException("Settings data isn't supported! Accept MsgQueueClientIncomingSettings only!"); | |||
} | |||
@Override | |||
public MsgQueueClientIncomingSettings decode(byte[] bytes) { | |||
return BinaryEncodingUtils.decodeAs(bytes, MsgQueueClientIncomingSettings.class); | |||
return BinaryProtocol.decodeAs(bytes, MsgQueueClientIncomingSettings.class); | |||
} | |||
} |
@@ -7,7 +7,7 @@ import org.springframework.web.bind.annotation.RequestMethod; | |||
import org.springframework.web.bind.annotation.ResponseBody; | |||
import org.springframework.web.bind.annotation.RestController; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.crypto.Crypto; | |||
import com.jd.blockchain.crypto.HashDigest; | |||
import com.jd.blockchain.crypto.SignatureFunction; | |||
@@ -53,7 +53,7 @@ public class TxProcessingController implements TransactionService { | |||
throw new IllegalStateException("Not implemented!"); | |||
} else { | |||
// 验证签名; | |||
byte[] content = BinaryEncodingUtils.encode(txRequest.getTransactionContent(), TransactionContent.class); | |||
byte[] content = BinaryProtocol.encode(txRequest.getTransactionContent(), TransactionContent.class); | |||
for (DigitalSignature sign : partiSigns) { | |||
SignatureFunction signFunc = Crypto | |||
.getSignatureFunction(sign.getPubKey().getAlgorithm()); | |||
@@ -3,7 +3,7 @@ package com.jd.blockchain.ledger.core; | |||
import java.util.HashMap; | |||
import java.util.Map; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.DataContractRegistry; | |||
import com.jd.blockchain.crypto.AddressEncoding; | |||
import com.jd.blockchain.crypto.HashDigest; | |||
@@ -99,7 +99,7 @@ public class AccountSet implements Transactional, MerkleProvable { | |||
// } | |||
private AccountHeader deserialize(byte[] txBytes) { | |||
return BinaryEncodingUtils.decode(txBytes); | |||
return BinaryProtocol.decode(txBytes); | |||
} | |||
/** | |||
@@ -289,13 +289,13 @@ public class AccountSet implements Transactional, MerkleProvable { | |||
private VersioningAccount deserialize(byte[] bytes, CryptoSetting cryptoSetting, String keyPrefix, | |||
ExPolicyKVStorage exStorage, VersioningKVStorage verStorage, boolean readonly, long version) { | |||
AccountHeader accInfo = BinaryEncodingUtils.decode(bytes); | |||
AccountHeader accInfo = BinaryProtocol.decode(bytes); | |||
return new VersioningAccount(accInfo.getAddress(), accInfo.getPubKey(), accInfo.getRootHash(), cryptoSetting, | |||
keyPrefix, exStorage, verStorage, readonly, accessPolicy, version); | |||
} | |||
private byte[] serialize(AccountHeader account) { | |||
return BinaryEncodingUtils.encode(account, AccountHeader.class); | |||
return BinaryProtocol.encode(account, AccountHeader.class); | |||
} | |||
@Override | |||
@@ -1,6 +1,6 @@ | |||
package com.jd.blockchain.ledger.core; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.PrimitiveType; | |||
import com.jd.blockchain.crypto.HashDigest; | |||
import com.jd.blockchain.crypto.PubKey; | |||
@@ -141,7 +141,7 @@ public class DataAccount implements AccountHeader, MerkleProvable { | |||
value = baseAccount.dataset.getValuesAtIndex(fromIndex); | |||
key = baseAccount.dataset.getKeyAtIndex(fromIndex); | |||
ver = baseAccount.dataset.getVersion(key); | |||
BytesValue decodeData = BinaryEncodingUtils.decode(value); | |||
BytesValue decodeData = BinaryProtocol.decode(value); | |||
kvDataEntries[i] = new KVDataObject(key, ver, PrimitiveType.valueOf(decodeData.getType().CODE), decodeData.getValue().toBytes()); | |||
fromIndex++; | |||
} | |||
@@ -3,7 +3,7 @@ package com.jd.blockchain.ledger.core; | |||
import org.slf4j.Logger; | |||
import org.slf4j.LoggerFactory; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.DataContractRegistry; | |||
import com.jd.blockchain.crypto.Crypto; | |||
import com.jd.blockchain.crypto.HashDigest; | |||
@@ -288,11 +288,11 @@ public class LedgerAdminAccount implements Transactional, LedgerAdministration { | |||
} | |||
private LedgerMetadata deserializeMetadata(byte[] bytes) { | |||
return BinaryEncodingUtils.decode(bytes); | |||
return BinaryProtocol.decode(bytes); | |||
} | |||
private byte[] serializeMetadata(LedgerMetadataImpl config) { | |||
return BinaryEncodingUtils.encode(config, LedgerMetadata.class); | |||
return BinaryProtocol.encode(config, LedgerMetadata.class); | |||
} | |||
@Override | |||
@@ -1,6 +1,6 @@ | |||
package com.jd.blockchain.ledger.core; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.DataContractRegistry; | |||
import com.jd.blockchain.crypto.HashDigest; | |||
import com.jd.blockchain.ledger.ParticipantNode; | |||
@@ -65,7 +65,7 @@ public class ParticipantDataSet implements Transactional, MerkleProvable { | |||
*/ | |||
public void addConsensusParticipant(ParticipantNode participant) { | |||
Bytes key = encodeKey(participant.getAddress()); | |||
byte[] participantBytes = BinaryEncodingUtils.encode(participant, ParticipantNode.class); | |||
byte[] participantBytes = BinaryProtocol.encode(participant, ParticipantNode.class); | |||
long nv = dataset.setValue(key, participantBytes, -1); | |||
if (nv < 0) { | |||
throw new LedgerException("Participant already exist! --[id=" + key + "]"); | |||
@@ -92,7 +92,7 @@ public class ParticipantDataSet implements Transactional, MerkleProvable { | |||
if (bytes == null) { | |||
return null; | |||
} | |||
return BinaryEncodingUtils.decode(bytes); | |||
return BinaryProtocol.decode(bytes); | |||
} | |||
public ParticipantNode[] getParticipants() { | |||
@@ -100,7 +100,7 @@ public class ParticipantDataSet implements Transactional, MerkleProvable { | |||
ParticipantNode[] pns = new ParticipantNode[bytes.length]; | |||
for (int i = 0; i < pns.length; i++) { | |||
pns[i] = BinaryEncodingUtils.decode(bytes[i]); | |||
pns[i] = BinaryProtocol.decode(bytes[i]); | |||
} | |||
return pns; | |||
} | |||
@@ -1,6 +1,6 @@ | |||
package com.jd.blockchain.ledger.core; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.DataContractRegistry; | |||
import com.jd.blockchain.crypto.HashDigest; | |||
import com.jd.blockchain.ledger.CryptoSetting; | |||
@@ -142,11 +142,11 @@ public class TransactionSet implements Transactional, MerkleProvable { | |||
} | |||
private LedgerTransaction deserialize(byte[] txBytes) { | |||
return BinaryEncodingUtils.decode(txBytes); | |||
return BinaryProtocol.decode(txBytes); | |||
} | |||
private byte[] serialize(LedgerTransaction txRequest) { | |||
return BinaryEncodingUtils.encode(txRequest, LedgerTransaction.class); | |||
return BinaryProtocol.encode(txRequest, LedgerTransaction.class); | |||
} | |||
public boolean isReadonly() { | |||
@@ -1,6 +1,6 @@ | |||
package com.jd.blockchain.ledger.core.impl; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.PrimitiveType; | |||
import com.jd.blockchain.crypto.HashDigest; | |||
import com.jd.blockchain.ledger.AccountHeader; | |||
@@ -274,7 +274,7 @@ public class LedgerQueryService implements BlockchainQueryService { | |||
entries[i] = new KVDataObject(keys[i], -1, PrimitiveType.NIL, null); | |||
}else { | |||
byte[] value = dataAccount.getBytes(Bytes.fromString(keys[i]), ver); | |||
BytesValue decodeData = BinaryEncodingUtils.decode(value); | |||
BytesValue decodeData = BinaryProtocol.decode(value); | |||
entries[i] = new KVDataObject(keys[i], ver, PrimitiveType.valueOf(decodeData.getType().CODE), decodeData.getValue().toBytes()); | |||
} | |||
} | |||
@@ -1,6 +1,6 @@ | |||
package com.jd.blockchain.ledger.core.impl; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.crypto.Crypto; | |||
import com.jd.blockchain.crypto.HashDigest; | |||
import com.jd.blockchain.crypto.HashFunction; | |||
@@ -225,11 +225,11 @@ public class LedgerRepositoryImpl implements LedgerRepository { | |||
if (block.getHeight() == 0) { | |||
// 计算创世区块的 hash 时,不包括 ledgerHash 字段; | |||
block.setLedgerHash(null); | |||
blockBodyBytes = BinaryEncodingUtils.encode(block, BlockBody.class); | |||
blockBodyBytes = BinaryProtocol.encode(block, BlockBody.class); | |||
// 恢复; | |||
block.setLedgerHash(block.getHash()); | |||
} else { | |||
blockBodyBytes = BinaryEncodingUtils.encode(block, BlockBody.class); | |||
blockBodyBytes = BinaryProtocol.encode(block, BlockBody.class); | |||
} | |||
HashFunction hashFunc = Crypto.getHashFunction(blockHash.getAlgorithm()); | |||
boolean pass = hashFunc.verify(blockHash, blockBodyBytes); | |||
@@ -256,7 +256,7 @@ public class LedgerRepositoryImpl implements LedgerRepository { | |||
} | |||
private LedgerBlock deserialize(byte[] blockBytes) { | |||
return BinaryEncodingUtils.decode(blockBytes); | |||
return BinaryProtocol.decode(blockBytes); | |||
} | |||
@Override | |||
@@ -2,7 +2,7 @@ package com.jd.blockchain.ledger.core.impl; | |||
import java.util.Stack; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.crypto.Crypto; | |||
import com.jd.blockchain.crypto.HashDigest; | |||
import com.jd.blockchain.ledger.BlockBody; | |||
@@ -188,7 +188,7 @@ public class LedgerTransactionalEditor implements LedgerEditor { | |||
newlyBlock.setTransactionSetHash(lastTxCtx.txset.getRootHash()); | |||
// compute block hash; | |||
byte[] blockBodyBytes = BinaryEncodingUtils.encode(newlyBlock, BlockBody.class); | |||
byte[] blockBodyBytes = BinaryProtocol.encode(newlyBlock, BlockBody.class); | |||
HashDigest blockHash = Crypto.getHashFunction(cryptoSetting.getHashAlgorithm()) | |||
.hash(blockBodyBytes); | |||
newlyBlock.setHash(blockHash); | |||
@@ -199,7 +199,7 @@ public class LedgerTransactionalEditor implements LedgerEditor { | |||
// persist block bytes; | |||
// only one version per block; | |||
byte[] blockBytes = BinaryEncodingUtils.encode(newlyBlock, LedgerBlock.class); | |||
byte[] blockBytes = BinaryProtocol.encode(newlyBlock, LedgerBlock.class); | |||
Bytes blockStorageKey = LedgerRepositoryImpl.encodeBlockStorageKey(newlyBlock.getHash()); | |||
long v = bufferedStorage.set(blockStorageKey, blockBytes, -1); | |||
if (v < 0) { | |||
@@ -1,6 +1,6 @@ | |||
package com.jd.blockchain.ledger.core.impl.handles; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.DataContractRegistry; | |||
import com.jd.blockchain.ledger.BytesValue; | |||
import com.jd.blockchain.ledger.DataAccountKVSetOperation; | |||
@@ -24,7 +24,7 @@ public class DataAccountKVSetOperationHandle implements OperationHandle{ | |||
DataAccount account = dataset.getDataAccountSet().getDataAccount(kvWriteOp.getAccountAddress()); | |||
KVWriteEntry[] writeset = kvWriteOp.getWriteSet(); | |||
for (KVWriteEntry kvw : writeset) { | |||
byte[] value = BinaryEncodingUtils.encode(kvw.getValue(), BytesValue.class); | |||
byte[] value = BinaryProtocol.encode(kvw.getValue(), BytesValue.class); | |||
account.setBytes(Bytes.fromString(kvw.getKey()), value, kvw.getExpectedVersion()); | |||
} | |||
} | |||
@@ -7,7 +7,7 @@ import java.util.Random; | |||
import org.junit.Before; | |||
import org.junit.Test; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.DataContractRegistry; | |||
import com.jd.blockchain.crypto.HashDigest; | |||
import com.jd.blockchain.crypto.PubKey; | |||
@@ -48,8 +48,8 @@ public class LedgerAccountTest { | |||
pubKey, hashDigest); | |||
// encode and decode | |||
byte[] encodeBytes = BinaryEncodingUtils.encode(accountHeaderData, AccountHeader.class); | |||
AccountHeader deAccountHeaderData = BinaryEncodingUtils.decode(encodeBytes); | |||
byte[] encodeBytes = BinaryProtocol.encode(accountHeaderData, AccountHeader.class); | |||
AccountHeader deAccountHeaderData = BinaryProtocol.decode(encodeBytes); | |||
// verify start | |||
assertEquals(accountHeaderData.getAddress(), deAccountHeaderData.getAddress()); | |||
@@ -13,7 +13,7 @@ import static org.junit.Assert.assertEquals; | |||
import org.junit.Before; | |||
import org.junit.Test; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.DataContractRegistry; | |||
import com.jd.blockchain.crypto.HashDigest; | |||
import com.jd.blockchain.crypto.service.classic.ClassicAlgorithm; | |||
@@ -54,8 +54,8 @@ public class LedgerBlockImplTest { | |||
@Test | |||
public void testSerialize_LedgerBlock() throws Exception { | |||
byte[] serialBytes = BinaryEncodingUtils.encode(data, LedgerBlock.class); | |||
LedgerBlock resolvedData = BinaryEncodingUtils.decode(serialBytes); | |||
byte[] serialBytes = BinaryProtocol.encode(data, LedgerBlock.class); | |||
LedgerBlock resolvedData = BinaryProtocol.decode(serialBytes); | |||
System.out.println("------Assert start ------"); | |||
assertEquals(resolvedData.getHash(), data.getHash()); | |||
assertEquals(resolvedData.getHeight(), data.getHeight()); | |||
@@ -105,8 +105,8 @@ public class LedgerBlockImplTest { | |||
transactionStagedSnapshot.setDataAccountSetHash(data); | |||
transactionStagedSnapshot.setUserAccountSetHash(user); | |||
byte[] serialBytes = BinaryEncodingUtils.encode(transactionStagedSnapshot, LedgerDataSnapshot.class); | |||
LedgerDataSnapshot resolvedData = BinaryEncodingUtils.decode(serialBytes); | |||
byte[] serialBytes = BinaryProtocol.encode(transactionStagedSnapshot, LedgerDataSnapshot.class); | |||
LedgerDataSnapshot resolvedData = BinaryProtocol.decode(serialBytes); | |||
// verify start | |||
assertEquals(resolvedData.getAdminAccountHash(), transactionStagedSnapshot.getAdminAccountHash()); | |||
@@ -9,7 +9,7 @@ import java.util.Random; | |||
import org.junit.Before; | |||
import org.junit.Test; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.DataContractRegistry; | |||
import com.jd.blockchain.crypto.AddressEncoding; | |||
import com.jd.blockchain.crypto.service.classic.ClassicAlgorithm; | |||
@@ -75,8 +75,8 @@ public class LedgerInitOperationTest { | |||
LedgerInitOpTemplate template = new LedgerInitOpTemplate(ledgerInitSettingData); | |||
byte[] encode = BinaryEncodingUtils.encode(template, LedgerInitOperation.class); | |||
LedgerInitOperation decode = BinaryEncodingUtils.decode(encode); | |||
byte[] encode = BinaryProtocol.encode(template, LedgerInitOperation.class); | |||
LedgerInitOperation decode = BinaryProtocol.decode(encode); | |||
for (int i = 0; i < template.getInitSetting().getConsensusParticipants().length; i++) { | |||
assertEquals(template.getInitSetting().getConsensusParticipants()[i].getAddress(), | |||
@@ -115,8 +115,8 @@ public class LedgerInitOperationTest { | |||
LedgerInitOpTemplate template = new LedgerInitOpTemplate(ledgerInitSettingData); | |||
byte[] encode = BinaryEncodingUtils.encode(template, LedgerInitOperation.class); | |||
LedgerInitOperation decode = BinaryEncodingUtils.decode(encode); | |||
byte[] encode = BinaryProtocol.encode(template, LedgerInitOperation.class); | |||
LedgerInitOperation decode = BinaryProtocol.decode(encode); | |||
for (int i = 0; i < template.getInitSetting().getConsensusParticipants().length; i++) { | |||
assertEquals(template.getInitSetting().getConsensusParticipants()[i].getAddress(), | |||
@@ -9,7 +9,7 @@ import java.util.Random; | |||
import org.junit.Before; | |||
import org.junit.Test; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.DataContractRegistry; | |||
import com.jd.blockchain.crypto.AddressEncoding; | |||
import com.jd.blockchain.crypto.service.classic.ClassicAlgorithm; | |||
@@ -72,9 +72,9 @@ public class LedgerInitSettingTest { | |||
ledgerInitSettingData.setConsensusParticipants(parties1); | |||
byte[] encode = BinaryEncodingUtils.encode(ledgerInitSettingData, LedgerInitSetting.class); | |||
byte[] encode = BinaryProtocol.encode(ledgerInitSettingData, LedgerInitSetting.class); | |||
LedgerInitSetting decode = BinaryEncodingUtils.decode(encode); | |||
LedgerInitSetting decode = BinaryProtocol.decode(encode); | |||
for (int i = 0; i < ledgerInitSettingData.getConsensusParticipants().length; i++) { | |||
assertEquals(ledgerInitSettingData.getConsensusParticipants()[i].getAddress(), | |||
@@ -116,9 +116,9 @@ public class LedgerInitSettingTest { | |||
ledgerInitSettingData.setConsensusParticipants(parties1); | |||
byte[] encode = BinaryEncodingUtils.encode(ledgerInitSettingData, LedgerInitSetting.class); | |||
byte[] encode = BinaryProtocol.encode(ledgerInitSettingData, LedgerInitSetting.class); | |||
LedgerInitSetting decode = BinaryEncodingUtils.decode(encode); | |||
LedgerInitSetting decode = BinaryProtocol.decode(encode); | |||
for (int i = 0; i < ledgerInitSettingData.getConsensusParticipants().length; i++) { | |||
assertEquals(ledgerInitSettingData.getConsensusParticipants()[i].getAddress(), | |||
@@ -10,7 +10,7 @@ import java.util.Random; | |||
import org.junit.Before; | |||
import org.junit.Test; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.DataContractRegistry; | |||
import com.jd.blockchain.crypto.AddressEncoding; | |||
import com.jd.blockchain.crypto.HashDigest; | |||
@@ -71,8 +71,8 @@ public class LedgerMetaDataTest { | |||
ledgerMetadata.setParticipantsHash(hashDigest); | |||
// encode and decode | |||
byte[] encodeBytes = BinaryEncodingUtils.encode(ledgerMetadata, LedgerMetadata.class); | |||
LedgerMetadata deLedgerMetaData = BinaryEncodingUtils.decode(encodeBytes); | |||
byte[] encodeBytes = BinaryProtocol.encode(ledgerMetadata, LedgerMetadata.class); | |||
LedgerMetadata deLedgerMetaData = BinaryProtocol.decode(encodeBytes); | |||
// verify start | |||
assertArrayEquals(ledgerMetadata.getSeed(), deLedgerMetaData.getSeed()); | |||
@@ -99,8 +99,8 @@ public class LedgerMetaDataTest { | |||
LedgerConfiguration ledgerConfiguration = new LedgerConfiguration(consensusProvider, new Bytes(csSettingsBytes), | |||
cryptoConfig); | |||
byte[] encodeBytes = BinaryEncodingUtils.encode(ledgerConfiguration, LedgerSetting.class); | |||
LedgerSetting deLedgerConfiguration = BinaryEncodingUtils.decode(encodeBytes); | |||
byte[] encodeBytes = BinaryProtocol.encode(ledgerConfiguration, LedgerSetting.class); | |||
LedgerSetting deLedgerConfiguration = BinaryProtocol.decode(encodeBytes); | |||
// verify start | |||
assertTrue(ledgerConfiguration.getConsensusSetting().equals(deLedgerConfiguration.getConsensusSetting())); | |||
assertEquals(ledgerConfiguration.getCryptoSetting().getAutoVerifyHash(), | |||
@@ -136,8 +136,8 @@ public class LedgerMetaDataTest { | |||
CryptoConfig cryptoConfig = new CryptoConfig(); | |||
cryptoConfig.setAutoVerifyHash(true); | |||
cryptoConfig.setHashAlgorithm(ClassicAlgorithm.SHA256); | |||
byte[] encodeBytes = BinaryEncodingUtils.encode(cryptoConfig, CryptoSetting.class); | |||
CryptoSetting deCryptoConfig = BinaryEncodingUtils.decode(encodeBytes); | |||
byte[] encodeBytes = BinaryProtocol.encode(cryptoConfig, CryptoSetting.class); | |||
CryptoSetting deCryptoConfig = BinaryProtocol.decode(encodeBytes); | |||
// verify start | |||
assertEquals(cryptoConfig.getHashAlgorithm(), deCryptoConfig.getHashAlgorithm()); | |||
@@ -162,8 +162,8 @@ public class LedgerMetaDataTest { | |||
ParticipantCertData participantCertData = new ParticipantCertData(address, name, pubKey); | |||
// encode and decode | |||
byte[] encodeBytes = BinaryEncodingUtils.encode(participantCertData, ParticipantNode.class); | |||
ParticipantNode deParticipantInfoData = BinaryEncodingUtils.decode(encodeBytes); | |||
byte[] encodeBytes = BinaryProtocol.encode(participantCertData, ParticipantNode.class); | |||
ParticipantNode deParticipantInfoData = BinaryProtocol.decode(encodeBytes); | |||
// verify start | |||
assertEquals(participantCertData.getAddress(), deParticipantInfoData.getAddress()); | |||
@@ -15,7 +15,7 @@ import java.util.UUID; | |||
import org.junit.Before; | |||
import org.junit.Test; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.DataContractRegistry; | |||
import com.jd.blockchain.crypto.Crypto; | |||
import com.jd.blockchain.crypto.HashDigest; | |||
@@ -86,8 +86,8 @@ public class LedgerTransactionDataTest { | |||
@Test | |||
public void testSerialize_LedgerTransaction() throws Exception { | |||
byte[] serialBytes = BinaryEncodingUtils.encode(data, LedgerTransaction.class); | |||
LedgerTransaction resolvedData = BinaryEncodingUtils.decode(serialBytes); | |||
byte[] serialBytes = BinaryProtocol.encode(data, LedgerTransaction.class); | |||
LedgerTransaction resolvedData = BinaryProtocol.decode(serialBytes); | |||
System.out.println("------Assert start ------"); | |||
assertEquals(resolvedData.getAdminAccountHash(), data.getAdminAccountHash()); | |||
@@ -120,8 +120,8 @@ public class LedgerTransactionDataTest { | |||
@Test | |||
public void testSerialize_Transaction() throws Exception { | |||
byte[] serialBytes = BinaryEncodingUtils.encode(data, Transaction.class); | |||
Transaction resolvedData = BinaryEncodingUtils.decode(serialBytes); | |||
byte[] serialBytes = BinaryProtocol.encode(data, Transaction.class); | |||
Transaction resolvedData = BinaryProtocol.decode(serialBytes); | |||
System.out.println("------Assert start ------"); | |||
assertEquals(resolvedData.getExecutionState(), data.getExecutionState()); | |||
@@ -150,8 +150,8 @@ public class LedgerTransactionDataTest { | |||
@Test | |||
public void testSerialize_LedgerDataSnapshot() throws Exception { | |||
byte[] serialBytes = BinaryEncodingUtils.encode(data, LedgerDataSnapshot.class); | |||
LedgerDataSnapshot resolvedData = BinaryEncodingUtils.decode(serialBytes); | |||
byte[] serialBytes = BinaryProtocol.encode(data, LedgerDataSnapshot.class); | |||
LedgerDataSnapshot resolvedData = BinaryProtocol.decode(serialBytes); | |||
System.out.println("------Assert start ------"); | |||
assertEquals(resolvedData.getAdminAccountHash(), data.getAdminAccountHash()); | |||
@@ -163,8 +163,8 @@ public class LedgerTransactionDataTest { | |||
@Test | |||
public void testSerialize_NodeRequest() throws Exception { | |||
byte[] serialBytes = BinaryEncodingUtils.encode(data, NodeRequest.class); | |||
NodeRequest resolvedData = BinaryEncodingUtils.decode(serialBytes); | |||
byte[] serialBytes = BinaryProtocol.encode(data, NodeRequest.class); | |||
NodeRequest resolvedData = BinaryProtocol.decode(serialBytes); | |||
System.out.println("------Assert start ------"); | |||
// EndpointSignatures 验证 | |||
@@ -189,8 +189,8 @@ public class LedgerTransactionDataTest { | |||
@Test | |||
public void testSerialize_EndpointRequest() throws Exception { | |||
byte[] serialBytes = BinaryEncodingUtils.encode(data, EndpointRequest.class); | |||
EndpointRequest resolvedData = BinaryEncodingUtils.decode(serialBytes); | |||
byte[] serialBytes = BinaryProtocol.encode(data, EndpointRequest.class); | |||
EndpointRequest resolvedData = BinaryProtocol.decode(serialBytes); | |||
System.out.println("------Assert start ------"); | |||
// EndpointSignatures 验证 | |||
@@ -13,7 +13,7 @@ import static org.junit.Assert.assertEquals; | |||
import org.junit.Before; | |||
import org.junit.Test; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.DataContractRegistry; | |||
import com.jd.blockchain.crypto.HashDigest; | |||
import com.jd.blockchain.crypto.service.classic.ClassicAlgorithm; | |||
@@ -43,8 +43,8 @@ public class TransactionStagedSnapshotTest { | |||
@Test | |||
public void testSerialize_LedgerDataSnapshot() throws Exception { | |||
byte[] serialBytes = BinaryEncodingUtils.encode(data, LedgerDataSnapshot.class); | |||
LedgerDataSnapshot resolvedData = BinaryEncodingUtils.decode(serialBytes); | |||
byte[] serialBytes = BinaryProtocol.encode(data, LedgerDataSnapshot.class); | |||
LedgerDataSnapshot resolvedData = BinaryProtocol.decode(serialBytes); | |||
System.out.println("------Assert start ------"); | |||
assertEquals(resolvedData.getAdminAccountHash(), data.getAdminAccountHash()); | |||
assertEquals(resolvedData.getContractAccountSetHash(), data.getContractAccountSetHash()); | |||
@@ -1,6 +1,6 @@ | |||
package com.jd.blockchain.transaction; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.crypto.AsymmetricKeypair; | |||
import com.jd.blockchain.crypto.Crypto; | |||
import com.jd.blockchain.crypto.HashDigest; | |||
@@ -39,7 +39,7 @@ public class PreparedTx implements PreparedTransaction { | |||
public DigitalSignature sign(AsymmetricKeypair keyPair) { | |||
SignatureFunction signatureFunction = Crypto.getSignatureFunction(keyPair.getAlgorithm()); | |||
PrivKey privKey = keyPair.getPrivKey(); | |||
byte[] content = BinaryEncodingUtils.encode(getTransactionContent(), TransactionContent.class); | |||
byte[] content = BinaryProtocol.encode(getTransactionContent(), TransactionContent.class); | |||
SignatureDigest signatureDigest = signatureFunction.sign(privKey, content); | |||
DigitalSignature signature = new DigitalSignatureBlob(keyPair.getPubKey(), signatureDigest); | |||
addSignature(signature); | |||
@@ -2,17 +2,17 @@ package com.jd.blockchain.transaction; | |||
import org.springframework.util.Base64Utils; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.ledger.DigitalSignature; | |||
public class SignatureEncoding { | |||
public static byte[] encode(DigitalSignature signature) { | |||
return BinaryEncodingUtils.encode(signature, DigitalSignature.class); | |||
return BinaryProtocol.encode(signature, DigitalSignature.class); | |||
} | |||
public static DigitalSignature decode(byte[] bytesSignature) { | |||
return BinaryEncodingUtils.decode(bytesSignature); | |||
return BinaryProtocol.decode(bytesSignature); | |||
} | |||
public static DigitalSignature decodeFromBase64(String base64Signature) { | |||
@@ -1,6 +1,6 @@ | |||
package com.jd.blockchain.transaction; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.DataContractRegistry; | |||
import com.jd.blockchain.crypto.Crypto; | |||
import com.jd.blockchain.crypto.HashDigest; | |||
@@ -42,7 +42,7 @@ public class TxBuilder implements TransactionBuilder { | |||
TxContentBlob txContent = new TxContentBlob(ledgerHash); | |||
txContent.addOperations(opFactory.getOperations()); | |||
byte[] contentBodyBytes = BinaryEncodingUtils.encode(txContent, TransactionContentBody.class); | |||
byte[] contentBodyBytes = BinaryProtocol.encode(txContent, TransactionContentBody.class); | |||
HashDigest contentHash = Crypto.getHashFunction(DEFAULT_HASH_ALGORITHM).hash(contentBodyBytes); | |||
txContent.setHash(contentHash); | |||
@@ -3,7 +3,7 @@ package com.jd.blockchain.transaction; | |||
import java.util.ArrayList; | |||
import java.util.List; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.crypto.AsymmetricKeypair; | |||
import com.jd.blockchain.crypto.Crypto; | |||
import com.jd.blockchain.crypto.HashDigest; | |||
@@ -86,7 +86,7 @@ public class TxRequestBuilder implements TransactionRequestBuilder { | |||
txMessage.addEndpointSignatures(endpointSignatures); | |||
txMessage.addNodeSignatures(nodeSignatures); | |||
byte[] reqBytes = BinaryEncodingUtils.encode(txMessage, NodeRequest.class); | |||
byte[] reqBytes = BinaryProtocol.encode(txMessage, NodeRequest.class); | |||
HashDigest reqHash = Crypto.getHashFunction(DEFAULT_HASH_ALGORITHM).hash(reqBytes); | |||
txMessage.setHash(reqHash); | |||
@@ -15,7 +15,7 @@ import static org.junit.Assert.assertTrue; | |||
import org.junit.Before; | |||
import org.junit.Test; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.DataContractRegistry; | |||
import com.jd.blockchain.crypto.Crypto; | |||
import com.jd.blockchain.crypto.PubKey; | |||
@@ -51,8 +51,8 @@ public class ContractCodeDeployOpTemplateTest { | |||
@Test | |||
public void testSerialize_ContractCodeDeployOperation() throws Exception { | |||
byte[] serialBytes = BinaryEncodingUtils.encode(data, ContractCodeDeployOperation.class); | |||
ContractCodeDeployOperation resolvedData = BinaryEncodingUtils.decode(serialBytes); | |||
byte[] serialBytes = BinaryProtocol.encode(data, ContractCodeDeployOperation.class); | |||
ContractCodeDeployOperation resolvedData = BinaryProtocol.decode(serialBytes); | |||
System.out.println("------Assert start ------"); | |||
assertArrayEquals(resolvedData.getChainCode(), data.getChainCode()); | |||
assertEquals(resolvedData.getContractID().getAddress(), data.getContractID().getAddress()); | |||
@@ -62,8 +62,8 @@ public class ContractCodeDeployOpTemplateTest { | |||
@Test | |||
public void testSerialize_Operation() throws Exception { | |||
byte[] serialBytes = BinaryEncodingUtils.encode(data, ContractCodeDeployOperation.class); | |||
ContractCodeDeployOperation resolvedData = BinaryEncodingUtils.decode(serialBytes); | |||
byte[] serialBytes = BinaryProtocol.encode(data, ContractCodeDeployOperation.class); | |||
ContractCodeDeployOperation resolvedData = BinaryProtocol.decode(serialBytes); | |||
BlockchainIdentity expCodeId = data.getContractID(); | |||
BlockchainIdentity actualCodeId = resolvedData.getContractID(); | |||
@@ -8,7 +8,7 @@ | |||
*/ | |||
package test.com.jd.blockchain.ledger.data; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.DataContractRegistry; | |||
import com.jd.blockchain.ledger.ContractEventSendOperation; | |||
import com.jd.blockchain.ledger.DataAccountKVSetOperation; | |||
@@ -45,8 +45,8 @@ public class ContractEventSendOpTemplateTest { | |||
@Test | |||
public void testSerialize_ContractEventSendOperation() throws Exception { | |||
byte[] serialBytes = BinaryEncodingUtils.encode(data, ContractEventSendOperation.class); | |||
ContractEventSendOperation resolvedData = BinaryEncodingUtils.decode(serialBytes); | |||
byte[] serialBytes = BinaryProtocol.encode(data, ContractEventSendOperation.class); | |||
ContractEventSendOperation resolvedData = BinaryProtocol.decode(serialBytes); | |||
System.out.println("------Assert start ------"); | |||
assertEquals(resolvedData.getContractAddress(), data.getContractAddress()); | |||
assertEquals(resolvedData.getEvent(), data.getEvent()); | |||
@@ -56,8 +56,8 @@ public class ContractEventSendOpTemplateTest { | |||
@Test | |||
public void testSerialize_Operation() throws Exception { | |||
byte[] serialBytes = BinaryEncodingUtils.encode(data, Operation.class); | |||
Operation resolvedData = BinaryEncodingUtils.decode(serialBytes); | |||
byte[] serialBytes = BinaryProtocol.encode(data, Operation.class); | |||
Operation resolvedData = BinaryProtocol.decode(serialBytes); | |||
System.out.println("------Assert start ------"); | |||
System.out.println(resolvedData); | |||
System.out.println("------Assert OK ------"); | |||
@@ -8,7 +8,7 @@ | |||
*/ | |||
package test.com.jd.blockchain.ledger.data; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.DataContractRegistry; | |||
import com.jd.blockchain.ledger.BytesValueEntry; | |||
import com.jd.blockchain.ledger.DataAccountKVSetOperation; | |||
@@ -56,8 +56,8 @@ public class DataAccountKVSetOpTemplateTest { | |||
@Test | |||
public void testSerialize_DataAccountKVSetOperation() throws Exception { | |||
byte[] serialBytes = BinaryEncodingUtils.encode(data, DataAccountKVSetOperation.class); | |||
DataAccountKVSetOperation resolvedData = BinaryEncodingUtils.decode(serialBytes); | |||
byte[] serialBytes = BinaryProtocol.encode(data, DataAccountKVSetOperation.class); | |||
DataAccountKVSetOperation resolvedData = BinaryProtocol.decode(serialBytes); | |||
System.out.println("------Assert start ------"); | |||
assertEquals(resolvedData.getAccountAddress(), data.getAccountAddress()); | |||
DataAccountKVSetOperation.KVWriteEntry[] resolvedKv = resolvedData.getWriteSet(); | |||
@@ -75,8 +75,8 @@ public class DataAccountKVSetOpTemplateTest { | |||
@Test | |||
public void testSerialize_Operation() throws Exception { | |||
byte[] serialBytes = BinaryEncodingUtils.encode(data, Operation.class); | |||
Operation resolvedData = BinaryEncodingUtils.decode(serialBytes); | |||
byte[] serialBytes = BinaryProtocol.encode(data, Operation.class); | |||
Operation resolvedData = BinaryProtocol.decode(serialBytes); | |||
System.out.println("------Assert start ------"); | |||
System.out.println(resolvedData); | |||
System.out.println("serialBytesLength=" + serialBytes.length); | |||
@@ -13,7 +13,7 @@ import static org.junit.Assert.assertEquals; | |||
import org.junit.Before; | |||
import org.junit.Test; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.DataContractRegistry; | |||
import com.jd.blockchain.crypto.Crypto; | |||
import com.jd.blockchain.crypto.PubKey; | |||
@@ -48,8 +48,8 @@ public class DataAccountRegisterOpTemplateTest { | |||
@Test | |||
public void testSerialize_DataAccountRegisterOperation() throws Exception { | |||
byte[] serialBytes = BinaryEncodingUtils.encode(data, DataAccountRegisterOperation.class); | |||
DataAccountRegisterOperation resolvedData = BinaryEncodingUtils.decode(serialBytes); | |||
byte[] serialBytes = BinaryProtocol.encode(data, DataAccountRegisterOperation.class); | |||
DataAccountRegisterOperation resolvedData = BinaryProtocol.decode(serialBytes); | |||
System.out.println("------Assert start ------"); | |||
assertEquals(resolvedData.getAccountID().getAddress(), data.getAccountID().getAddress()); | |||
assertEquals(resolvedData.getAccountID().getPubKey(), data.getAccountID().getPubKey()); | |||
@@ -59,8 +59,8 @@ public class DataAccountRegisterOpTemplateTest { | |||
@Test | |||
public void testSerialize_Operation() throws Exception { | |||
byte[] serialBytes = BinaryEncodingUtils.encode(data, Operation.class); | |||
Operation resolvedData = BinaryEncodingUtils.decode(serialBytes); | |||
byte[] serialBytes = BinaryProtocol.encode(data, Operation.class); | |||
Operation resolvedData = BinaryProtocol.decode(serialBytes); | |||
System.out.println("------Assert start ------"); | |||
System.out.println("serialBytesLength=" + serialBytes.length); | |||
System.out.println(resolvedData); | |||
@@ -13,7 +13,7 @@ import static org.junit.Assert.assertEquals; | |||
import org.junit.Before; | |||
import org.junit.Test; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.DataContractRegistry; | |||
import com.jd.blockchain.crypto.CryptoAlgorithm; | |||
import com.jd.blockchain.crypto.AsymmetricKeypair; | |||
@@ -50,8 +50,8 @@ public class DigitalSignatureBlobTest { | |||
@Test | |||
public void testSerialize_DigitalSignature() throws Exception { | |||
byte[] serialBytes = BinaryEncodingUtils.encode(data, DigitalSignature.class); | |||
DigitalSignature resolvedData = BinaryEncodingUtils.decode(serialBytes); | |||
byte[] serialBytes = BinaryProtocol.encode(data, DigitalSignature.class); | |||
DigitalSignature resolvedData = BinaryProtocol.decode(serialBytes); | |||
System.out.println("------Assert start ------"); | |||
assertEquals(resolvedData.getDigest(), data.getDigest()); | |||
assertEquals(resolvedData.getPubKey(), data.getPubKey()); | |||
@@ -60,8 +60,8 @@ public class DigitalSignatureBlobTest { | |||
@Test | |||
public void testSerialize_DigitalSignatureBody() throws Exception { | |||
byte[] serialBytes = BinaryEncodingUtils.encode(data, DigitalSignatureBody.class); | |||
DigitalSignatureBody resolvedData = BinaryEncodingUtils.decode(serialBytes); | |||
byte[] serialBytes = BinaryProtocol.encode(data, DigitalSignatureBody.class); | |||
DigitalSignatureBody resolvedData = BinaryProtocol.decode(serialBytes); | |||
System.out.println("------Assert start ------"); | |||
assertEquals(resolvedData.getDigest(), data.getDigest()); | |||
assertEquals(resolvedData.getPubKey(), data.getPubKey()); | |||
@@ -8,7 +8,7 @@ | |||
*/ | |||
package test.com.jd.blockchain.ledger.data; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.DataContractRegistry; | |||
import com.jd.blockchain.ledger.BytesValueEntry; | |||
import com.jd.blockchain.ledger.DataAccountKVSetOperation; | |||
@@ -44,8 +44,8 @@ public class KVDataTest { | |||
@Test | |||
public void testSerialize_KVEntry() throws Exception { | |||
byte[] serialBytes = BinaryEncodingUtils.encode(kvData, DataAccountKVSetOperation.KVWriteEntry.class); | |||
DataAccountKVSetOpTemplate.KVWriteEntry resolvedKvData = BinaryEncodingUtils.decode(serialBytes); | |||
byte[] serialBytes = BinaryProtocol.encode(kvData, DataAccountKVSetOperation.KVWriteEntry.class); | |||
DataAccountKVSetOpTemplate.KVWriteEntry resolvedKvData = BinaryProtocol.decode(serialBytes); | |||
System.out.println("------Assert start ------"); | |||
assertEquals(resolvedKvData.getKey(), kvData.getKey()); | |||
assertEquals(resolvedKvData.getExpectedVersion(), kvData.getExpectedVersion()); | |||
@@ -9,7 +9,7 @@ import java.util.UUID; | |||
import org.junit.Before; | |||
import org.junit.Test; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.DataContractRegistry; | |||
import com.jd.blockchain.crypto.Crypto; | |||
import com.jd.blockchain.crypto.HashDigest; | |||
@@ -56,8 +56,8 @@ public class TxContentBlobTest { | |||
public void testSerialize_TransactionContentBody() | |||
throws IOException, InstantiationException, IllegalAccessException { | |||
byte[] bytesContent = BinaryEncodingUtils.encode(contentBlob, TransactionContentBody.class); | |||
TransactionContentBody resolvedContentBlob = BinaryEncodingUtils.decode(bytesContent); | |||
byte[] bytesContent = BinaryProtocol.encode(contentBlob, TransactionContentBody.class); | |||
TransactionContentBody resolvedContentBlob = BinaryProtocol.decode(bytesContent); | |||
assertEquals(contentBlob.getLedgerHash(), resolvedContentBlob.getLedgerHash()); | |||
// assertEquals(contentBlob.getSubjectAccount(), | |||
@@ -87,8 +87,8 @@ public class TxContentBlobTest { | |||
@Test | |||
public void testSerialize_TransactionContent() throws IOException, InstantiationException, IllegalAccessException { | |||
byte[] bytesContent = BinaryEncodingUtils.encode(contentBlob, TransactionContent.class); | |||
TransactionContentBody resolvedContentBlob = BinaryEncodingUtils.decode(bytesContent); | |||
byte[] bytesContent = BinaryProtocol.encode(contentBlob, TransactionContent.class); | |||
TransactionContentBody resolvedContentBlob = BinaryProtocol.decode(bytesContent); | |||
assertEquals(contentBlob.getLedgerHash(), resolvedContentBlob.getLedgerHash()); | |||
// assertEquals(contentBlob.getSubjectAccount(), | |||
@@ -15,7 +15,7 @@ import java.util.UUID; | |||
import org.junit.Before; | |||
import org.junit.Test; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.DataContractRegistry; | |||
import com.jd.blockchain.crypto.AsymmetricKeypair; | |||
import com.jd.blockchain.crypto.Crypto; | |||
@@ -85,8 +85,8 @@ public class TxRequestMessageTest { | |||
@Test | |||
public void testSerialize_TransactionRequest() { | |||
byte[] serialBytes = BinaryEncodingUtils.encode(data, TransactionRequest.class); | |||
TransactionRequest resolvedData = BinaryEncodingUtils.decode(serialBytes); | |||
byte[] serialBytes = BinaryProtocol.encode(data, TransactionRequest.class); | |||
TransactionRequest resolvedData = BinaryProtocol.decode(serialBytes); | |||
System.out.println("------Assert start ------"); | |||
assertEquals(resolvedData.getEndpointSignatures().length, data.getEndpointSignatures().length); | |||
assertEquals(resolvedData.getNodeSignatures().length, data.getNodeSignatures().length); | |||
@@ -124,8 +124,8 @@ public class TxRequestMessageTest { | |||
@Test | |||
public void testSerialize_NodeRequest() { | |||
byte[] serialBytes = BinaryEncodingUtils.encode(data, NodeRequest.class); | |||
NodeRequest resolvedData = BinaryEncodingUtils.decode(serialBytes); | |||
byte[] serialBytes = BinaryProtocol.encode(data, NodeRequest.class); | |||
NodeRequest resolvedData = BinaryProtocol.decode(serialBytes); | |||
System.out.println("------Assert start ------"); | |||
assertEquals(resolvedData.getEndpointSignatures().length, data.getEndpointSignatures().length); | |||
assertEquals(resolvedData.getNodeSignatures().length, data.getNodeSignatures().length); | |||
@@ -161,8 +161,8 @@ public class TxRequestMessageTest { | |||
@Test | |||
public void testSerialize_EndpointRequest() { | |||
byte[] serialBytes = BinaryEncodingUtils.encode(data, EndpointRequest.class); | |||
EndpointRequest resolvedData = BinaryEncodingUtils.decode(serialBytes); | |||
byte[] serialBytes = BinaryProtocol.encode(data, EndpointRequest.class); | |||
EndpointRequest resolvedData = BinaryProtocol.decode(serialBytes); | |||
System.out.println("------Assert start ------"); | |||
assertEquals(resolvedData.getEndpointSignatures().length, data.getEndpointSignatures().length); | |||
DigitalSignature[] dataEndpointSignatures = data.getEndpointSignatures(); | |||
@@ -13,7 +13,7 @@ import static org.junit.Assert.assertEquals; | |||
import org.junit.Before; | |||
import org.junit.Test; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.DataContractRegistry; | |||
import com.jd.blockchain.crypto.Crypto; | |||
import com.jd.blockchain.crypto.HashDigest; | |||
@@ -50,8 +50,8 @@ public class TxResponseMessageTest { | |||
@Test | |||
public void testSerialize_TransactionResponse() { | |||
byte[] serialBytes = BinaryEncodingUtils.encode(data, TransactionResponse.class); | |||
TransactionResponse resolvedData = BinaryEncodingUtils.decode(serialBytes); | |||
byte[] serialBytes = BinaryProtocol.encode(data, TransactionResponse.class); | |||
TransactionResponse resolvedData = BinaryProtocol.decode(serialBytes); | |||
System.out.println("------Assert start ------"); | |||
assertEquals(resolvedData.getBlockHash(), data.getBlockHash()); | |||
assertEquals(resolvedData.getBlockHeight(), data.getBlockHeight()); | |||
@@ -13,7 +13,7 @@ import static org.junit.Assert.assertEquals; | |||
import org.junit.Before; | |||
import org.junit.Test; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.DataContractRegistry; | |||
import com.jd.blockchain.crypto.AsymmetricKeypair; | |||
import com.jd.blockchain.crypto.Crypto; | |||
@@ -47,8 +47,8 @@ public class UserRegisterOpTemplateTest { | |||
@Test | |||
public void testSerialize_UserRegisterOperation() throws Exception { | |||
byte[] serialBytes = BinaryEncodingUtils.encode(data, UserRegisterOperation.class); | |||
UserRegisterOperation resolvedData = BinaryEncodingUtils.decode(serialBytes); | |||
byte[] serialBytes = BinaryProtocol.encode(data, UserRegisterOperation.class); | |||
UserRegisterOperation resolvedData = BinaryProtocol.decode(serialBytes); | |||
System.out.println("------Assert start ------"); | |||
assertEquals(data.getUserID().getAddress(), resolvedData.getUserID().getAddress()); | |||
assertEquals(data.getUserID().getPubKey(), resolvedData.getUserID().getPubKey()); | |||
@@ -57,8 +57,8 @@ public class UserRegisterOpTemplateTest { | |||
@Test | |||
public void testSerialize_Operation() throws Exception { | |||
byte[] serialBytes = BinaryEncodingUtils.encode(data, Operation.class); | |||
Operation resolvedData = BinaryEncodingUtils.decode(serialBytes); | |||
byte[] serialBytes = BinaryProtocol.encode(data, Operation.class); | |||
Operation resolvedData = BinaryProtocol.decode(serialBytes); | |||
System.out.println("------Assert start ------"); | |||
System.out.println("serialBytesLength=" + serialBytes.length); | |||
System.out.println(resolvedData); | |||
@@ -19,7 +19,7 @@ import org.springframework.http.converter.AbstractHttpMessageConverter; | |||
import org.springframework.http.converter.HttpMessageNotReadableException; | |||
import org.springframework.http.converter.HttpMessageNotWritableException; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
/** | |||
* 针对二进制对象的序列化和反序列化的 HTTP 消息转换器; | |||
@@ -95,7 +95,7 @@ public class BinaryMessageConverter extends AbstractHttpMessageConverter<Object> | |||
throws IOException, HttpMessageNotReadableException { | |||
InputStream in = inputMessage.getBody(); | |||
byte[] serializeBytes = BytesUtils.readBytes(in); | |||
Object resolvedObj = BinaryEncodingUtils.decode(serializeBytes); | |||
Object resolvedObj = BinaryProtocol.decode(serializeBytes); | |||
return resolvedObj; | |||
} | |||
@@ -104,7 +104,7 @@ public class BinaryMessageConverter extends AbstractHttpMessageConverter<Object> | |||
throws IOException, HttpMessageNotWritableException { | |||
OutputStream out = outputMessage.getBody(); | |||
if (t instanceof TransactionResponse) { | |||
byte[] serializeBytes = BinaryEncodingUtils.encode(t, TransactionResponse.class); | |||
byte[] serializeBytes = BinaryProtocol.encode(t, TransactionResponse.class); | |||
out.write(serializeBytes); | |||
out.flush(); | |||
} | |||
@@ -1,6 +1,6 @@ | |||
package com.jd.blockchain.peer.consensus; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.ledger.LedgerBlock; | |||
import com.jd.blockchain.ledger.TransactionRequest; | |||
import com.jd.blockchain.ledger.TransactionResponse; | |||
@@ -70,7 +70,7 @@ public class ConsensusMessageDispatcher implements MessageHandle { | |||
if (!realmProcessor.getCurrBatchId().equalsIgnoreCase(batchId)) { | |||
throw new IllegalArgumentException("BatchId is not begin!"); | |||
} | |||
TransactionRequest txRequest = BinaryEncodingUtils.decode(message); | |||
TransactionRequest txRequest = BinaryProtocol.decode(message); | |||
return realmProcessor.schedule(txRequest); | |||
} | |||
@@ -258,7 +258,7 @@ public class ConsensusMessageDispatcher implements MessageHandle { | |||
TxResponse txResponse = new TxResponse(entry.getKey()); | |||
txResponse.setBlockHeight(blockHeight); | |||
txResponse.setBlockHash(blockHash); | |||
asyncResult.complete(BinaryEncodingUtils.encode(txResponse, TransactionResponse.class)); | |||
asyncResult.complete(BinaryProtocol.encode(txResponse, TransactionResponse.class)); | |||
} | |||
}); | |||
} | |||
@@ -7,7 +7,7 @@ import org.springframework.web.bind.annotation.RequestMethod; | |||
import org.springframework.web.bind.annotation.RequestParam; | |||
import org.springframework.web.bind.annotation.RestController; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.PrimitiveType; | |||
import com.jd.blockchain.crypto.HashDigest; | |||
import com.jd.blockchain.ledger.AccountHeader; | |||
@@ -342,7 +342,7 @@ public class LedgerQueryController implements BlockchainQueryService { | |||
entries[i] = new KVDataObject(keys[i], -1, PrimitiveType.NIL, null); | |||
}else { | |||
byte[] value = dataAccount.getBytes(Bytes.fromString(keys[i]), ver); | |||
BytesValue decodeData = BinaryEncodingUtils.decode(value); | |||
BytesValue decodeData = BinaryProtocol.decode(value); | |||
entries[i] = new KVDataObject(keys[i], ver, PrimitiveType.valueOf(decodeData.getType().CODE), decodeData.getValue().toBytes()); | |||
} | |||
} | |||
@@ -8,7 +8,7 @@ | |||
*/ | |||
package com.jd.blockchain.sdk.converters; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.consensus.ClientIdentifications; | |||
import com.jd.blockchain.ledger.TransactionRequest; | |||
import com.jd.blockchain.transaction.TxRequestMessage; | |||
@@ -32,11 +32,11 @@ public class BinarySerializeRequestConverter implements RequestBodyConverter { | |||
public void write(Object param, OutputStream out) throws IOException { | |||
// 使用自定义的序列化方式 | |||
if (param instanceof TransactionRequest) { | |||
byte[] serializeBytes = BinaryEncodingUtils.encode(param, TransactionRequest.class); | |||
byte[] serializeBytes = BinaryProtocol.encode(param, TransactionRequest.class); | |||
out.write(serializeBytes); | |||
out.flush(); | |||
} else if (param instanceof ClientIdentifications) { | |||
byte[] serializeBytes = BinaryEncodingUtils.encode(param, ClientIdentifications.class); | |||
byte[] serializeBytes = BinaryProtocol.encode(param, ClientIdentifications.class); | |||
out.write(serializeBytes); | |||
out.flush(); | |||
} | |||
@@ -8,7 +8,7 @@ | |||
*/ | |||
package com.jd.blockchain.sdk.converters; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.transaction.TxResponseMessage; | |||
import com.jd.blockchain.utils.http.HttpServiceContext; | |||
import com.jd.blockchain.utils.http.ResponseConverter; | |||
@@ -30,7 +30,7 @@ public class BinarySerializeResponseConverter implements ResponseConverter { | |||
public Object getResponse(ServiceRequest request, InputStream responseStream, HttpServiceContext serviceContext) | |||
throws Exception { | |||
byte[] serializeBytes = BytesUtils.readBytes(responseStream); | |||
Object resolvedObj = BinaryEncodingUtils.decode(serializeBytes); | |||
Object resolvedObj = BinaryProtocol.decode(serializeBytes); | |||
return resolvedObj; | |||
} | |||
@@ -3,7 +3,7 @@ package com.jd.blockchain.sdk.converters; | |||
import com.alibaba.fastjson.JSON; | |||
import com.alibaba.fastjson.JSONArray; | |||
import com.alibaba.fastjson.JSONObject; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.crypto.HashDigest; | |||
import com.jd.blockchain.crypto.PubKey; | |||
import com.jd.blockchain.crypto.SignatureDigest; | |||
@@ -1,6 +1,6 @@ | |||
package com.jd.blockchain.sdk.service; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.DataContractRegistry; | |||
import com.jd.blockchain.consensus.MessageService; | |||
import com.jd.blockchain.consensus.client.ConsensusClient; | |||
@@ -63,7 +63,7 @@ public class NodeSigningAppender implements TransactionService { | |||
TxRequestMessage txMessage = new TxRequestMessage(txRequest); | |||
// 生成网关签名; | |||
byte[] endpointRequestBytes = BinaryEncodingUtils.encode(txMessage, TransactionRequest.class); | |||
byte[] endpointRequestBytes = BinaryProtocol.encode(txMessage, TransactionRequest.class); | |||
short signAlgorithm = nodeKeyPair.getAlgorithm(); | |||
SignatureFunction signFunc = Crypto.getSignatureFunction(signAlgorithm); | |||
@@ -71,13 +71,13 @@ public class NodeSigningAppender implements TransactionService { | |||
txMessage.addNodeSignatures(new DigitalSignatureBlob(nodeKeyPair.getPubKey(), signDigest)); | |||
// 计算交易哈希; | |||
byte[] nodeRequestBytes = BinaryEncodingUtils.encode(txMessage, TransactionRequest.class); | |||
byte[] nodeRequestBytes = BinaryProtocol.encode(txMessage, TransactionRequest.class); | |||
HashFunction hashFunc = Crypto.getHashFunction(signAlgorithm); | |||
HashDigest txHash = hashFunc.hash(nodeRequestBytes); | |||
txMessage.setHash(txHash); | |||
AsyncFuture<byte[]> result = messageService.sendOrdered(BinaryEncodingUtils.encode(txMessage, TransactionRequest.class)); | |||
AsyncFuture<byte[]> result = messageService.sendOrdered(BinaryProtocol.encode(txMessage, TransactionRequest.class)); | |||
return BinaryEncodingUtils.decode(result.get()); | |||
return BinaryProtocol.decode(result.get()); | |||
} | |||
} |
@@ -1,6 +1,6 @@ | |||
package com.jd.blockchain.sdk.service; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.consensus.BinaryMessageConverter; | |||
import com.jd.blockchain.ledger.TransactionRequest; | |||
@@ -8,12 +8,12 @@ public class TransactionRequestMessageConverter implements BinaryMessageConverte | |||
@Override | |||
public byte[] encode(Object message) { | |||
return BinaryEncodingUtils.encode(message, TransactionRequest.class); | |||
return BinaryProtocol.encode(message, TransactionRequest.class); | |||
} | |||
@Override | |||
public Object decode(byte[] messageBytes) { | |||
return BinaryEncodingUtils.decode(messageBytes); | |||
return BinaryProtocol.decode(messageBytes); | |||
} | |||
} |
@@ -1,6 +1,6 @@ | |||
package com.jd.blockchain.sdk.service; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.consensus.BinaryMessageConverter; | |||
import com.jd.blockchain.ledger.TransactionResponse; | |||
@@ -8,12 +8,12 @@ public class TransactionResponseMessageConverter implements BinaryMessageConvert | |||
@Override | |||
public byte[] encode(Object message) { | |||
return BinaryEncodingUtils.encode(message, TransactionResponse.class); | |||
return BinaryProtocol.encode(message, TransactionResponse.class); | |||
} | |||
@Override | |||
public Object decode(byte[] messageBytes) { | |||
return BinaryEncodingUtils.decode(messageBytes); | |||
return BinaryProtocol.decode(messageBytes); | |||
} | |||
} |
@@ -2,7 +2,7 @@ package com.jd.blockchain.sdk.client; | |||
import java.io.Closeable; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.crypto.Crypto; | |||
import com.jd.blockchain.crypto.PrivKey; | |||
import com.jd.blockchain.crypto.SignatureDigest; | |||
@@ -135,7 +135,7 @@ public class GatewayServiceFactory implements BlockchainServiceFactory, Closeabl | |||
//TODO: 未实现按不同的账本的密码参数配置,采用不同的哈希算法和签名算法; | |||
if (!reqMsg.containsEndpointSignature(userKey.getAddress())) { | |||
// TODO: 优化上下文对此 TransactionContent 的多次序列化带来的额外性能开销; | |||
byte[] txContentBytes = BinaryEncodingUtils.encode(txRequest.getTransactionContent(), | |||
byte[] txContentBytes = BinaryProtocol.encode(txRequest.getTransactionContent(), | |||
TransactionContent.class); | |||
PrivKey userPrivKey = userKey.getPrivKey(); | |||
SignatureFunction signatureFunction = Crypto.getSignatureFunction(userKey.getAlgorithm()); | |||
@@ -9,7 +9,7 @@ import org.springframework.boot.SpringApplication; | |||
import org.springframework.context.ConfigurableApplicationContext; | |||
import org.springframework.core.io.ClassPathResource; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.consensus.ConsensusProvider; | |||
import com.jd.blockchain.consensus.ConsensusProviders; | |||
import com.jd.blockchain.consensus.ConsensusSettings; | |||
@@ -127,28 +127,28 @@ public class LedgerInitializeWebTest { | |||
LedgerInitOperation initOp0 = (LedgerInitOperation) oplist0[0]; | |||
LedgerInitOperation initOp1 = (LedgerInitOperation) oplist1[0]; | |||
byte[] initOpBytes0 = BinaryEncodingUtils.encode(initOp0, LedgerInitOperation.class); | |||
byte[] initOpBytes1 = BinaryEncodingUtils.encode(initOp1, LedgerInitOperation.class); | |||
byte[] initOpBytes0 = BinaryProtocol.encode(initOp0, LedgerInitOperation.class); | |||
byte[] initOpBytes1 = BinaryProtocol.encode(initOp1, LedgerInitOperation.class); | |||
UserRegisterOperation regOp00 = (UserRegisterOperation) oplist0[1]; | |||
UserRegisterOperation regOp10 = (UserRegisterOperation) oplist1[1]; | |||
byte[] regOpBytes00 = BinaryEncodingUtils.encode(regOp00, UserRegisterOperation.class); | |||
byte[] regOpBytes10 = BinaryEncodingUtils.encode(regOp10, UserRegisterOperation.class); | |||
byte[] regOpBytes00 = BinaryProtocol.encode(regOp00, UserRegisterOperation.class); | |||
byte[] regOpBytes10 = BinaryProtocol.encode(regOp10, UserRegisterOperation.class); | |||
UserRegisterOperation regOp01 = (UserRegisterOperation) oplist0[2]; | |||
UserRegisterOperation regOp11 = (UserRegisterOperation) oplist1[2]; | |||
byte[] regOpBytes01 = BinaryEncodingUtils.encode(regOp01, UserRegisterOperation.class); | |||
byte[] regOpBytes11 = BinaryEncodingUtils.encode(regOp11, UserRegisterOperation.class); | |||
byte[] regOpBytes01 = BinaryProtocol.encode(regOp01, UserRegisterOperation.class); | |||
byte[] regOpBytes11 = BinaryProtocol.encode(regOp11, UserRegisterOperation.class); | |||
UserRegisterOperation regOp02 = (UserRegisterOperation) oplist0[3]; | |||
UserRegisterOperation regOp12 = (UserRegisterOperation) oplist1[3]; | |||
byte[] regOpBytes02 = BinaryEncodingUtils.encode(regOp02, UserRegisterOperation.class); | |||
byte[] regOpBytes12 = BinaryEncodingUtils.encode(regOp12, UserRegisterOperation.class); | |||
byte[] regOpBytes02 = BinaryProtocol.encode(regOp02, UserRegisterOperation.class); | |||
byte[] regOpBytes12 = BinaryProtocol.encode(regOp12, UserRegisterOperation.class); | |||
UserRegisterOperation regOp03 = (UserRegisterOperation) oplist0[4]; | |||
UserRegisterOperation regOp13 = (UserRegisterOperation) oplist1[4]; | |||
byte[] regOpBytes03 = BinaryEncodingUtils.encode(regOp03, UserRegisterOperation.class); | |||
byte[] regOpBytes13 = BinaryEncodingUtils.encode(regOp13, UserRegisterOperation.class); | |||
byte[] regOpBytes03 = BinaryProtocol.encode(regOp03, UserRegisterOperation.class); | |||
byte[] regOpBytes13 = BinaryProtocol.encode(regOp13, UserRegisterOperation.class); | |||
} | |||
@@ -14,7 +14,7 @@ import org.springframework.boot.SpringApplication; | |||
import org.springframework.context.ConfigurableApplicationContext; | |||
import org.springframework.core.io.ClassPathResource; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.consensus.ConsensusProvider; | |||
import com.jd.blockchain.consensus.ConsensusSettings; | |||
import com.jd.blockchain.crypto.HashDigest; | |||
@@ -138,32 +138,32 @@ public class LedgerInitializeWeb4SingleStepsTest { | |||
LedgerInitOperation initOp0 = (LedgerInitOperation) oplist0[0]; | |||
LedgerInitOperation initOp1 = (LedgerInitOperation) oplist1[0]; | |||
byte[] initOpBytes0 = BinaryEncodingUtils.encode(initOp0, LedgerInitOperation.class); | |||
byte[] initOpBytes1 = BinaryEncodingUtils.encode(initOp1, LedgerInitOperation.class); | |||
byte[] initOpBytes0 = BinaryProtocol.encode(initOp0, LedgerInitOperation.class); | |||
byte[] initOpBytes1 = BinaryProtocol.encode(initOp1, LedgerInitOperation.class); | |||
assertTrue(BytesUtils.equals(initOpBytes0, initOpBytes1)); | |||
UserRegisterOperation regOp00 = (UserRegisterOperation) oplist0[1]; | |||
UserRegisterOperation regOp10 = (UserRegisterOperation) oplist1[1]; | |||
byte[] regOpBytes00 = BinaryEncodingUtils.encode(regOp00, UserRegisterOperation.class); | |||
byte[] regOpBytes10 = BinaryEncodingUtils.encode(regOp10, UserRegisterOperation.class); | |||
byte[] regOpBytes00 = BinaryProtocol.encode(regOp00, UserRegisterOperation.class); | |||
byte[] regOpBytes10 = BinaryProtocol.encode(regOp10, UserRegisterOperation.class); | |||
assertTrue(BytesUtils.equals(regOpBytes00, regOpBytes10)); | |||
UserRegisterOperation regOp01 = (UserRegisterOperation) oplist0[2]; | |||
UserRegisterOperation regOp11 = (UserRegisterOperation) oplist1[2]; | |||
byte[] regOpBytes01 = BinaryEncodingUtils.encode(regOp01, UserRegisterOperation.class); | |||
byte[] regOpBytes11 = BinaryEncodingUtils.encode(regOp11, UserRegisterOperation.class); | |||
byte[] regOpBytes01 = BinaryProtocol.encode(regOp01, UserRegisterOperation.class); | |||
byte[] regOpBytes11 = BinaryProtocol.encode(regOp11, UserRegisterOperation.class); | |||
assertTrue(BytesUtils.equals(regOpBytes01, regOpBytes11)); | |||
UserRegisterOperation regOp02 = (UserRegisterOperation) oplist0[3]; | |||
UserRegisterOperation regOp12 = (UserRegisterOperation) oplist1[3]; | |||
byte[] regOpBytes02 = BinaryEncodingUtils.encode(regOp02, UserRegisterOperation.class); | |||
byte[] regOpBytes12 = BinaryEncodingUtils.encode(regOp12, UserRegisterOperation.class); | |||
byte[] regOpBytes02 = BinaryProtocol.encode(regOp02, UserRegisterOperation.class); | |||
byte[] regOpBytes12 = BinaryProtocol.encode(regOp12, UserRegisterOperation.class); | |||
assertTrue(BytesUtils.equals(regOpBytes02, regOpBytes12)); | |||
UserRegisterOperation regOp03 = (UserRegisterOperation) oplist0[4]; | |||
UserRegisterOperation regOp13 = (UserRegisterOperation) oplist1[4]; | |||
byte[] regOpBytes03 = BinaryEncodingUtils.encode(regOp03, UserRegisterOperation.class); | |||
byte[] regOpBytes13 = BinaryEncodingUtils.encode(regOp13, UserRegisterOperation.class); | |||
byte[] regOpBytes03 = BinaryProtocol.encode(regOp03, UserRegisterOperation.class); | |||
byte[] regOpBytes13 = BinaryProtocol.encode(regOp13, UserRegisterOperation.class); | |||
assertTrue(BytesUtils.equals(regOpBytes03, regOpBytes13)); | |||
} | |||
@@ -17,7 +17,7 @@ import java.util.concurrent.ExecutorService; | |||
import java.util.concurrent.Executors; | |||
import java.util.concurrent.atomic.AtomicLong; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.capability.settings.CapabilitySettings; | |||
import com.jd.blockchain.consensus.mq.factory.MsgQueueFactory; | |||
import com.jd.blockchain.consensus.mq.producer.MsgQueueProducer; | |||
@@ -240,7 +240,7 @@ public class RemoteTransactionService { | |||
instanceFactory.execute(() -> { | |||
List<byte[]> currentBytes = new ArrayList<>(); | |||
TransactionRequest txRequest = dataAccountRegisterRequest(CapabilitySettings.ledgerHash, CapabilitySettings.adminKey); | |||
byte[] serializeBytes = BinaryEncodingUtils.encode(txRequest, TransactionRequest.class); | |||
byte[] serializeBytes = BinaryProtocol.encode(txRequest, TransactionRequest.class); | |||
currentBytes.add(serializeBytes); | |||
try { | |||
txBlockingQueue.put(currentBytes); | |||
@@ -285,7 +285,7 @@ public class RemoteTransactionService { | |||
LinkedList<byte[]> txSerializeBytes = new LinkedList<>(); | |||
for (int i = 0; i < CapabilitySettings.TX_SIZE_PER_SEND; i++) { | |||
TransactionRequest txRequest = userRegisterRequest(CapabilitySettings.ledgerHash, CapabilitySettings.adminKey); | |||
byte[] serializeBytes = BinaryEncodingUtils.encode(txRequest, TransactionRequest.class); | |||
byte[] serializeBytes = BinaryProtocol.encode(txRequest, TransactionRequest.class); | |||
txSerializeBytes.addFirst(serializeBytes); | |||
} | |||
return txSerializeBytes; | |||
@@ -300,7 +300,7 @@ public class RemoteTransactionService { | |||
LinkedList<byte[]> txSerializeBytes = new LinkedList<>(); | |||
for (int i = 0; i < CapabilitySettings.TX_SIZE_PER_SEND; i++) { | |||
TransactionRequest txRequest = dataAccountRegisterRequest(CapabilitySettings.ledgerHash, CapabilitySettings.adminKey, isSave); | |||
byte[] serializeBytes = BinaryEncodingUtils.encode(txRequest, TransactionRequest.class); | |||
byte[] serializeBytes = BinaryProtocol.encode(txRequest, TransactionRequest.class); | |||
txSerializeBytes.addFirst(serializeBytes); | |||
} | |||
return txSerializeBytes; | |||
@@ -311,7 +311,7 @@ public class RemoteTransactionService { | |||
LinkedList<byte[]> txSerializeBytes = new LinkedList<>(); | |||
for (int i = 0; i < CapabilitySettings.TX_SIZE_PER_SEND; i++) { | |||
TransactionRequest txRequest = kvStorageRequest(address, CapabilitySettings.ledgerHash, CapabilitySettings.adminKey); | |||
byte[] serializeBytes = BinaryEncodingUtils.encode(txRequest, TransactionRequest.class); | |||
byte[] serializeBytes = BinaryProtocol.encode(txRequest, TransactionRequest.class); | |||
txSerializeBytes.addFirst(serializeBytes); | |||
} | |||
return txSerializeBytes; | |||
@@ -3,7 +3,7 @@ package com.jd.blockchain.tools.initializer.web; | |||
import java.io.IOException; | |||
import java.io.OutputStream; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.ledger.core.LedgerInitDecision; | |||
import com.jd.blockchain.utils.http.RequestBodyConverter; | |||
@@ -12,7 +12,7 @@ public class DecisionRequestBodyConverter implements RequestBodyConverter { | |||
@Override | |||
public void write(Object param, OutputStream out) throws IOException { | |||
if (param instanceof LedgerInitDecision) { | |||
BinaryEncodingUtils.encode(param, LedgerInitDecision.class, out); | |||
BinaryProtocol.encode(param, LedgerInitDecision.class, out); | |||
return; | |||
} | |||
} | |||
@@ -2,7 +2,7 @@ package com.jd.blockchain.tools.initializer.web; | |||
import java.io.InputStream; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.tools.initializer.LedgerInitException; | |||
import com.jd.blockchain.utils.http.HttpServiceContext; | |||
import com.jd.blockchain.utils.http.ResponseConverter; | |||
@@ -17,7 +17,7 @@ public class DecisionResponseConverter implements ResponseConverter { | |||
if (resp.isError()) { | |||
throw new LedgerInitException("Error occurred at remote participant! --" + resp.getErrorMessage()); | |||
} | |||
return BinaryEncodingUtils.decode(resp.getData()); | |||
return BinaryProtocol.decode(resp.getData()); | |||
} | |||
} |
@@ -13,7 +13,7 @@ import org.springframework.http.converter.HttpMessageConverter; | |||
import org.springframework.http.converter.HttpMessageNotReadableException; | |||
import org.springframework.http.converter.HttpMessageNotWritableException; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.binaryproto.DataContractRegistry; | |||
import com.jd.blockchain.crypto.SignatureDigest; | |||
import com.jd.blockchain.ledger.core.LedgerInitDecision; | |||
@@ -87,7 +87,7 @@ public class LedgerInitMessageConverter implements HttpMessageConverter<Object> | |||
Class<?> contractType = getContractType(clazz); | |||
Class<?> implType = SUPPORTED_CONTRACT_TYPES.get(contractType); | |||
return BinaryEncodingUtils.decode(inputMessage.getBody()); | |||
return BinaryProtocol.decode(inputMessage.getBody()); | |||
} | |||
@Override | |||
@@ -104,7 +104,7 @@ public class LedgerInitMessageConverter implements HttpMessageConverter<Object> | |||
if (contractType == null) { | |||
throw new IllegalStateException("Unsupported type[" + t.getClass().getName() + "]!"); | |||
} | |||
byte[] data = BinaryEncodingUtils.encode(t, contractType); | |||
byte[] data = BinaryProtocol.encode(t, contractType); | |||
resp = LedgerInitResponse.success(data); | |||
outputMessage.getBody().write(resp.toBytes()); | |||
} | |||
@@ -2,7 +2,7 @@ package com.jd.blockchain.tools.initializer.web; | |||
import java.io.InputStream; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.binaryproto.BinaryProtocol; | |||
import com.jd.blockchain.ledger.core.LedgerInitPermissionData; | |||
import com.jd.blockchain.tools.initializer.LedgerInitException; | |||
import com.jd.blockchain.utils.http.HttpServiceContext; | |||
@@ -18,7 +18,7 @@ public class PermissionResponseConverter implements ResponseConverter { | |||
if (resp.isError()) { | |||
throw new LedgerInitException("Error occurred at remote participant! --" + resp.getErrorMessage()); | |||
} | |||
return BinaryEncodingUtils.decode(resp.getData()); | |||
return BinaryProtocol.decode(resp.getData()); | |||
} | |||
} |